gh-108901: Add Signature.from_code method

Doc/library/inspect.rst

@@ -765,6 +765,20 @@ 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*.
+
+      .. note::
+
+         Default values and annotations
+         will not be included in the signature,
+         since code objects have no knowledge of such things.
+         It is recommended to use :meth:`Signature.from_callable`
+         when a function object is available, it does not have these limitations.
+
+       .. versionadded:: 3.13
 
 .. class:: Parameter(name, kind, *, default=Parameter.empty, annotation=Parameter.empty)
 

Lib/inspect.py

@@ -2416,20 +2416,40 @@ def _signature_from_function(cls, func, skip_bound_arg=True,
     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_code(cls,
+                         func_code,
+                         globals=None,
+                         locals=None,
+                         eval_str=False,
+                         is_duck_function=False,
+                         func=None):
+    """Private helper function to get signature for code objects."""
     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:
+        annotations = {}
+        defaults = None
+        kwdefaults = None
 
     if defaults:
         pos_default_count = len(defaults)
@@ -3107,6 +3127,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(f'code object was expected, got {type(co).__name__!r}')
+        return _signature_from_code(cls, co)
+
     @property
     def parameters(self):
         return self._parameters

Lib/test/test_inspect.py

@@ -3674,6 +3674,43 @@ def test_signature_on_noncallable_mocks(self):
                 with self.assertRaises(TypeError):
                     inspect.signature(mock)
 
+    def test_signature_from_code(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,
+                )
+
+        with self.assertRaisesRegex(
+            TypeError,
+            "code object was expected, got 'int'",
+        ):
+            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 @@
+Add :meth:`inspect.Signature.from_code` to be able
+to construct :class:`inspect.Signature` objects from :class:`types.CodeType`.