def splat(value):
try:
result = target(*value[0], **value[1])
result.validate()
return result
except InvalidArgument:
reject()
def do_draw(self, data):
for _ in range(3):
i = data.index
try:
return self.pack(self.mapped_strategy.do_draw(data))
except UnsatisfiedAssumption:
if data.index == i:
raise
reject()
def just_draw_columns(draw):
index = draw(index_strategy)
local_index_strategy = st.just(index)
data = OrderedDict((c.name, None) for c in rewritten_columns)
# Depending on how the columns are going to be generated we group
# them differently to get better shrinking. For columns with fill
# enabled, the elements can be shrunk independently of the size,
# so we can just shrink by shrinking the index then shrinking the
# length and are generally much more free to move data around.
# For columns with no filling the problem is harder, and drawing
# them like that would result in rows being very far apart from
# each other in the underlying data stream, which gets in the way
# of shrinking. So what we do is reorder and draw those columns
# row wise, so that the values of each row are next to each other.
# This makes life easier for the shrinker when deleting blocks of
# data.
columns_without_fill = [c for c in rewritten_columns if c.fill.is_empty]
if columns_without_fill:
for c in columns_without_fill:
data[c.name] = pandas.Series(
np.zeros(shape=len(index), dtype=c.dtype), index=index
)
seen = {c.name: set() for c in columns_without_fill if c.unique}
for i in hrange(len(index)):
for c in columns_without_fill:
if c.unique:
for _ in range(5):
value = draw(c.elements)
if value not in seen[c.name]:
seen[c.name].add(value)
break
else:
reject()
else:
value = draw(c.elements)
data[c.name][i] = value
for c in rewritten_columns:
if not c.fill.is_empty:
data[c.name] = draw(
series(
index=local_index_strategy,
dtype=c.dtype,
elements=c.elements,
fill=c.fill,
unique=c.unique,
)
)
return pandas.DataFrame(data, index=index)
def test_foreign_key_primary(self, buf):
# Regression test for #1307
company_strategy = from_model(Company, name=just("test"))
strategy = from_model(
CompanyExtension, company=company_strategy, self_modifying=just(2)
)
try:
ConjectureData.for_buffer(buf).draw(strategy)
except HypothesisException:
reject()
# Draw again with the same buffer. This will cause a duplicate
# primary key.
ConjectureData.for_buffer(buf).draw(strategy)
assert CompanyExtension.objects.all().count() == 1
def assign_rows(draw):
index = draw(index_strategy)
result = pandas.DataFrame(OrderedDict(
(c.name, pandas.Series(
np.zeros(dtype=c.dtype, shape=len(index)), dtype=c.dtype))
for c in rewritten_columns
), index=index)
fills = {}
any_unique = any(c.unique for c in rewritten_columns)
if any_unique:
all_seen = [
set() if c.unique else None for c in rewritten_columns]
while all_seen[-1] is None:
all_seen.pop()
for row_index in hrange(len(index)):
for _ in hrange(5):
original_row = draw(rows)
row = original_row
if isinstance(row, dict):
as_list = [None] * len(rewritten_columns)
for i, c in enumerate(rewritten_columns):
try:
as_list[i] = row[c.name]
except KeyError:
try:
as_list[i] = fills[i]
except KeyError:
fills[i] = draw(c.fill)
as_list[i] = fills[i]
for k in row:
if k not in column_names:
raise InvalidArgument((
'Row %r contains column %r not in '
'columns %r)' % (
row, k, [
c.name for c in rewritten_columns
])))
row = as_list
if any_unique:
has_duplicate = False
for seen, value in zip(all_seen, row):
if seen is None:
continue
if value in seen:
has_duplicate = True
break
seen.add(value)
if has_duplicate:
continue
row = list(st.try_convert(tuple, row, 'draw(rows)'))
if len(row) > len(rewritten_columns):
raise InvalidArgument((
'Row %r contains too many entries. Has %d but '
'expected at most %d') % (
original_row, len(row), len(rewritten_columns)
))
while len(row) < len(rewritten_columns):
row.append(draw(rewritten_columns[len(row)].fill))
result.iloc[row_index] = row
break
else:
reject()
return result
def assign_rows(draw):
index = draw(index_strategy)
result = pandas.DataFrame(
OrderedDict((
c.name,
pandas.Series(np.zeros(dtype=c.dtype, shape=len(index)),
dtype=c.dtype),
) for c in rewritten_columns),
index=index,
)
fills = {}
any_unique = any(c.unique for c in rewritten_columns)
if any_unique:
all_seen = [
set() if c.unique else None for c in rewritten_columns
]
while all_seen[-1] is None:
all_seen.pop()
for row_index in range(len(index)):
for _ in range(5):
original_row = draw(rows)
row = original_row
if isinstance(row, dict):
as_list = [None] * len(rewritten_columns)
for i, c in enumerate(rewritten_columns):
try:
as_list[i] = row[c.name]
except KeyError:
try:
as_list[i] = fills[i]
except KeyError:
fills[i] = draw(c.fill)
as_list[i] = fills[i]
for k in row:
if k not in column_names:
raise InvalidArgument(
"Row %r contains column %r not in columns %r)"
% (row, k,
[c.name for c in rewritten_columns]))
row = as_list
if any_unique:
has_duplicate = False
for seen, value in zip(all_seen, row):
if seen is None:
continue
if value in seen:
has_duplicate = True
break
seen.add(value)
if has_duplicate:
continue
row = list(try_convert(tuple, row, "draw(rows)"))
if len(row) > len(rewritten_columns):
raise InvalidArgument(
("Row %r contains too many entries. Has %d but "
"expected at most %d") %
(original_row, len(row), len(rewritten_columns)))
while len(row) < len(rewritten_columns):
row.append(draw(rewritten_columns[len(row)].fill))
result.iloc[row_index] = row
break
else:
reject()
return result
def downcast(x):
try:
return float_of(x, width)
except OverflowError: # pragma: no cover
reject()
