pythongh-108901: Deprecate inspect.getargs, use Signature.from_code instead

Author: sobolevn

Doc/library/inspect.rst

@@ -765,6 +765,16 @@ function.
        .. versionadded:: 3.10
           ``globalns`` and ``localns`` parameters.
 
+   .. classmethod:: Signature.from_code(co)
+
+       Return a :class:`Signature` (or its subclass) object
+       for a given :class:`code object <types.CodeType>` ``co``.
+
+       Since code objects do not know anything
+       about default values or annotations,
+       they will always be ommited from the signature.
+
+       .. versionadded:: 3.13
 
 .. class:: Parameter(name, kind, *, default=Parameter.empty, annotation=Parameter.empty)
 

Lib/inspect.py

@@ -1364,6 +1364,13 @@ def getargs(co):
     'args' is the list of argument names. Keyword-only arguments are
     appended. 'varargs' and 'varkw' are the names of the * and **
     arguments or None."""
+    import warnings
+    warnings.warn(
+        'getargs is deprecated since Python3.13, '
+        'use Signature.from_code instead',
+        DeprecationWarning,
+    )
+
     if not iscode(co):
         raise TypeError('{!r} is not a code object'.format(co))
 
@@ -2384,52 +2391,34 @@ def p(name_node, default_node, default=empty):
     return cls(parameters, return_annotation=cls.empty)
 
 
-def _signature_from_builtin(cls, func, skip_bound_arg=True):
+def _signature_from_code(cls,
+                                func_code,
+                                globals=None,
+                                locals=None,
+                                eval_str=False,
+                                is_duck_function=False,
+                                func=None):
     """Private helper function to get signature for
-    builtin callables.
+    code objects.
     """
-
-    if not _signature_is_builtin(func):
-        raise TypeError("{!r} is not a Python builtin "
-                        "function".format(func))
-
-    s = getattr(func, "__text_signature__", None)
-    if not s:
-        raise ValueError("no signature found for builtin {!r}".format(func))
-
-    return _signature_fromstr(cls, func, s, skip_bound_arg)
-
-
-def _signature_from_function(cls, func, skip_bound_arg=True,
-                             globals=None, locals=None, eval_str=False):
-    """Private helper: constructs Signature for the given python function."""
-
-    is_duck_function = False
-    if not isfunction(func):
-        if _signature_is_functionlike(func):
-            is_duck_function = True
-        else:
-            # If it's not a pure Python function, and not a duck type
-            # of pure function:
-            raise TypeError('{!r} is not a Python function'.format(func))
-
-    s = getattr(func, "__text_signature__", None)
-    if s:
-        return _signature_fromstr(cls, func, s, skip_bound_arg)
-
     Parameter = cls._parameter_cls
 
     # Parameter information.
-    func_code = func.__code__
     pos_count = func_code.co_argcount
     arg_names = func_code.co_varnames
     posonly_count = func_code.co_posonlyargcount
     positional = arg_names[:pos_count]
     keyword_only_count = func_code.co_kwonlyargcount
     keyword_only = arg_names[pos_count:pos_count + keyword_only_count]
-    annotations = get_annotations(func, globals=globals, locals=locals, eval_str=eval_str)
-    defaults = func.__defaults__
-    kwdefaults = func.__kwdefaults__
+    if func is not None:
+        annotations = get_annotations(func, globals=globals, locals=locals, eval_str=eval_str)
+        defaults = func.__defaults__
+        kwdefaults = func.__kwdefaults__
+    else:
+        # `func` can be `None` when we get a signature from just a `CodeObject`
+        annotations = {}
+        defaults = None
+        kwdefaults = None
 
     if defaults:
         pos_default_count = len(defaults)
@@ -2495,6 +2484,46 @@ def _signature_from_function(cls, func, skip_bound_arg=True,
                __validate_parameters__=is_duck_function)
 
 
+def _signature_from_builtin(cls, func, skip_bound_arg=True):
+    """Private helper function to get signature for
+    builtin callables.
+    """
+
+    if not _signature_is_builtin(func):
+        raise TypeError("{!r} is not a Python builtin "
+                        "function".format(func))
+
+    s = getattr(func, "__text_signature__", None)
+    if not s:
+        raise ValueError("no signature found for builtin {!r}".format(func))
+
+    return _signature_fromstr(cls, func, s, skip_bound_arg)
+
+
+def _signature_from_function(cls, func, skip_bound_arg=True,
+                             globals=None, locals=None, eval_str=False):
+    """Private helper: constructs Signature for the given python function."""
+
+    is_duck_function = False
+    if not isfunction(func):
+        if _signature_is_functionlike(func):
+            is_duck_function = True
+        else:
+            # If it's not a pure Python function, and not a duck type
+            # of pure function:
+            raise TypeError('{!r} is not a Python function'.format(func))
+
+    s = getattr(func, "__text_signature__", None)
+    if s:
+        return _signature_fromstr(cls, func, s, skip_bound_arg)
+    return _signature_from_code(cls, func.__code__,
+                                       globals=globals,
+                                       locals=locals,
+                                       eval_str=eval_str,
+                                       is_duck_function=is_duck_function,
+                                       func=func)
+
+
 def _signature_from_callable(obj, *,
                              follow_wrapper_chains=True,
                              skip_bound_arg=True,
@@ -3107,6 +3136,17 @@ def from_callable(cls, obj, *,
                                         follow_wrapper_chains=follow_wrapped,
                                         globals=globals, locals=locals, eval_str=eval_str)
 
+    @classmethod
+    def from_code(cls, co):
+        """Constructs Signature for the given code object.
+
+        Signatures created from code objects cannot know about annotations
+        or default values.
+        """
+        if not iscode(co):
+            raise TypeError('{!r} is not a code object'.format(co))
+        return _signature_from_code(cls, co)
+
     @property
     def parameters(self):
         return self._parameters

Lib/test/test_inspect.py

@@ -435,6 +435,25 @@ class ConcreteGrandchild(ClassExample):
         self.assertEqual(isabstract_checks, [True, True, False])
 
 
+class TestGetArgs(unittest.TestCase):
+    def test_getargs_is_deprecated(self):
+        # We are only interested in the deprecation warning,
+        # because `getargs` is:
+        # - undocumented
+        # - untested
+        # - deprecated
+        # - has modern alternative
+        # - incorrect anyways.
+        def func(): ...
+
+        msg = (
+            'getargs is deprecated since Python3.13, '
+            'use Signature.from_code instead'
+        )
+        with self.assertWarnsRegex(DeprecationWarning, msg):
+            inspect.getargs(func.__code__)
+
+
 class TestInterpreterStack(IsTestBase):
     def __init__(self, *args, **kwargs):
         unittest.TestCase.__init__(self, *args, **kwargs)
@@ -3674,6 +3693,41 @@ def test_signature_on_noncallable_mocks(self):
                 with self.assertRaises(TypeError):
                     inspect.signature(mock)
 
+    def test_signature_on_code_objects(self):
+        def func1(
+            a, b: int,
+            /,
+            c, d: str = 'a',
+            *args: int,
+            e, f: bool = True,
+            **kwargs: str,
+        ) -> float:
+            ...
+
+        def func2(a: str, b: int = 0, /): ...
+        def func3(): ...
+        def func4(*a, **k): ...
+        def func5(*, kw=False): ...
+
+        known_sigs = {
+            func1: '(a, b, /, c, d, *args, e, f, **kwargs)',
+            func2: '(a, b, /)',
+            func3: '()',
+            func4: '(*a, **k)',
+            func5: '(*, kw)',
+        }
+
+        for test_func, expected_sig in known_sigs.items():
+            with self.subTest(test_func=test_func, expected_sig=expected_sig):
+                self.assertEqual(
+                    str(inspect.Signature.from_code(test_func.__code__)),
+                    expected_sig,
+                )
+
+    def test_signature_on_non_code_objects(self):
+        with self.assertRaisesRegex(TypeError, '1 is not a code object'):
+            inspect.Signature.from_code(1)
+
     def test_signature_equality(self):
         def foo(a, *, b:int) -> float: pass
         self.assertFalse(inspect.signature(foo) == 42)

Misc/NEWS.d/next/Library/2023-09-05-13-23-06.gh-issue-108901.2KcZab.rst

@@ -0,0 +1,2 @@
+Deprecate ``inspect.getargs``, use :meth:`inspect.Signature.from_code`
+instead.