Fix method resolution order of defaults for to_tap_class

Author: martinjm97

README.md

@@ -874,7 +874,7 @@ special argument behavior. For example, you can override [`configure`](#configur
 [`process_args`](#argument-processing).
 
 If the object can be `tapify`d, then it can be `to_tap_class`d, and vice-versa. `to_tap_class` provides full control
-over argument parsing.
+over argument parsing. Just as in `tapify`, the data extracted from standard Python classes (not `pydantic` models or `dataclass`es) only comes from the `__init__`, not from class variables.
 
 ### `to_tap_class` examples
 

src/tap/tapify.py

@@ -281,13 +281,14 @@ class ArgParser(Tap):
         def _configure(self):
             for arg_data in args_data:
                 variable = arg_data.name
-                self._annotations[variable] = str if arg_data.annotation is Any else arg_data.annotation
-                self.class_variables[variable] = {"comment": arg_data.description or ""}
-                if arg_data.is_required:
-                    kwargs = {}
-                else:
-                    kwargs = dict(required=False, default=arg_data.default)
-                self.add_argument(f"--{variable}", **kwargs)
+                if variable not in self.class_variables:
+                    self._annotations[variable] = str if arg_data.annotation is Any else arg_data.annotation
+                    self.class_variables[variable] = {"comment": arg_data.description or ""}
+                    if arg_data.is_required:
+                        kwargs = {}
+                    else:
+                        kwargs = dict(required=False, default = arg_data.default)
+                    self.add_argument(f"--{variable}", **kwargs)
 
             super()._configure()
 

tests/test_to_tap_class.py

@@ -547,3 +547,127 @@ def test_subclasser_subparser_help_message(
     _test_subclasser_message(
         subclasser_subparser, class_or_function_, expected_message, description=description, args_string=args_string
     )
+
+class TestMethodResolutionOrder:
+    @staticmethod
+    def _assert_all_two(class_or_function: Any) -> None:
+        class ParserClass(to_tap_class(class_or_function)):
+            a: int = 2
+
+        assert ParserClass.a == ParserClass().a == ParserClass().parse_args([]).a == 2
+
+    def test_function(self):
+        def foo(a: int = 0):
+            ...
+
+        self._assert_all_two(foo)
+
+    def test_plain_class(self):
+        class Foo:
+            def __init__(self, a: int = 0):
+                self.a = a
+
+        self._assert_all_two(Foo)
+
+    def test_pydantic_model(self):
+        class Foo(pydantic.BaseModel):
+            a: int = 0
+
+        self._assert_all_two(Foo)
+
+    def test_dataclass(self):
+        @dataclasses.dataclass
+        class Foo:
+            a: int = 0
+
+        self._assert_all_two(Foo)
+
+    def test_configure_in_leaf(self):
+        def foo(a: int = 0):
+            ...
+
+        class Leaf(to_tap_class(foo)):
+            a: int = 2
+
+            def configure(self) -> None:
+                # Add an extra argument to validate that leaf.configure runs after _configure in foo
+                self.add_argument("--a", default=3)
+
+        assert Leaf.a == Leaf().a == 2
+        assert Leaf().parse_args([]).a == 3
+
+    def test_class_to_tap_class_thats_subclassed(self):
+        class Parent:
+            def __init__(self, a: int = 0):
+                self.a = a
+
+        class TapChild(to_tap_class(Parent)):
+            a: int = 1
+
+        class TapGrandchild(TapChild):
+            a: int = 2
+
+        assert TapChild.a == TapChild().a == TapChild().parse_args([]).a == 1
+        assert TapGrandchild.a == TapGrandchild().a == TapGrandchild().parse_args([]).a == 2
+
+    def test_class_subclass_to_tap_class(self):
+        class Parent:
+            def __init__(self, a: int = 0):
+                self.a = a
+
+        class TapChild(Parent):
+            a: int = 1
+
+        class TapGrandchild(to_tap_class(TapChild)):
+            a: int = 2
+
+        assert TapGrandchild.a == TapGrandchild().a == TapGrandchild().parse_args([]).a == 2
+
+    def test_inheritance(self):
+        class Parent:
+            def __init__(self, a: int = 0, b: int = 5):
+                self.a = a
+                self.b = b
+
+        class TapChild(Parent):
+            def __init__(self, a: int = 0, b: int = 5, c: int = 3):
+                super().__init__(a=a, b=b)
+                self.c = c
+
+        class TapGrandchild(to_tap_class(TapChild)):
+            a: int = 2
+
+        assert TapGrandchild.a == TapGrandchild().a == TapGrandchild().parse_args([]).a == 2
+        assert TapGrandchild().parse_args([]).b == 5
+        assert TapGrandchild().parse_args([]).c == 3
+
+    def test_defaults_and_required(self):
+        class Parent:
+            def __init__(self, a: int, e: int, b: int = 5):
+                self.a = a
+                self.b = b
+                self.e = e
+
+        class TapChild(Parent):
+            def __init__(self, b: int, a: int = 0, c: int = 3):
+                super().__init__(a=a, b=b, e=6)
+                self.c = c
+
+        class TapGrandchild(to_tap_class(TapChild)):
+            a: int = 2
+            d: int
+
+        args = ["--b", "6", "--c", "5", "--d", "4"]
+        assert TapGrandchild.a == TapGrandchild().a == TapGrandchild().parse_args(args).a == 2
+        assert TapGrandchild().parse_args(args).b == 6
+        assert TapGrandchild().parse_args(args).c == 5
+        assert TapGrandchild().parse_args(args).d == 4
+        with pytest.raises(AttributeError):
+            TapGrandchild().parse_args(args).e
+
+        args = ["--b", "6"]
+        with pytest.raises(SystemExit):
+            TapGrandchild().parse_args(args)
+        args = ["--d", "4"]
+        with pytest.raises(SystemExit):
+            TapGrandchild().parse_args(args)