This decorator returns a "Callable" not a "FunctionType"

[dhruvinsh]

Hi,
with basedmypy 2.6.0 I am having this error, This decorator returns a "Callable" not a "FunctionType". Decorate this decorator with "basedtyping.as_functiontype" or add a 'type: ignore' if it's intentional error.

If anyone can help me here to understand what is the issue that would be great :)
To me it seems that adding Concatenate breaks the check but not sure.

The code in question that is giving error

from __future__ import annotations

import random
from collections.abc import Callable
from functools import wraps
from typing import Concatenate, ParamSpec, TypeVar

class SomeClass:
    """Some random class."""
    pass

P = ParamSpec("P")
T = TypeVar("T", bound=SomeClass)
R = bool | None


def validate(func: Callable[Concatenate[T, P], R]) -> Callable[Concatenate[T, P], R]:
    """Validate something."""

    @wraps(func)
    def inner(first: T, *args: P.args, **kwargs: P.kwargs) -> R:
        # do some crazy evaluation.
        ret = func(*args, **kwargs)
        return ret

    return inner


class NewClass(SomeClass):
    @validate  # This decorator returns a "Callable" not a "FunctionType"
    def foo(self) -> bool:
        """Foo func."""
        # doing some stuff
        return random.choice([True, False])

The code that works,

"""Test validating decorators."""

from __future__ import annotations

import random
from collections.abc import Callable
from functools import wraps
from typing import ParamSpec

P = ParamSpec("P")
R = bool | None


def validate(func: Callable[P, R]) -> Callable[P, R]:
    """Validate something."""

    @wraps(func)
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        # do some crazy evaluation.
        ret = func(*args, **kwargs)
        return ret

    return inner


@validate
def foo() -> bool:
    """Foo func."""
    # doing some stuff
    return random.choice([True, False])

[KotlinIsland]

thaks so much for reaching out, and sorry that you have run into a confusing situation.

tl;dr you are seeing #690

in this situation, basedmypy is warning you about an ambiguous situation regarding functions in classes:

class Call:
    def __call__(self, a: A):
        pass

def decorate(c: Callable[[A], None]) -> Callable[[A], None]:
    return Call()
    
class A:
    @decorate
    def foo(self):
        pass
A().foo()  # runtime error: Call.__call__() missing 1 required positional argument: 'a'

the intent of this error, is that a non-function Callable appears where a 'method' would normally be expected.

functions bind their first parameter, plain callables don't

unfortunately, functools.wraps isn't typed appropriately, such that it works properly at runtime, but it's type definition misleads basedmypy into reporting an error

I can see that this issue is causing you confusion and problems, so I will prioritise the resolution

[dhruvinsh]

unfortunately, functools.wraps isn't typed appropriately, such that it works properly at runtime, but it's type definition misleads basedmypy into reporting an error

Thank you for the investigation and prioritizing the resolution.

[KotlinIsland]

hey, i've done some work and some releases, functools.wraps is now much more correctly typed.

your example can be resolved be using from basedtyping import FunctionType, and using that as the return type of your decorator:

def validate(func: Callable[Concatenate[T, P], R]) -> FunctionType[Concatenate[T, P], R]:
    """Validate something."""

    @wraps(func)
    def inner(first: T, *args: P.args, **kwargs: P.kwargs) -> R:
        # do some crazy evaluation.
        ret = func(*args, **kwargs)
        return ret

    return inner

let me know if you have any questions