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, )