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("?")