`functools.wraps` `Any` in wrapped function

[CoolCat467]

Bug Report

Original Project: https://github.com/CoolCat467/Scanner-Server

functools.wraps decorator seems to find Any in unexpected way

To Reproduce

src/sanescansrv/server.py

from __future__ import annotations

import functools
from typing import TYPE_CHECKING, TypeVar

from quart.templating import stream_template
from werkzeug.exceptions import HTTPException

if TYPE_CHECKING:
    from collections.abc import (
        AsyncIterator,
        Awaitable,
        Callable,
    )

    from typing_extensions import ParamSpec

    PS = ParamSpec("PS")


T = TypeVar("T")


async def send_error(
    page_title: str,
    error_body: str,
    return_link: str | None = None,
) -> AsyncIterator[str]:
    """Stream error page."""
    return await stream_template(
        "error_page.html.jinja",
        page_title=page_title,
        error_body=error_body,
        return_link=return_link,
    )


async def get_exception_page(
    code: int,
    name: str,
    desc: str,
    return_link: str | None = None,
) -> tuple[AsyncIterator[str], int]:
    """Return Response for exception."""
    resp_body = await send_error(
        page_title=f"{code} {name}",
        error_body=desc,
        return_link=return_link,
    )
    return (resp_body, code)


def pretty_exception_name(exc: BaseException) -> str:
    """Make exception into pretty text (split by spaces)."""
    return "error string"


def pretty_exception(
    function: Callable[PS, Awaitable[T]],
) -> Callable[PS, Awaitable[T | tuple[AsyncIterator[str], int]]]:
    """Make exception pages pretty."""

    @functools.wraps(function)
    # types: misc error: Type of decorated function contains type "Any" ("_Wrapped[PS, Awaitable[T], PS, Coroutine[Any, Any, T | tuple[AsyncIterator[str], int]]]")
    async def wrapper(
        *args: PS.args,
        **kwargs: PS.kwargs,
    ) -> T | tuple[AsyncIterator[str], int]:
        code = 500
        name = "Exception"
        desc = "description"
        try:
            return await function(*args, **kwargs)
        except Exception as exception:
            if isinstance(exception, HTTPException):
                code = exception.code or code
                desc = exception.description or desc
                name = exception.name or name
            else:
                exc_name = pretty_exception_name(exception)
                name = f"Internal Server Error ({exc_name})"

        return await get_exception_page(
            code,
            name,
            desc,
        )

    return wrapper

pyproject.toml

[tool.mypy]
files = ["src/sanescansrv/",]
check_untyped_defs = true
disallow_any_decorated = true
disallow_any_generics = true
disallow_any_unimported = true
disallow_incomplete_defs = true
disallow_subclassing_any = true
disallow_untyped_calls = true
disallow_untyped_decorators = true
disallow_untyped_defs = true
ignore_missing_imports = true
local_partial_types = true
no_implicit_optional = true
no_implicit_reexport = true
show_column_numbers = true
show_error_codes = true
show_traceback = true
strict = true
strict_equality = true
warn_redundant_casts = true
warn_return_any = true
warn_unreachable = true
warn_unused_configs = true
warn_unused_ignores = true

Check:

mypy

Expected Behavior
Expected no issues, wrapped function does not use Any from what I understand.

Actual Behavior

src/sanescansrv/server.py:65:5: error: Type of decorated function contains type "Any" ("_Wrapped[PS, Awaitable[T], PS, Coroutine[Any, Any, T | tuple[AsyncIterator[str], int]]]")  [misc]
Found 1 error in 1 file (checked 1 source file)

Your Environment

• Mypy version used: mypy 1.13.0 (compiled: yes)
• Mypy command-line flags: See pyproject.toml above
• Mypy configuration options from mypy.ini (and other config files): See pyproject.toml above
• Python version used: Python 3.12.7 (main, Nov 6 2024, 18:29:01) [GCC 14.2.0] on linux

[region-spotteR]

I stumbled over this myself as well and decided to summarise things a bit. Hoping that someone else can turn this into action. I think needs to be addressed in functools. There is another mypy issue with the same bug: #17171 (comment). I would say it describes the same bug and has the most minimal reproducable example

There is a similar issue in the python repo is here: python/cpython#85403. Will write a comment there next. Not sure if what we describe is similar to them. When I properly annotated the example there, I didn't get the same error

Someone tried to fix this in a PR, however the approach chosen conflicted with a new PEP. Therefore it was abandoned

My reproducable example:

from collections.abc import Awaitable, Callable, Coroutine
from functools import wraps

from starlette.requests import Request
from starlette.responses import Response

type HandlerBefore = Callable[[str], Coroutine[None, None, dict[str, str]]]
type HandlerAfter = Callable[[Request], Awaitable[Response]]


def with_schema() -> Callable[[HandlerBefore], HandlerAfter]:
    def decorator(func: HandlerBefore) -> HandlerAfter:
        @wraps(func)
        async def wrapped(request: Request) -> Response:
            result = await func("some input")
            return Response(content=str(result))

        return wrapped

    return decorator


@with_schema()
async def my_handler(data: str) -> dict[str, str]:
    return {"message": data}

I get the error:

foss_issues/mypy_functool_issue.py:14: error: Type of decorated function contains type "Any" ("_Wrapped[[str], Coroutine[None, None, dict[str, str]], [Request], Coroutine[Any, Any, Response]]")  [misc]
            async def wrapped(request: Request) -> Response:
            ^
foss_issues/mypy_functool_issue.py:18: error: Expression type contains "Any" (has type "_Wrapped[[str], Coroutine[None, None, dict[str, str]], [Request], Coroutine[Any, Any, Response]]")  [misc]
            return wrapped
                   ^~~~~~~

pyproject.toml

[tool.mypy]
python_version = 3.13
strict = true
warn_unused_configs = true
show_error_codes = true
pretty = true
warn_return_any = true
warn_unused_ignores = true
warn_redundant_casts = true
disallow_untyped_defs = true
disallow_any_unimported = true
disallow_any_expr = true
disallow_any_decorated = true
disallow_any_explicit = true
disallow_any_generics = true
check_untyped_defs = true
no_implicit_optional = true
strict_optional = true
strict_equality = true

[region-spotteR]

Before I forget to mention it. My work around so far was to use update_wrapper from functools instead:

update_wrapper(
    wrapped,
    func,
    assigned=("__module__", "__name__", "__qualname__", "__doc__"),
    updated=(),
)

[brianschubert]

FWIW, I believe the CPython issue you mentioned is unrelated. mypy works purely by static analysis and does not depend on the runtime value of __annotations__.