tox-dev-sphinx-autodoc-typehints-607-606

total 32
drwxr-xr-x 1 root root 4096 Nov  5 05:53 .
drwxr-xr-x 1 root root 4096 Nov  5 05:53 ..
drwxr-xr-x 1 root root 4096 Nov  5 05:53 .git
drwxr-xr-x 1 root root 4096 Nov  5 05:53 .github
-rw-r--r-- 1 root root   94 Nov  5 05:53 .gitignore
-rw-r--r-- 1 root root  104 Nov  5 05:53 .markdownlint.yaml
-rw-r--r-- 1 root root 1211 Nov  5 05:53 .pre-commit-config.yaml
-rw-r--r-- 1 root root 1101 Nov  5 05:53 LICENSE
-rw-r--r-- 1 root root 6883 Nov  5 05:53 README.md
-rw-r--r-- 1 root root   14 Nov  5 05:53 ignore-words.txt
-rw-r--r-- 1 root root 4206 Nov  5 05:53 pyproject.toml

drwxr-xr-x 1 root root 4096 Nov  5 05:53 src
drwxr-xr-x 1 root root 4096 Nov  5 05:53 tests
-rw-r--r-- 1 root root 2189 Nov  5 05:53 tox.toml
-rw-r--r-- 1 root root    0 Nov  5 05:53 whitelist.txt
ec62719 base
On branch master
nothing to commit, working tree clean

src
src/sphinx_autodoc_typehints
sphinx_autodoc_typehints
[build-system]
build-backend = "hatchling.build"
requires = [
  "hatch-vcs>=0.5",
  "hatchling>=1.28",
]

[project]
name = "sphinx-autodoc-typehints"

description = "Type hints (PEP 484) support for the Sphinx autodoc extension"
readme.content-type = "text/markdown"
readme.file = "README.md"
keywords = [
  "environments",
  "isolated",
  "testing",
  "virtual",
]
license = "MIT"
maintainers = [
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
]
authors = [
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
]
requires-python = ">=3.12"
classifiers = [
  "Development Status :: 5 - Production/Stable",
  "Framework :: Sphinx :: Extension",
  "Intended Audience :: Developers",
  "License :: OSI Approved :: MIT License",
  "Programming Language :: Python",
  "Programming Language :: Python :: 3 :: Only",
  "P
…[350 chars omitted]…
age>=7.13.4",
  "defusedxml>=0.7.1",       # required by sphinx.testing
  "diff-cover>=10.2",
  "pytest>=9.0.2",
  "pytest-cov>=7",
  "sphobjinv>=2.3.1.3",
  "typing-extensions>=4.15",
]
urls.Changelog = "https://github.com/tox-dev/sphinx-autodoc-typehints/releases"
urls.Homepage = "https://github.com/tox-dev/sphinx-autodoc-typehints"
urls.Source = "https://github.com/tox-dev/sphinx-autodoc-typehints"

src/sphinx_autodoc_typehints/__init__.py
src/sphinx_autodoc_typehints/_parser.py
src/sphinx_autodoc_typehints/attributes_patch.py
src/sphinx_autodoc_typehints/patches.py
src/sphinx_autodoc_typehints/py.typed
src/sphinx_autodoc_typehints/version.py
tests/conftest.py
tests/roots/test-dummy/conf.py
tests/roots/test-dummy/dummy_module.py
tests/roots/test-dummy/dummy_module_future_annotations.py
tests/roots/test-dummy/dummy_module_simple.py
tests/roots/test-dummy/dummy_module_simple_default_role.py

tests/roots/test-dummy/dummy_module_simple_no_use_rtype.py
tests/roots/test-dummy/dummy_module_without_complete_typehints.py
tests/roots/test-dummy/export_module.py
tests/roots/test-dummy/future_annotations.rst
tests/roots/test-dummy/simple.rst
tests/roots/test-dummy/simple_default_role.rst
tests/roots/test-dummy/simple_no_use_rtype.rst
tests/roots/test-dummy/without_complete_typehints.rst
tests
…[521 chars omitted]…
ation.py
tests/test_integration_autodoc_type_aliases.py
tests/test_integration_issue_384.py
tests/test_sphinx_autodoc_typehints.py
tests/test_version.py
 1108 src/sphinx_autodoc_typehints/__init__.py
   31 src/sphinx_autodoc_typehints/_parser.py
   63 src/sphinx_autodoc_typehints/attributes_patch.py
  162 src/sphinx_autodoc_typehints/patches.py
   24 src/sphinx_autodoc_typehints/version.py
 1388 total

"""Sphinx autodoc type hints."""

from __future__ import annotations

import ast
import importlib
import inspect
import re
import sys
import textwrap
import types
from dataclasses import dataclass

from typing import TYPE_CHECKING, Any, AnyStr, ForwardRef, NewType, TypeVar, Union, get_type_hints

from docutils import nodes
from docutils.frontend import get_default_settings
from sphinx.ext.autodoc.mock import mock  # type: ignore[attr-defined]
from sphinx.parsers import RSTParser
from sphinx.util import logging, rst
from sphinx.util.inspect import TypeAliasForwardRef, stringify_signature
from sphinx.util.inspect import signature as sphinx_signature

from ._parser import parse
from .patches import install_patches
from .version import __version__

if TYPE_CHECKING:
    from ast import FunctionDef, Module, stmt
    from collections.abc import Callable

    from docutils.nodes import Node
 
…[8630 chars omitted]…
onnect("autodoc-process-docstring", process_docstring)
    install_patches(app)
    return {"parallel_read_safe": True, "parallel_write_safe": True}


__all__ = [
    "__version__",
    "backfill_type_hints",
    "format_annotation",
    "get_annotation_args",
    "get_annotation_class_name",
    "get_annotation_module",
    "normalize_source_lines",
    "process_docstring",
    "process_signature",
]

20:from sphinx.util.inspect import TypeAliasForwardRef, stringify_signature
21:from sphinx.util.inspect import signature as sphinx_signature
75:    def __or__(self, value: Any) -> Any:
79:def _get_types_type(obj: Any) -> str | None:
113:def _is_newtype(annotation: Any) -> bool:
367:def process_signature(  # noqa: C901, PLR0913, PLR0917
373:    signature: str,  # noqa: ARG001
377:    Process the signature.
384:    :param signature:
396:    obj = inspect.unwrap(obj)
397:    sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
400:    def _get_formatted_annotation(annotation: TypeVar) -> TypeVar:

406:    if app.config.typehints_use_signature_return:
407:        sph_signature = sph_signature.replace(
408:            return_annotation=_get_formatted_annotation(sph_signature.return_annotation)
411:    if app.config.typehints_use_signature:
414:            f
…[1891 chars omitted]…
st[str], arg_name: str) -> tuple[str, bool]:
873:def _append_default(
980:def _inject_rtype(  # noqa: C901, PLR0913, PLR0917
1087:    app.add_config_value("typehints_use_signature", False, "env")  # noqa: FBT003
1088:    app.add_config_value("typehints_use_signature_return", False, "env")  # noqa: FBT003
1092:    app.connect("autodoc-process-signature", process_signature)
1107:    "process_signature",

# Find the line and line number containing the function definition
    for pos, line in enumerate(lines):
        if line.lstrip().startswith("def "):
            idx = pos
            whitespace_separator = "def"
            break
        if line.lstrip().startswith("async def"):
            idx = pos
            whitespace_separator = "async def"
            break

    else:

        return "\n".join(lines)
    fn_def = lines[idx]

    # Get a string representing the amount of leading whitespace
    whitespace = fn_def.split(whitespace_separator)[0]

    # Add this leading whitespace to all lines before and after the `def`
    aligned_prefix = [whitespace + remove_prefix(s, whitespace) for s in lines[:idx]]
    aligned_suffix = [whitespace + remove_prefix(s, whitespace) for s in lines[idx + 1 :]]

    # Put it together again
    aligned_prefix.append(fn_def)
    return "\n".join(
…[6496 chars omitted]…
d_argument(line: str) -> tuple[str, str | None] | None:
    """
    Extract a keyword, and its optional argument out of a sphinx field option line.

    For example
    >>> _get_sphinx_line_keyword_and_argument(":param parameter:")
    ("param", "parameter")
    >>> _get_sphinx_line_keyword_and_argument(":return:")
    ("return", None)
    >>> _get_sphinx_line_keyword_and_argument("some invalid line")

src/sphinx_autodoc_typehints/__init__.py:392:    obj = getattr(obj, "__init__", getattr(obj, "__new__", None)) if inspect.isclass(obj) else obj

# file generated by vcs-versioning
# don't change, don't track in version control
from __future__ import annotations

__all__ = [
    "__version__",
    "__version_tuple__",
    "version",
    "version_tuple",
    "__commit_id__",
    "commit_id",
]

version: str
__version__: str
__version_tuple__: tuple[int | str, ...]
version_tuple: tuple[int | str, ...]
commit_id: str | None
__commit_id__: str | None

__version__ = version = '0.0.0'
__version_tuple__ = version_tuple = (0, 0, 0)

__commit_id__ = commit_id = None
/repo/src/sphinx_autodoc_typehints/__init__.py
Name: sphinx-autodoc-typehints
Version: 0.0.0
Summary: Type hints (PEP 484) support for the Sphinx autodoc extension
Home-page: https://github.com/tox-dev/sphinx-autodoc-typehints
Author: 
Author-email: Bernát Gábor <gaborjbernat@gmail.com>
License-Expression: MIT
Location: /usr/local/lib/python3.12/site-packages
Editable projec
…[259 chars omitted]…
eorg@python.org>
License-Expression: BSD-2-Clause
Location: /usr/local/lib/python3.12/site-packages
Requires: alabaster, babel, docutils, imagesize, Jinja2, packaging, Pygments, requests, roman-numerals, snowballstemmer, sphinxcontrib-applehelp, sphinxcontrib-devhelp, sphinxcontrib-htmlhelp, sphinxcontrib-jsmath, sphinxcontrib-qthelp, sphinxcontrib-serializinghtml
Required-by: sphinx-autodoc-typehints

from __future__ import annotations

import re
import sys
import types
import typing
from collections.abc import Callable, Mapping
from functools import cmp_to_key
from io import StringIO
from pathlib import Path
from textwrap import dedent, indent
from types import EllipsisType, FrameType, FunctionType, ModuleType, NotImplementedType, TracebackType

from typing import (  # noqa: UP035
    IO,
    Annotated,
    Any,
    AnyStr,
    Dict,
    Generic,
    List,
    NewType,
    NotRequired,
    Optional,
    Required,
    Tuple,
    Type,
    TypeVar,
    Union,
)
from unittest.mock import create_autospec, patch

import pytest
import typing_extensions
from sphinx.application import Sphinx
from sphinx.config import Config

from sphinx_autodoc_typehints import (
    _resolve_type_guarded_imports,
    backfill_type_hints,
    format_annotation,
    get_annotation_args,
    get_annotation_c
…[8628 chars omitted]…
str(Path(__file__).parent) or ".").absolute() / "roots"


def pytest_ignore_collect(collection_path: Path, config: Config) -> bool | None:  # noqa: ARG001
    version_re = re.compile(r"_py(\d)(\d)\.py$")
    match = version_re.search(collection_path.name)
    if match:
        version = tuple(int(x) for x in match.groups())
        if sys.version_info < version:
            return True
    return None

45:    process_docstring,
508:def test_process_docstring_slot_wrapper() -> None:
518:    process_docstring(app, "class", "SlotWrapper", Slotted, None, lines)
807:def test_default_no_signature(obj: Any) -> None:
817:    process_docstring(app, "what", "name", obj, None, lines)
834:    process_docstring(app, "class", method.__qualname__, method, None, [])
942:def test_sphinx_output_with_use_signature(app: SphinxTestApp, status: StringIO) -> None:
971:def test_sphinx_output_with_use_signature_return(app: SphinxTestApp, status: StringIO) -> None:
1000:def test_sphinx_output_with_use_signature_and_return(app: SphinxTestApp, status: StringIO) -> None:
tests/test_sphinx_autodoc_typehints.py:45:    process_docstring,
tests/test_sphinx_autodoc_typehints.py:508:def test_process_docstring_slot_wrapper() -> None:
tests/test_sphinx_autodoc_typehints.py:518:    process_docstring(app, "class", "SlotWrapper", Slotted, None, lines)

tests/test_sphinx_autodoc_typehints.py:817:    process_docstring(app, "what", "name", obj, None, lines)
tests/test_sphinx_autodoc_typehints.py:834:    process_docstring(app, "class", method.__qualname__, method, None, [])

commit ec627199fed51f00a2905871a934ce80ce0adf72
Author:     benchgen <sandbox@benchgen>
AuthorDate: Thu Nov 5 05:53:40 2026 +0000
Commit:     benchgen <sandbox@benchgen>
CommitDate: Thu Nov 5 05:53:40 2026 +0000

    base
* master

timeout: failed to run command ‘curl’: No such file or directory

URLError <urlopen error [Errno -3] Temporary failure in name resolution>

<function Employee.__new__ at 0x7fb33b181760>
module attr: namedtuple_Employee
qualname: Employee.__new__
name: __new__
annotations: {'name': <class 'str'>, 'id': <class 'int'>}
inspect.getmodule: None
Employee.__init__: <slot wrapper '__init__' of 'object' objects> None
Employee.__new__ wrapped: None
signature: (_cls, name: str, id: int)
Employee.__dict__ new: <staticmethod(<function Employee.__new__ at 0x7fb33b181760>)>

Refused: `find /` walks the whole container FS. Scope under /repo.

total 16
drwxr-xr-x  4 root root 4096 Nov  5 05:54 .
drwxr-xr-x  3 root root 4096 Nov  5 05:54 ..
drwxr-xr-x 18 root root 4096 Nov  5 05:54 http-v2
drwxr-xr-x  2 root root 4096 Nov  5 05:54 selfcheck
/root/.cache/pip/selfcheck/fe300af6f7d708c14827daac3afc81fbb8306b73de8dd6e3f1f8ea3b
install.log

("int | float | None", ":py:class:`int` | :py:class:`float` | :py:obj:`None`"),
        ("Union[int, float]", ":py:class:`int` | :py:class:`float`"),
        ("Union[int, float, None]", ":py:class:`int` | :py:class:`float` | :py:obj:`None`"),
        ("Optional[int | float]", ":py:class:`int` | :py:class:`float` | :py:obj:`None`"),
        ("Optional[Union[int, float]]", ":py:class:`int` | :py:class:`float` | :py:obj:`None`"),
        ("Union[int | float, str]", ":py:class:`int` | :py:class:`float` | :py:class:`str`"),
        ("Union[int, float] | str", ":py:class:`int` | :py:class:`float` | :py:class:`str`"),
    ],
)
def test_always_use_bars_union(annotation: str, expected_result: str) -> None:
    conf = create_autospec(Config, always_use_bars_union=True)
    result = format_annotation(eval(annotation), conf)  # noqa: S307

    assert result == expected_result


@pytest.mar
…[8628 chars omitted]…
hout_complete_typehints"  # create flag
    app.config.typehints_defaults = "comma"
    app.build()
    assert "build succeeded" in status.getvalue()
    text_path = Path(app.srcdir) / "_build" / "text" / "without_complete_typehints.txt"
    text_contents = text_path.read_text().replace("–", "--")  # noqa: RUF001 # keep ambiguous EN DASH
    expected_contents = """\
    Simple Module
    *************

...
    """

    assert normalize_source_lines(dedent(source)) == dedent(expected)


@pytest.mark.parametrize("obj", [cmp_to_key, 1])
def test_default_no_signature(obj: Any) -> None:
    config = create_autospec(
        Config,
        typehints_fully_qualified=False,
        simplify_optional_unions=False,

        typehints_formatter=None,
        autodoc_mock_imports=[],
    )
    app: Sphinx = create_autospec(Sphinx, config=config)
    lines: list[str] = []
    process_docstring(app, "what", "name", obj, None, lines)
    assert lines == []


@pytest.mark.parametrize("method", [HintedMethods.from_magic, HintedMethods().method])
def test_bound_class_method(method: FunctionType) -> None:
    config = create_autospec(
        Config,
        typehints_fully_qualified=False,
        simplify_optional_unions=False,
        typehints_document_rtype=False,
        always_document_
…[4823 chars omitted]…
ethod docstring.

        :param x: foo
        """

    @classmethod
    def a_classmethod(cls, x: bool, y: int, z: Optional[str] = None) -> str:
        """
        Classmethod docstring.

        :param x: foo
        :param y: bar
        :param z: baz
        """

    @staticmethod
    def a_staticmethod(x: bool, y: int, z: Optional[str] = None) -> str:
        """
        Staticmethod docstring.

Staticmethod docstring.

        :param x: foo
        :param y: bar
        :param z: baz
        """

    @property
    def a_property(self) -> str:
        """
        Property docstring
        """

    class InnerClass:
        """
        Inner class.
        """

        def inner_method(self, x: bool) -> str:
            """
            Inner method.

            :param x: foo
            """

        def __dunder_inner_method(self, x: bool) -> str:
            """
            Dunder inner method.

            :param x: foo
            """

    locally_defined_callable_field = get_local_function()


@expected(
    """\
exception mod.DummyException(message)

   Exception docstring

   Parameters:
      **message** ("str") -- blah
""",
)
class DummyException(Exception):  # noqa: N818
    """
    Exception docstring

    :param message: blah
    """

    def __init__(self
…[5372 chars omitted]…
s:
      **func** ("Callable"[["int", "str"], "str"]) -- function
""",
)
class Decorator:
    """
    Initializer docstring.

    :param func: function
    """

    def __init__(self, func: Callable[[int, str], str]) -> None:
        pass


@expected(
    """\
mod.mocked_import(x)

   A docstring.

   Parameters:
      **x** ("Mailbox") -- function
""",
)
def mocked_import(x: Mailbox):  # noqa: ANN201

def _is_dataclass(name: str, what: str, qualname: str) -> bool:
    # generated dataclass __init__() and class need extra checks, as the function operates on the generated class
    # and methods (not an instantiated dataclass object) it cannot be replaced by a call to
    # `dataclasses.is_dataclass()` => check manually for either generated __init__ or generated class
    return (what == "method" and name.endswith(".__init__")) or (what == "class" and qualname.endswith(".__init__"))


def _future_annotations_imported(obj: Any) -> bool:
    annotations_ = getattr(inspect.getmodule(obj), "annotations", None)
    if annotations_ is None:
        return False

    # Make sure that annotations is imported from __future__ - defined in cpython/Lib/__future__.py
    # annotations become strings at runtime
    return bool(annotations_.compiler_flag == 0x1000000)  # pragma: no cover # noqa: PL
…[7159 chars omitted]…
nt = comment.strip().lstrip("(").rstrip(")")
    result: list[str | None] = []
    if not comment:
        return result

    brackets, start_arg_at, at = 0, 0, 0
    for at, char in enumerate(comment):
        if char in {"[", "("}:
            brackets += 1
        elif char in {"]", ")"}:
            brackets -= 1
        elif char == "," and brackets == 0:
            add(comment[start_arg_at:at])

Running Sphinx v9.1.1
loading translations [en]... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting signature for demo.Employee.__new__: Handler <function process_signature at 0x7ddb2a309e40> for event 'autodoc-process-signature' threw an exception (exception: 'NoneType' object has no attribute 'Employee') [autodoc]
looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 1 warning (with warnings treated as errors).
EXIT:1

Running Sphinx v9.1.1
loading translations [en]... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for demo.circular: wrapper loop when unwrapping <function circular at 0x76bb4db92520> [autodoc]
WARNING: error while formatting signature for demo.circular: Handler <function process_signature at 0x76bb4db90400> for event 'autodoc-process-signature' threw an exception (exception: wrapper loop when unwrapping <function circular at 0x76bb4db92520>) [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 2 warnings (with warnings treated as errors).
EXIT:1

grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/fr/LC_MESSAGES/sphinx.mo: binary file matches
grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/sv/LC_MESSAGES/sphinx.mo: binary file matches
grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/ja/LC_MESSAGES/sphinx.mo: binary file matches
grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/zh_CN/LC_MESSAGES/sphinx.mo: binary file matches
grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/pt_BR/LC_MESSAGES/sphinx.mo: binary file matches
/usr/local/lib/python3.12/site-packages/sphinx/locale/fr/LC_MESSAGES/sphinx.po:3931:msgid "error while formatting arguments for %s: %s"
/usr/local/lib/python3.12/site-packages/sphinx/locale/ta/LC_MESSAGES/sphinx.po:2865:msgid "error while formatting arguments for %s: %s"
/usr/local/lib/python3.12/site-packages/sphinx/locale/sv/LC_MESSAGES/sphinx.po:3903:msgid
…[611 chars omitted]…
ocal/lib/python3.12/site-packages/sphinx/locale/en_DE/LC_MESSAGES/sphinx.po:3902:msgid "error while formatting arguments for %s: %s"
/usr/local/lib/python3.12/site-packages/sphinx/locale/si/LC_MESSAGES/sphinx.po:3903:msgid "error while formatting arguments for %s: %s"
/usr/local/lib/python3.12/site-packages/sphinx/locale/is/LC_MESSAGES/sphinx.po:3903:msgid "error while formatting arguments for %s: %s"

def format_args(self, **kwargs: Any) -> str:
        if self.config.autodoc_typehints in {'none', 'description'}:
            kwargs.setdefault('show_annotation', False)
        if self.config.autodoc_typehints_format == 'short':
            kwargs.setdefault('unqualified_typehints', True)
        if self.config.python_display_short_literal_types:
            kwargs.setdefault('short_literals', True)

        try:
            self._events.emit('autodoc-before-process-signature', self.object, False)
            sig = inspect.signature(
                self.object, type_aliases=self.config.autodoc_type_aliases

            )
            args = stringify_signature(sig, **kwargs)
        except TypeError as exc:
            LOGGER.warning(
                __('Failed to get a function signature for %s: %s'), self.fullname, exc
            )
            return ''
        except ValueError:
            args = ''

        if self.config.strip_signature_backslash:
            # escape backslashes for reST
            args = args.replace('\\', '\\\\')
        return args

grep: /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/__pycache__/_signatures.cpython-312.pyc: binary file matches
grep: /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_legacy_class_based/__pycache__/_documenters.cpython-312.pyc: binary file matches
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:102:            msg = __('error while formatting arguments for %s: %s')
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_legacy_class_based/_documenters.py:358:                    __('error while formatting arguments for %s: %s'),

assert isinstance(props, _ClassDefProperties)
        if props.doc_as_attr:
            return []
        if config.autodoc_class_signature == 'separated':
            # do not show signatures
            return []

    if config.autodoc_typehints_format == 'short':
        kwargs.setdefault('unqualified_typehints', True)
    if config.python_display_short_literal_types:
        kwargs.setdefault('short_literals', True)

    if args is None:
        signatures: list[_FormattedSignature] = []
    else:
        signatures = [(args, retann or '')]

    if (
        not signatures
        and config.autodoc_docstring_signature
        and props.obj_type not in {'module', 'data', 'type'}
        and docstrings is not None
    ):
        # only act if a signature is not explicitly given already,
        # and if the feature is enabled
        signatures[:] = _extract_signatures_fro
…[2807 chars omitted]…
._events.emit_firstresult(
            'autodoc-process-signature',
            self.objtype,
            self.fullname,
            self.object,
            self.options,
            args,
            retann,
        )
        if result:
            args, retann = result

        if args is not None:
            return args + ((' -> %s' % retann) if retann else '')
        else:
            return ''

408:def _extract_signature_from_object(
465:def _get_signature_object(
        props.full_name,
        props._obj,
        options,
        signatures[0][0] if signatures else None,  # args
        signatures[0][1] if signatures else '',  # retann
    ):
        if len(result) == 2 and isinstance(result[0], str):
            args, retann = result
            signatures[0] = (args, retann if isinstance(retann, str) else '')

    if props.obj_type in {'module', 'data', 'type'}:
        signatures[1:] = ()  # discard all signatures save the first

    analyzer_overloads: dict[str, list[Signature]] = {}
    try:
        analyzer = ModuleAnalyzer.for_module(props.canonical_module_name)
        # parse right now, to get PycodeErrors on parsing (results will
        # be cached anyway)
        analyzer.analyze()
    except PycodeError as exc:
        LOGGER.debug('[autodoc] module analyzer 
…[5322 chars omitted]…
patch'ed methods
            for typ, func in meth.dispatcher.registry.items():
                if typ is object:
                    continue  # default implementation. skipped.
                if inspect.isclassmethod(func):
                    func = func.__func__
                dispatch_meth = _annotate_to_first_argument(
                    func, typ, config=config, props=props
                )

def _extract_signature_from_object(
    config: _AutodocConfig,
    events: EventManager,
    get_attr: _AttrGetter,
    parent: Any,
    props: _ItemProperties,
    **kwargs: Any,
) -> list[_FormattedSignature]:
    """Format the signature using runtime introspection."""
    sig = _get_signature_object(
        events=events,
        get_attr=get_attr,

        parent=parent,
        preserve_defaults=config.autodoc_preserve_defaults,
        props=props,
        type_aliases=config.autodoc_type_aliases,
        use_type_comments=config.autodoc_use_type_comments,
    )
    if sig is None:
        return []

    if props.obj_type == 'decorator' and len(sig.parameters) == 1:
        # Special case for single-argument decorators
        return [('', '')]

    if config.autodoc_typehints in {'none', 'description'}:
        kwargs.setdefault('show_annotation', False)
    if config.autodoc_
…[3504 chars omitted]…
lable(object_sig):
                # Support for enum.Enum.__signature__ in Python 3.12 & 3.13
                if isinstance(object_sig_str := object_sig(), str):
                    return inspect.signature_from_str(object_sig_str), False

        def get_user_defined_function_or_method(obj: Any, attr: str) -> Any:
            """Get the `attr` function or method from `obj`, if it is user-defined."""

"""Signature utilities for autodoc"""

from __future__ import annotations

import sys
from inspect import Parameter, Signature
from typing import TYPE_CHECKING, NewType, TypeVar

from sphinx.errors import PycodeError
from sphinx.ext.autodoc._dynamic._preserve_defaults import update_default_value
from sphinx.ext.autodoc._dynamic._type_annotations import _record_typehints
from sphinx.ext.autodoc._dynamic._type_comments import (

    _update_annotations_using_type_comments,
)
from sphinx.ext.autodoc._names import py_ext_sig_re
from sphinx.ext.autodoc._property_types import _AssignStatementProperties
from sphinx.ext.autodoc._shared import LOGGER
from sphinx.locale import __
from sphinx.pycode import ModuleAnalyzer
from sphinx.util import inspect
from sphinx.util.docstrings import prepare_docstring
from sphinx.util.inspect import (
    _stringify_signature_to_parts,
    evaluate_signature,

…[6076 chars omitted]…
""Merge default values of actual implementation to the overload variants."""
    parameters = list(overload.parameters.values())
    for i, param in enumerate(parameters):
        actual_param = actual.parameters.get(param.name)
        if actual_param and param.default == '...':
            parameters[i] = param.replace(default=actual_param.default)

    return overload.replace(parameters=parameters)

prefix = f'{key}.'
        return key in ns or any(k.startswith(prefix) for k in ns)

    def __iter__(self) -> Iterator[str]:
        for k in self.__mapping:
            yield k
            for i in range(k.count('.')):
                yield k.rsplit('.', i + 1)[0]

    def __len__(self) -> int:
        return sum(k.count('.') + 1 for k in self.__mapping)

def _should_unwrap(subject: _SignatureType) -> bool:
    """Check the function should be unwrapped on getting signature."""
    __globals__ = getglobals(subject)
    # contextmanger should be unwrapped
    return (
        __globals__.get('__name__') == 'contextlib'
        and __globals__.get('__file__') == contextlib.__file__
    )


# Python 3.14 uses deferred evaluation of annotations by default.
# Using annotationlib's FORWARDREF format gives us more robust handling
# of forward references in type annotations.
signat
…[3594 chars omitted]…
# might be a mock object
        return obj


def unwrap_all(obj: Any, *, stop: Callable[[Any], bool] | None = None) -> Any:
    """Get an original object from wrapped object.

    Unlike :func:`unwrap`, this unwraps partial functions, wrapped functions,
    class methods and static methods.

    When specified, *stop* is a predicate indicating whether an object should
    be unwrapped or not.
    """

29M	/root/.cache/pip
/root/.cache/pip/http-v2/1/1/f/7/5/11f75a06ff5b02ee1a73710f03abaef62a1b067e07dda15bf4e3fe23
/root/.cache/pip/http-v2/1/1/f/7/5/11f75a06ff5b02ee1a73710f03abaef62a1b067e07dda15bf4e3fe23.body
/root/.cache/pip/http-v2/1/1/2/7/e/1127e3d2d646b8b978b6f86221cfed3abb713e990a117406d3ce6b47
/root/.cache/pip/http-v2/1/1/2/7/e/1127e3d2d646b8b978b6f86221cfed3abb713e990a117406d3ce6b47.body
/root/.cache/pip/http-v2/1/b/1/2/1/1b121906158ba2d12abc2c30cfac9ca37bf57e7f25d46922f9e3a0b2
/root/.cache/pip/http-v2/1/b/1/2/1/1b121906158ba2d12abc2c30cfac9ca37bf57e7f25d46922f9e3a0b2.body
/root/.cache/pip/http-v2/1/b/9/c/e/1b9ce7c403ccacaf2df65a285516be534e09cde2ce9fa453d15fb732.body
/root/.cache/pip/http-v2/1/b/9/c/e/1b9ce7c403ccacaf2df65a285516be534e09cde2ce9fa453d15fb732
/root/.cache/pip/http-v2/1/0/b/2/a/10b2a8b62ea67a4cd49d0d353a09c43832fb02ba7b3a804e29c73417
/root/.cache/pip/http-v2/1/0
…[8630 chars omitted]…

body
1898 /root/.cache/pip/http-v2/7/f/d/2/3/7fd23999479d232e1db8dfb9d09b023db54b32339c313a181ff356ae
2478 /root/.cache/pip/http-v2/7/f/d/2/3/7fd23999479d232e1db8dfb9d09b023db54b32339c313a181ff356ae.body
119300 /root/.cache/pip/http-v2/7/9/2/2/3/7922381989e3f4a494917b1b4287f20f29132e36652a490fb2ddd2db.body
1220 /root/.cache/pip/http-v2/7/9/2/2/3/7922381989e3f4a494917b1b4287f20f29132e36652a490fb2ddd2db

113:sphinx-autodoc-typehints. See [Issue 15](https://github.com/tox-dev/sphinx-autodoc-typehints/issues/15) on the issue
ec62719 base
 .github/FUNDING.yml                                |    1 +
 .github/SECURITY.md                                |   13 +
 .github/dependabot.yml                             |    6 +
 .github/release.yml                                |    5 +
 .github/workflows/check.yaml                       |   52 +
 .github/workflows/release.yaml                     |   48 +
 .gitignore                                         |    8 +
 .markdownlint.yaml                                 |    8 +
 .pre-commit-config.yaml                            |   41 +
 LICENSE                                            |   21 +

 README.md                                          |  124 ++
 ignore-words.txt                                   |    2 +
 pyproject.toml               
…[1906 chars omitted]…
ntegration_autodoc_type_aliases.py     |  165 ++
 tests/test_integration_issue_384.py                |  118 ++
 tests/test_sphinx_autodoc_typehints.py             | 1119 ++++++++++++++
 tests/test_version.py                              |    7 +
 tox.toml                                           |   89 ++
 whitelist.txt                                      |    0
 49 files changed, 5359 insertions(+)

def mocked_import(x: Mailbox):  # noqa: ANN201
    """
    A docstring.

    :param x: function
    """


@expected(
    """\
mod.func_with_examples()

   A docstring.

   Return type:
      "int"

   -[ Examples ]-

   Here are a couple of examples of how to use this function.
""",
)
def func_with_examples() -> int:
    """
    A docstring.

    .. rubric:: Examples

    Here are a couple of examples of how to use this function.
    """


@overload
def func_with_overload(a: int, b: int) -> None: ...


@overload
def func_with_overload(a: str, b: str) -> None: ...


@expected(
    """\
mod.func_with_overload(a, b)

   f does the thing. The arguments can either be ints or strings but
   they must both have the same type.

   Parameters:
      * **a** ("int" | "str") -- The first thing

      * **b** ("int" | "str") -- The second thing

   Return type:
      "None"
""",
)
def func_with_o
…[5554 chars omitted]…
   """
    A Class

    Parameters
    ----------
    blah:
        Description of parameter blah
    """

    def __init__(self, blah: CodeType) -> None:
        pass

    blah: ModuleType
    """Description of attribute blah"""


@expected(
    """
    mod.napoleon_returns()

       A function.

       Return type:
          "CodeType"

       Returns:
          The info about the whatever.
    """,

""",
)
def napoleon_returns() -> CodeType:
    """
    A function.

    Returns
    -------
        The info about the whatever.
    """

@expected(
    """
    mod.google_docstrings(arg1, arg2)

       Summary line.

       Extended description of function.

       Parameters:
          * **arg1** ("CodeType") -- Description of arg1

          * **arg2** ("ModuleType") -- Description of arg2

       Return type:
          "CodeType"

       Returns:
          Description of return value

    """,
)
def google_docstrings(arg1: CodeType, arg2: ModuleType) -> CodeType:
    """Summary line.

    Extended description of function.

    Args:
        arg1: Description of arg1
        arg2: Description of arg2

    Returns:
        Description of return value
    """


@expected(
    """
    mod.docstring_with_multiline_note_after_params(param)

       Do something.

       Parameters:

…[8086 chars omitted]…
info:
        warning_info.assert_warning(value)
    else:
        assert not value

    result = (Path(app.srcdir) / "_build/text/index.txt").read_text()

    expected = val.EXPECTED
    try:
        assert result.strip() == dedent(expected).strip()
    except Exception:
        indented = indent(f'"""\n{result}\n"""', " " * 4)
        print(f"@expected(\n{indented}\n)\n")  # noqa: T201
        raise

count: 57
size: 104
in-pack: 0
packs: 0
size-pack: 0
prune-packable: 0
garbage: 0
size-garbage: 0

urls.Source = "https://github.com/tox-dev/sphinx-autodoc-typehints"
urls.Tracker = "https://github.com/tox-dev/sphinx-autodoc-typehints/issues"

[tool.hatch]
build.hooks.vcs.version-file = "src/sphinx_autodoc_typehints/version.py"
version.source = "vcs"

[tool.ruff]
line-length = 120
format.preview = true
format.docstring-code-line-length = 100
format.docstring-code-format = true

lint.select = [
  "ALL",
]
lint.ignore = [
  "ANN401", # allow Any as type annotation
  "COM812", # Conflict with formatter
  "CPY",    # No copyright statements
  "D203",   # `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible
  "D212",   # `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible
  "DOC",    # no sphinx support
  "ISC001", # Conflict with formatter
  "RUF067", # `__init__` module should only contain docstrin
…[3563 chars omitted]…
  "twine>=6.2",
  "uv>=0.10.2",
]
commands = [
  [ "uv", "build", "--sdist", "--wheel", "--out-dir", "{env_tmp_dir}", "." ],
  [ "twine", "check", "{env_tmp_dir}{/}*" ],
  [ "check-wheel-contents", "--no-config", "{env_tmp_dir}" ],
]

[env.dev]
description = "generate a DEV environment"
package = "editable"
commands = [ [ "uv", "pip", "tree" ], [ "python", "-c", "import sys; print(sys.executable)" ] ]

from __future__ import annotations

import pathlib
import sys

# Make dummy_module.py available for autodoc.
sys.path.insert(0, str(pathlib.Path(__file__).parent))


master_doc = "index"

extensions = [

    "sphinx.ext.autodoc",
    "sphinx.ext.napoleon",
    "sphinx_autodoc_typehints",
]
from __future__ import annotations

import pathlib
import sys

# Make dummy_module.py available for autodoc.
sys.path.insert(0, str(pathlib.Path(__file__).parent))


master_doc = "index"

extensions = [
    "sphinx.ext.autodoc",
    "sphinx.ext.napoleon",
    "sphinx_autodoc_typehints",
]

from __future__ import annotations

import re
import sys
from pathlib import Path
from textwrap import dedent, indent
from typing import TYPE_CHECKING, Any, NewType, TypeVar

import pytest

if TYPE_CHECKING:
    from collections.abc import Callable

    from io import StringIO

    from sphinx.testing.util import SphinxTestApp

T = TypeVar("T")
W = NewType("W", str)


def expected(expected: str, **options: dict[str, Any]) -> Callable[[T], T]:
    def dec(val: T) -> T:
        val.EXPECTED = expected
        val.OPTIONS = options
        return val

    return dec


def warns(pattern: str) -> Callable[[T], T]:
    def dec(val: T) -> T:
        val.WARNING = pattern
        return val

    return dec


@expected(
    """\
mod.function(x=5, y=10, z=15)

   Function docstring.

   Parameters:
      * **x** ("int") -- optional specifier line 2 (default: "5")

      * **y** ("int") --

     
…[2832 chars omitted]…
t) -> bool:
        return True


class Schema(metaclass=_SchemaMeta):
    pass


@expected(
    """
mod.f(s)

   Do something.

   Parameters:
      **s** ("Schema") -- Some schema.

   Return type:
      "Schema"
"""
)
def f(s: Schema) -> Schema:
    """
    Do something.

    Args:
        s: Some schema.
    """
    return s


class AliasedClass: ...


@expected(
    """
mod.g(s)

   Do something.

# at end. (I don't know of any input where this happens.)
        next_sibling = child.next_node(descend=False, siblings=True)
        line_no = node_line_no(next_sibling) if next_sibling else None
        at = max(line_no - 2, 0) if line_no else len(lines)
        return InsertIndexInfo(insert_index=at, found_param=True)

    # 4. Insert before examples
    for child in doc.children:
        if tag_name(child) in {"literal_block", "paragraph", "field_list"}:
            continue
        line_no = node_line_no(child)
        at = max(line_no - 2, 0) if line_no else len(lines)

        if lines[at - 1]:  # skip if something on this line
            break
        return InsertIndexInfo(insert_index=at, found_directive=True)

    # 5. Otherwise, insert at end
    return InsertIndexInfo(insert_index=len(lines))


def _inject_rtype(  # noqa: C901, PLR0913, PLR0917
    type_hints: di
…[2587 chars omitted]…
_class(type_rst: str) -> str:
    return f":sphinx_autodoc_typehints_type:`{rst.escape(type_rst)}`"


def sphinx_autodoc_typehints_type_role(
    _role: str,
    _rawtext: str,
    text: str,
    _lineno: int,
    inliner: states.Inliner,
    _options: dict[str, Any] | None = None,
    _content: list[str] | None = None,
) -> tuple[list[Node], list[Node]]:
    """
    Add css tag around rendered type.

def _inject_types_to_docstring(  # noqa: PLR0913, PLR0917
    type_hints: dict[str, Any],
    signature: inspect.Signature | None,
    original_obj: Any,
    app: Sphinx,
    what: str,
    name: str,
    lines: list[str],
) -> None:
    if signature is not None:
        _inject_signature(type_hints, signature, app, lines)
    if "return" in type_hints:

        _inject_rtype(type_hints, original_obj, app, what, name, lines)


def _inject_signature(
    type_hints: dict[str, Any],
    signature: inspect.Signature,
    app: Sphinx,

    The body should be escaped rst. This renders its body as rst and wraps the
    result in <span class="sphinx_autodoc_typehints-type"> </span>
    """
    unescaped = unescape(text)
    doc = parse(unescaped, inliner.document.settings)
    n = nodes.inline(text)
    n["classes"].append("sphinx_autodoc_typehints-type")
    n += doc.children[0].children
 
…[1272 chars omitted]…
onnect("autodoc-process-docstring", process_docstring)
    install_patches(app)
    return {"parallel_read_safe": True, "parallel_write_safe": True}


__all__ = [
    "__version__",
    "backfill_type_hints",
    "format_annotation",
    "get_annotation_args",
    "get_annotation_class_name",
    "get_annotation_module",
    "normalize_source_lines",
    "process_docstring",
    "process_signature",
]

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..266a8a5 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:  # circular __wrapped__ reference

+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
     typehints_formatter: Callable[..., str | None] | None = getattr(app.config, "typehints_formatter", None)
 
@@ -432,8 +435,9 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
                 )
           
…[590 chars omitted]…
@ def process_docstring(  # noqa: PLR0913, PLR0917
     if not callable(obj):
         return
     obj = obj.__init__ if inspect.isclass(obj) else obj
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:  # circular __wrapped__ reference
+        return
 
     try:
         signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: Cannot resolve forward reference in type annotations of "demo.Employee.__new__": name 'str' is not defined [sphinx_autodoc_typehints.forward_reference]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 1 warning (with warnings treated as errors).
EXIT:1
--- OUTPUT ---
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(name, id)

      Create new instance of Employee(name, id)

   id: int

      Alias for field number 1

   name: str

      Alias for field number 0

__globals__: {'_tuple_new': <built-in method __new__ of type object at 0x74ed18eea0e0>, '__builtins__': {}, '__name__': 'namedtuple_Employee'}
__annotations__: {'name': ForwardRef('str'), 'id': ForwardRef('int')}
__module__: namedtuple_Employee
get_type_hints: NameError name 'str' is not defined
inspect.getmodule: None
demo module annotations? _Feature((3, 7, 0, 'beta', 1), None, 16777216)
__globals__ keys: ['__builtins__', '__name__', '_tuple_new']

src/sphinx_autodoc_typehints/__init__.py:67:# types has a bunch of things like ModuleType where ModuleType.__module__ is
src/sphinx_autodoc_typehints/__init__.py:105:    if hasattr(annotation, "__module__"):
src/sphinx_autodoc_typehints/__init__.py:106:        return annotation.__module__  # type: ignore[no-any-return]
src/sphinx_autodoc_typehints/__init__.py:108:        return annotation.__origin__.__module__  # type: ignore[no-any-return]
src/sphinx_autodoc_typehints/__init__.py:437:            outer = inspect.getmodule(obj)
src/sphinx_autodoc_typehints/__init__.py:470:    annotations_ = getattr(inspect.getmodule(obj), "annotations", None)
src/sphinx_autodoc_typehints/__init__.py:506:    if hasattr(obj, "__module__"):
src/sphinx_autodoc_typehints/__init__.py:507:        return obj.__module__ in _TYPE_GUARD_IMPORTS_RESOLVED or obj.__module__ in sys.builtin_module_names
src/sphinx_autodoc_typehints/__init__.py:541:    module = inspect.getmodule(obj)

total 12
drwxr-xr-x 3 root root 4096 Nov  5 05:54 .
drwx------ 1 root root 4096 Nov  5 05:54 ..
drwxr-xr-x 4 root root 4096 Nov  5 05:54 pip
/root/.cache
/root/.cache/pip
/root/.cache/pip/selfcheck
/root/.cache/pip/http-v2
_editable_impl_sphinx_autodoc_typehints.pth
sphinx
sphinx-9.1.1.dist-info
sphinx_autodoc_typehints-0.0.0.dist-info

sphinxcontrib
sphinxcontrib_applehelp-2.0.0.dist-info
sphinxcontrib_devhelp-2.0.0.dist-info
sphinxcontrib_htmlhelp-2.1.0.dist-info
sphinxcontrib_jsmath-2.0.0.dist-info
sphinxcontrib_qthelp-2.0.0.dist-info
sphinxcontrib_serializinghtml-2.0.0.dist-info

from typing import NamedTuple


class Employee(NamedTuple):
    """Employee docs."""

    name: str
    id: int
Running Sphinx v9.1.1
loading translations [en]... done
building [mo]: targets for 0 po files that are out of date
writing output... 

building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/repro_namedtuple2/out.
EXIT:0
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(name, id)

      Create new instance of Employee(name, id)

   id: int

      Alias for field number 1

   name: str

      Alias for field number 0

from __future__ import annotations

from dataclasses import dataclass


def undocumented_function(x: int) -> str:
    """Hi"""

    return str(x)


@dataclass

class DataClass:
    """Class docstring."""

    x: int
from __future__ import annotations

import pathlib
import sys

# Make dummy_module.py available for autodoc.
sys.path.insert(0, str(pathlib.Path(__file__).parent))


master_doc = "index"

extensions = [
    "sphinx.ext.autodoc",
    "sphinx.ext.napoleon",
    "sphinx_autodoc_typehints",
]
from __future__ import annotations

import re
import sys
from dataclasses import dataclass
from inspect import isclass
from pathlib import Path
from textwrap import dedent, indent
from typing import (  # no type comments
    TYPE_CHECKING,
    Any,
    Literal,
    NewType,
    Optional,
    TypeVar,
    Union,
    overload,
)

import pytest

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: Cannot resolve forward reference in type annotations of "demo.Employee.__new__": name 'str' is not defined [sphinx_autodoc_typehints.forward_reference]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 1 warning (with warnings treated as errors).
EXIT:1
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(_cls, name: str, id: int)

      Create new instance of Employee(name, id)

   id: int

      Alias for field number 1

   name: str

      Alias for field number 0

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'brotli'

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/repro_namedtuple2/out.
EXIT:0
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(_cls, name: str, id: int)

      Create new instance of Employee(name, id)

   id: int

      Alias for field number 1

   name: str

      Alias for field number 0

For variant 'global', will try loading '/etc/xdg/pip/pip.conf'
For variant 'global', will try loading '/etc/pip.conf'
For variant 'user', will try loading '/root/.pip/pip.conf'
For variant 'user', will try loading '/root/.config/pip/pip.conf'
For variant 'site', will try loading '/usr/local/pip.conf'
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::	ip6-localnet
ff00::	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
# Generated by Docker Engine.

# This file can be edited; Docker Engine will not make further changes once it
# has been modified.

nameserver 192.168.65.7

# Based on host file: '/etc/resolv.conf' (legacy)
# Overrides: []

151.101.0.223 OSError [Errno 101] Network is unreachable
140.82.112.4 OSError [Errno 101] Network is unreachable
1.1.1.1 OSError [Errno 101] Network is unreachable
192.168.65.7 OSError [Errno 101] Network is unreachable

[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
	ignorecase = true
COMMIT_EDITMSG
HEAD
branches
config
description
hooks

index
info
logs
objects
refs

"""Custom patches to make the world work."""

from __future__ import annotations

from functools import lru_cache
from typing import TYPE_CHECKING, Any

from docutils import nodes
from docutils.parsers.rst.directives.admonitions import BaseAdmonition
from docutils.parsers.rst.states import Body, Text
from sphinx.ext.napoleon.docstring import GoogleDocstring

from .attributes_patch import patch_attribute_handling

if TYPE_CHECKING:
    from sphinx.application import Sphinx
    from sphinx.ext.autodoc import Options


def napoleon_numpy_docstring_return_type_processor(  # noqa: PLR0913, PLR0917
    app: Sphinx,
    what: str,
    name: str,  # noqa: ARG001
    obj: Any,  # noqa: ARG001
    options: Options | None,  # noqa: ARG001
    lines: list[str],
) -> None:
    """Insert a : under Returns: to tell napoleon not to look for a return type."""
    if what not in {"function", "method"}:
…[3951 chars omitted]…
install_patches(app: Sphinx) -> None:
    """
    Install the patches.

    :param app: the Sphinx app
    """
    # For Sphinx 9+ directive-based architecture
    fix_directive_based_signature_formatting()
    patch_attribute_handling(app)
    _patch_google_docstring_lookup_annotation()
    fix_napoleon_numpy_docstring_return_type(app)
    _patch_line_numbers()


___all__ = [
    "install_patches",
]

===tests/roots/test-dummy/conf.py
from __future__ import annotations

import pathlib
===tests/roots/test-dummy/dummy_module.py
from __future__ import annotations

from dataclasses import dataclass
===tests/roots/test-dummy/dummy_module_future_annotations.py
from __future__ import annotations

===tests/roots/test-dummy/dummy_module_simple.py
from __future__ import annotations


===tests/roots/test-dummy/dummy_module_simple_default_role.py
from __future__ import annotations


===tests/roots/test-dummy/dummy_module_simple_no_use_rtype.py
from __future__ import annotations


===tests/roots/test-dummy/dummy_module_without_complete_typehints.py
from __future__ import annotations


===tests/roots/test-dummy/export_module.py
from __future__ import annotations

from wrong_module_path import A, f
===tests/roots/test-dummy/wrong_module_path.py
from __future__ import annotations


===tests/roots
…[327 chars omitted]…
 annotations
===tests/roots/test-resolve-typing-guard/conf.py
from __future__ import annotations

import pathlib
===tests/roots/test-resolve-typing-guard/demo_typing_guard.py
"""Module demonstrating imports that are type guarded"""

from __future__ import annotations
===tests/roots/test-resolve-typing-guard/demo_typing_guard_dummy.py
from __future__ import annotations

from typing import TYPE_CHECKING

181:def getslots(obj: Any) -> dict[str, Any] | dict[str, None] | None:
454:def safe_getattr(obj: Any, name: str, *defargs: Any) -> Any:

headers = dict(req.unredirected_hdrs)
        headers.update({k: v for k, v in req.headers.items()
                        if k not in headers})
    
        # TODO(jhylton): Should this be redesigned to handle
        # persistent connections?
    
        # We want to make an HTTP/1.1 request, but the addinfourl
        # class isn't prepared to deal with a persistent connection.
        # It will try to read all remaining data from the socket,
        # which will block while the server waits for the next request.
        # So make sure the connection gets closed after the (only)

        # request.
        headers["Connection"] = "close"
        headers = {name.title(): val for name, val in headers.items()}
    
        if req._tunnel_host:
            tunnel_headers = {}
            proxy_auth_hdr = "Proxy-Authorization"
            if proxy_auth_hdr in headers:
     
…[601 chars omitted]…
r [Errno -3] Temporary failure in name resolution>

/usr/local/lib/python3.12/urllib/request.py:1347: URLError
=========================== short test summary info ============================
ERROR tests/test_sphinx_autodoc_typehints.py::test_format_annotation[str] - u...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
216 passed, 464 warnings, 1 error in 10.34s
EXIT:1

/usr/local/lib/python3.12/site-packages/pip/_vendor/rich/pretty.py:93:def _has_default_namedtuple_repr(obj: object) -> bool:
/usr/local/lib/python3.12/site-packages/pip/_vendor/rich/pretty.py:795:        elif _is_namedtuple(obj) and _has_default_namedtuple_repr(obj):
/usr/local/lib/python3.12/site-packages/typing_extensions.py:3443:    _prohibited_namedtuple_fields = typing._prohibited
/usr/local/lib/python3.12/site-packages/typing_extensions.py:3444:    _special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})
/usr/local/lib/python3.12/site-packages/typing_extensions.py:3484:                if key in _prohibited_namedtuple_fields:
/usr/local/lib/python3.12/site-packages/typing_extensions.py:3486:                elif key not in _special_namedtuple_fields:
/usr/local/lib/python3.12/site-packages/typing_extensions.py:3519:    def _namedtuple_mro_entries(bases):
/usr/local/lib/python3.12/site-packages/typing_extensions.py:3588:    NamedTuple.__mro_entries__ = _namedtuple_mro_entries

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..0d0c53c 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,8 +393,11 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
-    sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
+    try:
+        obj = inspect.unwrap(obj)

+        sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
+    except (ValueError, TypeError):  # circular __wrapped__ reference, or an otherwise uninspectable object
+        return None
     typehints_formatter: Callable[..., str | None] | None = getattr(a
…[1083 chars omitted]…
erence
+        return
+
+    module_name = getattr(obj, "__module__", None)
+    if inspect.getmodule(obj) is None and isinstance(module_name, str) and module_name not in sys.modules:
+        # synthetic modules (e.g. the one generated for a NamedTuple's __new__) cannot be resolved
+        return
 
     try:
         signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/repro_namedtuple/out.
EXIT:0
--- OUTPUT ---
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(name, id)

      Create new instance of Employee(name, id)

   id: int

      Alias for field number 1

   name: str

      Alias for field number 0

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for demo.circular: wrapper loop when unwrapping <function circular at 0x79fb27236480> [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/repro_circular/out.
EXIT:0
Test
****

demo.circular()

   Circular docs.

   Parameters:
      **x** -- value

   Returns:
      string

50:    from sphobjinv import Inventory
407:def test_format_annotation(inv: Inventory, annotation: Any, expected_result: str) -> None:
453:    # Test for the correct role (class vs data) using the official Sphinx inventory
460:        expected_role = next((o.role for o in inv.objects if o.name == name), None)
163:def test_parse_annotation(annotation: Any, module: str, class_name: str, args: tuple[Any, ...]) -> None:
407:def test_format_annotation(inv: Inventory, annotation: Any, expected_result: str) -> None:
479:def test_always_use_bars_union(annotation: str, expected_result: str) -> None:
496:def test_format_annotation_both_libs(library: ModuleType, annotation: str, params: Any, expected_result: str) -> None:
508:def test_process_docstring_slot_wrapper() -> None:
532:def test_always_document_param_types(
592:def test_sphinx_output_future_annotations(app: SphinxTestApp, status: String
…[932 chars omitted]…

ne:
971:def test_sphinx_output_with_use_signature_return(app: SphinxTestApp, status: StringIO) -> None:
1000:def test_sphinx_output_with_use_signature_and_return(app: SphinxTestApp, status: StringIO) -> None:
1030:def test_default_annotation_without_typehints(app: SphinxTestApp, status: StringIO) -> None:
1101:def test_wrong_module_path(app: SphinxTestApp, status: StringIO, warning: StringIO) -> None:

........................................................................ [ 28%]
........................................................................ [ 56%]
........................................................................ [ 85%]
......................................                                   [100%]
254 passed, 90 deselected, 840 warnings in 17.99s
EXIT:0

/usr/local/lib/python3.12/site-packages/sphinx_autodoc_typehints-0.0.0.dist-info
/usr/local/lib/python3.12/site-packages/_editable_impl_sphinx_autodoc_typehints.pth
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc

/usr/local/bin/python: No module named ruff
RUFF_EXIT:1
/usr/local/bin/python: No module named mypy
MYPY_EXIT:1

process_signature circular: None
process_docstring circular lines unchanged: True ['Circular docs.', '', ':param x: value', ':return: string']
namedtuple new module: namedtuple_Employee
process_signature namedtuple new: ('(name, id)', None)
process_docstring namedtuple lines: ['Create new instance of Employee(name, id).']

EXIT:1
Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 2 source files that are out of date
updating environment: [new config] 2 added, 0 changed, 0 removed
reading sources... [ 50%] index
reading sources... [100%] index2

<unknown>:1: WARNING: duplicate object description of demo.Employee, other instance in index, use :no-index: for one of them

<unknown>:1: WARNING: duplicate object description of demo.Employee.__new__, other instance in index, use :no-index: for one of them
looking for now-outdated files... none found
pickling environment... done
checking consistency... /tmp/repro_namedtuple/src/index2.rst: WARNING: document isn't included in any toctree [toc.not_included]
done
preparing documents... done
copying assets... 
copying assets: done
writing output... [ 50%] index
writing output... [100%] index2

build finished with problems, 3 warnings (with warnings treated as errors).
---
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(name, id)

      Create new instance of Employee(name, id)

import sys
sys.path.insert(0, '/tmp/repro_namedtuple/src')
extensions = ['sphinx.ext.autodoc']
master_doc = 'index'
project = 'repro'
Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed

reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/repro_namedtuple_noext/out.
EXIT:0
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(_cls, name: str, id: int)

      Create new instance of Employee(name, id)

M src/sphinx_autodoc_typehints/__init__.py
    :param return_annotation:
    :return:
    """
    if not callable(obj):
        return None

    original_obj = obj
    obj = getattr(obj, "__init__", getattr(obj, "__new__", None)) if inspect.isclass(obj) else obj
    if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
        return None

    try:
        obj = inspect.unwrap(obj)
        sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
    except (ValueError, TypeError):  # circular __wrapped__ reference, or an otherwise uninspectable object
        return None
    typehints_formatter: Callable[..., str | None] | None = getattr(app.config, "typehints_formatter", None)

    def _get_formatted_annotation(annotation: TypeVar) -> TypeVar:
        if typehints_formatter is None:
            retur
…[3289 chars omitted]…
for key, value in app.config["autodoc_type_aliases"].items()}
    type_hints = get_all_type_hints(app.config.autodoc_mock_imports, obj, name, localns)
    app.config._annotation_globals = getattr(obj, "__globals__", {})  # noqa: SLF001
    try:
        _inject_types_to_docstring(type_hints, signature, original_obj, app, what, name, lines)
    finally:
        delattr(app.config, "_annotation_globals")

from __future__ import annotations


def function_with_py310_annotations(
    self,  # noqa: ANN001
    x: bool | None,
    y: int | str | float,  # noqa: PYI041
    z: str | None = None,
) -> str:
    """
    Method docstring.

    :param x: foo
    :param y: bar
    :param z: baz
    """

    contents = (Path(app.srcdir) / "_build/text/index.txt").read_text()
    expected_contents = """\
    dummy_module.undocumented_function(x)

       Hi{undoc_params_0}

       Return type:
          "str"

    class dummy_module.DataClass(x)

       Class docstring.{undoc_params_0}

       __init__(x){undoc_params_1}
    """
    expected_contents = dedent(expected_contents).format(**format_args)
    assert contents == expected_contents


@pytest.mark.sphinx("text", testroot="dummy")
@patch("sphinx.writers.text.MAXWIDTH", 2000)
def test_sphinx_output_future_annotations(app: SphinxTestApp, status: 
…[612 chars omitted]…
z

       Return type:
          "str"
    """
    expected_contents = dedent(expected_contents)
    expected_contents = dedent(expected_contents)
    assert contents == expected_contents


@pytest.mark.sphinx("pseudoxml", testroot="dummy")
@patch("sphinx.writers.text.MAXWIDTH", 2000)
:orphan:

Dummy Module
============

.. autofunction:: dummy_module_future_annotations.function_with_py310_annotations

COMPILE_OK
 src/sphinx_autodoc_typehints/__init__.py | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

name: str,
    lines: list[str],
) -> None:
    if signature is not None:
        _inject_signature(type_hints, signature, app, lines)
    if "return" in type_hints:
        _inject_rtype(type_hints, original_obj, app, what, name, lines)


def _inject_signature(
    type_hints: dict[str, Any],
    signature: inspect.Signature,

    app: Sphinx,
    lines: list[str],
) -> None:
    for arg_name in signature.parameters:
        _inject_arg_signature(type_hints, signature, app, lines, arg_name)


def _inject_arg_signature(
    type_hints: dict[str, Any],
    signature: inspect.Signature,
    app: Sphinx,
    lines: list[str],
    arg_name: str,
) -> None:
    annotation = type_hints.get(arg_name)

    default = signature.parameters[arg_name].default

    if arg_name.endswith("_"):
        arg_name = f"{arg_name[:-1]}\\_"

    insert_index = None
    for at, line in enumerate(lines):
 
…[633 chars omitted]…
notation = False

        if annotation is None:
            type_annotation, has_preexisting_annotation = _find_preexisting_type_annotation(lines, arg_name)
        else:
            short_literals = app.config.python_display_short_literal_types
            formatted_annotation = add_type_css_class(
                format_annotation(annotation, app.config, short_literals=short_literals)
            )

False ('(name, id)', None)
True ('(name: str, id: int)', None)

<function Employee.__new__ at 0x7481511aa5c0> namedtuple_Employee None False {'name': ForwardRef('str'), 'id': ForwardRef('int')}
('(name, id)', None)
['x']

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 2 source files that are out of date
updating environment: [new config] 2 added, 0 changed, 0 removed
reading sources... [ 50%] index
reading sources... [100%] index2

<unknown>:1: WARNING: duplicate object description of demo.Employee, other instance in index, use :no-index: for one of them
<unknown>:1: WARNING: duplicate object description of demo.Employee.__new__, other instance in index, use :no-index: for one of them

looking for now-outdated files... none found
pickling environment... done
checking consistency... /tmp/repro_namedtuple/src/index2.rst: WARNING: document isn't included in any toctree [toc.not_included]
done
preparing documents... done
copying assets... 
copying assets: done
writing output... [ 50%] index
writing output... [100%] index2

build finished with problems, 3 warnings (with warnings treated as errors).
EXIT:1
Test
****

class demo.Employee(name: str, id: int)

   Employee docs.

   static __new__(name: str, id: int)

      Create new instance of Employee(name, id)

........................................................................ [ 28%]
........................................................................ [ 56%]
........................................................................ [ 85%]
......................................                                   [100%]
254 passed, 90 deselected, 840 warnings in 13.26s
EXIT:0

/:
total 68
drwxr-xr-x   1 root root 4096 Nov  5 05:53 .
drwxr-xr-x   1 root root 4096 Nov  5 05:53 ..
-rwxr-xr-x   1 root root    0 Nov  5 05:53 .dockerenv
lrwxrwxrwx   1 root root    7 Jul  4 09:05 bin -> usr/bin
drwxr-xr-x   2 root root 4096 Jul  4 09:05 boot
drwxr-xr-x   5 root root  340 Nov  5 05:53 dev
drwxr-xr-x   1 root root 4096 Nov  5 05:54 etc
drwxr-xr-x   2 root root 4096 Jul  4 09:05 home
lrwxrwxrwx   1 root root    7 Jul  4 09:05 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Jul  4 09:05 lib64 -> usr/lib64

drwxr-xr-x   2 root root 4096 Aug  3 00:00 media
drwxr-xr-x   2 root root 4096 Aug  3 00:00 mnt
drwxr-xr-x   2 root root 4096 Aug  3 00:00 opt
dr-xr-xr-x 296 root root    0 Nov  5 05:53 proc
drwxr-xr-x   1 root root 4096 Nov  5 05:58 repo
drwx------   1 root root 4096 Nov  5 05:54 root
drwxr-xr-x   1 root root 4096 Nov  5 05:54 run
lrwxrwxrwx   1 root root    8 Jul  4 09:05 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 Aug  3 00:00 srv
dr-xr-xr-x  13 root root    0 Oct 28 20:41 sys
drwxrwxrwt   1 root root 4096 Nov  5 06:00 tmp
drwxr-xr-x   1 root root 4096 Aug  3 00:00 usr
drwxr-xr-x   1 root root 4096 Aug  3 00:00 var

/opt:
total 8
drwxr-xr-x 2 root root 4096 Aug  3 00:00 .
drwxr-xr-x 1 root root 4096 Nov  5 05:53 ..

total 120
drwxrwxrwt 1 root root  4096 Nov  5 06:00 .
drwxr-xr-x 1 root root  4096 Nov  5 05:53 ..
-rw-r--r-- 1 root root 41996 Nov  5 05:57 init_guard.py
-rw-r--r-- 1 root root 41996 Nov  5 05:57 init_guard2.py
-rw-r--r-- 1 root root     0 Nov  5 05:54 install.log
drwx------ 5 root root  4096 Nov  5 06:00 pytest-of-root
drwxr-xr-x 4 root root  4096 Nov  5 05:58 repro_circular
-rw-r--r-- 1 root root  1917 Nov  5 05:59 repro_direct.py
drwxr-xr-x 4 root root  4096 Nov  5 06:00 repro_namedtuple
drwxr-xr-x 4 root root  4096 Nov  5 05:57 repro_namedtuple2
drwxr-xr-x 4 root root  4096 Nov  5 05:59 repro_namedtuple_noext

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..0d0c53c 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,8 +393,11 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
-    sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
+    try:
+        obj = inspect.unwrap(obj)

+        sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
+    except (ValueError, TypeError):  # circular __wrapped__ reference, or an otherwise uninspectable object
+        return None
     typehints_formatter: Callable[..., str | None] | None = getattr(a
…[1127 chars omitted]…
getattr(obj, "__module__", None)
+    if inspect.getmodule(obj) is None and isinstance(module_name, str) and module_name not in sys.modules:
+        # synthetic modules (e.g. the one generated for a NamedTuple's __new__) cannot be resolved
+        return
 
     try:
         signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
 M src/sphinx_autodoc_typehints/__init__.py

Local.__new__
namedtuple_Local

…[307 chars omitted]…
ers for both cases (build succeeds with no extension warnings), and ran the existing test suite excluding the network-dependent `test_format_annotation`: 254 passed."}
submitted.

/repo
total 32
drwxr-xr-x 1 root root 4096 Nov  2 10:38 .
drwxr-xr-x 1 root root 4096 Nov  2 10:38 ..
drwxr-xr-x 1 root root 4096 Nov  2 10:38 .git
drwxr-xr-x 1 root root 4096 Nov  2 10:38 .github
-rw-r--r-- 1 root root   94 Nov  2 10:38 .gitignore
-rw-r--r-- 1 root root  104 Nov  2 10:38 .markdownlint.yaml
-rw-r--r-- 1 root root 1211 Nov  2 10:38 .pre-commit-config.yaml
-rw-r--r-- 1 root root 1101 Nov  2 10:38 LICENSE
-rw-r--r-- 1 root root 6883 Nov  2 10:38 README.md
-rw-r--r-- 1 root root   14 Nov  2 10:38 ignore-words.txt

-rw-r--r-- 1 root root 4206 Nov  2 10:38 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  2 10:38 src
drwxr-xr-x 1 root root 4096 Nov  2 10:38 tests
-rw-r--r-- 1 root root 2189 Nov  2 10:38 tox.toml
-rw-r--r-- 1 root root    0 Nov  2 10:38 whitelist.txt
./.git/COMMIT_EDITMSG
./.git/config
./.git/description
./.git/HEAD
./.git/index
./.github/dependabot.yml
./.github/FUNDING.yml
./.github/release.yml
./.github/SECURITY.md
./.gitignore
./.markdownlint.yaml
./.pre-commit-config.yaml
./ignore-words.txt
./LICENSE
./pyproject.toml
./README.md
./tests/conftest.py
./tests/test_integration.py
./tests/test_integration_autodoc_type_aliases.py
./tests/test_integration_issue_384.py
./tests/test_sphinx_autodoc_typehints.py
./tests/test_version.py
./tox.toml
./whitelist.txt

[build-system]
build-backend = "hatchling.build"
requires = [
  "hatch-vcs>=0.5",
  "hatchling>=1.28",
]

[project]
name = "sphinx-autodoc-typehints"
description = "Type hints (PEP 484) support for the Sphinx autodoc extension"
readme.content-type = "text/markdown"
readme.file = "README.md"

keywords = [
  "environments",
  "isolated",
  "testing",
  "virtual",
]
license = "MIT"
maintainers = [
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
]
authors = [
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
]
requires-python = ">=3.12"
classifiers = [
  "Development Status :: 5 - Production/Stable",
  "Framework :: Sphinx :: Extension",
  "Intended Audience :: Developers",
  "License :: OSI Approved :: MIT License",
  "Programming Language :: Python",
  "Programming Language :: Python :: 3 :: Only",
  "Programming Language :: Python :: 3.12",
  "Programming Lan
…[2913 chars omitted]…
,
  ".tox/pypy*/.venv/site-packages",
  ".tox\\*\\.venv\\Lib\\site-packages",
  "*/src",
  "*\\src",
]
report.fail_under = 88
report.omit = []
html.show_contexts = true
html.skip_covered = false

[tool.mypy]
python_version = "3.12"
strict = true
exclude = "^(.*/roots/.*)|(tests/test_integration.*.py)$"
overrides = [
  { module = [
    "sphobjinv.*",
  ], ignore_missing_imports = true },
]
894aa2a base

src/sphinx_autodoc_typehints/__init__.py:13:from typing import TYPE_CHECKING, Any, AnyStr, ForwardRef, NewType, TypeVar, Union, get_type_hints
src/sphinx_autodoc_typehints/__init__.py:67:# types has a bunch of things like ModuleType where ModuleType.__module__ is
src/sphinx_autodoc_typehints/__init__.py:68:# "builtins" and ModuleType.__name__ is "module", so we have to check for this.
src/sphinx_autodoc_typehints/__init__.py:87:def get_annotation_module(annotation: Any) -> str:
src/sphinx_autodoc_typehints/__init__.py:89:    Get module for an annotation.
src/sphinx_autodoc_typehints/__init__.py:105:    if hasattr(annotation, "__module__"):
src/sphinx_autodoc_typehints/__init__.py:106:        return annotation.__module__  # type: ignore[no-any-return]
src/sphinx_autodoc_typehints/__init__.py:108:        return annotation.__origin__.__module__  # type: ignore[no-any-return]
src/sphinx_a
…[4695 chars omitted]…
init__.py:585:        children = module.body  # use the body to ignore type comments
src/sphinx_autodoc_typehints/__init__.py:1079:    app.add_config_value("typehints_fully_qualified", False, "env")  # noqa: FBT003

src/sphinx_autodoc_typehints/__init__.py:1089:    app.add_config_value("typehints_fixup_module_name", None, "env")
src/sphinx_autodoc_typehints/__init__.py:1104:    "get_annotation_module",

tests/test_integration.py:1197:    mod.docstring_with_enum_list_after_params(param)
tests/test_integration.py:1213:def docstring_with_enum_list_after_params(param: int) -> None:
tests/test_sphinx_autodoc_typehints.py:638:    list_item_idxs = [i for i, line in enumerate(contents_lines) if line.strip() == "<list_item>"]

<staticmethod(<function Point.__new__ at 0x7ee521b15760>)> <class 'staticmethod'>
class attr <function Point.__new__ at 0x7ee521b15760> <class 'function'>
module namedtuple_Point None
qual Point.__new__
__annotations__ {'x': <class 'int'>}
signature class attr (_cls, x: int)
dict sig (_cls, x: int)

WARNING: error while formatting signature for model.Point.__new__: Handler <function process_signature at 0x7fc01502d580> for event 'autodoc-process-signature' threw an exception (exception: 'NoneType' object has no attribute 'Point') [autodoc]
BUILD_RC=1 TMP=/tmp/tmp.8GbyLrbpTY

def format_signature(self, **kwargs: Any) -> str:
        if self.config.autodoc_typehints_format == 'short':
            kwargs.setdefault('unqualified_typehints', True)
        if self.config.python_display_short_literal_types:
            kwargs.setdefault('short_literals', True)

        sigs = []
        if (
            self.analyzer
            and '.'.join(self.objpath) in self.analyzer.overloads
            and self.config.autodoc_typehints != 'none'
        ):

            # Use signatures for overloaded functions instead of the implementation function.
            overloaded = True
        else:
            overloaded = False
            sig = super().format_signature(**kwargs)
            sigs.append(sig)

        if inspect.is_singledispatch_function(self.object):
            # append signature of singledispatch'ed functions
            for typ, func in self.object.reg
…[2416 chars omitted]…
gs,
            retann,
        )
        if result:
            args, retann = result

        if args is not None:
            return args + ((' -> %s' % retann) if retann else '')
        else:
            return ''

Traceback (most recent call last):
  File "<stdin>", line 6, in <module>
AttributeError: type object 'FunctionDocumenter' has no attribute 'get_signature'. Did you mean: '_signatures'?

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..b702194 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:

+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
     typehints_formatter: Callable[..., str | None] | None = getattr(app.config, "typehints_formatter", None)
 
@@ -432,8 +435,14 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
                 )
                 return None
             ou
…[748 chars omitted]…
the class name
@@ -732,7 +741,10 @@ def process_docstring(  # noqa: PLR0913, PLR0917
     if not callable(obj):
         return
     obj = obj.__init__ if inspect.isclass(obj) else obj
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:
+        return
 
     try:
         signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])

....................................EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE [ 44%]
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE............................ [ 88%]
...................                                                      [100%]
==================================== ERRORS ====================================
________________ ERROR at setup of test_format_annotation[str] _________________

self = <urllib.request.HTTPSHandler object at 0x7d9b713ea0f0>
http_class = <class 'http.client.HTTPSConnection'>
req = <urllib.request.Request object at 0x7d9b713ea000>
http_conn_args = {'context': <ssl.SSLContext object at 0x7d9b71fa7ed0>}

    def do_open(self, http_class, req, **http_conn_args):

        """Return an HTTPResponse object for the request, using http_class.
    
        http_class must implement the HTTPConnection API from http.client.
        """
        host = req.host
  
…[8631 chars omitted]…
ation[Tuple-p-int-int]
ERROR tests/test_sphinx_autodoc_typehints.py::test_format_annotation[Tuple-p-Ellipsis]
ERROR tests/test_sphinx_autodoc_typehints.py::test_format_annotation[Annotated-metadata]
ERROR tests/test_sphinx_autodoc_typehints.py::test_format_annotation[Required]
ERROR tests/test_sphinx_autodoc_typehints.py::test_format_annotation[NotRequired]
83 passed, 376 warnings, 80 errors in 10.50s

tests/test_sphinx_autodoc_typehints.py::test_always_document_param_types[doc_param_type]
tests/test_sphinx_autodoc_typehints.py::test_always_document_param_types[no_doc_param_type]
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_future_annotations
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_default_role
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_defaults[None-("int") -- bar]
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_defaults[comma-("int", default: "1") -- bar]
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_defaults[braces-("int" (default: "1")) -- bar]
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_defaults[braces-after-("int") -- bar (default: "1")]
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_defaults[comma-after-expected4]
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_forma
…[1072 chars omitted]…
doc_typehints.py::test_sphinx_output_with_use_signature

tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_with_use_signature_return
tests/test_sphinx_autodoc_typehints.py::test_sphinx_output_with_use_signature_and_return
tests/test_sphinx_autodoc_typehints.py::test_default_annotation_without_typehints
tests/test_sphinx_autodoc_typehints.py::test_wrong_module_path

163 tests collected in 0.10s

def _call_format_args(self, **kwargs: Any) -> str:
        if kwargs:
            try:
                return self.format_args(**kwargs)
            except TypeError:
                # avoid chaining exceptions, by putting nothing here
                pass

        # retry without arguments for old documenters
        return self.format_args()

    def format_args(self, **kwargs: Any) -> str:

        if self.config.autodoc_typehints in {'none', 'description'}:
            kwargs.setdefault('show_annotation', False)
        if self.config.autodoc_typehints_format == 'short':
            kwargs.setdefault('unqualified_typehints', True)
        if self.config.python_display_short_literal_types:
            kwargs.setdefault('short_literals', True)

        try:
            self._events.emit('autodoc-before-process-signature', self.object, False)
            sig = inspect.signature(
 
…[2336 chars omitted]…
          overload = evaluate_signature(
                    overload, __globals__, self.config.autodoc_type_aliases
                )

                sig = stringify_signature(overload, **kwargs)
                sigs.append(sig)

        return '\n'.join(sigs)

Traceback (most recent call last):
  File "<stdin>", line 7, in <module>
AttributeError: type object 'Documenter' has no attribute '_events'

407:def test_format_annotation(inv: Inventory, annotation: Any, expected_result: str) -> None:
496:def test_format_annotation_both_libs(library: ModuleType, annotation: str, params: Any, expected_result: str) -> None:
163:def test_parse_annotation(annotation: Any, module: str, class_name: str, args: tuple[Any, ...]) -> None:
407:def test_format_annotation(inv: Inventory, annotation: Any, expected_result: str) -> None:
479:def test_always_use_bars_union(annotation: str, expected_result: str) -> None:
496:def test_format_annotation_both_libs(library: ModuleType, annotation: str, params: Any, expected_result: str) -> None:
508:def test_process_docstring_slot_wrapper() -> None:
532:def test_always_document_param_types(
592:def test_sphinx_output_future_annotations(app: SphinxTestApp, status: StringIO) -> None:
626:def test_sphinx_output_default_role(app: SphinxTestApp, status: StringIO) -
…[840 chars omitted]…
ne:

971:def test_sphinx_output_with_use_signature_return(app: SphinxTestApp, status: StringIO) -> None:
1000:def test_sphinx_output_with_use_signature_and_return(app: SphinxTestApp, status: StringIO) -> None:
1030:def test_default_annotation_without_typehints(app: SphinxTestApp, status: StringIO) -> None:
1101:def test_wrong_module_path(app: SphinxTestApp, status: StringIO, warning: StringIO) -> None:

/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/__init__.py
bash: line 134: rg: command not found

grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/fr/LC_MESSAGES/sphinx.mo: binary file matches
/usr/local/lib/python3.12/site-packages/sphinx/locale/fr/LC_MESSAGES/sphinx.po:3931:msgid "error while formatting arguments for %s: %s"
/usr/local/lib/python3.12/site-packages/sphinx/locale/ta/LC_MESSAGES/sphinx.po:2865:msgid "error while formatting arguments for %s: %s"
grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/sv/LC_MESSAGES/sphinx.mo: binary file matches
/usr/local/lib/python3.12/site-packages/sphinx/locale/sv/LC_MESSAGES/sphinx.po:3903:msgid "error while formatting arguments for %s: %s"
grep: /usr/local/lib/python3.12/site-packages/sphinx/locale/ja/LC_MESSAGES/sphinx.mo: binary file matches
/usr/local/lib/python3.12/site-packages/sphinx/locale/ja/LC_MESSAGES/sphinx.po:3918:msgid "error while formatting arguments for %s: %s"
grep: /usr/local/lib/python3.12/sit
…[8629 chars omitted]…
/_signatures.py:102:            msg = __('error while formatting arguments for %s: %s')
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_legacy_class_based/_documenters.py:358:                    __('error while formatting arguments for %s: %s'),
grep: /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_legacy_class_based/__pycache__/_documenters.cpython-312.pyc: binary file matches

"""Custom patches to make the world work."""

from __future__ import annotations

from functools import lru_cache
from typing import TYPE_CHECKING, Any

from docutils import nodes
from docutils.parsers.rst.directives.admonitions import BaseAdmonition
from docutils.parsers.rst.states import Body, Text
from sphinx.ext.napoleon.docstring import GoogleDocstring

from .attributes_patch import patch_attribute_handling

if TYPE_CHECKING:
    from sphinx.application import Sphinx
    from sphinx.ext.autodoc import Options


def napoleon_numpy_docstring_return_type_processor(  # noqa: PLR0913, PLR0917
    app: Sphinx,
    what: str,
    name: str,  # noqa: ARG001
    obj: Any,  # noqa: ARG001
    options: Options | None,  # noqa: ARG001
    lines: list[str],
) -> None:
    """Insert a : under Returns: to tell napoleon not to look for a return type."""
    if what not in {"function", "method"}:
…[6536 chars omitted]…
2225:                        'autodoc-before-process-signature', self.object, True
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_legacy_class_based/_documenters.py:2870:        self._events.emit('autodoc-before-process-signature', func, False)
grep: /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_legacy_class_based/__pycache__/_documenters.cpython-312.pyc: binary file matches

kwargs['show_return_annotation'] = False

    args, retann = _stringify_signature_to_parts(sig, **kwargs)
    if config.strip_signature_backslash:
        # escape backslashes for reST
        args = args.replace('\\', '\\\\')
        retann = retann.replace('\\', '\\\\')

    return [(args, retann)]


# Types which have confusing metaclass signatures it would be best not to show.

# These are listed by name, rather than storing the objects themselves, to avoid
# needing to import the modules.
_METACLASS_CALL_BLACKLIST = frozenset({
    'enum.EnumType.__call__',
})


# Types whose __new__ signature is a pass-through.
_CLASS_NEW_BLACKLIST = frozenset({
    'typing.Generic.__new__',
})


def _get_signature_object(
    events: EventManager,
    get_attr: _AttrGetter,
    parent: Any,
    preserve_defaults: bool,
    props: _ItemProperties,
    type_aliases: Mapping[str, str] | Non
…[6164 chars omitted]…
ite-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:118:        'autodoc-process-signature',
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:485:    events.emit('autodoc-before-process-signature', obj, is_bound_method)
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:582:        # to the ``autodoc-before-process-signature`` hook.

408:def _extract_signature_from_object(
            stripped_docstrings[i] = prepare_docstring(
                '\n'.join(doclines[j:]), tab_width
            )

            # finish the loop after finding at least one signature
            break

    if not signatures:
        return []

    # Update docstrings from stripped_docstrings if needed

    if props.obj_type in {
        'class',
        'exception',
        'function',
        'method',
        'property',
        'decorator',
    } or (
        props.obj_type == 'attribute'
        and isinstance(props, _AssignStatementProperties)
        and props._obj_is_attribute_descriptor
    ):
        docstrings[:] = stripped_docstrings

    return signatures


def _extract_signature_from_object(
    config: _AutodocConfig,
    events: EventManager,
    get_attr: _AttrGetter,
    parent: Any,
    props: _ItemProperties,
    **kwargs
…[1524 chars omitted]…
_call__',
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_member_finder.py:29:    unwrap_all,
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_member_finder.py:742:    return unwrap_all(obj) is unwrap_all(Enum.__dict__[name])
grep: /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/__pycache__/_member_finder.cpython-312.pyc: binary file matches

True ValueError wrapper loop when unwrapping <function f at 0x785483fb2340>
False (x: int) -> int
withsig True (x: int) -> int
withsig False (x: int) -> int

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..033a577 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:

+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
     typehints_formatter: Callable[..., str | None] | None = getattr(app.config, "typehints_formatter", None)
 
@@ -433,7 +436,9 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
                 return None
             outer = inspect.getmod
…[463 chars omitted]…
the class name
@@ -732,7 +737,10 @@ def process_docstring(  # noqa: PLR0913, PLR0917
     if not callable(obj):
         return
     obj = obj.__init__ if inspect.isclass(obj) else obj
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:
+        return
 
     try:
         signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])

def _should_unwrap(subject: _SignatureType) -> bool:
    """Check the function should be unwrapped on getting signature."""
    __globals__ = getglobals(subject)
    # contextmanger should be unwrapped
    return (
        __globals__.get('__name__') == 'contextlib'
        and __globals__.get('__file__') == contextlib.__file__
    )

<module 'sphinx.util.inspect' from '/usr/local/lib/python3.12/site-packages/sphinx/util/inspect.py'>
def _get_signature_object(
    events: EventManager,

    get_attr: _AttrGetter,
    parent: Any,
    preserve_defaults: bool,
    props: _ItemProperties,
    type_aliases: Mapping[str, str] | None,
    use_type_comments: bool,
) -> Signature | None:
    """Return a Signature for *obj*, or None on failure."""
    obj, is_bound_method = _get_object_for_signature(
        props=props, get_attr=get_attr, parent=parent, type_aliases=type_aliases
    )
    if o
…[938 chars omitted]…
iled to get a method signature for %s: %s')
            else:
                msg = __('Failed to get a signature for %s: %s')
            LOGGER.warning(msg, props.full_name, exc)
            return None
        except ValueError:
            # Still no signature: happens e.g. for old-style classes
            # with __init__ in C and no `__text_signature__`.
            return None

    return None

<class 'ValueError'> wrapper loop when unwrapping <function f at 0x76f6ffaf2340>

def _update_annotations_using_type_comments(obj: Any, bound_method: bool) -> None:
    """Update annotations info of *obj* using type_comments."""
    try:
        type_sig = get_type_comment(obj, bound_method)
        if type_sig:
            sig = inspect.signature(obj, bound_method)
            for param in sig.parameters.values():
                if param.name not in obj.__annotations__:
                    annotation = type_sig.parameters[param.name].annotation
                    if annotation is not Parameter.empty:
                        obj.__annotations__[param.name] = ast_unparse(annotation)

            if 'return' not in obj.__annotations__:
                obj.__annotations__['return'] = type_sig.return_annotation
    except KeyError as exc:
        LOGGER.warning(
            __('Failed to update signature for %r: parameter not found: %s'), obj, exc
        )
    except NotImplementedError as exc:  # failed to ast.unparse()
        LOGGER.warning(__('Failed to parse type_comment for %r: %s'), obj, exc)

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
AttributeError: module 'sphinx.ext.autodoc._dynamic._type_comments' has no attribute '_get_type_comments'. Did you mean: 'get_type_comment'?

BUILD_RC=0 TMP=/tmp/tmp.8GbyLrbpTY
Test
****

class model.Point(x: int, y: str)

   A point.

   x: int

      Alias for field number 0

   y: str

      Alias for field number 1

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..21f936d 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -70,6 +70,9 @@ _TYPES_DICT = {getattr(types, name): name for name in types.__all__}
 # Prefer FunctionType to LambdaType (they are synonymous)
 _TYPES_DICT[types.FunctionType] = "FunctionType"
 
+_MISSING_SIGNATURE = object()
+_CIRCULAR_WRAPPER_SIGNATURES: dict[int, tuple[Any, Any]] = {}
+
 

 class MyTypeAliasForwardRef(TypeAliasForwardRef):
     def __or__(self, value: Any) -> Any:
@@ -364,6 +367,41 @@ def normalize_source_lines(source_lines: str) -> str:
     return "\n".join(aligned_prefix + aligned_suffix)
 
 
+def _prepare_circular_wrapper_signature(obj: Any, _is_bound_method: bool) -> None:
+    """Prevent autodoc from warning when it cannot unwrap a circular
…[3203 chars omitted]…
ints_type", sphinx_autodoc_typehints_type_role)
     app.connect("env-before-read-docs", validate_config)  # config may be changed after “config-inited” event
+    app.connect("autodoc-before-process-signature", _prepare_circular_wrapper_signature)
     app.connect("autodoc-process-signature", process_signature)
     app.connect("autodoc-process-docstring", process_docstring)
     install_patches(app)

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF [ 39%]
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF [ 79%]
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.                                    [100%]
=================================== FAILURES ===================================
______________ test_integration[default_conf-get_local_function] _______________

app = <SphinxTestApp buildername='text'>
status = <_io.StringIO object at 0x78cd4e338940>
warning = <_io.StringIO object at 0x78cd4e338d00>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x78cd4d520b30>
val = <function get_local_function at 0x78cd4e2e2b60>, conf_run = 'default_conf'

    @pytest.mark.parametrize("val", [x for x in globals().values() if hasattr(x, "EXPECTED")])
    @pytest.mark.parametrize("conf_run", ["default_conf", "prolog_conf", "epilog_conf", "bothlog_conf"])
…[8632 chars omitted]…
ature]
FAILED tests/test_integration_autodoc_type_aliases.py::test_integration[default_conf-f]
FAILED tests/test_integration_autodoc_type_aliases.py::test_integration[default_conf-g]
FAILED tests/test_integration_autodoc_type_aliases.py::test_integration[default_conf-function]
FAILED tests/test_integration_issue_384.py::test_integration[default_conf-function]
180 failed, 1 passed, 26 warnings in 8.66s

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/tmp.xiFPe51TkH/out.
NAMEDTUPLE_BUILD_RC=0 TMP=/tmp/tmp.xiFPe51TkH

Test
****

class model.Point(x: int, y: str)

   A point.

   static __new__(x, y)

      Create new instance of Point(x, y)

   x: int

      Alias for field number 0

   y: str

      Alias for field number 1
def _prepare_circular_wrapper_signature(app: Sphinx, obj: Any, _is_bound_method: bool) -> None:
    """Prevent autodoc from warning when it cannot unwrap a circular wrapper."""
    if not callable(obj) or id(obj) in _CIRCULAR_WRAPPER_SIGNATURES:
        return

    try:
        inspect.unwrap(obj)
    except ValueError:
        try:
            previous_signature = getattr(obj, "__signature__", _MISSING_SIGNATURE)
            if previous_signature is not _MISSING_SIGNATURE and previous_signature is not None:
                return
            obj.__signature__ = inspect.Signature()
        except Exception:  # noqa: BLE001
            return
        _CIRCULAR_WRAPPER_SIGNATURES
…[181 chars omitted]…
 loop."""
    record = _CIRCULAR_WRAPPER_SIGNATURES.pop(id(obj), None)
    if record is None or record[0] is not obj:
        return False

    previous_signature = record[1]
    try:
        if previous_signature is _MISSING_SIGNATURE:
            del obj.__signature__
        else:
            obj.__signature__ = previous_signature
    except Exception:  # noqa: BLE001
        pass
    return True

74:_CIRCULAR_WRAPPER_SIGNATURES: dict[int, tuple[Any, Any]] = {}
370:def _prepare_circular_wrapper_signature(_app: Sphinx, obj: Any, _is_bound_method: bool) -> None:
372:    if not callable(obj) or id(obj) in _CIRCULAR_WRAPPER_SIGNATURES:
385:        _CIRCULAR_WRAPPER_SIGNATURES[id(obj)] = (obj, previous_signature)
388:def _restore_circular_wrapper_signature(obj: Any) -> bool:
390:    record = _CIRCULAR_WRAPPER_SIGNATURES.pop(id(obj), None)
426:    if _restore_circular_wrapper_signature(obj):
1140:    app.connect("autodoc-before-process-signature", _prepare_circular_wrapper_signature)

before ValueError wrapper loop when unwrapping <function X.f at 0x72f292a15da0>
before ValueError wrapper loop when unwrapping <function X.f at 0x72f292a15da0>
after <function X.f at 0x72f292a15da0> ()
after ValueError invalid method signature

src/sphinx_autodoc_typehints/__init__.py | 55 ++++++++++++++++++++++++++++++--
 1 file changed, 52 insertions(+), 3 deletions(-)
diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..8300307 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -70,6 +70,9 @@ _TYPES_DICT = {getattr(types, name): name for name in types.__all__}
 # Prefer FunctionType to LambdaType (they are synonymous)
 _TYPES_DICT[types.FunctionType] = "FunctionType"
 
+_MISSING_SIGNATURE = object()
+_CIRCULAR_WRAPPER_SIGNATURES: dict[int, tuple[Any, Any]] = {}

+
 
 class MyTypeAliasForwardRef(TypeAliasForwardRef):
     def __or__(self, value: Any) -> Any:
@@ -364,6 +367,41 @@ def normalize_source_lines(source_lines: str) -> str:
     return "\n".join(aligned_prefix + aligned_suffix)
 
 
+def _prepare_circular_
…[3368 chars omitted]…
ints_type", sphinx_autodoc_typehints_type_role)
     app.connect("env-before-read-docs", validate_config)  # config may be changed after “config-inited” event
+    app.connect("autodoc-before-process-signature", _prepare_circular_wrapper_signature)
     app.connect("autodoc-process-signature", process_signature)
     app.connect("autodoc-process-docstring", process_docstring)
     install_patches(app)

CIRCULAR_BUILD_RC=0
NAMEDTUPLE_BUILD_RC=0

extensions = ['sphinx.ext.autodoc', 'sphinx_autodoc_typehints']
master_doc = 'index'
project = 'test'
def loop(x: int) -> int:
    """A function with a circular wrapped reference."""
    return x
loop.__wrapped__ = loop
Test
====

.. automodule:: model
   :members:

Test
****

model.loop()

   A function with a circular wrapped reference.
1:extensions = ['sphinx.ext.autodoc', 'sphinx_autodoc_typehints']

Running Sphinx v9.1.1
loading translations [en]... done
loading pickled environment... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 0 source files that are out of date
updating environment: 0 added, 0 changed, 0 removed
reading sources... 
looking for now-outdated files... none found
no targets are out of date.
preparing documents... done
copying assets... 

copying assets: done
build succeeded.

The text files are in ../tmp/tmp.RlRvD5WIay/out.
Test
****

model.loop()

   A function with a circular wrapped reference.

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7f5fe207a340> [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 1 warning (with warnings treated as errors).
CIRCULAR_BUILD_RC=1 TMP=/tmp/tmp.RlRvD5WIay
Test
****

model.loop()

   A function with a circular wrapped reference.

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7628f419a480> [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/tmp.RlRvD5WIay/out.

loading translations [en]... locale_dir /tmp/tmp.RlRvD5WIay/locales/en/LC_MESSAGES does not exist
WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7cb778baa480> [autodoc]

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7e63a9f16480> [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/tmp.RlRvD5WIay/out2.
EVENTS:
cat: /tmp/sphinx_events.txt: No such file or directory

extensions = ['sphinx.ext.autodoc', 'sphinx_autodoc_typehints']
master_doc = 'index'
project = 'test'

def check_callback(app, obj, bound):
    with open('/tmp/sphinx_events.txt', 'a') as f:
        f.write(f'EVENT {obj!r} {bound!r} sig={getattr(obj, "__signature__", "MISSING")!r}\\n')

def setup(app):
    app.connect('autodoc-before-process-signature', check_callback, priority=1)
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>

AttributeError: type object 'Sphinx' has no attribute '_load_extensions'

Running Sphinx v9.1.1

Configuration error!

Versions
========

* Platform:         linux; (Linux-6.18.33.2-microsoft-standard-WSL2-x86_64-with-glibc2.41)
* Python version:   3.12.13 (CPython)
* Sphinx version:   9.1.1
* Docutils version: 0.22.4
* Jinja2 version:   3.1.6

* Pygments version: 2.21.0

Last Messages
=============

None.

Loaded Extensions
=================

None.

Traceback
=========

      File "/usr/local/lib/python3.12/site-packages/sphinx/config.py", line 611, in eval_config_file
        raise ConfigError(msg % traceback.format_exc()) from exc
    sphinx.errors.ConfigError: There is a programmable error in your configuration file:
    
    Traceback (most recent call last):
      File "/usr/local/lib/python3.12/site-packages/sphinx/config.py", line 596, in eval_config_file
        exec(code, namespace)  # NoQA: S102
        ^^^^^^^^^^^^^^^^^^^^^
      File "/tmp/tmp.R
…[48 chars omitted]…
sys.path.insert(0, '.')
        ^^^
    NameError: name 'sys' is not defined. Did you forget to import 'sys'


The full traceback has been saved in:
/tmp/sphinx-err-ykw25388.log

To report this error to the developers, please open an issue at <https://github.com/sphinx-doc/sphinx/issues/>. Thanks!
Please also report this if it was a user error, so that a better error message can be provided next time.

Running Sphinx v9.1.1
loading translations [en]... done
SPY SETUP EXECUTED
making output directory... done
CONF SETUP EXECUTED
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7313cb85a520> [autodoc]

looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/tmp.Urvfyqnphj/out.

/tmp/tmp.Urvfyqnphj/index.rst:3:.. automodule:: model
/tmp/tmp.Urvfyqnphj/conf.py:3:extensions = ['sphinx.ext.autodoc', 'sphinx_autodoc_typehints', 'spy']
Test
====
.. automodule:: model
   :members:

Running Sphinx v9.1.1
loading translations [en]... done
SPY SETUP EXECUTED
making output directory... done
CONF SETUP EXECUTED
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index
SPY CALLBACK (<sphinx.application.Sphinx object at 0x7ad8446b6810>, 'module', 'model', <module 'model' from '/tmp/tmp.Urvfyqnphj/model.py'>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')
SPY CALLBACK (<sphinx.application.Sphinx object at 0x7ad8446b6810>, 'function', 'model.loop', <function loop at 0x7ad84311a520>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7ad84311a520> [autodoc]
looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/tmp.Urvfyqnphj/out.

Running Sphinx v9.1.1
loading translations [en]... done
SPY SETUP EXECUTED
making output directory... done
CONF SETUP EXECUTED
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index
SPY AFTER (<sphinx.application.Sphinx object at 0x782c1206a780>, 'module', 'model', <module 'model' from '/tmp/tmp.Urvfyqnphj/model.py'>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')
SPY AFTER (<sphinx.application.Sphinx object at 0x782c1206a780>, 'function', 'model.loop', <function loop at 0x782c10ade5c0>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x782c10ade5c0> [autodoc]
looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/tmp.Urvfyqnphj/out.

[app] adding config value: ('autodoc_use_type_comments', True, 'env', frozenset({<class 'bool'>}))
[app] adding config value: ('autodoc_use_legacy_class_based', False, 'env', frozenset({<class 'bool'>}))
[app] adding event: 'autodoc-before-process-signature'
[app] adding event: 'autodoc-process-docstring'
[app] adding event: 'autodoc-process-signature'
[app] adding event: 'autodoc-skip-member'
[app] adding event: 'autodoc-process-bases'
[app] connecting event 'object-description-transform' (500): <function _merge_typehints at 0x70e0cb8fafc0> [id=63]
--
[app] adding role: ('sphinx_autodoc_typehints_type', <function sphinx_autodoc_typehints_type_role at 0x70e0cb875300>)
[app] connecting event 'env-before-read-docs' (500): <function validate_config at 0x70e0cb875120> [id=65]
[app] connecting event 'autodoc-before-process-signature' (0): <function _prepare_circular_wrapper_signature at 0x

…[8629 chars omitted]…
.application.Sphinx object at 0x70e0cce16cc0>, 'function', 'model.loop', <function loop at 0x70e0cb876660>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')
[app] emitting event: 'autodoc-process-docstring'('function', 'model.loop', <function loop at 0x70e0cb876660>, _AutoDocumenterOptions(members=ALL, _tab_width=8), ['A function with a circular wrapped reference.', ''])
[autodoc] output:

528:[app] adding event: 'autodoc-before-process-signature'
530:[app] adding event: 'autodoc-process-signature'
550:[app] connecting event 'autodoc-before-process-signature' (0): <function _prepare_circular_wrapper_signature at 0x796eab017e20> [id=66]
551:[app] connecting event 'autodoc-process-signature' (0): <function process_signature at 0x796eab017f60> [id=67]
556:[app] connecting event 'autodoc-before-process-signature' (1): <function before at 0x796eab0214e0> [id=70]
557:[app] connecting event 'autodoc-process-signature' (1): <function after at 0x796eab021580> [id=71]
589:[app] emitting event: 'autodoc-process-signature'('module', 'model', <module 'model' from '/tmp/tmp.Urvfyqnphj/model.py'>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')
590:SPY AFTER (<sphinx.application.Sphinx object at 0x796eac5c6a80>, 'module', 'model', <module 'model' from '/tmp/tmp.Urvfyqnphj
…[171 chars omitted]…
 0x796eab022660>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')
618:SPY AFTER (<sphinx.application.Sphinx object at 0x796eac5c6a80>, 'function', 'model.loop', <function loop at 0x796eab022660>, _AutoDocumenterOptions(members=ALL, _tab_width=8), None, '')
634:WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x796eab022660> [autodoc]

def get_type_comment(obj: Any, bound_method: bool = False) -> Signature | None:
    """Get type_comment'ed FunctionDef object from living object.

    This tries to parse original code for living object and returns
    Signature for given *obj*.
    """
    try:
        source = getsource(obj)
        if source.startswith((' ', r'\t')):
            # subject is placed inside class or block.  To read its docstring,
            # this adds if-block before the declaration.
            module = ast.parse('if True:\n' + source, type_comments=True)

            subject = cast('ast.FunctionDef', module.body[0].body[0])  # type: ignore[attr-defined]
        else:
            module = ast.parse(source, type_comments=True)
            subject = cast('ast.FunctionDef', module.body[0])

        type_comment = getattr(subject, 'type_comment', None)
        if type_comment:
            function = as
…[1449 chars omitted]…
        msg = __('Failed to get a constructor signature for %s: %s')
            elif props.obj_type in {'function', 'decorator'}:
                msg = __('Failed to get a function signature for %s: %s')
            elif props.obj_type == 'method':
                msg = __('Failed to get a method signature for %s: %s')
            else:
                msg = __('Failed to get a signature for %s: %s')

Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved., 'credits':     Thanks to CWI, CNRI, BeOpen, Zope Corporation, the Python Software
    Foundation, and a cast of thousands for supporting Python
    development.  See www.python.org for more information., 'license': Type license() to see the full license text, 'help': Type help() for interactive help, or help(object) for help about object.}, True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__cached__', '/tmp/tmp.Urvfyqnphj/__pycache__/model.cpython-312.pyc', True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__doc__', None, True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__file__', '/tmp/tmp.Urvfyqnphj/model.py',
…[2257 chars omitted]…
w-outdated files... [app] emitting event: 'env-get-updated'(<sphinx.environment.BuildEnvironment object at 0x796eadbcac30>,)
none found
pickling environment... done
checking consistency... [app] emitting event: 'env-check-consistency'(<sphinx.environment.BuildEnvironment object at 0x796eadbcac30>,)

done
[app] emitting event: 'write-started'(<sphinx.builders.text.TextBuilder object at 0x796eaba7c3e0>,)

def update_default_value(obj: Any, bound_method: bool) -> None:
    """Update default value info of *obj* using type_comments."""
    try:
        lines = inspect.getsource(obj).splitlines()
        if lines[0].startswith((' ', '\t')):
            # insert a dummy line to follow what _get_arguments() does.
            lines.insert(0, '')
    except (OSError, TypeError):
        lines = []

    try:
        args = _get_arguments(obj)

    except SyntaxError:
        return
    if args is None:
        # If the object is a built-in, we won't be always able to recover
        # the function definition and its arguments. This happens if *obj*
        # is the `__init__` method generated automatically for dataclasses.
        return

    if not args.defaults and not args.kw_defaults:
        return

    try:
        if bound_method and inspect.ismethod(obj) and hasattr(obj, '__func__'):
   
…[6965 chars omitted]…
in or extension types).
        # For user-defined functions, "obj" may not have __dict__,
        # e.g. when decorated with a class that defines __slots__.
        # In this case, we can't set __signature__.
        return
    except NotImplementedError as exc:  # failed to ast_unparse()
        LOGGER.warning(
            __('Failed to parse a default argument value for %r: %s'), obj, exc
        )

/usr/local/lib/python3.12/site-packages/sphinx/util/inspect.py:976:def signature_from_ast(node: ast.FunctionDef, code: str = '') -> Signature:
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_type_comments.py:127:def get_type_comment(obj: Any, bound_method: bool = False) -> Signature | None:
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_type_comments.py:156:def signature_from_ast(
    return ()


def getorigbases(obj: Any) -> tuple[type, ...] | None:
    """Safely get ``obj.__orig_bases__``.

    This returns ``None`` if the object is not a class or if ``__orig_bases__``
    is not well-defined (e.g., a non-tuple object or an empty sequence).
    """

    if not isclass(obj):
        return None

    # Get __orig_bases__ from obj.__dict__ to avoid accessing the parent's __orig_bases__.
    # See: https://github.com/sphinx-doc/sphinx/issues/960
…[6764 chars omitted]…
meter not found: %s'), obj, exc
        )
    except NotImplementedError as exc:  # failed to ast.unparse()
        LOGGER.warning(__('Failed to parse type_comment for %r: %s'), obj, exc)


def get_type_comment(obj: Any, bound_method: bool = False) -> Signature | None:
    """Get type_comment'ed FunctionDef object from living object.

    This tries to parse original code for living object and returns

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x75096f091f80> [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded, 1 warning.

The text files are in ../tmp/tmp.qw9xXYZibC/out.

def before(*args):
    print('SPY BEFORE', repr(args))
def after(*args):
    print('SPY AFTER', repr(args))
def setup(app):
    print('SPY SETUP EXECUTED')
    app.connect('autodoc-before-process-signature', before, priority=1)
    app.connect('autodoc-process-signature', after, priority=1)
    return {'parallel_read_safe': True}

[app] emitting event: 'autodoc-skip-member'('module', '__doc__', None, True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__file__', '/tmp/tmp.Urvfyqnphj/model.py', True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__loader__', <_frozen_importlib_external.SourceFileLoader object at 0x796eab00d760>, True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__name__', 'model', True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__package__', '', True, _AutoDocumenterOptions(members=ALL, _tab_width=8))
[app] emitting event: 'autodoc-skip-member'('module', '__spec__', ModuleSpec(name='model', loader=<_frozen_importlib_external.SourceFileLoader object at 0x
…[1988 chars omitted]…
 _format_signatures(
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:40:def _format_signatures(
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:183:                signatures += _format_signatures(
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:295:                signatures += _format_signatures(

class_doc_from = options.class_doc_from
    else:
        class_doc_from = config.autoclass_content

    docstrings = _get_docstring_lines(
        props,
        class_doc_from=class_doc_from,
        get_attr=get_attr,
        inherit_docstrings=config.autodoc_inherit_docstrings,
        parent=parent,
        tab_width=options._tab_width,
    )

    if docstrings:
        for docstring_lines in docstrings:
            for line in docstring_lines:
                if _hide_value_re.match(line):
                    props._docstrings_has_hide_value = True
                    break

    # format the object's signature, if any
    try:
        signatures = _format_signatures(
            args=args,
            retann=retann,
            autodoc_annotations=current_document.autodoc_annotations,
            config=config,
            docstrings=docstrings,
            events=events,
            get_attr=get_attr,
            parent=parent,
            options=options,
            props=props,
        )
    except Exception as exc:
        msg = __('error while formatting signature for %s: %s')
        LOGGER.warning(msg, props.full_name, exc, type='autodoc')

msg = __('Failed to get a signature for %s: %s')
            LOGGER.warning(msg, props.full_name, exc)
            return None
        except ValueError:
            # Still no signature: happens e.g. for old-style classes
            # with __init__ in C and no `__text_signature__`.
            return None

    return None


def _get_object_for_signature(

    props: _ItemProperties,
    get_attr: _AttrGetter,
    parent: Any,
    type_aliases: Mapping[str, str] | None,
) -> tuple[Any, bool]:
    """Return the object from which we will obtain the signature."""
    obj = props._obj
    if props.obj_type in {'function', 'decorator'}:
        return obj, False

    if props.obj_type in {'class', 'exception'}:
        if isinstance(obj, (NewType, TypeVar)):
            # Suppress signature
            return None, False

        try:
            object_sig = obj.__signatur
…[2419 chars omitted]…
 passed
        # to the ``autodoc-before-process-signature`` hook.
        return obj, False

    if props.obj_type == 'method':
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:465:def _get_signature_object(
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_signatures.py:485:    events.emit('autodoc-before-process-signature', obj, is_bound_method)

# only act if a signature is not explicitly given already, and if
            # the feature is enabled
            result = self._find_signature()
            if result is not None:
                # Discarding _args is a only difference with
                # DocstringSignatureMixin.format_signature.
                # Documenter.format_signature use self.args value to format.
                _args, self.retann = result
        return super().format_signature(**kwargs)


class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type: ignore[misc]

    """Specialized Documenter subclass for functions."""

    objtype = 'function'
    member_order = 30

    @classmethod
    def can_document_member(
        cls: type[Documenter], member: Any, membername: str, isattr: bool, parent: Any
    ) -> bool:
        # supports functions, builtins and bound methods ex
…[5936 chars omitted]…
                  __('error while formatting arguments for %s: %s'),
                    self.fullname,
                    exc,
                    type='autodoc',
                )
                args = None

        result = self._events.emit_firstresult(
            'autodoc-process-signature',
            self.objtype,
            self.fullname,
            self.object,
            self.options,

15:from sphinx.ext.autodoc._dynamic._importer import (
18:from sphinx.ext.autodoc._dynamic._mock import ismock, mock, undecorate
20:from sphinx.ext.autodoc._legacy_class_based._directive_options import (
32:from sphinx.ext.autodoc._legacy_class_based._documenters import (
59:from sphinx.ext.autodoc._legacy_class_based._sentinels import (
196:        'autodoc_use_legacy_class_based', False, 'env', types=frozenset({bool})
216:    if not config.autodoc_use_legacy_class_based:
grep: /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/__pycache__/__init__.cpython-312.pyc: binary file matches
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/__init__.py:196:        'autodoc_use_legacy_class_based', False, 'env', types=frozenset({bool})
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/__init__.py:216:    if not config.autodoc_use_legacy_class_based:

app.add_config_value('autodoc_warningiserror', True, 'env', types=frozenset({bool}))
    app.add_config_value(
        'autodoc_inherit_docstrings', True, 'env', types=frozenset({bool})
    )
    app.add_config_value(
        'autodoc_preserve_defaults', False, 'env', types=frozenset({bool})
    )
    app.add_config_value(
        'autodoc_use_type_comments', True, 'env', types=frozenset({bool})
    )
    app.add_config_value(
        'autodoc_use_legacy_class_based', False, 'env', types=frozenset({bool})

    )

    app.add_event('autodoc-before-process-signature')
    app.add_event('autodoc-process-docstring')
    app.add_event('autodoc-process-signature')
    app.add_event('autodoc-skip-member')
    app.add_event('autodoc-process-bases')

    app.connect('object-description-transform', _merge_typehints)

    app.connect('config-inited', _register_directives)

    return {
      
…[414 chars omitted]…
erty',
            'attribute',
            'data',
            'type',
        ):
            # register the automodule, autoclass, etc. directives
            app.add_directive(f'auto{obj_type}', AutodocDirective)
    else:
        from sphinx.ext.autodoc.preserve_defaults import update_defvalue
        from sphinx.ext.autodoc.type_comment import (
            update_annotations_using_type_comments,

1277:            self._events.emit('autodoc-before-process-signature', self.object, False)
1495:    def _get_signature(self) -> tuple[Any | None, str | None, Signature | None]:
1531:            self._events.emit('autodoc-before-process-signature', call, True)
1550:            self._events.emit('autodoc-before-process-signature', new, True)
1564:            self._events.emit('autodoc-before-process-signature', init, True)
1579:        self._events.emit('autodoc-before-process-signature', self.object, False)
1603:            self._signature_class, _signature_method_name, sig = self._get_signature()
2216:                        'autodoc-before-process-signature', self.object, False
2225:                        'autodoc-before-process-signature', self.object, True
2870:        self._events.emit('autodoc-before-process-signature', func, False)

Running Sphinx v9.1.1
loading translations [en]... done
SPY SETUP EXECUTED
making output directory... done
CONF SETUP EXECUTED
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index
SPY AFTER (<sphinx.application.Sphinx object at 0x711a927ba780>, 'module', 'model', <module 'model' from '/tmp/tmp.Urvfyqnphj/model.py'>, {'members': <sphinx.ext.autodoc._legacy_class_based._sentinels._All object at 0x711a91007920>}, '', None)
SPY BEFORE (<sphinx.application.Sphinx object at 0x711a927ba780>, <function loop at 0x711a90de6b60>, False)

SPY AFTER (<sphinx.application.Sphinx object at 0x711a927ba780>, 'function', 'model.loop', <function loop at 0x711a90de6b60>, {'members': <sphinx.ext.autodoc._legacy_class_based.
…[219 chars omitted]…
ocess-signature' threw an exception (exception: wrapper loop when unwrapping <function loop at 0x711a90de6b60>) [autodoc]
looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 1 warning (with warnings treated as errors).
RC=1

sphinx getsource <function getsource at 0x70e41513a3e0> inspect
def getsource(object):
    """Return the text of the source code for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a single string.  An
    OSError is raised if the source code cannot be retrieved."""
    lines, lnum = getsourcelines(object)
    return ''.join(lines)

inspect getsource unwrap?
def getsource(object):

    """Return the text of the source code for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a single string.  An
    OSError is raised if the source code cannot be retrieved."""
    lines, lnum = getsourcelines(object)
    return ''.join(lines)

def getsourcelines(object):
    """Return a list of source lines and starting line number for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a list of the lines
    corresponding to the object and the line number indicates where in the
    original source file the first line of code was found.  An OSError is
    raised if the source code cannot be retrieved."""
    object = unwrap(object)
    lines, lnum = findsource(object)

    if istraceback(object):

        object = object.tb_frame

    # for module or frame that corresponds to module, return all source lines
    if (ismodule(object) or
        (isframe(object) and object.f_code.co_name == "<module>")):
        return lines, 0
    else:
        return getblock(lines[lnum:]), lnum + 1

def findsource(object):
    """Return the entire sourc
…[1926 chars omitted]…
at = re.compile(r'^(\s*def\s)|(\s*async\s+def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
        while lnum > 0:
            try:
                line = lines[lnum]
            except IndexError:
                raise OSError('lineno is out of bounds')
            if pat.match(line):
                break
            lnum = lnum - 1
        return lines, lnum
    raise OSError('could not find code object')

/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/type_comment.py
type comment module functions [('_update_annotations_using_type_comments', <function _update_annotations_using_type_comments at 0x71287876fba0>), ('update_annotations_using_type_comments', <function update_annotations_using_type_comments at 0x712879016ac0>)]
"""Update annotations info of living objects using type_comments."""

from __future__ import annotations

from typing import TYPE_CHECKING

from sphinx.ext.autodoc._dynamic._type_comments import (
    _update_annotations_using_type_comments,
    not_suppressed,  # NoQA: F401
    signature_from_ast,  # NoQA: F401

)

if TYPE_CHECKING:
    from typing import Any

    from sphinx.application import Sphinx


# Retained: legacy class-based
def update_annotations_using_type_comments(
    app: Sphinx, obj: Any, bound_method: bool
) -> None:
    if not app.config.autodoc_use_type_comments:
        return None

    return _update_annotations_using_type_comments(obj, bound_method)

Traceback (most recent call last):
  File "<stdin>", line 7, in <module>
AttributeError: module 'sphinx.ext.autodoc.type_comment' has no attribute 'get_type_comment'

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..0808623 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -70,7 +70,6 @@ _TYPES_DICT = {getattr(types, name): name for name in types.__all__}
 # Prefer FunctionType to LambdaType (they are synonymous)
 _TYPES_DICT[types.FunctionType] = "FunctionType"
 
-
 class MyTypeAliasForwardRef(TypeAliasForwardRef):
     def __or__(self, value: Any) -> Any:
         return Union[self, value]  # noqa: UP007

@@ -393,7 +392,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:
+        return None

…[2114 chars omitted]…
  def get_type_comment_without_circular_wrappers(obj: Any, bound_method: bool = False) -> Any:
+        try:
+            unwrap(obj)
+        except ValueError:
+            return None
+        return get_type_comment(obj, bound_method)
+
+    _type_comments.get_type_comment = get_type_comment_without_circular_wrappers
+
+
 def install_patches(app: Sphinx) -> None:
     """
     Install the patches.

get_type_comment = _type_comments.get_type_comment

    def get_type_comment_without_circular_wrappers(obj: Any, bound_method: bool = False) -> Any:
        try:
            unwrap(obj)
        except ValueError:
            return None
        return get_type_comment(obj, bound_method)

    _type_comments.get_type_comment = get_type_comment_without_circular_wrappers

def install_patches(app: Sphinx) -> None:
    """
    Install the patches.

    :param app: the Sphinx app
    """
    # For Sphinx 9+ directive-based architecture
    fix_directive_based_signature_formatting()
    patch_attribute_handling(app)
    _patch_google_docstring_lookup_annotation()
    fix_napoleon_numpy_docstring_return_type(app)
    _patch_line_numbers()


___all__ = [
    "install_patches",
]
    "WrapperDescriptorType",
}
_PYDATA_ANNOTATIONS = {
    *(("typing", n) for n in _PYDATA_ANNOTS_TYPING),
   
…[313 chars omitted]…
(they are synonymous)
_TYPES_DICT[types.FunctionType] = "FunctionType"

class MyTypeAliasForwardRef(TypeAliasForwardRef):
    def __or__(self, value: Any) -> Any:
        return Union[self, value]  # noqa: UP007


def _get_types_type(obj: Any) -> str | None:
    try:
        return _TYPES_DICT.get(obj)
    except Exception:  # noqa: BLE001
        # e.g. exception: unhashable type
        return None

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/tmp.ZutKW1qXSI/out.
CIRCULAR_BUILD_RC=0 TMP=/tmp/tmp.ZutKW1qXSI
Test
****

model.loop()

   A function with a circular wrapped reference.

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..033a577 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:

+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
     typehints_formatter: Callable[..., str | None] | None = getattr(app.config, "typehints_formatter", None)
 
@@ -433,7 +436,9 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
                 return None
             outer = inspect.getmod
…[8629 chars omitted]…
signature, original_obj, app, what, name, lines)
    finally:
        delattr(app.config, "_annotation_globals")


def _get_sphinx_line_keyword_and_argument(line: str) -> tuple[str, str | None] | None:
    """
    Extract a keyword, and its optional argument out of a sphinx field option line.

    For example
    >>> _get_sphinx_line_keyword_and_argument(":param parameter:")
    ("param", "parameter")

M src/sphinx_autodoc_typehints/__init__.py
 M src/sphinx_autodoc_typehints/patches.py

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

WARNING: error while formatting arguments for model.loop: wrapper loop when unwrapping <function loop at 0x7a2462e1a3e0> [autodoc]
looking for now-outdated files... none found
pickling environment... done

checking consistency... done
preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build finished with problems, 1 warning (with warnings treated as errors).
PRESERVE_DEFAULTS_BUILD_RC=1 TMP=/tmp/tmp.D40uYpuRhn

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/tmp.D40uYpuRhn/out.
PRESERVE_DEFAULTS_BUILD_RC=0
Test
****

model.loop()

   A function with a circular wrapped reference.
CIRCULAR_BUILD_RC=0
NAMEDTUPLE_BUILD_RC=0

/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_loader.py:11:from sphinx.ext.autodoc._dynamic._docstrings import (
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_loader.py:15:from sphinx.ext.autodoc._dynamic._importer import _import_object
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_loader.py:16:from sphinx.ext.autodoc._dynamic._mock import ismock
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_loader.py:17:from sphinx.ext.autodoc._dynamic._signatures import _format_signatures
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_loader.py:18:from sphinx.ext.autodoc._dynamic._type_comments import (
/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/_loader.py:49:    from sphinx.ext.autodoc._dynamic._importer import _ImportedObject
/usr/local/lib/python3.12/site-pack
…[2131 chars omitted]…
ns import _AutoDocumenterOptions
    from sphinx.ext.autodoc._dynamic._importer import _ImportedObject
    from sphinx.ext.autodoc._property_types import _AutodocFuncProperty, _AutodocObjType
    from sphinx.ext.autodoc._shared import _AttrGetter, _AutodocConfig

_hide_value_re = re.compile(r'^:meta \s*hide-value:( +|$)')


def _load_object_by_name(
    *,
    name: str,
    objtype: _AutodocObjType,

total 152
drwxr-xr-x 3 root root  4096 Nov  2 10:39 .
drwxr-xr-x 5 root root  4096 Nov  2 10:39 ..
-rw-r--r-- 1 root root    54 Nov  2 10:39 __init__.py
drwxr-xr-x 2 root root  4096 Nov  2 10:39 __pycache__
-rw-r--r-- 1 root root 10677 Nov  2 10:39 _docstrings.py
-rw-r--r-- 1 root root 14519 Nov  2 10:39 _importer.py
-rw-r--r-- 1 root root 17547 Nov  2 10:39 _loader.py
-rw-r--r-- 1 root root 31956 Nov  2 10:39 _member_finder.py
-rw-r--r-- 1 root root  6379 Nov  2 10:39 _mock.py
-rw-r--r-- 1 root root  5436 Nov  2 10:39 _preserve_defaults.py
-rw-r--r-- 1 root root 23987 Nov  2 10:39 _signatures.py

-rw-r--r-- 1 root root  1387 Nov  2 10:39 _type_annotations.py
-rw-r--r-- 1 root root  8408 Nov  2 10:39 _type_comments.py
"""The dynamic (import-based) backend for autodoc."""
<module 'sphinx.ext.autodoc._dynamic' from '/usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/__init__.py'> /usr/local/lib/python3.12/site-packages/sphinx/ext/autodoc/_dynamic/__init__.py
True

True

214:145:def format_annotation(annotation: Any, config: Config, *, short_literals: bool = False) -> str:  # noqa: C901, PLR0911, PLR0912, PLR0915, PLR0914
 M src/sphinx_autodoc_typehints/__init__.py
 M src/sphinx_autodoc_typehints/patches.py

diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..033a577 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None
 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:

+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
     typehints_formatter: Callable[..., str | None] | None = getattr(app.config, "typehints_formatter", None)
 
@@ -433,7 +436,9 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
                 return None
             outer = inspect.getmod
…[2805 chars omitted]…
  """
     Install the patches.
@@ -150,6 +188,7 @@ def install_patches(app: Sphinx) -> None:
     :param app: the Sphinx app
     """
     # For Sphinx 9+ directive-based architecture
+    _patch_autodoc_type_comment_unwrap()
     fix_directive_based_signature_formatting()
     patch_attribute_handling(app)
     _patch_google_docstring_lookup_annotation()
<function get_type_comment at 0x7f5012693c40>

233:        from sphinx.ext.autodoc.preserve_defaults import update_defvalue
235:            update_annotations_using_type_comments,
249:        app.connect('autodoc-before-process-signature', update_defvalue)
251:            'autodoc-before-process-signature', update_annotations_using_type_comments

........................................................................ [ 98%]
.                                                                        [100%]
=============================== warnings summary ===============================
tests/test_sphinx_autodoc_typehints.py: 376 warnings
  /usr/local/lib/python3.12/site-packages/sphinx/ext/napoleon/docstring.py:361: RemovedInSphinx11Warning: The mapping interface for autodoc options objects is deprecated, and will be removed in Sphinx 11. Use attribute access instead.
    if options:

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
73 passed, 90 deselected, 376 warnings in 4.80s
........................................................................ [ 39%]
........................................................................ [ 79%]
.....................................                                  

…[191 chars omitted]…
sts/test_integration_issue_384.py: 2 warnings
  /usr/local/lib/python3.12/site-packages/sphinx/ext/napoleon/docstring.py:361: RemovedInSphinx11Warning: The mapping interface for autodoc options objects is deprecated, and will be removed in Sphinx 11. Use attribute access instead.
    if options:

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
181 passed, 464 warnings in 11.10s

# if typ doesn't start with our label, use original function
    if not typ.startswith(TYPE_IS_RST_LABEL):
        assert _parse_annotation is not None  # noqa: S101
        return _parse_annotation(typ, env)
    # Otherwise handle as rst
    typ = typ[len(TYPE_IS_RST_LABEL) :]
    return rst_to_docutils(settings, typ)


def patched_handle_signature(self: PyAttribute, sig: str, signode: desc_signature) -> tuple[str, str]:
    target = "sphinx.domains.python._parse_annotation"
    new_func = partial(patched_parse_annotation, self.state.document.settings)

    with patch(target, new_func):
        return orig_handle_signature(self, sig, signode)


def patch_attribute_handling(app: Sphinx) -> None:  # noqa: ARG001
    """Patch PyAttribute.handle_signature to format class attribute type annotations."""
    if not OKAY_TO_PATCH:
        return
    PyAttribute.handle_signature = patched_
…[452 chars omitted]…
n  # type: ignore[method-assign,assignment]
src/sphinx_autodoc_typehints/patches.py:117:    Body.doctest = _patched_body_doctest  # type: ignore[method-assign]
src/sphinx_autodoc_typehints/patches.py:144:    ModuleAnalyzer.analyze = patched_analyze  # type: ignore[method-assign]
src/sphinx_autodoc_typehints/patches.py:164:    _type_comments.get_type_comment = get_type_comment_without_circular_wrappers

M src/sphinx_autodoc_typehints/__init__.py
 M src/sphinx_autodoc_typehints/patches.py
 src/sphinx_autodoc_typehints/__init__.py | 14 +++++++++---
 src/sphinx_autodoc_typehints/patches.py  | 39 ++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 3 deletions(-)
diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..033a577 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None

 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:
+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.confi
…[3037 chars omitted]…
 def install_patches(app: Sphinx) -> None:
     """
     Install the patches.
@@ -150,6 +188,7 @@ def install_patches(app: Sphinx) -> None:
     :param app: the Sphinx app
     """
     # For Sphinx 9+ directive-based architecture
+    _patch_autodoc_type_comment_unwrap()
     fix_directive_based_signature_formatting()
     patch_attribute_handling(app)
     _patch_google_docstring_lookup_annotation()

try:
        from sphinx.ext.autodoc._dynamic import _type_comments  # noqa: PLC0415
    except ImportError:
        return

    get_type_comment = _type_comments.get_type_comment

    def get_type_comment_without_circular_wrappers(obj: Any, bound_method: bool = False) -> Signature | None:
        try:
            unwrap(obj)
        except ValueError:
            return None

        return get_type_comment(obj, bound_method)

    _type_comments.get_type_comment = get_type_comment_without_circular_wrappers

    try:
        from sphinx.ext.autodoc._dynamic import _preserve_defaults, _signatures  # noqa: PLC0415
    except ImportError:
        return

    update_default_value = _preserve_defaults.update_default_value

    def update_default_value_without_circular_wrappers(obj: Any, bound_method: bool) -> None:
        try:
            unwrap(obj)
        except ValueError:
        
…[220 chars omitted]…
_circular_wrappers


def install_patches(app: Sphinx) -> None:
    """
    Install the patches.

    :param app: the Sphinx app
    """
    # For Sphinx 9+ directive-based architecture
    _patch_autodoc_type_comment_unwrap()
    fix_directive_based_signature_formatting()
    patch_attribute_handling(app)
    _patch_google_docstring_lookup_annotation()
    fix_napoleon_numpy_docstring_return_type(app)

Running Sphinx v9.1.1
loading translations [en]... done
making output directory... done
building [mo]: targets for 0 po files that are out of date
writing output... 
building [text]: targets for 1 source files that are out of date
updating environment: [new config] 1 added, 0 changed, 0 removed
reading sources... [100%] index

looking for now-outdated files... none found
pickling environment... done
checking consistency... done

preparing documents... done
copying assets... 
copying assets: done
writing output... [100%] index

build succeeded.

The text files are in ../tmp/tmp.c8ZKvz1rcr/out.
LEGACY_BUILD_RC=0 TMP=/tmp/tmp.c8ZKvz1rcr

src/sphinx_autodoc_typehints/__init__.py | 14 +++++++++---
 src/sphinx_autodoc_typehints/patches.py  | 39 ++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 3 deletions(-)
 M src/sphinx_autodoc_typehints/__init__.py
 M src/sphinx_autodoc_typehints/patches.py
diff --git a/src/sphinx_autodoc_typehints/__init__.py b/src/sphinx_autodoc_typehints/__init__.py
index a7a020b..033a577 100644
--- a/src/sphinx_autodoc_typehints/__init__.py
+++ b/src/sphinx_autodoc_typehints/__init__.py
@@ -393,7 +393,10 @@ def process_signature(  # noqa: C901, PLR0913, PLR0917
     if not getattr(obj, "__annotations__", None):  # when has no annotation we cannot autodoc typehints so bail
         return None

 
-    obj = inspect.unwrap(obj)
+    try:
+        obj = inspect.unwrap(obj)
+    except ValueError:
+        return None
     sph_signature = sphinx_signature(obj, type_aliases=app.confi
…[3051 chars omitted]…
tall_patches(app: Sphinx) -> None:
     """
     Install the patches.
@@ -150,6 +188,7 @@ def install_patches(app: Sphinx) -> None:
     :param app: the Sphinx app
     """
     # For Sphinx 9+ directive-based architecture
+    _patch_autodoc_circular_wrapper_inspection()
     fix_directive_based_signature_formatting()
     patch_attribute_handling(app)
     _patch_google_docstring_lookup_annotation()

M src/sphinx_autodoc_typehints/__init__.py
 M src/sphinx_autodoc_typehints/patches.py
 src/sphinx_autodoc_typehints/__init__.py | 14 +++++++++---
 src/sphinx_autodoc_typehints/patches.py  | 39 ++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 3 deletions(-)

........................................................................ [ 28%]
........................................................................ [ 56%]
........................................................................ [ 85%]
......................................                                   [100%]
=============================== warnings summary ===============================
tests/test_sphinx_autodoc_typehints.py: 376 warnings
tests/test_integration.py: 456 warnings
tests/test_integration_autodoc_type_aliases.py: 6 warnings
tests/test_integration_issue_384.py: 2 warnings
  /usr/local/lib/python3.12/site-packages/sphinx/ext/napoleon/docstring.py:361: RemovedInSphinx11Warning: The mapping interface for autodoc options objects is deprecated, and will be removed in Sphinx 11. Use attribute access instead.
    if options:

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
254 passed, 90 deselected, 840 warnings in 15.23s

LEGACY_NAMEDTUPLE_BUILD_RC=0 TMP=/tmp/tmp.LB7WvLJTEs

submitted.