fix #140

Author: bckohan

django_typer/management/__init__.py

@@ -688,6 +688,10 @@ class Finalizer(t.Generic[P, R]):
     finalizer: t.Callable[P, R]
     is_method: bool
 
+    @property
+    def name(self):
+        return self.finalizer.__name__
+
     def __init__(self, finalizer: t.Callable[P, R]):
         self.finalizer = finalizer
         self.is_method = bool(is_method(finalizer))
@@ -1361,6 +1365,21 @@ def create_app(func: t.Callable[P2, R2]) -> Typer[P2, R2]:
 
         return create_app
 
+    def finalize(self):
+        """
+        Add a finalizer callback to collect the results of all commands run as part of this
+        command group. This is analogous to the ``result_callback`` on ``Typer.add_typer`` but
+        works seamlessly for methods. See :ref:`howto_finalizers` for more information.
+        """
+
+        def create_finalizer(func: t.Callable[P2, R2]) -> t.Callable[P2, R2]:
+            func = _strip_static(func)
+            # TODO not this easy: setattr(self, func.__name__, func)
+            self.info.result_callback = Finalizer(func)
+            return func
+
+        return create_finalizer
+
 
 class BoundProxy(t.Generic[P, R]):
     """
@@ -1369,7 +1388,7 @@ class BoundProxy(t.Generic[P, R]):
     """
 
     command: "TyperCommand"
-    proxied: TyperFunction
+    proxied: t.Union[TyperFunction, Finalizer]
 
     def __init__(self, command: "TyperCommand", proxied: TyperFunction):
         self.command = command
@@ -1379,6 +1398,8 @@ def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
         if isinstance(self.proxied, Typer) and not self.proxied.parent:
             # if we're calling a top level Typer app we need invoke Typer's call
             return self.proxied(*args, **kwargs)
+        elif isinstance(self.proxied, Finalizer):
+            return self.proxied(*args, _command=self.command, **kwargs)
         return _get_direct_function(self.command, self.proxied)(*args, **kwargs)
 
     def __getattr__(self, name: str) -> t.Any:
@@ -1393,6 +1414,10 @@ def __getattr__(self, name: str) -> t.Any:
             if isinstance(attr, (Typer, typer.models.CommandInfo)):
                 return BoundProxy(self.command, attr)
             return attr
+        elif isinstance(self.proxied, Typer) and isinstance(
+            self.proxied.info.result_callback, Finalizer
+        ):
+            return BoundProxy(self.command, self.proxied.info.result_callback)
 
         raise AttributeError(
             "{cls} object has no attribute {name}".format(
@@ -1548,7 +1573,36 @@ def make_initializer(func: t.Callable[P2, R2]) -> t.Callable[P2, R2]:
 
 def finalize() -> t.Callable[[t.Callable[P2, R2]], t.Callable[P2, R2]]:
     """
-    TODO
+    Attach a callback function that collects and finalizes results returned
+    from any invoked subcommands. This is a wrapper around typer's result_callback that
+    extends it to work as a method and for non-compound commands.
+
+    .. code-block:: python
+
+        class Command(TyperCommand, chain=True):
+
+            @finalize()
+            def collect(self, results: t.List[str]):
+                return ", ".join(results)
+
+            @command()
+            def cmd1(self):
+                return "result1"
+
+            @command()
+            def cmd2(self):
+                return "result2"
+
+    .. code-block:: bash
+
+        $ ./manage.py command cmd1 cmd2
+        result1, result2
+
+    The callback must at minimum accept a single argument that is either a list of
+    results or a singular result if the command is not compound. The callback may
+    optionally accept named arguments that correspond to parameters at the given
+    command group scope. These parameters will also be available on the current
+    context.
     """
 
     def make_finalizer(func: t.Callable[P2, R2]) -> t.Callable[P2, R2]:
@@ -1839,7 +1893,7 @@ def _names(tc: t.Union[typer.models.CommandInfo, Typer]) -> t.List[str]:
     """
     For a command or group, get a list of attribute name and its CLI name.
 
-    This annoyingly lives in difference places depending on how the command
+    This annoyingly lives in different places depending on how the command
     or group was defined. This logic is sensitive to typer internals.
     """
     names = []
@@ -1858,7 +1912,7 @@ def _names(tc: t.Union[typer.models.CommandInfo, Typer]) -> t.List[str]:
 
 def _bfs_match(
     app: Typer, name: str
-) -> t.Optional[t.Union[typer.models.CommandInfo, Typer]]:
+) -> t.Optional[t.Union[typer.models.CommandInfo, Typer, Finalizer]]:
     """
     Perform a breadth first search for a command or group by name.
 
@@ -1869,12 +1923,18 @@ def _bfs_match(
 
     def find_at_level(
         lvl: Typer,
-    ) -> t.Optional[t.Union[typer.models.CommandInfo, Typer]]:
+    ) -> t.Optional[t.Union[typer.models.CommandInfo, Typer, Finalizer]]:
         for cmd in reversed(lvl.registered_commands):
             if name in _names(cmd):
                 return cmd
         if name in _names(lvl):
             return lvl
+
+        if (
+            isinstance(lvl.info.result_callback, Finalizer)
+            and lvl.info.result_callback.name == name
+        ):
+            return lvl.info.result_callback
         return None
 
     # fast exit out if at top level (most searches - avoid building BFS)
@@ -2191,7 +2251,7 @@ def __init__(self, cls_name, bases, attrs, **kwargs):
     def __getattr__(cls, name: str) -> t.Any:
         """
         Fall back breadth first search of the typer app tree to resolve attribute accesses of the type:
-            Command.sub_grp or Command.sub_cmd
+            Command.sub_grp or Command.sub_cmd or Command.finalizer
         """
         if name != "typer_app":
             if called_from_command_definition():
@@ -2740,6 +2800,33 @@ def make_initializer(func: t.Callable[P, R]) -> t.Callable[P, R]:
 
     callback = initialize
 
+    @classmethod
+    def finalize(cls) -> t.Callable[[t.Callable[P2, R2]], t.Callable[P2, R2]]:
+        """
+        Override the finalizer for this command class after it has been defined.
+
+        .. note::
+            See :ref:`plugins` for details on when you might want to use this extension
+            pattern.
+
+        .. code-block:: python
+
+            from your_app.management.commands.your_command import Command as YourCommand
+
+            @YourCommand.finalize()
+            def collect(self, ...):
+                # implement your command result collection logic here
+        """
+        if called_from_command_definition():
+            return finalize()
+
+        def make_finalizer(func: t.Callable[P2, R2]) -> t.Callable[P2, R2]:
+            setattr(cls, func.__name__, func)
+            cls.typer_app.info.result_callback = Finalizer(_strip_static(func))
+            return func
+
+        return make_finalizer
+
     @classmethod
     def command(
         cmd,  # pyright: ignore[reportSelfClsParameterName]

django_typer/patch.py

@@ -52,7 +52,7 @@ def apply() -> None:
         # are not attached to ttys. Upstream Django should change the init
         # call to a just_fix_windows_console - we undo this and redo the right
         # thing here.
-        import colorama
+        import colorama  # pyright: ignore[reportMissingModuleSource]
 
         colorama.deinit()
         colorama.just_fix_windows_console()

doc/source/howto.rst

@@ -262,6 +262,16 @@ decorator. This is like defining a group at the command root and is an extension
     command.init(False)
     assert not command.subcommand2()
 
+
+.. _howto_finalizer:
+
+Collect and Finalize Results
+----------------------------
+
+.. TODO::
+
+    This section is not yet implemented.
+
 Call Commands from Code
 -----------------------
 

tests/apps/test_app/management/commands/finalize_multi_named_param.py

@@ -3,20 +3,36 @@
 
 
 class Command(TyperCommand, chain=True):
+    suppressed_base_arguments = {
+        "verbosity",
+        "skip_checks",
+        "version",
+        "settings",
+        "pythonpath",
+    }
+
     @finalize()
-    def final(self, result, **kwargs):
+    def final(self, result, force_color=None, no_color=None, traceback=None):
         assert isinstance(self, Command)
-        click_params = getattr(get_current_context(silent=True), "params", {})
-        assert len(kwargs) == len(click_params)
-        for key, value in kwargs.items():
-            assert key in click_params
-            assert click_params[key] == value
-        return "finalized: {}".format(result)
+        try:
+            click_params = getattr(get_current_context(silent=False), "params", {})
+            assert "force_color" in click_params
+            assert click_params["force_color"] == force_color
+            assert "no_color" in click_params
+            assert click_params["no_color"] == no_color
+            assert "traceback" in click_params
+            assert click_params["traceback"] == traceback
+        except Exception:
+            pass
+        return "finalized: {} | {}".format(
+            result,
+            {"force_color": force_color, "no_color": no_color, "traceback": traceback},
+        )
 
     @command()
-    def cmd1(self):
-        return "cmd1"
+    def cmd1(self, arg1: int = 1):
+        return "cmd1 {}".format(arg1)
 
     @command()
-    def cmd2(self):
-        return "cmd2"
+    def cmd2(self, arg2: int):
+        return "cmd2 {}".format(arg2)

tests/apps/test_app/management/commands/finalize_multi_no_params.py

@@ -9,9 +9,9 @@ def final(self, result):
         return "finalized: {}".format(result)
 
     @command()
-    def cmd1(self):
-        return "cmd1"
+    def cmd1(self, arg1: int = 1):
+        return "cmd1 {}".format(arg1)
 
     @command()
-    def cmd2(self):
-        return "cmd2"
+    def cmd2(self, arg2: int):
+        return "cmd2 {}".format(arg2)

tests/apps/test_app/management/commands/finalize_override.py

@@ -0,0 +1,9 @@
+from .finalize_simple import Command as FinalizeSimple
+
+
+class Command(FinalizeSimple):
+    @FinalizeSimple.finalize()
+    def collect(self, result, **_):
+        assert isinstance(self, Command)
+        assert result == "handle"
+        return "collect: {}".format(result)

tests/apps/test_app/management/commands/finalize_override_inherit.py

@@ -0,0 +1,5 @@
+from .finalize_simple import Command as FinalizeSimple
+
+
+class Command(FinalizeSimple):
+    pass

tests/apps/test_app/management/commands/finalize5.py renamed to tests/apps/test_app/management/commands/finalize_simple.py

@@ -0,0 +1,12 @@
+from django_typer.management import TyperCommand, finalize
+
+
+class Command(TyperCommand):
+    @finalize()
+    @staticmethod
+    def final(result, traceback: bool = False):
+        assert result == "handle"
+        return f"finalized: {result} | traceback={traceback}"
+
+    def handle(self):
+        return "handle"