Literal[True] prints as Literal[1] in some cases

[kornicameister]

BPO	39308
Nosy	@gvanrossum, @ilevkivskyi, @kornicameister
PRs	bpo-39308: Make _tp_cache typed #17974
Files	scratch_1.py: snipped to match comment

^{Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.}

Show more details

GitHub fields:

assignee = None
closed_at = <Date 2020-01-17.16:22:53.307>
created_at = <Date 2020-01-11.23:35:15.579>
labels = ['ctypes', 'type-bug', '3.8', '3.9']
title = 'Literal[True] prints as Literal[1] in some cases'
updated_at = <Date 2020-01-17.16:22:53.306>
user = 'https://github.com/kornicameister'

bugs.python.org fields:

activity = <Date 2020-01-17.16:22:53.306>
actor = 'gvanrossum'
assignee = 'none'
closed = True
closed_date = <Date 2020-01-17.16:22:53.307>
closer = 'gvanrossum'
components = ['ctypes']
creation = <Date 2020-01-11.23:35:15.579>
creator = 'kornicameister'
dependencies = []
files = ['48835']
hgrepos = []
issue_num = 39308
keywords = ['patch']
message_count = 5.0
messages = ['359822', '359823', '359831', '359864', '360151']
nosy_count = 3.0
nosy_names = ['gvanrossum', 'levkivskyi', 'kornicameister']
pr_nums = ['17974']
priority = 'normal'
resolution = 'wont fix'
stage = 'resolved'
status = 'closed'
superseder = None
type = 'behavior'
url = 'https://bugs.python.org/issue39308'
versions = ['Python 3.8', 'Python 3.9']

[kornicameister]

Consider code (in attachment) that is being run on Python 3.9.
An expected output of such code ought to be:

(typing_extensions.Literal[1], typing_extensions.Literal[0]) (typing_extensions.Literal[True], typing_extensions.Literal[False])

However that's not the case. An output of the code, given that A is declared first, will be:

(typing.Literal[1], typing.Literal[0]) (typing.Literal[1], typing.Literal[0])

and if B is declared first we receive:

(typing.Literal[True], typing.Literal[False]) (typing.Literal[True], typing.Literal[False])

I believe a reason for that is having bool as subclass of int and consecutively having typing._tp_cache function that declares untyped cache. Indeed changing cached = functools.lru_cache()(func) to cached = functools.lru_cache(typed=True)(func) makes the linked code immune to A and B deceleration order.

[kornicameister]

Also happens in 3.8, so right when Literal got moved to core Python.

[gvanrossum]

No need to open the attachment -- a simpler repro is:

>>> from typing import Literal
>>> Literal[1]
typing.Literal[1]
>>> Literal[True]
typing.Literal[1]
>>> 

However, in a fresh session

>>> from typing import Literal
>>> Literal[True]
typing.Literal[True]
>>> 

This must be because there's a cache in typing.py that use == but doesn't check the type. We can demonstrate that this is the case using a similar equivalence between 2.0 and 2:

>>> Literal[2.0]
typing.Literal[2.0]
>>> Literal[2]
typing.Literal[2.0]
>>> 

It looks like the function _tp_cache() is the culprit -- it uses functools.lru_cache() which apparently uses simple equality.

def _tp_cache(func):
    """..."""
    cached = functools.lru_cache()(func)
    _cleanups.append(cached.cache_clear)

    @functools.wraps(func)
    def inner(*args, **kwds):
        try:
            return cached(*args, **kwds)
        except TypeError:
            pass  # All real errors (not unhashable args) are raised below.
        return func(*args, **kwds)
    return inner

Here's a confusing demo:

>> @functools.lru_cache()
... def f(a): return a
... 
>>> f(1)
1
>>> f(True)
True
>>> f(1)
1
>>> f(1.0)
True
>>> 

(Confusing because it distinguishes between 1 and True, unlike Literal, but it then maps 1.0 to True.)

However a possible fix might be to add typed=True to the functools.lru_cache() call in typing.py, which should have the desired effect (not tested).