python - 是时候举手 throw 了吗？

Question

非常清楚 typing.cast 应该保留给最特殊的特殊场合，现在是时候放弃了吗？？

向函数对象添加自定义属性是一个非常巧妙的技巧(例如 functools.lru_cache )，而且，感谢 Python 的上帝，使用 setattr 这样做是微不足道的。不幸的是，让那些 Shiny 的新属性出现在自动完成前瞻中或通过静态类型检查器和 linters(不隐式或显式求助于 Any)的集合并不是那么微不足道。例如，

def badfoo():
    """not gonna work"""
    print("oh no")
setattr(badfoo, "new_attr", "here it is")
badfoo.new_attr

在运行时有效，但新属性不会出现在自动完成中，也不会被 mypy 或 pylint 识别:

pylint: testvcd.py:38:0: E1101: Function 'badfoo' has no 'new_attr' member (no-member)
mypy:   testvcd.py:38: error: "Callable[[], Any]" has no attribute "new_attr"

使用无类型装饰器添加属性可以防止 pylint 和 mypy 错误，但它不能解决自动完成问题或允许对附加属性进行类型检查。

编辑

感谢@Markus Unterwaditzer，推荐了一种更简洁的方法来获得所需的结果，以及对我试图解决的问题的更精确的陈述，即添加一个静态可发现、类型可检查的自定义函数的属性。 @Markus' recommended method (稍微添加一些以保留装饰函数的签名)将装饰器定义为:

"""attribute_decorator.py: define a `with_attribute` decorator"""

from typing import TypeVar, Generic, Callable, ParamSpec

T = TypeVar("T")
T_ATTR = TypeVar("T_ATTR")
P = ParamSpec("P")

class _FuncWithAttr(Generic[P, T, T_ATTR]):
    new_attr: T_ATTR
    def __call__(self: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
        ...

def with_attribute(value: T_ATTR) -> Callable[[Callable[P, T]], _FuncWithAttr[P, T, T_ATTR]]:
    def inner(f: Callable[P, T]) -> _FuncWithAttr[P, T, T_ATTR]:
        f.new_attr = value  # type: ignore
        return f  # type: ignore
    return inner

和用法:

from attribute_decorator import with_attribute

@with_attribute({"my": "dict"})
def foo(some: int, args: int) -> int:
    return some + args

# typechecks!
x = {"your": "dict"}
x |= foo.new_attr
assert foo(1, 2) == 3

如图所示，Markus 的方法仍然需要一些“# type: ignore”指令。 我仍然希望有人会出现并演示一种无需强制转换即可实现此目的的方法(在下面我的原始解决方案中使用)或忽略(在上面的 Markus 解决方案中使用)，所以如果你知道任何既无聊又仁慈的 mypy 开发人员，请按我的方式发送给他们... XD

除非你对我原来的、更令人困惑的例子感兴趣，否则请停止阅读这里；)

作为一个长期的规避主义者，我开始以一种看似半连贯的方式摸索着绕过这些限制，你瞧，我设法破解了代码……在装饰器用例中……有点儿。 ..**

**我依靠 typing.cast 让它工作。我编写了以下“RollingDefaults”装饰器作为(稍微)实用的示例来演示键入机制。我敢肯定它会在很多用例中无法达到其既定目的，但这不是重点。问题是我是否可以在不依赖 typing.cast 的情况下实现相同的发现/静态检查器好处。请注意，这些好处扩展到对任何和所有附加属性以及传递给包装函数的 args/kwargs 执行类型检查，因此强制转换似乎是一个相当有效的解决方案，至少在表面上是这样。

rolling_defaults.py

"""use the most recently passed parameter values as the defaults for
subsequent calls to the wrapped function and provide visibility to the
current (rolling) and original default parameter values"""
from collections.abc import Callable
from functools import wraps
from typing import Any, Generic, ParamSpec, TypeVar, cast


T = TypeVar("T")
P = ParamSpec("P")


class _RollingDefaultFunc(Generic[P, T]):
    rolling_defaults: dict[str, Any]
    original_defaults: dict[str, Any]

    def __call__(self: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
        ...

    def reset_defaults(self):
        """return to original defaults"""


class RollingDefaults:
    """add "rolling_defaults", "original_defaults", and "reset_defaults"
    attributes to wrapped function
    """

    def __init__(self):
        self.func: Callable
        self._defaults: dict[str, Any]
        self._rolling_defaults: dict[str, Any]

    def __call__(self, func: Callable[P, T]) -> _RollingDefaultFunc[P, T]:
        self.func = func
        self._rolling_defaults = {
            k: v() if isinstance(v, type) else None
            for k, v in func.__annotations__.items()
            if k != "return"
        }
        true_defaults = [] if func.__defaults__ is None else list(func.__defaults__)
        if func.__kwdefaults__ is not None:
            true_defaults.extend(list(func.__kwdefaults__.values()))
        type_defaults = list(self._rolling_defaults.values())
        for diff_idx in reversed(range(len(type_defaults) - len(true_defaults))):
            true_defaults.insert(0, type_defaults[diff_idx])
        self._defaults = dict(zip(self._rolling_defaults, true_defaults))
        self._rolling_defaults |= self._defaults

        @wraps(func)
        def rolling_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
            return self._wrapper(*args, **kwargs)

        setattr(rolling_wrapper, "rolling_defaults", self.rolling_defaults)
        setattr(rolling_wrapper, "original_defaults", self.original_defaults)
        setattr(rolling_wrapper, "reset_defaults", self.reset_defaults)

        #
        # Is cast a good option here?
        #
        return cast(_RollingDefaultFunc[P, T], rolling_wrapper)
        #
        # Is there a better way that doesn't use the cast above?
        #

    @property
    def rolling_defaults(self) -> dict[str, Any]:
        """parameter defaults for the next call"""
        return self._rolling_defaults

    @property
    def original_defaults(self) -> dict[str, Any]:
        """original defaults"""
        return self._defaults

    def reset_defaults(self):
        """reset to originals"""
        self._rolling_defaults |= self._defaults

    def _wrapper(self, *args, **kwargs) -> T:
        self._rolling_defaults |= dict(zip(self._defaults, args))
        self._rolling_defaults |= kwargs
        return self.func(**self._rolling_defaults)

测试卷.py

from rolling_defaults import RollingDefaults

@RollingDefaults()
def foo(bar: int = 1, *, baz: str = "test") -> str:
    return f"{bar=}; {baz=}"

if __name__ == "__main__":
    print(foo())
    print(foo.rolling_defaults)
    print(foo(11, baz="passed"))
    print(foo.rolling_defaults)
    print(foo())
    foo.reset_defaults()
    print(foo.rolling_defaults)
    print(foo())

结果

自动完成适用于新属性并显示正确的调用签名，并且 pylint/mypy 不再引发属性错误，但会引发适当的错误分配给附加属性和/或调用 foo 时传递的错误 arg 值。输出:

>python testroll.py
bar=1; baz='test'
{'bar': 1, 'baz': 'test'}
bar=11; baz='passed'
{'bar': 11, 'baz': 'passed'}
bar=11; baz='passed'
{'bar': 1, 'baz': 'test'}
bar=1; baz='test'

Answer 1

如果核心问题是“我怎样才能在函数上设置一个类型安全的属性”，答案是，在某些方面，您可以封装类型不安全:

from typing import TypeVar, Generic, Callable

T = TypeVar("T")

class FunctionWithAttribute(Generic[T]):
    new_attr: str
    __call__: T

def with_attribute(value: str) -> Callable[[T], FunctionWithAttribute[T]]:
    def inner(f: T) -> FunctionWithAttribute[T]:
        f.new_attr = value  # type: ignore
        return f  # type: ignore

    return inner


@with_attribute("hello")
def foo(some: int, args: int) -> int:
    return some + args

# typechecks!
x: str = foo.new_attr + ""
assert foo(1, 2) == 3

在装饰器内部，你有相当多的转换/忽略正在进行，而在外部则没有。

一个问题:如果你将这个装饰器应用到一个不允许你设置属性的可调用对象上，mypy 将不会捕获它并且你的代码仍然会在导入时崩溃