WIP

Author: ThomasWaldmann

src/borg/archiver/__init__.py

@@ -221,6 +221,9 @@ def __init__(self, define_common_options, suffix_precedence):
             # This is the sentinel object that replaces all default values in parsers
             # below the top-level parser.
             self.default_sentinel = object()
+            # Maps dest names to their type functions, for options where type= was
+            # stripped from sub-parsers to avoid jsonargparse validation of sentinel defaults.
+            self.type_functions = dict()
 
         def add_common_group(self, parser, suffix, provide_defaults=False):
             """
@@ -238,9 +241,9 @@ def add_common_group(self, parser, suffix, provide_defaults=False):
 
             def add_argument(*args, **kwargs):
                 if "dest" in kwargs:
-                    kwargs.setdefault("action", "store")
-                    assert kwargs["action"] in ("help", "store_const", "store_true", "store_false", "store", "append")
-                    is_append = kwargs["action"] == "append"
+                    action = kwargs.get("action", "store")
+                    assert action in ("help", "store_const", "store_true", "store_false", "store", "append")
+                    is_append = action == "append"
                     if is_append:
                         self.append_options.add(kwargs["dest"])
                         assert (
@@ -258,6 +261,11 @@ def add_argument(*args, **kwargs):
                         kwargs["help"] = kwargs["help"] % kwargs
                         if not is_append:
                             kwargs["default"] = self.default_sentinel
+                            # Remove type= so jsonargparse won't validate the sentinel default.
+                            # Store the type function for manual conversion in resolve().
+                            type_fn = kwargs.pop("type", None)
+                            if type_fn is not None:
+                                self.type_functions[kwargs["dest"]] = type_fn
 
                 common_group.add_argument(*args, **kwargs)
 
@@ -286,6 +294,10 @@ def resolve(self, args: argparse.Namespace):  # Namespace has "in" but otherwise
                         # value was indeed specified on this level. Transfer value to target,
                         # and un-clobber the args (for tidiness - you *cannot* use the suffixed
                         # names for other purposes, obviously).
+                        # Apply type conversion if type= was stripped from this sub-parser.
+                        type_fn = self.type_functions.get(map_from)
+                        if type_fn is not None and isinstance(value, str):
+                            value = type_fn(value)
                         setattr(args, map_to, value)
                     try:
                         delattr(args, map_from)

src/borg/archiver/_common.py

@@ -17,10 +17,10 @@
 from ..repository import Repository
 from ..repoobj import RepoObj, RepoObj1
 from ..patterns import (
+    ArgparseExcludePatternAction,
     ArgparsePatternAction,
     ArgparseExcludeFileAction,
     ArgparsePatternFileAction,
-    parse_exclude_pattern,
 )
 
 
@@ -272,8 +272,7 @@ def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components
         "--exclude",
         metavar="PATTERN",
         dest="patterns",
-        type=parse_exclude_pattern,
-        action="append",
+        action=ArgparseExcludePatternAction,
         help="exclude paths matching PATTERN",
     )
     add_option(
@@ -304,7 +303,6 @@ def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components
             metavar="NAME",
             dest="exclude_if_present",
             action="append",
-            type=str,
             help="exclude directories that are tagged by containing a filesystem object with the given NAME",
         )
         add_option(

src/borg/helpers/jap_wrapper.py

@@ -3,14 +3,7 @@
 This module provides a compatibility layer between Borg's argparse patterns
 and jsonargparse's API. Key adaptations:
 
-1. type+action combination: jsonargparse forbids combining type= and action=
-   in add_argument(). Our override strips type= from kwargs and ensures
-   type conversion happens within the action itself:
-   - Highlander action class: handles type via _type_fn (pops type in __init__)
-   - Standard actions (append, store, etc.): wrapped in TypeConvertingAction
-   - Custom action classes: type is popped and stored on the action after creation
-
-2. Namespace flattening: jsonargparse creates nested namespaces for subcommands
+1. Namespace flattening: jsonargparse creates nested namespaces for subcommands
    (args.create.name instead of args.name). flatten_namespace() merges these
    into a flat namespace compatible with Borg's command handlers.
 """
@@ -21,78 +14,13 @@
 from jsonargparse._core import ArgumentGroup as _JAPArgumentGroup
 
 
-def _make_type_converting_action(base_action_name, type_fn):
-    """Create a custom action class that wraps a standard action and applies type conversion.
-
-    This is used for standard string actions (e.g. 'append', 'store') when combined with type=.
-    jsonargparse forbids type+action, so we strip type= and wrap the action to do conversion.
-    """
-    # Map action name to argparse's built-in action class
-    _action_map = {"append": argparse._AppendAction, "store": argparse._StoreAction}
-
-    base_cls = _action_map.get(base_action_name)
-    if base_cls is None:
-        # Unknown action string - can't wrap it
-        return None
-
-    class TypeConvertingAction(base_cls):
-        def __call__(self, parser, namespace, values, option_string=None):
-            if type_fn is not None and isinstance(values, str):
-                try:
-                    values = type_fn(values)
-                except argparse.ArgumentTypeError as e:
-                    raise argparse.ArgumentError(self, str(e))
-            super().__call__(parser, namespace, values, option_string)
-
-    TypeConvertingAction.__name__ = f"TypeConverting{base_action_name.title()}Action"
-    return TypeConvertingAction
-
-
-class BorgAddArgumentMixin:
-    """Mixin to provide Borg's add_argument logic to ArgumentParser and ArgumentGroup."""
-
-    def add_argument(self, *args, **kwargs):
-        """Handle type+action combination that jsonargparse forbids.
-
-        jsonargparse raises ValueError when both type= and action= are given.
-        We strip type= from kwargs and ensure the action handles type conversion:
-        - Standard string actions: wrapped in TypeConvertingAction
-        - Other custom actions: type stored as _type_fn on action instance
-        """
-        action = kwargs.get("action")
-        if action is not None and "type" in kwargs:
-            type_fn = kwargs.pop("type")
-
-            if isinstance(action, str):
-                # Standard action string like 'append', 'store'
-                wrapper = _make_type_converting_action(action, type_fn)
-                if wrapper is not None:
-                    kwargs["action"] = wrapper
-                    return super().add_argument(*args, **kwargs)
-                else:
-                    # Unknown standard action, put type back and try anyway
-                    kwargs["type"] = type_fn
-
-            elif isinstance(action, type) and issubclass(action, argparse.Action):
-                # Custom action class - register without type, then patch the action
-                result = super().add_argument(*args, **kwargs)
-                # Store type_fn on the action for potential manual use
-                if hasattr(result, "_type_fn"):
-                    pass  # already handled
-                else:
-                    result._type_fn = type_fn
-                return result
-
-        return super().add_argument(*args, **kwargs)
-
-
-class ArgumentGroup(BorgAddArgumentMixin, _JAPArgumentGroup):
-    """ArgumentGroup that supports Borg's add_argument patterns."""
+class ArgumentGroup(_JAPArgumentGroup):
+    """ArgumentGroup for Borg."""
 
     pass
 
 
-class ArgumentParser(BorgAddArgumentMixin, _JAPArgumentParser):
+class ArgumentParser(_JAPArgumentParser):
     """ArgumentParser bridging Borg's argparse patterns with jsonargparse."""
 
     def __init__(self, *args, **kwargs):

src/borg/patterns.py

@@ -75,6 +75,15 @@ def parse(self, fobj, args):
         load_pattern_file(fobj, ArgparsePatternFileAction.roots_from_patterns, args.patterns)
 
 
+class ArgparseExcludePatternAction(argparse.Action):
+    """Action for --exclude that parses and appends an exclude pattern."""
+
+    def __call__(self, parser, args, values, option_string=None):
+        if args.patterns is None:
+            args.patterns = []
+        args.patterns.append(parse_exclude_pattern(values))
+
+
 class ArgparseExcludeFileAction(ArgparsePatternFileAction):
     def parse(self, fobj, args):
         # jsonargparse may initialize list-like attributes to None instead of []