def array_dtypes( subtype_strategy=scalar_dtypes(), # type: st.SearchStrategy[np.dtype] min_size=1, # type: int max_size=5, # type: int allow_subarrays=False, # type: bool ): # type: (...) -> st.SearchStrategy[np.dtype] """Return a strategy for generating array (compound) dtypes, with members drawn from the given subtype strategy.""" order_check("size", 0, min_size, max_size) # Field names must be native strings and the empty string is weird; see #1963. if PY2: field_names = st.binary(min_size=1) else: field_names = st.text(min_size=1) elements = st.tuples(field_names, subtype_strategy) if allow_subarrays: elements |= st.tuples( field_names, subtype_strategy, array_shapes(max_dims=2, max_side=2) ) return st.lists( elements=elements, min_size=min_size, max_size=max_size, unique_by=lambda d: d[0], )
def array_shapes(min_dims=1, max_dims=None, min_side=1, max_side=None): # type: (int, int, int, int) -> st.SearchStrategy[Shape] """Return a strategy for array shapes (tuples of int >= 1).""" check_type(integer_types, min_dims, "min_dims") check_type(integer_types, min_side, "min_side") if min_dims > 32: raise InvalidArgument( "Got min_dims=%r, but numpy does not support arrays greater than 32 dimensions" % min_dims ) if max_dims is None: max_dims = min(min_dims + 2, 32) check_type(integer_types, max_dims, "max_dims") if max_dims > 32: raise InvalidArgument( "Got max_dims=%r, but numpy does not support arrays greater than 32 dimensions" % max_dims ) if max_side is None: max_side = min_side + 5 check_type(integer_types, max_side, "max_side") order_check("dims", 0, min_dims, max_dims) order_check("side", 0, min_side, max_side) return st.lists( st.integers(min_side, max_side), min_size=min_dims, max_size=max_dims ).map(tuple)
def array_shapes(min_dims=1, max_dims=3, min_side=1, max_side=10): # type: (int, int, int, int) -> st.SearchStrategy[Tuple[int, ...]] """Return a strategy for array shapes (tuples of int >= 1).""" order_check("dims", 0, min_dims, max_dims) order_check("side", 0, min_side, max_side) return st.lists(st.integers(min_side, max_side), min_size=min_dims, max_size=max_dims).map(tuple)
def domains(): """A strategy for :rfc:`1035` fully qualified domain names.""" atoms = st.text( string.ascii_letters + "0123456789-", min_size=1, max_size=63 ).filter(lambda s: "-" not in s[0] + s[-1]) return st.builds( lambda x, y: ".".join(x + [y]), st.lists(atoms, min_size=1), # TODO: be more devious about top-level domains st.sampled_from(["com", "net", "org", "biz", "info"]), ).filter(lambda url: len(url) <= 255)
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 all_types(draw): return draw( one_of( text(), integers(), none(), booleans(), floats(), tuples(), times(), uuids(), lists(integers()), dictionaries(text(), text()), ))
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 valid_tuple_axes(ndim, min_size=0, max_size=None): # type: (int, int, int) -> st.SearchStrategy[Shape] """Return a strategy for generating permissible tuple-values for the ``axis`` argument for a numpy sequential function (e.g. :func:`numpy:numpy.sum`), given an array of the specified dimensionality. All tuples will have an length >= min_size and <= max_size. The default value for max_size is ``ndim``. Examples from this strategy shrink towards an empty tuple, which render most sequential functions as no-ops. The following are some examples drawn from this strategy. .. code-block:: pycon >>> [valid_tuple_axes(3).example() for i in range(4)] [(-3, 1), (0, 1, -1), (0, 2), (0, -2, 2)] ``valid_tuple_axes`` can be joined with other strategies to generate any type of valid axis object, i.e. integers, tuples, and ``None``: .. code-block:: pycon any_axis_strategy = none() | integers(-ndim, ndim - 1) | valid_tuple_axes(ndim) """ if max_size is None: max_size = ndim check_type(integer_types, ndim, "ndim") check_type(integer_types, min_size, "min_size") check_type(integer_types, max_size, "max_size") order_check("size", 0, min_size, max_size) check_valid_interval(max_size, ndim, "max_size", "ndim") # shrink axis values from negative to positive axes = st.integers(0, max(0, 2 * ndim - 1)).map( lambda x: x if x < ndim else x - 2 * ndim ) return st.lists(axes, min_size, max_size, unique_by=lambda x: x % ndim).map(tuple)
def array_dtypes( subtype_strategy=scalar_dtypes(), # type: st.SearchStrategy[np.dtype] min_size=1, # type: int max_size=5, # type: int allow_subarrays=False, # type: bool ): # type: (...) -> st.SearchStrategy[np.dtype] """Return a strategy for generating array (compound) dtypes, with members drawn from the given subtype strategy.""" order_check("size", 0, min_size, max_size) native_strings = st.from_type(str).filter( bool) # See issue #1798 re: filter! elements = st.tuples(native_strings, subtype_strategy) if allow_subarrays: elements |= st.tuples(native_strings, subtype_strategy, array_shapes(max_dims=2, max_side=2)) return st.lists( elements=elements, min_size=min_size, max_size=max_size, unique_by=lambda d: d[0], )
def array_dtypes( subtype_strategy=scalar_dtypes(), # type: st.SearchStrategy[np.dtype] min_size=1, # type: int max_size=5, # type: int allow_subarrays=False, # type: bool ): # type: (...) -> st.SearchStrategy[np.dtype] """Return a strategy for generating array (compound) dtypes, with members drawn from the given subtype strategy.""" order_check("size", 0, min_size, max_size) native_strings = st.text() # type: SearchStrategy[Any] if text_type is not str: # pragma: no cover native_strings = st.binary() elements = st.tuples(native_strings, subtype_strategy) if allow_subarrays: elements |= st.tuples(native_strings, subtype_strategy, array_shapes(max_dims=2, max_side=2)) return st.lists( elements=elements, min_size=min_size, max_size=max_size, unique_by=lambda d: d[0], )
symbols[36] = carriers[14] symbols[37] = carriers[15] symbols[38] = carriers[16] symbols[39] = carriers[17] symbols[40] = carriers[18] symbols[41] = carriers[19] symbols[42] = carriers[20] # pilots[3] = carriers[21] symbols[43] = carriers[22] symbols[44] = carriers[23] symbols[45] = carriers[24] symbols[46] = carriers[25] symbols[47] = carriers[26] return list(symbols) def do(symbols: List[Symbol]) -> List[Carriers]: return [do_one(chunk) for chunk in chunked(symbols, 48)] def undo(carriers: List[Carriers]) -> List[Symbol]: return list(flatten([undo_one(carrier) for carrier in carriers])) @given(lists(arrays(complex, 48), min_size=1)) def test_hypothesis(data): data = np.hstack(data).tolist() un = undo(do(data)) np.testing.assert_equal(data, un)
n = randint(1, 100) r = set(l) for _ in range(n): r.add(random()) return r def test_empty_to_empty() -> None: matches, unmatched_1, unmatched_2, _ = linear_sum_match([], [], euclidean) assert matches == [] assert unmatched_1 == [] assert unmatched_2 == [] @given(lists(floats(min_value=1e-5, max_value=100.0))) def test_list_to_empty(fs: List[float]) -> None: matches, unmatched_1, unmatched_2, _ = linear_sum_match(fs, [], euclidean) assert matches == [] assert unmatched_1 == list(range(len(fs))) assert unmatched_2 == [] @given(lists(floats(min_value=1e-5, max_value=100.0))) def test_list_to_self(fs: List[float]) -> None: matches, unmatched_1, unmatched_2, _ = linear_sum_match(fs, fs, euclidean) assert matches == list(zip(range(len(fs)), range(len(fs)))) assert unmatched_1 == [] assert unmatched_2 == []
from typing import List import numpy as np from hypothesis import given from hypothesis._strategies import lists, complex_numbers from wifi.to_time_domain import OFDMFrame SIZE = 16 def do(frames: List[OFDMFrame]) -> List[OFDMFrame]: return [frame[-SIZE:] + frame for frame in frames] def undo(frames: List[OFDMFrame]) -> List[OFDMFrame]: return [frame[SIZE:] for frame in frames] @given( lists(lists(complex_numbers(), min_size=64, max_size=64), min_size=1, max_size=32)) def test_hypothesis(data): un = undo(do(data)) np.testing.assert_equal(data, un)
# not a perfect reconstuction! def undo(iq): short = iq[:160] long = iq[160:320] frame_size = guard_interval.SIZE + 64 frames = list(chunked(iq[320:], frame_size)) if len(frames[-1]) != frame_size: frames = frames[:-1] return short, long, frames @given( lists(lists(complex_numbers(), min_size=80, max_size=80), min_size=1, max_size=32)) def test_hypothesis(frames): from wifi import preambler short = preambler.short_training_sequence() long = preambler.long_training_sequence() res_short, res_long, res_frames = undo(do(short, long, frames)) # 'do' contaminates the first sample of each symbol, cannot be restored with 'undo' assert res_short[1:] == short[1:] assert res_long[1:] == long[1:] for frame, res_frame in zip(frames, res_frames): assert frame[1:] == res_frame[1:]
def undo_one(carriers: Carriers, index_in_package: int) -> Carriers: pilots = np.empty(4, dtype=complex) pilots[0] = carriers[-21] pilots[1] = carriers[-7] pilots[2] = carriers[7] pilots[3] = carriers[21] # remove latent frequency offset by using pilot symbols pilots *= PILOT_POLARITY[index_in_package % 127] mean_phase_offset = np.angle(np.mean(pilots)) carriers = np.array(carriers) * np.exp(-1j * mean_phase_offset) return carriers.tolist() def do(carriers: List[Carriers]) -> List[Carriers]: return [do_one(carrier, index) for index, carrier in enumerate(carriers)] def undo(carriers: List[Carriers]) -> List[Carriers]: return [undo_one(carrier, index) for index, carrier in enumerate(carriers)] @given(lists(lists(complex_numbers(allow_nan=False, allow_infinity=False), min_size=64, max_size=64), min_size=1, max_size=32)) def test_hypothesis(data): un = undo(do(data)) np.testing.assert_allclose(data, un, rtol=1e-16, atol=1e-16)