def convert(expansion):
parts = []
for p in expansion:
if parts and ignore_names:
# Chance to insert ignored substrings between meaningful
# tokens, e.g. whitespace between values in JSON.
parts.append(
st.just(u"")
| st.one_of([strategies[name] for name in ignore_names]))
if p.name in strategies:
# This might be a Terminal, or it might be a NonTerminal
# that we've previously handled.
parts.append(strategies[p.name])
else:
# It must be the first time we've encountered this NonTerminal.
# Recurse to handle it, relying on lazy strategy instantiation
# to allow forward references, then add it to the strategies
# cache to avoid infinite loops.
assert isinstance(p, lark.grammar.NonTerminal)
s = st.one_of([convert(ex) for ex in nonterminals[p.name]])
parts.append(s)
strategies[p.name] = s
# Special-case rules with only one expansion; it's worthwhile being
# efficient when this includes terminals! Otherwise, join the parts.
if len(parts) == 1:
return parts[0]
return st.tuples(*parts).map(u"".join)
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 from_dtype(dtype):
# type: (np.dtype) -> st.SearchStrategy[Any]
"""Creates a strategy which can generate any value of the given dtype."""
check_type(np.dtype, dtype, "dtype")
# Compound datatypes, eg 'f4,f4,f4'
if dtype.names is not None:
# mapping np.void.type over a strategy is nonsense, so return now.
return st.tuples(*[from_dtype(dtype.fields[name][0]) for name in dtype.names])
# Subarray datatypes, eg '(2, 3)i4'
if dtype.subdtype is not None:
subtype, shape = dtype.subdtype
return arrays(subtype, shape)
# Scalar datatypes
if dtype.kind == u"b":
result = st.booleans() # type: SearchStrategy[Any]
elif dtype.kind == u"f":
if dtype.itemsize == 2:
result = st.floats(width=16)
elif dtype.itemsize == 4:
result = st.floats(width=32)
else:
result = st.floats()
elif dtype.kind == u"c":
if dtype.itemsize == 8:
float32 = st.floats(width=32)
result = st.builds(complex, float32, float32)
else:
result = st.complex_numbers()
elif dtype.kind in (u"S", u"a"):
# Numpy strings are null-terminated; only allow round-trippable values.
# `itemsize == 0` means 'fixed length determined at array creation'
result = st.binary(max_size=dtype.itemsize or None).filter(
lambda b: b[-1:] != b"\0"
)
elif dtype.kind == u"u":
result = st.integers(min_value=0, max_value=2 ** (8 * dtype.itemsize) - 1)
elif dtype.kind == u"i":
overflow = 2 ** (8 * dtype.itemsize - 1)
result = st.integers(min_value=-overflow, max_value=overflow - 1)
elif dtype.kind == u"U":
# Encoded in UTF-32 (four bytes/codepoint) and null-terminated
result = st.text(max_size=(dtype.itemsize or 0) // 4 or None).filter(
lambda b: b[-1:] != u"\0"
)
elif dtype.kind in (u"m", u"M"):
if "[" in dtype.str:
res = st.just(dtype.str.split("[")[-1][:-1])
else:
res = st.sampled_from(TIME_RESOLUTIONS)
result = st.builds(dtype.type, st.integers(-(2 ** 63), 2 ** 63 - 1), res)
else:
raise InvalidArgument(u"No strategy inference for {}".format(dtype))
return result.map(dtype.type)
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 submit_details_request(db):
submission = from_model(Submission, urls=just(['http://twitter.com/'])).example()
yield {
"identify": "female",
"age": 40,
"job": 'public speaker',
"perpetrator": PerpetratorType.single_stranger.value,
'interaction': InteractionType.post_rarely_for_friends.value,
'reaction_type': ReactionType.i_took_a_break_from_platform.value,
'experienced': ['sad'],
'feeling': 'hurt',
'submission': submission.id
}
def urls():
# type: () -> SearchStrategy[Text]
"""A strategy for :rfc:`3986`, generating http/https URLs."""
def url_encode(s):
return "".join(c if c in URL_SAFE_CHARACTERS else "%%%02X" % ord(c)
for c in s)
schemes = st.sampled_from(["http", "https"])
ports = st.integers(min_value=0, max_value=2**16 - 1).map(":{}".format)
paths = st.lists(st.text(string.printable).map(url_encode)).map("/".join)
return st.builds(u"{}://{}{}/{}".format, schemes, domains(),
st.just(u"") | ports, paths)
def urls():
"""A strategy for :rfc:`3986`, generating http/https URLs."""
def url_encode(s):
safe_chars = set(string.ascii_letters + string.digits + "$-_.+!*'(),")
return "".join(c if c in safe_chars else "%%%02X" % ord(c) for c in s)
schemes = st.sampled_from(["http", "https"])
ports = st.integers(min_value=0, max_value=2 ** 16 - 1).map(":{}".format)
paths = st.lists(st.text(string.printable).map(url_encode)).map(
lambda path: "/".join([""] + path)
)
return st.builds(
"{}://{}{}{}".format, schemes, domains(), st.one_of(st.just(""), ports), paths
)
def get_examples(endpoint: Endpoint) -> Generator[Case, None, None]:
for name in PARAMETERS:
parameter = getattr(endpoint, name)
if "example" in parameter:
other_parameters = {
other: from_schema(getattr(endpoint, other))
for other in PARAMETERS - {name}
}
yield st.builds(
Case,
path=st.just(endpoint.path),
method=st.just(endpoint.method),
**{
name: just(parameter["example"])
},
**other_parameters,
).example()
def boolean_dtypes():
# type: () -> st.SearchStrategy[np.dtype]
return st.just("?")
