autopkg-wrapper 2026.2.6__py3-none-any.whl → 2026.2.9__py3-none-any.whl

autopkg_wrapper/autopkg_wrapper.py

@@ -11,7 +11,10 @@ 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_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
 
@@ -27,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())
@@ -75,6 +78,12 @@ def get_override_repo_info(args):
 
 
 def update_recipe_repo(recipe, git_info, disable_recipe_trust_check, args):
+    if getattr(args, "dry_run", False):
+        logging.info(
+            "Dry run: would update trust info in override repo for %s",
+            recipe.identifier,
+        )
+        return
     logging.debug(f"recipe.verified: {recipe.verified}")
     logging.debug(f"disable_recipe_trust_check: {disable_recipe_trust_check}")
 
@@ -103,7 +112,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)
@@ -120,21 +129,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):
@@ -205,6 +214,21 @@ def parse_post_processors(post_processors):
 
 
 def process_recipe(recipe, disable_recipe_trust_check, args):
+    if getattr(args, "dry_run", False):
+        logging.info("Dry run: processing recipe %s", recipe.identifier)
+        if disable_recipe_trust_check:
+            logging.info(
+                "Dry run: trust verification disabled for %s", recipe.identifier
+            )
+            recipe.verified = None
+        else:
+            logging.info("Dry run: would verify trust info for %s", recipe.identifier)
+        logging.info("Dry run: would run recipe %s", recipe.identifier)
+        logging.info(
+            "Dry run: would evaluate trust update flow for %s",
+            recipe.identifier,
+        )
+        return recipe
     if disable_recipe_trust_check:
         logging.debug("Setting Recipe verification to None")
         recipe.verified = None
@@ -230,7 +254,7 @@ def main():
     setup_logger(args.debug if args.debug else False)
     logging.info("Running autopkg_wrapper")
 
-    override_repo_info = get_override_repo_info(args)
+    override_repo_info = None
 
     post_processors_list = parse_post_processors(post_processors=args.post_processors)
     recipe_list = parse_recipe_list(
@@ -242,12 +266,22 @@ def main():
 
     failed_recipes = []
 
+    if getattr(args, "dry_run", False):
+        logging.info("Dry run enabled: no external commands will be executed")
+        if args.disable_git_commands:
+            logging.info("Dry run: git commands already disabled")
+
     # Run recipes concurrently using a thread pool to parallelize subprocess calls
     max_workers = max(1, int(getattr(args, "concurrency", 1)))
     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}")
+        if args.dry_run:
+            logging.info(
+                "Dry run: would process recipe %s with trust checks and run",
+                r.identifier,
+            )
         process_recipe(
             recipe=r,
             disable_recipe_trust_check=args.disable_recipe_trust_check,
@@ -261,58 +295,112 @@ def main():
             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'}"
-            )
+        logging.info("Recipe processing batches:")
+        batch_descriptions = describe_recipe_batches(batches)
+        for batch_desc in batch_descriptions:
+            batch_type = batch_desc.get("type") or "unknown"
+            logging.info(f"Batch type={batch_type} count={batch_desc.get('count', 0)}")
+        for batch, batch_desc in zip(batches, batch_descriptions, strict=False):
+            batch_type = batch_desc.get("type") or "unknown"
+            logging.info(f"Beginning {batch_type} batch")
+            logging.info(f"Batch recipes: {batch_desc.get('recipes', [])}")
+            if args.dry_run:
+                for r in batch:
+                    run_one(r)
+                continue
             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)
+    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])
+        if args.dry_run:
+            for r in recipe_list:
+                run_one(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:
-        update_recipe_repo(
-            git_info=override_repo_info,
-            recipe=r,
-            disable_recipe_trust_check=args.disable_recipe_trust_check,
-            args=args,
-        )
+    if args.dry_run:
+        logging.info("Dry run: skipping git updates")
+    elif args.disable_git_commands:
+        logging.info("Skipping git updates (disabled)")
+    else:
+        if override_repo_info is None:
+            override_repo_info = get_override_repo_info(args)
+        for r in recipe_list:
+            update_recipe_repo(
+                git_info=override_repo_info,
+                recipe=r,
+                disable_recipe_trust_check=args.disable_recipe_trust_check,
+                args=args,
+            )
 
     # Send notifications serially to simplify rate limiting and ordering
     if args.slack_token:
-        for r in recipe_list:
-            slack.send_notification(recipe=r, token=args.slack_token)
+        if args.dry_run:
+            logging.info("Dry run: skipping Slack notifications")
+        else:
+            for r in recipe_list:
+                slack.send_notification(recipe=r, token=args.slack_token)
 
     # Optionally open a PR for updated trust information
     if args.create_pr and recipe_list:
-        # Choose a representative recipe for the PR title/body
-        rep_recipe = next(
-            (r for r in recipe_list if r.updated is True or r.verified is False),
-            recipe_list[0],
-        )
-        pr_url = git.create_pull_request(git_info=override_repo_info, recipe=rep_recipe)
-        logging.info(f"Created Pull Request for trust info updates: {pr_url}")
+        if args.dry_run:
+            logging.info("Dry run: skipping PR creation")
+        elif args.disable_git_commands:
+            logging.info("Skipping PR creation (disabled git commands)")
+        else:
+            if override_repo_info is None:
+                override_repo_info = get_override_repo_info(args)
+            # Choose a representative recipe for the PR title/body
+            rep_recipe = next(
+                (r for r in recipe_list if r.updated is True or r.verified is False),
+                recipe_list[0],
+            )
+            pr_url = git.create_pull_request(
+                git_info=override_repo_info, recipe=rep_recipe
+            )
+            logging.info(f"Created Pull Request for trust info updates: {pr_url}")
 
     # Create GitHub issue for failed recipes
     if args.create_issues and failed_recipes and args.github_token:
-        issue_url = git.create_issue_for_failed_recipes(
-            git_info=override_repo_info, failed_recipes=failed_recipes
-        )
-        logging.info(f"Created GitHub issue for failed recipes: {issue_url}")
+        if args.dry_run:
+            logging.info("Dry run: skipping issue creation")
+        elif args.disable_git_commands:
+            logging.info("Skipping issue creation (disabled git commands)")
+        else:
+            if override_repo_info is None:
+                override_repo_info = get_override_repo_info(args)
+            issue_url = git.create_issue_for_failed_recipes(
+                git_info=override_repo_info, failed_recipes=failed_recipes
+            )
+            logging.info(f"Created GitHub issue for failed recipes: {issue_url}")
 
     # Optionally process reports after running recipes
     if getattr(args, "process_reports", False):
+        if args.dry_run:
+            logging.info("Dry run: skipping report processing")
+            return
+        repo_branch = ""
+        repo_url = None
+        repo_path = None
+        if override_repo_info is None and not args.disable_git_commands:
+            override_repo_info = get_override_repo_info(args)
+        if override_repo_info is not None:
+            repo_url = override_repo_info.get("override_repo_url")
+            repo_path = str(override_repo_info.get("override_repo_path"))
+            if not args.disable_git_commands:
+                repo_branch = git.get_current_branch(override_repo_info)
         rc = process_reports(
             zip_file=getattr(args, "reports_zip", None),
             extract_dir=getattr(
@@ -324,6 +412,9 @@ def main():
             out_dir=getattr(args, "reports_out_dir", "autopkg_reports_summary/summary"),
             debug=bool(getattr(args, "debug", False)),
             strict=bool(getattr(args, "reports_strict", False)),
+            repo_url=repo_url,
+            repo_branch=repo_branch,
+            repo_path=repo_path,
         )
         if rc:
             sys.exit(rc)

autopkg_wrapper/models/recipe.py

@@ -8,7 +8,7 @@ from itertools import chain
 from pathlib import Path
 
 
-class Recipe(object):
+class Recipe:
     def __init__(self, name: str, post_processors: list = None):
         self.filename = name
         self.error = False
@@ -27,6 +27,10 @@ class Recipe(object):
 
         return name
 
+    @property
+    def identifier(self):
+        return self.filename
+
     def verify_trust_info(self, args):
         verbose_output = ["-vvvv"] if args.debug else []
         prefs_file = (
@@ -40,6 +44,10 @@ class Recipe(object):
         )
         logging.debug(f"cmd: {cmd}")
 
+        if getattr(args, "dry_run", False):
+            logging.info("Dry run: would verify trust info for %s", self.identifier)
+            return self.verified
+
         result = subprocess.run(cmd, capture_output=True, text=True)
         if result.returncode == 0:
             self.verified = True
@@ -56,6 +64,10 @@ class Recipe(object):
         cmd = [autopkg_bin, "update-trust-info", self.filename] + prefs_file
         logging.debug(f"cmd: {cmd}")
 
+        if getattr(args, "dry_run", False):
+            logging.info("Dry run: would update trust info for %s", self.identifier)
+            return
+
         # Fail loudly if this exits 0
         try:
             subprocess.check_call(cmd)
@@ -79,6 +91,34 @@ class Recipe(object):
         return {"imported": imported_items, "failed": failed_items}
 
     def run(self, args):
+        if getattr(args, "dry_run", False):
+            autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
+            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 []
+            )
+            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 = report_dir / report_name
+            cmd = (
+                [autopkg_bin, "run", self.filename, "--report-plist", report]
+                + verbose_output
+                + prefs_file
+                + post_processor_cmd
+            )
+            logging.info("Dry run: would run recipe %s", self.identifier)
+            logging.debug(f"cmd: {cmd}")
+            return self
         if self.verified is False:
             self.error = True
             self.results["failed"] = True

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/args.py

@@ -94,6 +94,11 @@ def setup_args():
         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(
+        "--dry-run",
+        action="store_true",
+        help="Show planned actions without executing external commands",
+    )
 
     parser.add_argument(
         "--debug",

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

@@ -1,21 +1,24 @@
 from __future__ import annotations
 
-from typing import Iterable, Protocol, TypeVar
+from collections.abc import Iterable
+from typing import Protocol
 
 
 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(
+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)
@@ -39,3 +42,17 @@ def build_recipe_batches(
     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}")