Generic function decorated with functools.cache returns the wrong type

[adonig]

Bug report

A generic function decorated with functools.cache returns the wrong type sometimes. Try this example:

from decimal import Decimal
from functools import cache
from typing import SupportsRound, TypeVar

_T = TypeVar("_T")


@cache
def rnd(val: SupportsRound[_T]) -> _T:
    return round(val, 2)


def test_rnd():
    actual = rnd(Decimal("123"))
    assert actual == Decimal("123")
    assert type(actual) == Decimal
    actual = rnd(123.0)
    assert actual == 123.0
    assert type(actual) == float

My understanding is that the test should run without raising any errors but instead the last assertion fails:

./xxx/tests/test_cache.py::test_rnd Failed: [undefined]AssertionError: assert <class 'decimal.Decimal'> == float
 +  where <class 'decimal.Decimal'> = type(Decimal('123.00'))
def test_rnd():
        actual = rnd(Decimal("123"))
        assert actual == Decimal("123")
        assert type(actual) == Decimal
        actual = rnd(123.0)
        assert actual == 123.0
>       assert type(actual) == float
E       AssertionError: assert <class 'decimal.Decimal'> == float
E        +  where <class 'decimal.Decimal'> = type(Decimal('123.00'))

xxx/tests/test_cache.py:19: AssertionError

Your environment

• CPython versions tested on: Python 3.11.0
• Operating system and architecture: Darwin mbp 22.1.0 Darwin Kernel Version 22.1.0: Sun Oct 9 20:14:54 PDT 2022; root:xnu-8792.41.9~2/RELEASE_X86_64 x86_64

[adonig]

I believe this is because functools.cache uses hash to make the cache key. Maybe it should also hash the argument type.

>>> from decimal import Decimal
>>> hash(Decimal("123.0"))
123
>>> hash(123.0)
123
>>> hash(Decimal)
271182336
>>> hash(float)
270673721

EDIT - It looks like it already hashes the type but only when typed=True in lru_cache and by default typed=False when using functools.cache instead of lru_cache:

def cache(user_function, /):
    'Simple lightweight unbounded cache.  Sometimes called "memoize".'
    return lru_cache(maxsize=None)(user_function)

Maybe it should use typing.get_type_hints to detect whether the function is typed (not sure about the performance impact though).

import typing

def cache(user_function, /):
    'Simple lightweight unbounded cache.  Sometimes called "memoize".'
    typed = bool(typing.get_type_hints(user_function))
    return lru_cache(maxsize=None, typed=typed)(user_function)

[FrozenBob]

typed=True isn't supposed to mean the function has type hints. It means that different argument types should be cached separately. This can't be determined just by looking at the function.

If a function needs to behave differently for equal arguments, using functools.cache or functools.lru_cache is likely to be a bad idea. Even with @functools.lru_cache(maxsize=None, typed=True), the cache still isn't going to distinguish between calls like f(0.0) and f(-0.0), or f((1, True)) and f((True, 1)). You'd need an equivalence relation stricter than equality, and Python doesn't really have anything good between == and is.

[adonig]

I understand that this is a won't fix and I'm going to close the issue. We ran into this problem because we wrote some code to automatically wrap all the functions in a big module with the cache decorator to speed up a slow calculation. It was a great improvement and some weeks later we suddenly ran into strange errors and had to debug Decimals coming out of nowhere. Now we moved the function out of the module into a utils module so it doesn't get cached and the errors are gone. Sometimes you just wish Python would be a true functional programming language with referential transparency.

[rhettinger]

Now we moved the function out of the module into a utils module

Why didn't you just change from @cache to @lru_cache(maxsize=None, typed=True)?

[adonig]

@rhettinger It wasn't performance critical to cache this function. The performance of the app was good as long as the other functions were cached and from a logical perspective it made a lot of sense to put it in a utils module.