def do_filtered_draw(self, data):
# Set of indices that have been tried so far, so that we never test
# the same element twice during a draw.
known_bad_indices = set()
# Start with ordinary rejection sampling. It's fast if it works, and
# if it doesn't work then it was only a small amount of overhead.
for _ in range(3):
i = cu.integer_range(data, 0, len(self.elements) - 1)
if i not in known_bad_indices:
element = self.get_element(i)
if element is not filter_not_satisfied:
return element
if not known_bad_indices:
FilteredStrategy.note_retried(self, data)
known_bad_indices.add(i)
# If we've tried all the possible elements, give up now.
max_good_indices = len(self.elements) - len(known_bad_indices)
if not max_good_indices:
return filter_not_satisfied
# Figure out the bit-length of the index that we will write back after
# choosing an allowed element.
write_length = len(self.elements).bit_length()
# Impose an arbitrary cutoff to prevent us from wasting too much time
# on very large element lists.
cutoff = 10000
max_good_indices = min(max_good_indices, cutoff)
# Before building the list of allowed indices, speculatively choose
# one of them. We don't yet know how many allowed indices there will be,
# so this choice might be out-of-bounds, but that's OK.
speculative_index = cu.integer_range(data, 0, max_good_indices - 1)
# Calculate the indices of allowed values, so that we can choose one
# of them at random. But if we encounter the speculatively-chosen one,
# just use that and return immediately. Note that we also track the
# allowed elements, in case of .map(some_stateful_function)
allowed = []
for i in range(min(len(self.elements), cutoff)):
if i not in known_bad_indices:
element = self.get_element(i)
if element is not filter_not_satisfied:
allowed.append((i, element))
if len(allowed) > speculative_index:
# Early-exit case: We reached the speculative index, so
# we just return the corresponding element.
data.draw_bits(write_length, forced=i)
return element
# The speculative index didn't work out, but at this point we've built
# and can choose from the complete list of allowed indices and elements.
if allowed:
i, element = cu.choice(data, allowed)
data.draw_bits(write_length, forced=i)
return element
# If there are no allowed indices, the filter couldn't be satisfied.
return filter_not_satisfied
def draw_capped_multipart(data,
min_value,
max_value,
duration_names=DATENAMES + TIMENAMES):
assert isinstance(min_value, (dt.date, dt.time, dt.datetime))
assert type(min_value) == type(max_value)
assert min_value <= max_value
result = {}
cap_low, cap_high = True, True
for name in duration_names:
low = getattr(min_value if cap_low else dt.datetime.min, name)
high = getattr(max_value if cap_high else dt.datetime.max, name)
if name == "day" and not cap_high:
_, high = monthrange(**result)
if name == "year":
val = utils.integer_range(data, low, high, 2000)
else:
val = utils.integer_range(data, low, high)
result[name] = val
cap_low = cap_low and val == low
cap_high = cap_high and val == high
if hasattr(min_value, "fold"):
# The `fold` attribute is ignored in comparison of naive datetimes.
# In tz-aware datetimes it would require *very* invasive changes to
# the logic above, and be very sensitive to the specific timezone
# (at the cost of efficient shrinking and mutation), so at least for
# now we stick with the status quo and generate it independently.
result["fold"] = utils.integer_range(data, 0, 1)
return result
def do_draw(self, data):
result = {}
cap_low, cap_high = True, True
for name in ("year", "month", "day", "hour", "minute", "second",
"microsecond"):
low = getattr(self.min_dt if cap_low else dt.datetime.min, name)
high = getattr(self.max_dt if cap_high else dt.datetime.max, name)
if name == "day" and not cap_high:
_, high = monthrange(**result)
if name == "year":
val = utils.integer_range(data, low, high, 2000)
else:
val = utils.integer_range(data, low, high)
result[name] = val
cap_low = cap_low and val == low
cap_high = cap_high and val == high
result = dt.datetime(**result)
tz = data.draw(self.tz_strat)
try:
if is_pytz_timezone(tz):
# Can't just construct; see http://pytz.sourceforge.net
return tz.normalize(tz.localize(result))
return result.replace(tzinfo=tz)
except (ValueError, OverflowError):
msg = "Failed to draw a datetime between %r and %r with timezone from %r."
data.note_event(msg % (self.min_dt, self.max_dt, self.tz_strat))
data.mark_invalid()
def do_draw(self, data):
if len(self.intervals) > 256:
if biased_coin(data, 0.2):
i = integer_range(data, 256, len(self.intervals) - 1)
else:
i = integer_range(data, 0, 255)
else:
i = integer_range(data, 0, len(self.intervals) - 1)
i = self.rewrite_integer(i)
return chr(self.intervals[i])
def test_restricted_bits():
assert (
cu.integer_range(
ConjectureData.for_buffer([1, 0, 0, 0, 0]), lower=0, upper=2 ** 64 - 1
)
== 0
)
def do_draw(self, data):
should_draw = cu.many(
data,
min_size=self.min_size,
max_size=self.max_size,
average_size=self.average_size,
)
seen_sets = tuple(set() for _ in self.keys)
result = []
remaining = LazySequenceCopy(self.element_strategy.elements)
while should_draw.more():
i = len(remaining) - 1
j = cu.integer_range(data, 0, i)
if j != i:
remaining[i], remaining[j] = remaining[j], remaining[i]
value = remaining.pop()
if all(
key(value) not in seen
for (key, seen) in zip(self.keys, seen_sets)):
for key, seen in zip(self.keys, seen_sets):
seen.add(key(value))
result.append(value)
else:
should_draw.reject()
assert self.max_size >= len(result) >= self.min_size
return result
def do_draw(self, data):
return integer_range(
data,
self.lower,
self.upper,
center=self.center,
)
def do_draw(self, data):
should_draw = cu.many(
data,
min_size=self.min_size,
max_size=self.max_size,
average_size=self.average_size,
)
seen_sets = tuple(set() for _ in self.keys)
result = []
remaining = LazySequenceCopy(self.element_strategy.elements)
while remaining and should_draw.more():
i = len(remaining) - 1
j = cu.integer_range(data, 0, i)
if j != i:
remaining[i], remaining[j] = remaining[j], remaining[i]
value = self.element_strategy._transform(remaining.pop())
if value is not filter_not_satisfied and all(
key(value) not in seen
for key, seen in zip(self.keys, seen_sets)):
for key, seen in zip(self.keys, seen_sets):
seen.add(key(value))
if self.tuple_suffixes is not None:
value = (value, ) + data.draw(self.tuple_suffixes)
result.append(value)
else:
should_draw.reject()
assert self.max_size >= len(result) >= self.min_size
return result
def do_draw(self, data):
if self.start is None and self.end is None:
return d.unbounded_integers(data)
if self.start is None:
if self.end <= 0:
return self.end - abs(d.unbounded_integers(data))
else:
probe = self.end + 1
while self.end < probe:
data.start_example(ONE_BOUND_INTEGERS_LABEL)
probe = d.unbounded_integers(data)
data.stop_example(discard=self.end < probe)
return probe
if self.end is None:
if self.start >= 0:
return self.start + abs(d.unbounded_integers(data))
else:
probe = self.start - 1
while probe < self.start:
data.start_example(ONE_BOUND_INTEGERS_LABEL)
probe = d.unbounded_integers(data)
data.stop_example(discard=probe < self.start)
return probe
return d.integer_range(data, self.start, self.end, center=0)
def do_draw(self, data):
machine = data.draw(self_strategy)
bundle = machine.bundle(self.name)
if not bundle:
data.mark_invalid()
reference = bundle.pop()
bundle.insert(integer_range(data, 0, len(bundle)), reference)
return machine.names_to_values[reference.name]
def do_draw(self, data):
return integer_range(
data,
self.lower,
self.upper,
center=self.center,
distribution=self.distribution,
)
def do_draw(self, data):
machine = data.draw(self_strategy)
bundle = machine.bundle(self.name)
if not bundle:
data.mark_invalid()
reference = bundle.pop()
bundle.insert(integer_range(data, 0, len(bundle)), reference)
return machine.names_to_values[reference.name]
def do_draw(self, data):
i = integer_range(
data,
0,
len(self.intervals) - 1,
center=self.zero_point,
)
return hunichr(self.intervals[i])
def do_draw(self, data):
# Reversed Fisher-Yates shuffle. Reverse order so that it shrinks
# propertly: This way we prefer things that are lexicographically
# closer to the identity.
result = list(values)
for i in hrange(len(result)):
j = integer_range(data, i, len(result) - 1)
result[i], result[j] = result[j], result[i]
return result
def do_draw(self, data):
while True:
i = integer_range(
data, 0, len(self.intervals) - 1,
center=self.zero_point,
)
c = hunichr(self.intervals[i])
if c not in self.blacklist_characters:
return c
def do_draw(self, data):
# type: (ConjectureData) -> Ex
n = len(self.element_strategies)
assert n > 0
if n == 1:
return data.draw(self.element_strategies[0])
i = cu.integer_range(data, 0, n - 1)
return data.draw(self.element_strategies[i], label=self.branch_labels[i])
def do_draw(self, data):
# type: (ConjectureData) -> Ex
n = len(self.element_strategies)
assert n > 0
if n == 1:
return data.draw(self.element_strategies[0])
i = cu.integer_range(data, 0, n - 1)
return data.draw(self.element_strategies[i], label=self.branch_labels[i])
def do_draw(self, data):
n = len(self.element_strategies)
assert n > 0
if n == 1:
return data.draw(self.element_strategies[0])
elif self.sampler is None:
i = cu.integer_range(data, 0, n - 1)
else:
i = self.sampler.sample(data)
return data.draw(self.element_strategies[i])
def do_draw(self, data):
n = len(self.element_strategies)
assert n > 0
if n == 1:
return data.draw(self.element_strategies[0])
elif self.sampler is None:
i = cu.integer_range(data, 0, n - 1)
else:
i = self.sampler.sample(data)
return data.draw(self.element_strategies[i])
def do_draw(self, data):
machine = data.draw(self_strategy)
bundle = machine.bundle(self.name)
if not bundle:
data.mark_invalid()
# Shrink towards the right rather than the left. This makes it easier
# to delete data generated earlier, as when the error is towards the
# end there can be a lot of hard to remove padding.
return bundle[
integer_range(data, 0, len(bundle) - 1, center=len(bundle))
]
def do_draw(self, data):
while True:
i = integer_range(
data,
0,
len(self.intervals) - 1,
center=self.zero_point,
)
c = hunichr(self.intervals[i])
if c not in self.blacklist_characters:
return c
def do_draw(self, data):
result = dict()
low_bound = True
high_bound = True
for name in ("days", "seconds", "microseconds"):
low = getattr(self.min_value if low_bound else dt.timedelta.min, name)
high = getattr(self.max_value if high_bound else dt.timedelta.max, name)
val = utils.integer_range(data, low, high, 0)
result[name] = val
low_bound = low_bound and val == low
high_bound = high_bound and val == high
return dt.timedelta(**result)
def do_draw(self, data):
machine = data.draw(self_strategy)
bundle = machine.bundle(self.name)
if not bundle:
data.mark_invalid()
# Shrink towards the right rather than the left. This makes it easier
# to delete data generated earlier, as when the error is towards the
# end there can be a lot of hard to remove padding.
return bundle[integer_range(data,
0,
len(bundle) - 1,
center=len(bundle))]
def do_draw(self, data):
result = {}
low_bound = True
high_bound = True
for name in ("days", "seconds", "microseconds"):
low = getattr(self.min_value if low_bound else dt.timedelta.min, name)
high = getattr(self.max_value if high_bound else dt.timedelta.max, name)
val = utils.integer_range(data, low, high, 0)
result[name] = val
low_bound = low_bound and val == low
high_bound = high_bound and val == high
return dt.timedelta(**result)
def do_draw(self, data):
result = data.draw(self.fixed)
remaining = [k for k in self.optional_keys if not self.optional[k].is_empty]
should_draw = cu.many(
data, min_size=0, max_size=len(remaining), average_size=len(remaining) / 2
)
while should_draw.more():
j = cu.integer_range(data, 0, len(remaining) - 1)
remaining[-1], remaining[j] = remaining[j], remaining[-1]
key = remaining.pop()
result[key] = data.draw(self.optional[key])
return result
def do_draw(self, data):
n = len(self.element_strategies)
if n == 0:
data.mark_invalid()
elif n == 1:
return self.element_strategies[0].do_draw(data)
elif self.sampler is None:
i = cu.integer_range(data, 0, n - 1)
else:
i = self.sampler.sample(data)
return data.draw(self.element_strategies[i])
def do_draw(self, data):
# This strategy is slightly strange in its implementation.
# We don't want the interpretation of the rule we draw to change based
# on whether other rules satisfy their preconditions or have data in
# their bundles. Therefore the index into the rule list needs to stay
# stable. BUT we don't want to draw invalid rules. So what we do is we
# draw an index. We *could* just loop until it's valid, but if most
# rules are invalid then that could result in a very long loop.
# So what we do is the following:
#
# 1. We first draw a rule unconditionally, and check if it's valid.
# If it is, great. Nothing more to do, that's our rule.
# 2. If it is invalid, we now calculate the list of valid rules and
# draw from that list (if there are none, that's an error in the
# definition of the machine and we complain to the user about it).
# 3. Once we've drawn a valid rule, we write that back to the byte
# stream. As a result, when shrinking runs the shrinker can delete
# the initial failed draw + the draw that lead to us finding an
# index into valid_rules, leaving just the written value of i.
# When this is run, it will look as we got lucky and just happened
# to pick a valid rule.
#
# Easy, right?
n = len(self.rules)
i = cu.integer_range(data, 0, n - 1)
u, v = data.blocks[-1]
block_length = v - u
rule = self.rules[i]
if not self.is_valid(rule):
valid_rules = [
j for j, r in enumerate(self.rules) if self.is_valid(r)
]
if not valid_rules:
raise InvalidDefinition(
u'No progress can be made from state %r' %
(self.machine, ))
i = valid_rules[cu.integer_range(data, 0, len(valid_rules) - 1)]
data.write(int_to_bytes(i, block_length))
rule = self.rules[i]
return (rule, data.draw(rule.arguments_strategy))
def do_draw(self, data):
# This strategy is slightly strange in its implementation.
# We don't want the interpretation of the rule we draw to change based
# on whether other rules satisfy their preconditions or have data in
# their bundles. Therefore the index into the rule list needs to stay
# stable. BUT we don't want to draw invalid rules. So what we do is we
# draw an index. We *could* just loop until it's valid, but if most
# rules are invalid then that could result in a very long loop.
# So what we do is the following:
#
# 1. We first draw a rule unconditionally, and check if it's valid.
# If it is, great. Nothing more to do, that's our rule.
# 2. If it is invalid, we now calculate the list of valid rules and
# draw from that list (if there are none, that's an error in the
# definition of the machine and we complain to the user about it).
# 3. Once we've drawn a valid rule, we write that back to the byte
# stream. As a result, when shrinking runs the shrinker can delete
# the initial failed draw + the draw that lead to us finding an
# index into valid_rules, leaving just the written value of i.
# When this is run, it will look as we got lucky and just happened
# to pick a valid rule.
#
# Easy, right?
n = len(self.rules)
i = cu.integer_range(data, 0, n - 1)
u, v = data.blocks[-1].bounds
block_length = v - u
rule = self.rules[i]
if not self.is_valid(rule):
valid_rules = [
j for j, r in enumerate(self.rules) if self.is_valid(r)
]
if not valid_rules:
raise InvalidDefinition(
u'No progress can be made from state %r' % (self.machine,)
)
i = valid_rules[cu.integer_range(data, 0, len(valid_rules) - 1)]
data.write(int_to_bytes(i, block_length))
rule = self.rules[i]
return (rule, data.draw(rule.arguments_strategy))
def _attempt_one_draw(self, data):
result = dict()
cap_low, cap_high = True, True
for name in ("year", "month", "day", "hour", "minute", "second", "microsecond"):
low = getattr(self.min_dt if cap_low else dt.datetime.min, name)
high = getattr(self.max_dt if cap_high else dt.datetime.max, name)
if name == "year":
val = utils.integer_range(data, low, high, 2000)
else:
val = utils.integer_range(data, low, high)
result[name] = val
cap_low = cap_low and val == low
cap_high = cap_high and val == high
tz = data.draw(self.tz_strat)
try:
result = dt.datetime(**result)
if is_pytz_timezone(tz):
# Can't just construct; see http://pytz.sourceforge.net
return tz.normalize(tz.localize(result))
return result.replace(tzinfo=tz)
except (ValueError, OverflowError):
return None
def do_draw(self, data):
n = len(self.element_strategies)
if self.bias is None:
i = cu.integer_range(data, 0, n - 1)
else:
def biased_i(random):
while True:
i = random.randint(0, n - 1)
if random.random() <= self.weights[i]:
return i
i = cu.integer_range_with_distribution(
data, 0, n - 1, biased_i)
return data.draw(self.element_strategies[i])
def do_draw(self, data):
# type: (ConjectureData) -> Ex
n = len(self.element_strategies)
assert n > 0
if n == 1:
return data.draw(self.element_strategies[0])
if self.bias is None:
i = cu.integer_range(data, 0, n - 1)
else:
i = self.sampler.sample(data)
assert 0 <= i < n
return data.draw(self.element_strategies[i], label=self.branch_labels[i])
def do_draw(self, data):
n = len(self.element_strategies)
if self.bias is None:
i = cu.integer_range(data, 0, n - 1)
else:
def biased_i(random):
while True:
i = random.randint(0, n - 1)
if random.random() <= self.weights[i]:
return i
i = cu.integer_range_with_distribution(
data, 0, n - 1, biased_i)
return data.draw(self.element_strategies[i])
def draw_capped_multipart(data, min_value, max_value):
assert isinstance(min_value, (dt.date, dt.time, dt.datetime))
assert type(min_value) == type(max_value)
assert min_value <= max_value
result = {}
cap_low, cap_high = True, True
duration_names_by_type = {
dt.date: DATENAMES,
dt.time: TIMENAMES,
dt.datetime: DATENAMES + TIMENAMES,
}
for name in duration_names_by_type[type(min_value)]:
low = getattr(min_value if cap_low else dt.datetime.min, name)
high = getattr(max_value if cap_high else dt.datetime.max, name)
if name == "day" and not cap_high:
_, high = monthrange(**result)
if name == "year":
val = utils.integer_range(data, low, high, 2000)
else:
val = utils.integer_range(data, low, high)
result[name] = val
cap_low = cap_low and val == low
cap_high = cap_high and val == high
return result
def do_draw(self, data):
# type: (ConjectureData) -> Ex
n = len(self.element_strategies)
assert n > 0
if n == 1:
return data.draw(self.element_strategies[0])
if self.bias is None:
i = cu.integer_range(data, 0, n - 1)
else:
i = self.sampler.sample(data)
assert 0 <= i < n
return data.draw(
self.element_strategies[i], label=self.branch_labels[i])
def do_draw(self, data):
denom = math.log1p(-1 / 127)
def d(random):
if self.special and random.randint(0, 10) == 0:
return random.choice(self.special)
if len(self.intervals) <= 256 or random.randint(0, 1):
i = random.randint(0, len(self.intervals.offsets) - 1)
u, v = self.intervals.intervals[i]
return self.intervals.offsets[i] + random.randint(0, v - u + 1)
else:
return min(
len(self.intervals) - 1,
int(math.log(random.random()) / denom))
while True:
i = integer_range(
data, 0, len(self.intervals) - 1,
center=self.zero_point, distribution=d
)
c = hunichr(self.intervals[i])
if c not in self.blacklist_characters:
return c
def do_draw(self, data):
while True:
try:
result = dt.datetime(
year=cu.centered_integer_range(data, self.min_year, self.max_year, 2000),
month=cu.integer_range(data, 1, 12),
day=cu.integer_range(data, 1, 31),
hour=cu.integer_range(data, 0, 24),
minute=cu.integer_range(data, 0, 59),
second=cu.integer_range(data, 0, 59),
microsecond=cu.integer_range(data, 0, 999999),
)
if not self.allow_naive or (self.timezones and cu.boolean(data)):
result = cu.choice(data, self.timezones).localize(result)
return result
except (OverflowError, ValueError):
pass
def do_draw(self, data):
while True:
try:
result = dt.datetime(
year=cu.centered_integer_range(data, self.min_year,
self.max_year, 2000),
month=cu.integer_range(data, 1, 12),
day=cu.integer_range(data, 1, 31),
hour=cu.integer_range(data, 0, 24),
minute=cu.integer_range(data, 0, 59),
second=cu.integer_range(data, 0, 59),
microsecond=cu.integer_range(data, 0, 999999))
if (not self.allow_naive
or (self.timezones and cu.boolean(data))):
result = cu.choice(data, self.timezones).localize(result)
return result
except (OverflowError, ValueError):
pass
def do_filtered_draw(self, data, filter_strategy):
# Set of indices that have been tried so far, so that we never test
# the same element twice during a draw.
known_bad_indices = set()
def check_index(i):
"""Return ``True`` if the element at ``i`` satisfies the filter
condition.
"""
if i in known_bad_indices:
return False
ok = filter_strategy.condition(self.elements[i])
if not ok:
if not known_bad_indices:
filter_strategy.note_retried(data)
known_bad_indices.add(i)
return ok
# Start with ordinary rejection sampling. It's fast if it works, and
# if it doesn't work then it was only a small amount of overhead.
for _ in hrange(3):
i = d.integer_range(data, 0, len(self.elements) - 1)
if check_index(i):
return self.elements[i]
# If we've tried all the possible elements, give up now.
max_good_indices = len(self.elements) - len(known_bad_indices)
if not max_good_indices:
return filter_not_satisfied
# Figure out the bit-length of the index that we will write back after
# choosing an allowed element.
write_length = bit_length(len(self.elements))
# Impose an arbitrary cutoff to prevent us from wasting too much time
# on very large element lists.
cutoff = 10000
max_good_indices = min(max_good_indices, cutoff)
# Before building the list of allowed indices, speculatively choose
# one of them. We don't yet know how many allowed indices there will be,
# so this choice might be out-of-bounds, but that's OK.
speculative_index = d.integer_range(data, 0, max_good_indices - 1)
# Calculate the indices of allowed values, so that we can choose one
# of them at random. But if we encounter the speculatively-chosen one,
# just use that and return immediately.
allowed_indices = []
for i in hrange(min(len(self.elements), cutoff)):
if check_index(i):
allowed_indices.append(i)
if len(allowed_indices) > speculative_index:
# Early-exit case: We reached the speculative index, so
# we just return the corresponding element.
data.draw_bits(write_length, forced=i)
return self.elements[i]
# The speculative index didn't work out, but at this point we've built
# the complete list of allowed indices, so we can just choose one of
# them.
if allowed_indices:
i = d.choice(data, allowed_indices)
data.draw_bits(write_length, forced=i)
return self.elements[i]
# If there are no allowed indices, the filter couldn't be satisfied.
return filter_not_satisfied
def do_draw(self, data):
return integer_range(
data, self.lower, self.upper, center=self.center,
distribution=self.distribution,
)
def test_does_draw_data_for_empty_range():
data = ConjectureData.for_buffer(b"\1")
assert cu.integer_range(data, 1, 1) == 1
data.freeze()
assert data.buffer == hbytes(b"\0")
def do_draw(self, data):
days = utils.integer_range(data, 0, self.days_apart, center=self.center)
return self.min_value + dt.timedelta(days=days)
def _hypothesis_do_random(self, method, kwargs):
if method == "choices":
key = (method, len(kwargs["population"]), kwargs.get("k"))
elif method == "choice":
key = (method, len(kwargs["seq"]))
elif method == "shuffle":
key = (method, len(kwargs["x"]))
else:
key = (method, ) + tuple(sorted(kwargs))
try:
result, self.__state = self.__state.next_states[key]
except KeyError:
pass
else:
return self.__convert_result(method, kwargs, result)
if method == "_randbelow":
result = cu.integer_range(self.__data, 0, kwargs["n"] - 1)
elif method in ("betavariate", "random"):
result = self.__data.draw(UNIFORM)
elif method == "uniform":
a = normalize_zero(kwargs["a"])
b = normalize_zero(kwargs["b"])
result = self.__data.draw(st.floats(a, b))
elif method in ("weibullvariate", "gammavariate"):
result = self.__data.draw(
st.floats(min_value=0.0, allow_infinity=False))
elif method in ("gauss", "normalvariate"):
mu = kwargs["mu"]
result = mu + self.__data.draw(
st.floats(allow_nan=False, allow_infinity=False))
elif method == "vonmisesvariate":
result = self.__data.draw(st.floats(0, 2 * math.pi))
elif method == "randrange":
if kwargs["stop"] is None:
stop = kwargs["start"]
start = 0
else:
start = kwargs["start"]
stop = kwargs["stop"]
step = kwargs["step"]
if start == stop:
raise ValueError("empty range for randrange(%d, %d, %d)" %
(start, stop, step))
if step != 1:
endpoint = (stop - start) // step
if (start - stop) % step == 0:
endpoint -= 1
i = cu.integer_range(self.__data, 0, endpoint)
result = start + i * step
else:
result = cu.integer_range(self.__data, start, stop - 1)
elif method == "randint":
result = cu.integer_range(self.__data, kwargs["a"], kwargs["b"])
elif method == "choice":
seq = kwargs["seq"]
result = cu.integer_range(self.__data, 0, len(seq) - 1)
elif method == "choices":
k = kwargs["k"]
result = self.__data.draw(
st.lists(
st.integers(0,
len(kwargs["population"]) - 1),
min_size=k,
max_size=k,
))
elif method == "sample":
k = kwargs["k"]
seq = kwargs["population"]
if k > len(seq) or k < 0:
raise ValueError(
"Sample size %d not in expected range 0 <= k <= %d" %
(k, len(seq)))
result = self.__data.draw(
st.lists(
st.sampled_from(range(len(seq))),
min_size=k,
max_size=k,
unique=True,
))
elif method == "getrandbits":
result = self.__data.draw_bits(kwargs["n"])
elif method == "triangular":
low = normalize_zero(kwargs["low"])
high = normalize_zero(kwargs["high"])
mode = normalize_zero(kwargs["mode"])
if mode is None:
result = self.__data.draw(st.floats(low, high))
elif self.__data.draw_bits(1):
result = self.__data.draw(st.floats(mode, high))
else:
result = self.__data.draw(st.floats(low, mode))
elif method in ("paretovariate", "expovariate", "lognormvariate"):
result = self.__data.draw(st.floats(min_value=0.0))
elif method == "shuffle":
result = self.__data.draw(st.permutations(range(len(kwargs["x"]))))
# This is tested for but only appears in 3.9 so doesn't appear in coverage.
elif method == "randbytes": # pragma: no cover
n = kwargs["n"]
result = self.__data.draw(st.binary(min_size=n, max_size=n))
else:
raise NotImplementedError(method)
new_state = RandomState()
self.__state.next_states[key] = (result, new_state)
self.__state = new_state
return self.__convert_result(method, kwargs, result)
def test_does_not_draw_data_for_empty_range():
assert integer_range(TestData.for_buffer(b""), 1, 1) == 1
def do_draw(self, data):
return d.integer_range(data, self.start, self.end)
def test_does_draw_data_for_empty_range():
data = ConjectureData.for_buffer(b"\1")
assert cu.integer_range(data, 1, 1) == 1
data.freeze()
assert data.buffer == hbytes(b"\0")
def do_draw(self, data):
return integer_range(data, self.lower, self.upper, center=self.center)
def do_draw(self, data):
if 0 in self.shape:
return np.zeros(dtype=self.dtype, shape=self.shape)
# This could legitimately be a np.empty, but the performance gains for
# that would be so marginal that there's really not much point risking
# undefined behaviour shenanigans.
result = np.zeros(shape=self.array_size, dtype=self.dtype)
if self.fill.is_empty:
# We have no fill value (either because the user explicitly
# disabled it or because the default behaviour was used and our
# elements strategy does not produce reusable values), so we must
# generate a fully dense array with a freshly drawn value for each
# entry.
if self.unique:
seen = set()
elements = cu.many(
data,
min_size=self.array_size, max_size=self.array_size,
average_size=self.array_size
)
i = 0
while elements.more():
# We assign first because this means we check for
# uniqueness after numpy has converted it to the relevant
# type for us. Because we don't increment the counter on
# a duplicate we will overwrite it on the next draw.
result[i] = data.draw(self.element_strategy)
if result[i] not in seen:
seen.add(result[i])
i += 1
else:
elements.reject()
else:
for i in hrange(len(result)):
result[i] = data.draw(self.element_strategy)
else:
# We draw numpy arrays as "sparse with an offset". We draw a
# collection of index assignments within the array and assign
# fresh values from our elements strategy to those indices. If at
# the end we have not assigned every element then we draw a single
# value from our fill strategy and use that to populate the
# remaining positions with that strategy.
elements = cu.many(
data,
min_size=0, max_size=self.array_size,
# sqrt isn't chosen for any particularly principled reason. It
# just grows reasonably quickly but sublinearly, and for small
# arrays it represents a decent fraction of the array size.
average_size=math.sqrt(self.array_size),
)
needs_fill = np.full(self.array_size, True)
seen = set()
while elements.more():
i = cu.integer_range(data, 0, self.array_size - 1)
if not needs_fill[i]:
elements.reject()
continue
result[i] = data.draw(self.element_strategy)
if self.unique:
if result[i] in seen:
elements.reject()
continue
else:
seen.add(result[i])
needs_fill[i] = False
if needs_fill.any():
# We didn't fill all of the indices in the early loop, so we
# put a fill value into the rest.
# We have to do this hilarious little song and dance to work
# around numpy's special handling of iterable values. If the
# value here were e.g. a tuple then neither array creation
# nor putmask would do the right thing. But by creating an
# array of size one and then assigning the fill value as a
# single element, we both get an array with the right value in
# it and putmask will do the right thing by repeating the
# values of the array across the mask.
one_element = np.zeros(shape=1, dtype=self.dtype)
one_element[0] = data.draw(self.fill)
fill_value = one_element[0]
if self.unique:
try:
is_nan = np.isnan(fill_value)
except TypeError:
is_nan = False
if not is_nan:
raise InvalidArgument(
'Cannot fill unique array with non-NaN '
'value %r' % (fill_value,))
np.putmask(result, needs_fill, one_element)
return result.reshape(self.shape)
def do_draw(self, data):
i = integer_range(data, 0, len(self.intervals) - 1, center=self.zero_point)
return hunichr(self.intervals[i])
def do_draw(self, data):
if 0 in self.shape:
return self.xp.zeros(self.shape, dtype=self.dtype)
if self.fill.is_empty:
# We have no fill value (either because the user explicitly
# disabled it or because the default behaviour was used and our
# elements strategy does not produce reusable values), so we must
# generate a fully dense array with a freshly drawn value for each
# entry.
elems = data.draw(
st.lists(
self.elements_strategy,
min_size=self.array_size,
max_size=self.array_size,
unique=self.unique,
))
try:
result = self.xp.asarray(elems, dtype=self.dtype)
except Exception as e:
if len(elems) <= 6:
f_elems = str(elems)
else:
f_elems = f"[{elems[0]}, {elems[1]}, ..., {elems[-2]}, {elems[-1]}]"
types = tuple(
sorted({type(e)
for e in elems}, key=lambda t: t.__name__))
f_types = f"type {types[0]}" if len(
types) == 1 else f"types {types}"
raise InvalidArgument(
f"Generated elements {f_elems} from strategy "
f"{self.elements_strategy} could not be converted "
f"to array of dtype {self.dtype}. "
f"Consider if elements of {f_types} "
f"are compatible with {self.dtype}.") from e
for i in range(self.array_size):
self.check_set_value(elems[i], result[i],
self.elements_strategy)
else:
# We draw arrays as "sparse with an offset". We assume not every
# element will be assigned and so first draw a single value from our
# fill strategy to create a full array. We then draw a collection of
# index assignments within the array and assign fresh values from
# our elements strategy to those indices.
fill_val = data.draw(self.fill)
try:
result = self.xp.full(self.array_size,
fill_val,
dtype=self.dtype)
except Exception as e:
raise InvalidArgument(
f"Could not create full array of dtype={self.dtype} "
f"with fill value {fill_val!r}") from e
sample = result[0]
self.check_set_value(fill_val, sample, self.fill)
if self.unique and not self.xp.all(self.xp.isnan(result)):
raise InvalidArgument(
f"Array module {self.xp.__name__} did not recognise fill "
f"value {fill_val!r} as NaN - instead got {sample!r}. "
"Cannot fill unique array with non-NaN values.")
elements = cu.many(
data,
min_size=0,
max_size=self.array_size,
# sqrt isn't chosen for any particularly principled reason. It
# just grows reasonably quickly but sublinearly, and for small
# arrays it represents a decent fraction of the array size.
average_size=min(
0.9 *
self.array_size, # ensure small arrays sometimes use fill
max(10,
math.sqrt(self.array_size)), # ...but *only* sometimes
),
)
assigned = set()
seen = set()
while elements.more():
i = cu.integer_range(data, 0, self.array_size - 1)
if i in assigned:
elements.reject()
continue
val = data.draw(self.elements_strategy)
if self.unique:
if val in seen:
elements.reject()
continue
else:
seen.add(val)
try:
result[i] = val
except Exception as e:
raise InvalidArgument(
f"Could not add generated array element {val!r} "
f"of type {type(val)} to array of dtype {result.dtype}."
) from e
self.check_set_value(val, result[i], self.elements_strategy)
assigned.add(i)
result = self.xp.reshape(result, self.shape)
return result
def test_does_not_draw_data_for_empty_range():
assert integer_range(ConjectureData.for_buffer(b''), 1, 1) == 1