BUG: Partial fix for docstring validation for parameters

scripts/tests/test_validate_docstrings.py

@@ -1,3 +1,4 @@
+from functools import wraps
 import io
 import random
 import string
@@ -12,6 +13,24 @@
 validate_one = validate_docstrings.validate_one
 
 
+class Decorators:
+    @staticmethod
+    def good_decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            """
+            Wrapper function.
+
+            This docstring should be hidden, and not used during validation.
+            Using the @wraps decorator should allow validation to get the
+            signature of the wrapped function when comparing against the
+            docstring.
+            """
+            return func(*args, **kwargs)
+
+        return wrapper
+
+
 class GoodDocStrings:
     """
     Collection of good doc strings.
@@ -68,6 +87,23 @@ def sample(self):
         """
         return random.random()
 
+    @Decorators.good_decorator
+    def decorated_sample(self, max):
+        """
+        Generate and return a random integer between 0 and max.
+
+        Parameters
+        ----------
+        max : int
+            The maximum value of the random number.
+
+        Returns
+        -------
+        int
+            Random number generated.
+        """
+        return random.randint(0, max)
+
     def random_letters(self):
         """
         Generate and return a sequence of random letters.
@@ -870,6 +906,7 @@ def test_good_class(self, capsys):
             "plot",
             "swap",
             "sample",
+            "decorated_sample",
             "random_letters",
             "sample_values",
             "head",

scripts/validate_docstrings.py

@@ -430,24 +430,34 @@ def doc_parameters(self):
 
     @property
     def signature_parameters(self):
+        def add_stars(param_name: str, info: inspect.Parameter):
+            """
+            Add stars to *args and **kwargs parameters
+            """
+            if info.kind == inspect.Parameter.VAR_POSITIONAL:
+                return f"*{param_name}"
+            elif info.kind == inspect.Parameter.VAR_KEYWORD:
+                return f"**{param_name}"
+            else:
+                return param_name
+
         if inspect.isclass(self.obj):
             if hasattr(self.obj, "_accessors") and (
                 self.name.split(".")[-1] in self.obj._accessors
             ):
                 # accessor classes have a signature but don't want to show this
                 return tuple()
         try:
-            sig = inspect.getfullargspec(self.obj)
+            sig = inspect.signature(self.obj)
         except (TypeError, ValueError):
             # Some objects, mainly in C extensions do not support introspection
             # of the signature
             return tuple()
-        params = sig.args
-        if sig.varargs:
-            params.append("*" + sig.varargs)
-        if sig.varkw:
-            params.append("**" + sig.varkw)
-        params = tuple(params)
+
+        params = tuple(
+            add_stars(parameter, sig.parameters[parameter])
+            for parameter in sig.parameters
+        )
         if params and params[0] in ("self", "cls"):
             return params[1:]
         return params