Merge pull request #10 from ButterflyNetwork/support-wrappers

Support multi-layer wrapped functions.

Author: espdev

click_option_group/_core.py

@@ -12,6 +12,7 @@
     get_callback_and_params,
     get_fake_option_name,
     raise_mixing_decorators_error,
+    resolve_wrappers
 )
 
 
@@ -182,7 +183,7 @@ def decorator(func):
     def get_options(self, ctx: click.Context) -> ty.Dict[str, GroupedOption]:
         """Returns the dictionary with group options
         """
-        return self._options.get(ctx.command.callback, {})
+        return self._options.get(resolve_wrappers(ctx.command.callback), {})
 
     def get_option_names(self, ctx: click.Context) -> ty.List[str]:
         """Returns the list with option names ordered by addition in the group

click_option_group/_helpers.py

@@ -23,6 +23,7 @@ def get_callback_and_params(func) -> ty.Tuple[abc.Callable, ty.List[click.Option
     else:
         params = getattr(func, '__click_params__', [])
 
+    func = resolve_wrappers(func)
     return func, params
 
 
@@ -37,3 +38,8 @@ def raise_mixing_decorators_error(wrong_option: click.Option, callback: abc.Call
         "Grouped options must not be mixed with regular parameters while adding by decorator. "
         f"Check decorator position for {error_hint} option in '{callback.__name__}'."
     ))
+
+
+def resolve_wrappers(f):
+    """Get the underlying function behind any level of function wrappers."""
+    return resolve_wrappers(f.__wrapped__) if hasattr(f, "__wrapped__") else f

tests/test_click_option_group.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+from functools import wraps
+
 import pytest
 import click
 
@@ -695,3 +697,55 @@ def cli(foo, bar):
     assert "Group 1" in result.output
     assert "foo" in result.output
     assert "bar" not in result.output
+
+
+def test_wrapped_functions(runner):
+    def make_z():
+        """A unified option interface for making a `z`."""
+
+        def decorator(f):
+            @optgroup.group("Group xyz")
+            @optgroup.option("-x", type=int)
+            @optgroup.option("-y", type=int)
+            @wraps(f)
+            def new_func(*args, x=0, y=0, **kwargs):
+                # Here we handle every detail about how to make a `z` from the given options
+                f(*args, z=x + y, **kwargs)
+
+            return new_func
+
+        return decorator
+
+    def make_c():
+        """A unified option interface for making a `c`."""
+
+        def decorator(f):
+            @optgroup.group("Group abc")
+            @optgroup.option("-a", type=int)
+            @optgroup.option("-b", type=int)
+            @wraps(f)
+            def new_func(*args, a=0, b=0, **kwargs):
+                # Here we do the same, but for another object `c` (and many others to come)
+                f(*args, c=a * b, **kwargs)
+
+            return new_func
+
+        return decorator
+
+    # Here I want to create a script that has a commen UI to make a `z`.
+    # I want to reuse a common set of options for how to make a `z` and don't want
+    # to sweat the details. Also, I've decided that I also want a `c` for this script.
+    @click.command()
+    @make_z()
+    @make_c()
+    def f(z, c):
+        print(z, c)
+
+    # Test
+    result = runner.invoke(f, ["--help"])
+    assert "Group xyz" in result.output
+    assert "-x" in result.output
+    assert "-y" in result.output
+    assert "Group abc" in result.output
+    assert "-a" in result.output
+    assert "-b" in result.output