def ip_addresses( *, v: int = None, network: Union[str, IPv4Network, IPv6Network] = None ) -> SearchStrategy[Union[IPv4Address, IPv6Address]]: r"""Generate IP addresses - ``v=4`` for :class:`~python:ipaddress.IPv4Address`\ es, ``v=6`` for :class:`~python:ipaddress.IPv6Address`\ es, or leave unspecified to allow both versions. ``network`` may be an :class:`~python:ipaddress.IPv4Network` or :class:`~python:ipaddress.IPv6Network`, or a string representing a network such as ``"127.0.0.0/24"`` or ``"2001:db8::/32"``. As well as generating addresses within a particular routable network, this can be used to generate addresses from a reserved range listed in the `IANA <https://www.iana.org/assignments/iana-ipv4-special-registry/>`__ `registries <https://www.iana.org/assignments/iana-ipv6-special-registry/>`__. If you pass both ``v`` and ``network``, they must be for the same version. """ if v is not None: check_type(int, v, "v") if v != 4 and v != 6: raise InvalidArgument("v=%r, but only v=4 or v=6 are valid" % (v, )) if network is None: # We use the reserved-address registries to boost the chance # of generating one of the various special types of address. four = binary( 4, 4).map(IPv4Address) | sampled_from(SPECIAL_IPv4_RANGES).flatmap( lambda network: ip_addresses(network=network)) six = binary( 16, 16).map(IPv6Address) | sampled_from(SPECIAL_IPv6_RANGES).flatmap( lambda network: ip_addresses(network=network)) if v == 4: return four if v == 6: return six return four | six if isinstance(network, str): network = ip_network(network) check_type((IPv4Network, IPv6Network), network, "network") assert isinstance(network, (IPv4Network, IPv6Network)) # for Mypy if v not in (None, network.version): raise InvalidArgument("v=%r is incompatible with network=%r" % (v, network)) addr_type = IPv4Address if network.version == 4 else IPv6Address return integers(int(network[0]), int(network[-1])).map(addr_type) # type: ignore
def _hypothesis_do_random(self, method, kwargs): if method == "choices": key = (method, len(kwargs["population"]), kwargs.get("k")) elif method == "choice": key = (method, len(kwargs["seq"])) elif method == "shuffle": key = (method, len(kwargs["x"])) else: key = (method, ) + tuple(sorted(kwargs)) try: result, self.__state = self.__state.next_states[key] except KeyError: pass else: return self.__convert_result(method, kwargs, result) if method == "_randbelow": result = cu.integer_range(self.__data, 0, kwargs["n"] - 1) elif method in ("betavariate", "random"): result = self.__data.draw(UNIFORM) elif method == "uniform": a = normalize_zero(kwargs["a"]) b = normalize_zero(kwargs["b"]) result = self.__data.draw(st.floats(a, b)) elif method in ("weibullvariate", "gammavariate"): result = self.__data.draw( st.floats(min_value=0.0, allow_infinity=False)) elif method in ("gauss", "normalvariate"): mu = kwargs["mu"] result = mu + self.__data.draw( st.floats(allow_nan=False, allow_infinity=False)) elif method == "vonmisesvariate": result = self.__data.draw(st.floats(0, 2 * math.pi)) elif method == "randrange": if kwargs["stop"] is None: stop = kwargs["start"] start = 0 else: start = kwargs["start"] stop = kwargs["stop"] step = kwargs["step"] if start == stop: raise ValueError("empty range for randrange(%d, %d, %d)" % (start, stop, step)) if step != 1: endpoint = (stop - start) // step if (start - stop) % step == 0: endpoint -= 1 i = cu.integer_range(self.__data, 0, endpoint) result = start + i * step else: result = cu.integer_range(self.__data, start, stop - 1) elif method == "randint": result = cu.integer_range(self.__data, kwargs["a"], kwargs["b"]) elif method == "choice": seq = kwargs["seq"] result = cu.integer_range(self.__data, 0, len(seq) - 1) elif method == "choices": k = kwargs["k"] result = self.__data.draw( st.lists( st.integers(0, len(kwargs["population"]) - 1), min_size=k, max_size=k, )) elif method == "sample": k = kwargs["k"] seq = kwargs["population"] if k > len(seq) or k < 0: raise ValueError( "Sample size %d not in expected range 0 <= k <= %d" % (k, len(seq))) result = self.__data.draw( st.lists( st.sampled_from(range(len(seq))), min_size=k, max_size=k, unique=True, )) elif method == "getrandbits": result = self.__data.draw_bits(kwargs["n"]) elif method == "triangular": low = normalize_zero(kwargs["low"]) high = normalize_zero(kwargs["high"]) mode = normalize_zero(kwargs["mode"]) if mode is None: result = self.__data.draw(st.floats(low, high)) elif self.__data.draw_bits(1): result = self.__data.draw(st.floats(mode, high)) else: result = self.__data.draw(st.floats(low, mode)) elif method in ("paretovariate", "expovariate", "lognormvariate"): result = self.__data.draw(st.floats(min_value=0.0)) elif method == "shuffle": result = self.__data.draw(st.permutations(range(len(kwargs["x"])))) # This is tested for but only appears in 3.9 so doesn't appear in coverage. elif method == "randbytes": # pragma: no cover n = kwargs["n"] result = self.__data.draw(st.binary(min_size=n, max_size=n)) else: raise NotImplementedError(method) new_state = RandomState() self.__state.next_states[key] = (result, new_state) self.__state = new_state return self.__convert_result(method, kwargs, result)