bundlewrap 5.1.0__tar.gz → 5.2.0__tar.gz

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 5.2.0
+
+2026-10-07
+
+* added `$BW_LOCK_ADD_SKIP_ITEM_VERIFICATION`: This sets a default for the `--skip-item-verification` option of `bw lock`
+* `bw verify` will skip items when Faults are unavailable (instead of showing long stack traces), now matches the behavior of `bw apply`
+* added `pre_purge_command` to `directory` items
+* fixed `repo.nodes_matching()`: No longer swallows errors and now raises `NoSuchTarget` as documented
+
 # 5.1.0
 
 2026-06-18

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bundlewrap
-Version: 5.1.0
+Version: 5.2.0
 Summary: Config management with Python
 Home-page: http://bundlewrap.org
 Author: Torsten Rehn

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/bundlewrap/__init__.py

@@ -1,2 +1,2 @@
-VERSION = (5, 1, 0)
+VERSION = (5, 2, 0)
 VERSION_STRING = ".".join([str(v) for v in VERSION])

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/bundlewrap/cmdline/parser.py

@@ -1,4 +1,5 @@
-from argparse import ArgumentParser, RawTextHelpFormatter, SUPPRESS
+from argparse import (ArgumentParser, BooleanOptionalAction,
+                      RawTextHelpFormatter, SUPPRESS)
 from os import environ, getcwd
 from os.path import join
 
@@ -581,7 +582,8 @@ bundle:my_bundle  # items in this bundle
     )
     parser_lock_add.add_argument(
         "--skip-item-verification",
-        action='store_true',
+        action=BooleanOptionalAction,
+        default=bool(int(environ.get('BW_LOCK_ADD_SKIP_ITEM_VERIFICATION', 0))),
         dest='skip_item_verification',
         help=_("disable verification of item selector (-i)"),
     )

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/bundlewrap/items/directories.py

@@ -49,6 +49,7 @@ class Directory(Item):
         'mode': "0755",
         'owner': "root",
         'purge': False,
+        'pre_purge_command': None,
     }
     ITEM_TYPE_NAME = "directory"
 
@@ -98,6 +99,11 @@ class Directory(Item):
             return
 
         for path in status.actual_state.get('paths_to_purge', set()):
+            if self.attributes['pre_purge_command']:
+                self.run(self.attributes['pre_purge_command'].format(
+                    path=quote(path),
+                    file=quote(path.split('/')[-1]),
+                ))
             self.run("rm -rf -- {}".format(quote(path)))
 
         for fix_type in ('mode', 'owner', 'group'):
@@ -280,6 +286,14 @@ class Directory(Item):
         for key, value in attributes.items():
             ATTRIBUTE_VALIDATORS[key](item_id, value)
 
+        if attributes.get('pre_purge_command') and not attributes.get('purge'):
+            raise BundleError(_(
+                "{b}  {i}  cannot use pre_purge_command if not purging"
+            ).format(
+                n=bundle.name,
+                i=item_id,
+            ))
+
     @classmethod
     def validate_name(cls, bundle, name):
         if normpath(name) != name:

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/bundlewrap/node.py

@@ -13,6 +13,7 @@ from .concurrency import WorkerPool
 from .deps import find_item, ItemDependencyLoop
 from .exceptions import (
     BundleError,
+    FaultUnavailable,
     GracefulApplyException,
     ItemSkipped,
     NodeLockedException,
@@ -1145,38 +1146,44 @@ def verify_items(
         return bool(items)
 
     def next_task():
-        while True:
-            try:
-                item = items.pop()
-            except IndexError:
-                return None
-            if item._faults_missing_for_attributes:
-                if item.error_on_missing_fault:
-                    item._raise_for_faults()
-                else:
-                    io.progress_advance()
-                    io.stdout(_("{x} {node}  {bundle}  {item}  ({msg})").format(
-                        bundle=bold(item.bundle.name),
-                        item=item.id,
-                        msg=yellow(_("Fault unavailable")),
-                        node=bold(node.name),
-                        x=yellow("»"),
-                    ))
-            else:
-                return {
-                    'task_id': node.name + ":" + item.bundle.name + ":" + item.id,
-                    'target': item.verify,
-                    'kwargs': {
-                        'autoskip_selector': autoskip_selector,
-                        'autoonly_selector': autoonly_selector,
-                    },
-                }
+        try:
+            item = items.pop()
+        except IndexError:
+            return None
+        return {
+            'task_id': node.name + ":" + item.bundle.name + ":" + item.id,
+            'target': item.verify,
+            'kwargs': {
+                'autoskip_selector': autoskip_selector,
+                'autoonly_selector': autoonly_selector,
+            },
+        }
 
     def handle_exception(task_id, exception, traceback):
         node_name, bundle_name, item_id = task_id.split(":", 2)
         io.progress_advance()
         if isinstance(exception, (ItemSkipped, NotImplementedError)):
             pass
+        elif isinstance(exception, FaultUnavailable):
+            item = node.get_item(item_id)
+            if item.error_on_missing_fault:
+                io.stderr(_("{x} {node}  {bundle}  {item}  ({msg})").format(
+                    bundle=bold(bundle_name),
+                    item=item_id,
+                    msg=red(_("Fault unavailable")),
+                    node=bold(node_name),
+                    x=red("!"),
+                ))
+                return False
+            else:
+                io.stdout(_("{x} {node}  {bundle}  {item}  ({msg})").format(
+                    bundle=bold(bundle_name),
+                    item=item_id,
+                    msg=yellow(_("Fault unavailable")),
+                    node=bold(node_name),
+                    x=yellow("»"),
+                ))
+                return None
         else:
             # Unlike with `bw apply`, it is OK for `bw verify` to encounter
             # exceptions when getting an item's status. `bw verify` doesn't

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/bundlewrap/repo.py

@@ -696,28 +696,35 @@ class Repository(MetadataGenerator):
         targets = set()
         for name in target_strings:
             name = name.strip()
+            targets_for_name = set()
             if name.startswith("bundle:"):
                 bundle_name = name.split(":", 1)[1]
-                targets.update(self.nodes_with_bundle(bundle_name))
+                targets_for_name.update(self.nodes_with_bundle(bundle_name))
             elif name.startswith("!bundle:"):
                 bundle_name = name.split(":", 1)[1]
-                targets.update(self.nodes_without_bundle(bundle_name))
+                targets_for_name.update(self.nodes_without_bundle(bundle_name))
             elif name.startswith("!group:"):
                 group_name = name.split(":", 1)[1]
-                targets.update(self.nodes_not_in_group(group_name))
+                targets_for_name.update(self.nodes_not_in_group(group_name))
             elif name.startswith("lambda:"):
                 lambda_str = name.split(":", 1)[1]
-                targets.update(self.nodes_matching_lambda(lambda_str, lambda_workers))
+                targets_for_name.update(self.nodes_matching_lambda(lambda_str, lambda_workers))
             else:
                 try:
-                    targets.add(self.get_node(name))
+                    targets_for_name.add(self.get_node(name))
                 except NoSuchNode:
                     try:
                         group = self.get_group(name)
-                        targets.update(group.nodes)
+                        targets_for_name.update(group.nodes)
                     except NoSuchGroup:
                         raise NoSuchTarget(name)
 
+            # Puplic API docs demand this.
+            if not targets_for_name:
+                raise NoSuchTarget(name)
+
+            targets |= targets_for_name
+
         return list(targets)
 
     def metadata_hash(self):

bundlewrap-5.2.0/bundlewrap/utils/node_lambda.py

@@ -0,0 +1,34 @@
+from bundlewrap.concurrency import WorkerPool
+
+
+def parallel_node_eval(
+    nodes,
+    expression,
+    workers,
+):
+    nodes = set(nodes)
+
+    def tasks_available():
+        return bool(nodes)
+
+    def next_task():
+        node = nodes.pop()
+
+        def get_values():
+            return eval("lambda node: " + expression)(node)
+
+        return {
+            'task_id': node.name,
+            'target': get_values,
+        }
+
+    def handle_result(task_id, result, _duration):
+        return task_id, result
+
+    worker_pool = WorkerPool(
+        tasks_available,
+        next_task,
+        handle_result=handle_result,
+        workers=workers,
+    )
+    return dict(worker_pool.run())

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/bundlewrap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bundlewrap
-Version: 5.1.0
+Version: 5.2.0
 Summary: Config management with Python
 Home-page: http://bundlewrap.org
 Author: Torsten Rehn

{bundlewrap-5.1.0 → bundlewrap-5.2.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="bundlewrap",
-    version="5.1.0",
+    version="5.2.0",
     description="Config management with Python",
     long_description=(
         "By allowing for easy and low-overhead config management, BundleWrap fills the gap between complex deployments using Chef or Puppet and old school system administration over SSH.\n"

bundlewrap-5.1.0/bundlewrap/utils/node_lambda.py

@@ -1,55 +0,0 @@
-from traceback import format_exc
-
-from bundlewrap.concurrency import WorkerPool
-from bundlewrap.exceptions import RepositoryError
-from bundlewrap.utils.text import red, bold, prefix_lines, _
-from bundlewrap.utils.ui import io
-
-
-def parallel_node_eval(
-    nodes,
-    expression,
-    workers,
-):
-    nodes = set(nodes)
-
-    def tasks_available():
-        return bool(nodes)
-
-    def next_task():
-        node = nodes.pop()
-
-        def get_values():
-            try:
-                return eval("lambda node: " + expression)(node)
-            except RepositoryError:
-                raise
-            except Exception:
-                traceback = format_exc()
-                io.stderr(_(
-                    "{x}  {node}  Exception while evaluating `{expression}`, returning as None:\n{traceback}"
-                ).format(
-                    x=red("✘"),
-                    node=bold(node),
-                    expression=expression,
-                    traceback=prefix_lines("\n" + traceback, f"{red('│')} ") + red("╵"),
-                ))
-                # Returning None here is kinda meh. But it's the only alternative
-                # to failing hard by re-raising, which would be very annoying.
-                return None
-
-        return {
-            'task_id': node.name,
-            'target': get_values,
-        }
-
-    def handle_result(task_id, result, _duration):
-        return task_id, result
-
-    worker_pool = WorkerPool(
-        tasks_available,
-        next_task,
-        handle_result=handle_result,
-        workers=workers,
-    )
-    return dict(worker_pool.run())