def accept(*args, **kwargs):
if try_non_lazy:
# Why not try this unconditionally? Because we'd end up with very
# deep nesting of recursive strategies - better to be lazy unless we
# *know* that eager evaluation is the right choice.
try:
return strategy_definition(*args, **kwargs)
except Exception:
# If invoking the strategy definition raises an exception,
# wrap that up in a LazyStrategy so it happens again later.
pass
result = LazyStrategy(strategy_definition, args, kwargs)
if force_reusable_values:
result.force_has_reusable_values = True
assert result.has_reusable_values
return result
def _get_strategies(
*funcs: Callable,
pass_result_to_next_func: bool = False
) -> Dict[str, st.SearchStrategy]:
"""Return a dict of strategies for the union of arguments to `funcs`.
If `pass_result_to_next_func` is True, assume that the result of each function
is passed to the next, and therefore skip the first argument of all but the
first function.
This dict is used to construct our call to the `@given(...)` decorator.
"""
assert funcs, "Must pass at least one function"
given_strategies: Dict[str, st.SearchStrategy] = {}
for i, f in enumerate(funcs):
params = _get_params(f)
if pass_result_to_next_func and i >= 1:
del params[next(iter(params))]
hints = get_type_hints(f)
builder_args = {
k: infer if k in hints else _strategy_for(v)
for k, v in params.items()
}
with _with_any_registered():
strat = st.builds(f,
**builder_args).wrapped_strategy # type: ignore
if strat.args:
raise NotImplementedError("Expected to pass everything as kwargs")
for k, v in strat.kwargs.items():
if _valid_syntax_repr(v)[1] == "nothing()" and k in hints:
# e.g. from_type(Hashable) is OK but the unwrapped repr is not
v = LazyStrategy(st.from_type, (hints[k], ), {})
if k in given_strategies:
given_strategies[k] |= v
else:
given_strategies[k] = v
# If there is only one function, we pass arguments to @given in the order of
# that function's signature. Otherwise, we use alphabetical order.
if len(funcs) == 1:
return {name: given_strategies[name] for name in _get_params(f)}
return dict(sorted(given_strategies.items()))
def test_unrepr_identity_elem():
# Works with inferred identity element
source_code = ghostwriter.binary_operation(compose_types)
exec(source_code, {})
# and also works with explicit identity element
source_code = ghostwriter.binary_operation(compose_types, identity=type)
exec(source_code, {})
@pytest.mark.parametrize(
"strategy, imports",
# The specifics don't matter much here; we're just demonstrating that
# we can walk the strategy and collect all the objects to import.
[
# Lazy from_type() is handled without being unwrapped
(LazyStrategy(from_type, (enum.Enum, ), {}), {("enum", "Enum")}),
# Mapped, filtered, and flatmapped check both sides of the method
(
builds(enum.Enum).map(Decimal),
{("enum", "Enum"), ("decimal", "Decimal")},
),
(
builds(enum.Enum).flatmap(Decimal),
{("enum", "Enum"), ("decimal", "Decimal")},
),
(
builds(enum.Enum).filter(Decimal).filter(re.compile),
{("enum", "Enum"), ("decimal", "Decimal"), ("re", "compile")},
),
# one_of() strategies recurse into all the branches
(
def test_lazy_slow_initialization_issue_2108_regression(data):
# Slow init in strategies wrapped in a LazyStrategy, inside an interactive draw,
# should be attributed to drawing from the strategy (not the test function).
# Specifically, this used to fail with a DeadlineExceeded error.
data.draw(LazyStrategy(slow_init_integers, (), {}))
