Generation doesn't work with Annotated types

[vstrimaitis]

Versions

python==3.7.7
hypothesis==6.8.3
typing-extensions==3.7.4.3

Also tested with python==3.9.0 and using typing.Annotated instead of typing_extensions.Annotated.

Problem description

hypothesis is unable to generate data for a type if Annotated is added. Example:

import hypothesis.strategies as st
from hypothesis import given
from typing_extensions import Annotated

# @given(st.from_type(int))                  # <-- this works
@given(st.from_type(Annotated[int, "foo"]))  # <-- this doesn't
def test(s):
    print(s)

test()

The error that I receive is as follows:

hypothesis.errors.ResolutionFailed: Could not resolve typing.Annotated[int, 'foo'] to a strategy; consider using register_type_strategy

I tried registering a strategy as the error message suggests like so:

def my_strategy(t):
    raise Exception("Should enter here")

st.register_type_strategy(Annotated, my_strategy)

# ... rest of the example from above

... but the my_strategy function is never called, and the example fails with the same error.

Potential solution

I followed the traceback to the function that failed and discovered this piece of code:

hypothesis/hypothesis-python/src/hypothesis/strategies/_internal/types.py

Lines 207 to 213 in ef0c174

	origin = getattr(thing, "__origin__", thing)
	if (
	typing.Hashable is not collections.abc.Hashable
	and origin in vars(collections.abc).values()
	and len(getattr(thing, "__args__", None) or []) == 0
	):
	return st.from_type(origin)

As far as I've tested, Annotated[int, "foo"].__origin__ returns int, but len(Annotated[int, "foo"].__args__) is 1. I guess adding an extra condition here to check for the case of Annotated would fix the issue, but I'm not familiar with the codebase, so correct me if I'm wrong.

I found no workarounds for the issue, so any suggestions are highly appreciated!

[Zac-HD]

I think adding a clause for Annotated here would indeed fix your problem.

However, we might want to have a separate clause like if is_annotated_type(thing): just after is_typing_literal(), because we have both typing and typing_extensions, plus complications like type(typing_extensions.Annotated[int, "label"]) == typing_extensions._AnnotatedAlias which can probably vary with Python version.

(this would also make it easier for a future PR to support e.g. Annotated[float, lambda x: 0 <= x < 1], and resolve this to st.floats().filter(lambda x: 0 <= x < 1) with a plan (#2701) for st.floats(0, 1, exclude_max=True)... at least if we can convince people that this is the natural interpretation of callable predicates for annotated types)

---

Are you interested in writing a PR for this one?

[vstrimaitis]

Sure, I can take a stab at it. Could you just clarify this part?

we might want to have a separate clause like if is_typing_literal(thing): just after is_typing_literal()

I mean did you intentionally leave the name is_typing_literal in both places here? 😁

[Zac-HD]

Ahem, that's is_annotated_type() 😅