def lists(
elements=None,
min_size=None,
average_size=None,
max_size=None,
unique_by=None,
unique=False,
):
"""Returns a list containing values drawn from elements length in the
interval [min_size, max_size] (no bounds in that direction if these are
None). If max_size is 0 then elements may be None and only the empty list
will be drawn.
average_size may be used as a size hint to roughly control the size
of list but it may not be the actual average of sizes you get, due
to a variety of factors.
If unique is True (or something that evaluates to True), we compare direct
object equality, as if unique_by was `lambda x: x`. This comparison only
works for hashable types.
if unique_by is not None it must be a function returning a hashable type
when given a value drawn from elements. The resulting list will satisfy the
condition that for i != j, unique_by(result[i]) != unique_by(result[j]).
"""
check_valid_sizes(min_size, average_size, max_size)
if elements is None or (max_size is not None and max_size <= 0):
if max_size is None or max_size > 0:
raise InvalidArgument(
u'Cannot create non-empty lists without an element type')
else:
return builds(list)
check_strategy(elements)
if elements.is_empty:
if (min_size or 0) > 0:
raise InvalidArgument(
('Cannot create non-empty lists with elements drawn from '
'strategy %r because it has no values.') % (elements, ))
else:
return builds(list)
if unique:
if unique_by is not None:
raise InvalidArgument(
('cannot specify both unique and unique_by (you probably only '
'want to set unique_by)'))
else:
def unique_by(x):
return x
if unique_by is not None:
from hypothesis.searchstrategy.collections import UniqueListStrategy
check_strategy(elements)
min_size = min_size or 0
max_size = max_size or float(u'inf')
if average_size is None:
if max_size < float(u'inf'):
if max_size <= 5:
average_size = min_size + 0.75 * (max_size - min_size)
else:
average_size = (max_size + min_size) / 2
else:
average_size = max(_AVERAGE_LIST_LENGTH, min_size * 2)
check_valid_sizes(min_size, average_size, max_size)
result = UniqueListStrategy(elements=elements,
average_size=average_size,
max_size=max_size,
min_size=min_size,
key=unique_by)
return result
check_valid_sizes(min_size, average_size, max_size)
from hypothesis.searchstrategy.collections import ListStrategy
if min_size is None:
min_size = 0
if average_size is None:
if max_size is None:
average_size = _AVERAGE_LIST_LENGTH
else:
average_size = (min_size + max_size) * 0.5
check_strategy(elements)
return ListStrategy(
(elements, ),
average_length=average_size,
min_size=min_size,
max_size=max_size,
)
def lists(
elements=None, min_size=None, average_size=None, max_size=None,
unique_by=None
):
"""Returns a list containining values drawn from elements length in the
interval [min_size, max_size] (no bounds in that direction if these are
None). If max_size is 0 then elements may be None and only the empty list
will be drawn.
average_size may be used as a size hint to roughly control the size
of list but it may not be the actual average of sizes you get, due
to a variety of factors.
if unique_by is not None it must be a function returning a hashable type
when given a value drawn from elements. The resulting list will satisfy the
condition that for i != j, unique_by(result[i]) != unique_by(result[j]).
"""
if unique_by is not None:
from hypothesis.searchstrategy.collections import UniqueListStrategy
if max_size == 0:
return builds(list)
check_strategy(elements)
if min_size is not None and elements.template_upper_bound < min_size:
raise InvalidArgument((
u'Cannot generate unique lists of size %d from %r, which '
u'contains no more than %d distinct values') % (
min_size, elements, elements.template_upper_bound,
))
min_size = min_size or 0
max_size = max_size or float(u'inf')
max_size = min(max_size, elements.template_upper_bound)
if average_size is None:
if max_size < float(u'inf'):
if max_size <= 5:
average_size = min_size + 0.75 * (max_size - min_size)
else:
average_size = (max_size + min_size) / 2
else:
average_size = max(
Settings.default.average_list_length,
min_size * 2
)
check_valid_sizes(min_size, average_size, max_size)
result = UniqueListStrategy(
elements=elements,
average_size=average_size,
max_size=max_size,
min_size=min_size,
key=unique_by
)
return result
check_valid_sizes(min_size, average_size, max_size)
from hypothesis.searchstrategy.collections import ListStrategy, \
SingleElementListStrategy
if min_size is None:
min_size = 0
if average_size is None:
if max_size is None:
average_size = Settings.default.average_list_length
else:
average_size = (min_size + max_size) * 0.5
if elements is None or (max_size is not None and max_size <= 0):
if max_size is None or max_size > 0:
raise InvalidArgument(
u'Cannot create non-empty lists without an element type'
)
else:
return ListStrategy(())
else:
check_strategy(elements)
if elements.template_upper_bound == 1:
from hypothesis.searchstrategy.numbers import IntegersFromStrategy
if max_size is None:
length_strat = IntegersFromStrategy(
min_size, average_size=average_size - min_size)
else:
length_strat = integers(min_size, max_size)
return SingleElementListStrategy(elements, length_strat)
return ListStrategy(
(elements,), average_length=average_size,
min_size=min_size, max_size=max_size,
)