Merge pull request #175 from Daraan/ignore-tapify

TapIgnore for to_tap_class / tapify

Author: martinjm97

README.md

@@ -399,16 +399,14 @@ args = MyTap().parse_args(["--help"])
 ```
 
 ```txt
-usage: ipython --package PACKAGE [--stars STARS] [-h]
+usage: main.py --package PACKAGE [--stars STARS] [-h]
 
 options:
   --package PACKAGE  (str, required)
   --stars STARS      (int, default=5)
   -h, --help         show this help message and exit
 ```
 
-Note: this is currently only for `Tap` objects, not `tapify`.
-
 ### Argument processing
 
 With complex argument parsing, arguments often end up having interdependencies. This means that it may be necessary to disallow certain combinations of arguments or to modify some arguments based on other arguments.

src/tap/tapify.py

@@ -304,6 +304,8 @@ def _configure(self):
                             annotation.__metadata__ = (*annotation.__metadata__, *arg_data.pydantic_metadata)
                     self._annotations_with_extras[variable] = annotation
                     self._annotations[variable] = _remove_extras_from_annotation(annotation)
+                    if self._is_ignored_argument(variable):
+                        continue
                     self.class_variables[variable] = {"comment": arg_data.description or ""}
                     if arg_data.is_required:
                         kwargs = {}
@@ -371,13 +373,15 @@ def tapify(
         raise ValueError(f"Unknown keyword arguments: {func_kwargs}")
 
     # Parse command line arguments
-    command_line_args: Tap = tap.parse_args(args=command_line_args, known_only=known_only)
+    parsed_command_line_args: Tap = tap.parse_args(args=command_line_args, known_only=known_only)
 
     # Prepare command line arguments for class_or_function, respecting positional-only args
     class_or_function_args: list[Any] = []
     class_or_function_kwargs: dict[str, Any] = {}
-    command_line_args_dict = command_line_args.as_dict()
+    command_line_args_dict = parsed_command_line_args.as_dict()
     for arg_data in tap_data.args_data:
+        if tap._is_ignored_argument(arg_data.name):
+            continue
         arg_value = command_line_args_dict[arg_data.name]
         if arg_data.is_positional_only:
             class_or_function_args.append(arg_value)

tests/test_tap_ignore.py

@@ -1,7 +1,16 @@
 import sys
 import unittest
 from typing import Annotated
-from tap import Tap, TapIgnore
+from tap import Tap, TapIgnore, tapify
+from dataclasses import dataclass
+
+
+try:
+    import pydantic
+except ModuleNotFoundError:
+    _IS_PYDANTIC_V1 = None
+else:
+    _IS_PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 
 
 # Suppress prints from SystemExit
@@ -262,6 +271,68 @@ def configure(self):
         args = Args().parse_args(["--a", "1"])
         self.assertEqual(args.b, 3)
 
+    def test_tapify_function_with_tap_ignore(self):
+        """Test that tapify handles TapIgnore annotations on function arguments."""
+
+        def my_func(a: int, b: TapIgnore[int] = 2, c: str = "hello") -> str:
+            return f"{a} {b} {c}"
+
+        # b is ignored, so it shouldn't be parsed from CLI - should use default
+        output = tapify(my_func, command_line_args=["--a", "1", "--c", "world"])
+        self.assertEqual(output, "1 2 world")
+
+        # Passing --b should fail because it's not a recognized argument
+        with self.assertRaises(SystemExit):
+            tapify(my_func, command_line_args=["--a", "1", "--b", "99", "--c", "world"])
+
+    def test_tapify_function_with_tap_ignore_known_only(self):
+        """Test tapify with TapIgnore and known_only=True."""
+
+        def my_func(a: int, b: TapIgnore[int] = 2, c: str = "hello") -> str:
+            return f"{a} {b} {c}"
+
+        # With known_only=True, --b should be ignored (not cause an error)
+        output = tapify(
+            my_func,
+            command_line_args=["--a", "1", "--b", "99", "--c", "world"],
+            known_only=True
+        )
+        # b should still be 2 (the default), not 99
+        self.assertEqual(output, "1 2 world")
+
+    def test_tapify_class_with_tap_ignore(self):
+        """Test that tapify handles TapIgnore annotations on class __init__ arguments."""
+
+        class MyClass:
+            def __init__(self, a: int, b: TapIgnore[int] = 2, c: str = "hello"):
+                self.result = f"{a} {b} {c}"
+
+        # Passing --b should fail because it's not a recognized argument
+        with self.assertRaises(SystemExit):
+            tapify(MyClass, command_line_args=["--a", "1", "--b", "99", "--c", "world"])
+
+        # test with known_only
+        myclass = tapify(MyClass, known_only=True, command_line_args=["--a", "1", "--b", "99", "--c", "world"])
+        # b should still be 2 (the default), not 99
+        self.assertEqual(myclass.result, "1 2 world")
+
+    def test_tapify_ignore_dataclass(self):
+        @dataclass
+        class DataclassConfig:
+            x: int
+            y: TapIgnore[str] = "ignore_me"
+
+        class PydanticModel(pydantic.BaseModel):
+            x: int
+            y: TapIgnore[str] = "ignore_me"
+
+        for struct_cls in (DataclassConfig, PydanticModel):
+            with self.subTest(struct_cls=struct_cls.__name__):
+                model = tapify(struct_cls, command_line_args=["--x", "20"])
+                self.assertEqual(model.x, 20)
+                self.assertEqual(model.y, "ignore_me")
+                with self.assertRaises(SystemExit):
+                    tapify(struct_cls, command_line_args=["--x", "10", "--y", "should_fail"])
 
 if __name__ == "__main__":
     unittest.main()