tests for coverage and many more self tests

Author: Brian Kohan

django_typer/__init__.py

@@ -25,11 +25,12 @@
 interface is preserved and the Typer_ interface is added on top of it. This means that
 this code base is more robust to changes in the Django management command system - because
 most of the base class functionality is preserved but many Typer_ and click_ internals are
-used directly to achieve this. We rely on robust CI to catch breaking changes upstream.
+used directly to achieve this. We rely on robust CI to catch breaking changes upstream and
+keep a tight version lock on Typer.
 """
 
 # During development of django-typer_ I've wrestled with a number of encumbrances in the
-# aging django management command design. I detail them here mostly to keep track of them
+# old django management command design. I detail them here mostly to keep track of them
 # for possible future refactors of core Django.
 
 # 1) BaseCommand::execute() prints results to stdout without attempting to convert them
@@ -74,8 +75,8 @@
 # Typer.add_typer in many different contexts to achieve the nice interface we would
 # like and also because we list out each parameter for developer experience
 #
-# The other complexity comes from the fact that we enter pull in methods into the typer
-# infrastructure before classes are created so we have to do some booking to make sure
+# The other complexity comes from the fact that we pull in methods into the typer
+# infrastructure before classes are created so we have to do some bookkeeping to make sure
 # methods are bound to the right objects when called
 
 import inspect
@@ -124,11 +125,11 @@
 )
 from .utils import (
     _command_context,
+    _load_command_extensions,
     called_from_command_definition,
     called_from_module,
     get_usage_script,
     is_method,
-    _load_command_extensions,
     traceback_config,
     with_typehint,
 )
@@ -173,7 +174,7 @@
 
 
 if sys.version_info < (3, 10):
-    # todo - remove this when support for <=3.9 is dropped
+    # todo - remove this when support for <3.10 is dropped
     class static_factory(type):
         def __call__(self, *args, **kwargs):
             assert args
@@ -258,10 +259,6 @@ def handle(
     }
 
 
-class CallableCommand(t.Protocol):
-    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any: ...  # pragma: no cover
-
-
 @t.overload  # pragma: no cover
 def get_command(  # type: ignore[overload-overlap]
     command_name: str,
@@ -841,7 +838,9 @@ class Command(
                 ):
                     pass
 
-                Command.__module__ = cmd_module.__name__  # spoof it hard
+                # spoof it so hard
+                Command.__module__ = cmd_module.__name__
+                Command.__qualname__ = f"{cmd_module.__name__}.Command"
                 setattr(cmd_module, "Command", Command)
                 return Command.typer_app
             else:
@@ -901,9 +900,6 @@ def __get__(self, obj, _=None) -> "Typer[P, R]":
         return self
 
     def __getattr__(self, name: str) -> t.Any:
-        if isinstance(attr := getattr(self.__class__, name, None), property):
-            return t.cast(t.Callable, attr.fget)(self)
-
         for cmd in self.registered_commands:
             assert cmd.callback
             if name in (cmd.callback.__name__, cmd.name):
@@ -1988,8 +1984,6 @@ def get_ctor(attr: t.Any) -> t.Optional[t.Callable[..., t.Any]]:
                         assert name
                         to_remove.append(name)
                         _defined_groups[name] = attr
-                        if attr.info.name and name != attr.info.name:
-                            _defined_groups[attr.info.name] = attr
                     elif register := get_ctor(attr):
                         to_register.append(register)
 

django_typer/tests/apps/adapter0/management/adapters/adapted.py

@@ -8,7 +8,7 @@ def new_echo(self, msg1: str, msg2: str):
     """
     Echo both messages.
     """
-    assert isinstance(self, Adapted)
+    assert self.__class__ is Adapted
     self.echo(f"test_app2: {msg1} {msg2}")
 
 

django_typer/tests/apps/adapter0/management/adapters/adapted2.py

@@ -6,24 +6,24 @@
 @Adapted2.command()
 def top1(self, msg1: str, msg2: str):
     """Extend with top level command."""
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"test_app2::adapted2({self.verbosity})::top1({msg1}, {msg2})"
 
 
 @Adapted2.grp1.command()
 def grp1_adpt1(self):
     """Extend grp1 with command."""
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"test_app2::adapted2({self.verbosity})::grp1({self.argg3})::grp1_adpt1()"
 
 
 @Adapted2.grp2.group(invoke_without_command=True)
 def sub_grp2(self):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"test_app2::adapted2({self.verbosity})::grp2({self.flag1})::sub_grp2()"
 
 
 @Adapted2.subsubgroup.command()
 def ssg_cmd(self):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"test_app2::interference::grp1({self.argg3})::subgroup({self.arg5_0})::subsubgroup({self.subsubgroup_called})::ssg_cmd()"

django_typer/tests/apps/adapter0/management/adapters/native_override_init.py

@@ -1,5 +1,6 @@
 from django_typer.tests.apps.test_app.management.commands.native_override_init import (
     app,
+    Command,
 )
 from django_typer.types import Verbosity
 
@@ -8,6 +9,7 @@
 def init(self, verbosity: Verbosity = 0, bog: bool = False):
     self.verbosity = verbosity
     self.bog = bog
+    assert self.__class__ is Command
     return {"verbosity": self.verbosity, "bog": self.bog}
 
 
@@ -16,6 +18,7 @@ def grp2(self):
     """
     test_app2::grp2
     """
+    assert self.__class__ is Command
     self.grp2_called = True
 
 
@@ -24,6 +27,7 @@ def grp2_cmd1(self, g2arg1: int):
     """
     test_app2::grp2::grp2_cmd1
     """
+    assert self.__class__ is Command
     return {
         "verbosity": self.verbosity,
         "bog": self.bog,

django_typer/tests/apps/adapter1/management/adapters/adapted2.py

@@ -6,30 +6,30 @@
 @Adapted2.command()
 def top1(self, msg1: str):
     """Extend with top level command."""
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter1::adapted2({self.verbosity})::top1({msg1})"
 
 
 @Adapted2.grp1.command()
 def grp1_adpt1(self, int_arg1: int):
     """Extend grp1 with command."""
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter1::adapted2({self.verbosity})::grp1({self.argg3})::grp1_adpt1({int_arg1})"
 
 
 @Adapted2.group(invoke_without_command=True)
 def grp3(self):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter1::adapted2({self.verbosity})::grp3()"
 
 
 @Adapted2.grp2.group(invoke_without_command=True)
 def sub_grp2(self, int_arg2: int):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter1::adapted2({self.verbosity})::grp2({self.flag1})::sub_grp2({int_arg2})"
 
 
 @Adapted2.subsubgroup.command()
 def ssg_cmd(self, int_arg3: int):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter1::interference::grp1({self.argg3})::subgroup({self.arg5_0})::subsubgroup({self.subsubgroup_called})::ssg_cmd({int_arg3})"

django_typer/tests/apps/adapter2/management/adapters/adapted2.py

@@ -6,20 +6,20 @@
 @Adapted2.command()
 def top1(self):
     """Extend with top level command."""
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter2::adapted2({self.verbosity})::top1()"
 
 
 @Adapted2.grp1.command()
 def grp1_adpt1(self, int_arg1: int, int_arg1_2: int):
     """Extend grp1 with command."""
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter2::adapted2({self.verbosity})::grp1({self.argg3})::grp1_adpt1({int_arg1}, {int_arg1_2})"
 
 
 @Adapted2.grp2.group(invoke_without_command=True)
 def sub_grp2(self, int_arg2: int, int_arg2_2: int):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter2::adapted2({self.verbosity})::grp2({self.flag1})::sub_grp2({int_arg2}, {int_arg2_2})"
 
 
@@ -41,5 +41,5 @@ def subsub_grp2():
 
 @Adapted2.subsubgroup.command()
 def ssg_cmd(self, int_arg3: int, int_arg3_2: int):
-    assert isinstance(self, Adapted2)
+    assert self.__class__ is Adapted2
     return f"adapter2::interference::grp1({self.argg3})::subgroup({self.arg5_0})::subsubgroup({self.subsubgroup_called})::ssg_cmd({int_arg3}, {int_arg3_2})"

django_typer/tests/apps/test_app/management/commands/adapted.py

@@ -6,4 +6,5 @@
 
 class Command(TyperCommand):
     def handle(self, message: str):
+        assert isinstance(self, Command)
         self.echo(f"test_app: {message}")

django_typer/tests/apps/test_app/management/commands/adapted2.py

@@ -32,22 +32,27 @@ def init(
             ),
         ] = verbosity,
     ):
+        assert isinstance(self, Command)
         self.verbosity = verbosity
 
     @group()
     def grp2(self, flag1: bool = False):
         """Group 2, take a flag"""
+        assert isinstance(self, Command)
         self.flag1 = flag1
 
     @grp2.command()
     def grp2_cmd1(self, cmd1_arg: str):
+        assert isinstance(self, Command)
         return f"test_app::adapted2({self.verbosity})::grp2({self.flag1})::grp2_cmd1({cmd1_arg})"
 
     @grp2.command()
     def grp2_cmd2(self, cmd2_arg: str):
+        assert isinstance(self, Command)
         return f"test_app::adapted2({self.verbosity})::grp2({self.flag1})::grp2_cmd2({cmd2_arg})"
 
     @Interference.grp1.command()
     def grp1_ext(self):
         """Inherit/extend grp1 with a cmd"""
+        assert isinstance(self, Command)
         return f"test_app::adapted2({self.verbosity})::grp1({self.argg3})::grp1_ext()"

django_typer/tests/apps/test_app/management/commands/basic.py

@@ -6,6 +6,6 @@
 
 class Command(TyperCommand):
     def handle(self, arg1: str, arg2: str, arg3: float = 0.5, arg4: int = 1):
-        assert self.__class__ == Command
+        assert self.__class__ is Command
         opts = {"arg1": arg1, "arg2": arg2, "arg3": arg3, "arg4": arg4}
         return json.dumps(opts)

django_typer/tests/apps/test_app/management/commands/callback1.py

@@ -13,10 +13,10 @@ def init(self, p1: int, flag1: bool = False, flag2: bool = True):
         """
         The callback to initialize the command.
         """
-        assert self.__class__ == Command
+        assert self.__class__ is Command
         self.parameters = {"p1": p1, "flag1": flag1, "flag2": flag2}
 
     def handle(self, arg1: str, arg2: str, arg3: float = 0.5, arg4: int = 1):
-        assert self.__class__ == Command
+        assert self.__class__ is Command
         self.parameters.update({"arg1": arg1, "arg2": arg2, "arg3": arg3, "arg4": arg4})
         return json.dumps(self.parameters)