Like :obj:`~hypothesis.strategies.DrawFn`.

Tries to generate a small number of examples from the strategy, to verify that it can do so without raising. Nothing is returned, it only che

Returns a strategy which generates integers. If min_value is not None then all values will be >= min_value. If max_value is not None then all

Asserts that all examples of the given strategy match the predicate. :param strategy: Hypothesis strategy to check :param predicate: (callabl

Run a state machine definition as a test, either silently doing nothing or printing a minimal breaking program and raising an exception. stat

Returns a list containing values drawn from elements with length in the interval [min_size, max_size] (no bounds in that direction if these are

If ``error_on_discard`` is set to True this will raise ``ContainsDiscard`` in preference to running the actual test function. This is

Like assert_all_examples, intended as a self-documenting shortcut for simple constant properties (`is`, `isinstance`, `==`, ...) that can be adequ

Returns a strategy which generates floats. - If min_value is not None, all values will be ``>= min_value`` (or ``> min_value`` if ``exclude

Looks up the appropriate search strategy for the given type. |st.from_type| is used internally to fill in missing arguments to |st.builds| an

Register and un-register a type for st.from_type(). This is not too hard, but there's a subtlety in restoring the previously-registered strat

Run steps from each pass in ``passes`` until the current shrink target is a fixed point of all of them.

Run the full set of shrinks and update shrink_target. This method is "mostly idempotent" - calling it twice is unlikely to have any e

Creates and returns an InterestingOrigin, parameterized by n, such that interesting_origin(n) == interesting_origin(m) iff n = m. Since

Return a strategy which only generates ``value``. Note: ``value`` is not copied. Be wary of using mutable values. If ``value`` is the result

Returns a strategy which generates instances of :class:`python:bool`. Examples from this strategy will shrink towards ``False`` (i.e. shrinki

Record a note on this |test case|. Non-string values will be automatically converted to a string. This value is reported for the |minima

The name of the current settings profile. For example: .. code-block:: python >>> settings.load_profile("myprofile")

Generates strings with characters drawn from ``alphabet``, which should be a collection of length one strings or a strategy generating such string

Remove all keys, regardless of their pinned status.

Returns the minimal example from the given strategy ``specifier`` that matches the predicate function ``condition``.

A sort key ordering aware datetimes by the moment they refer to. Unlike comparison of datetimes which share a tzinfo - which falls back to ig

Serialize a list of choices to a bytestring. Inverts choices_from_bytes.

Should I draw another element to add to the collection?

r"""Generates characters, length-one :class:`python:str`\ ings, following specified filtering rules. - When no filtering rules are specified,

Attempts to add ``data`` to the pareto front. Returns True if ``data`` is now in the front, including if data is already in the collec

Returns a strategy that generates :class:`~python:complex` numbers. This strategy draws complex numbers with constrained magnitudes. The

Like the typing version, but tries harder and never errors. Tries harder: if the thing to inspect is a class but typing.get_type_hints raises

Convert the result of running this test into either an Overrun object or a ConjectureResult.

Checks that lower_bound and upper_bound are either unspecified, or they define a valid interval on the number line. Otherwise raises InvalidA

Return some element of values satisfying the condition that will not lead to an exhausted branch, or raise DeadBranch if no such eleme

Returns whether or not Hypothesis considers |observability| to be enabled. Observability is enabled if there is at least one observability

times(min_value=datetime.time.min, max_value=datetime.time.max, *, timezones=none()) A strategy for times between ``min_value`` and ``max_value``