Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
The drawn sample to match desired fill_value.
"""
float_strategy = st.floats(**float_generic_params)
tuple_strategy = st.tuples(float_strategy, float_strategy)
string_strategy = st.just("extrapolate")
nan_strategy = st.just(np.nan)
if strategy_spec == "float":
fill_strategy = float_strategy
elif strategy_spec == "tuple":
fill_strategy = tuple_strategy
elif strategy_spec == "str":
fill_strategy = string_strategy
elif strategy_spec == "nan":
fill_strategy = nan_strategy
else:
fill_strategy = st.one_of(
float_strategy, tuple_strategy, string_strategy, nan_strategy
)
return draw(fill_strategy)
def urls ():
""" Build http/https URL """
scheme = st.sampled_from (['http', 'https'])
# Path must start with a slash
pathSt = st.builds (lambda x: '/' + x, st.text ())
args = st.fixed_dictionaries ({
'scheme': scheme,
'host': domains (),
'port': st.one_of (st.none (), st.integers (min_value=1, max_value=2**16-1)),
'path': pathSt,
'query_string': st.text (),
'fragment': st.text (),
})
return st.builds (lambda x: URL.build (**x), args)
def st_coins(draw):
""" generator for random coin status """
st_usual_denominations = st.sets(st.sampled_from([200, 100, 50, 20, 10, 5, 2, 1]))
st_strange_denominations_and_duplicates = st.lists(st.integers(1, 200), average_size=8)
coin_values = draw(st.one_of(st_usual_denominations, st_strange_denominations_and_duplicates))
# sort descending by coin value, and convert to list
coin_values = sorted(coin_values, reverse=True)
coin_list = [(value, draw(st.integers(min_value=0, max_value=10))) for value in coin_values]
return coin_list
def dict_val_strat(ascii_only=False):
blacklist_characters = []
if ascii_only:
max_codepoint = ASCII_CODEPOINT
blacklist_characters = ['u', "'", '"']
else:
max_codepoint = None
text = st.text(alphabet=st.characters(max_codepoint=max_codepoint,
blacklist_characters=blacklist_characters),
# avoid u'str'!
average_size=10, min_size=1,
max_size=100000)
return st.one_of(text, st.integers(),
st.floats(allow_nan=False, allow_infinity=False),
st.lists(st.one_of(st.text(max_size=10),
st.floats(allow_nan=False, allow_infinity=False),
st.integers())))
words = ['post']
if not strict:
words.extend(['r', 'rev'])
sep1 = separator(strict=strict, optional=not strict)
word = sampled_from(words)
blank = just('')
sep2 = separator(strict=strict, optional=True)
if strict:
sep2 = blank
num_part = sep2.map(lambda s: s + draw(num_str))
if not strict:
num_part = one_of(blank, num_part)
post = sep1.map(lambda s: s + draw(word) + draw(num_part))
if strict:
return draw(post)
post_implicit = num_str.map(lambda s: '-' + s)
return draw(one_of(blank, post_implicit, post))
def incidentSummaries() -> SearchStrategy: # str
"""
Strategy that generates incident summaries.
"""
return one_of(none(), text())
def gen_any_of(prop, customs):
possible_values = []
for value in prop["anyOf"]:
possible_values.append(get_generator(value, customs))
return hs.one_of(possible_values)
def gen_one_of(prop):
possible_values = []
for value in prop["oneOf"]:
possible_values.append(get_generator(value))
return hs.one_of(possible_values)