A settings object controls the following aspects of test behavior: |~settings.max_examples|, |~settings.derandomize|, |~settings.database|,

Used to indicate that the arguments to a Hypothesis function were in some manner incorrect.

A non-persistent example database, implemented in terms of an in-memory dictionary. This can be useful if you call a test function several ti

A collection of values for use in stateful testing. Bundles are a kind of strategy where values can be added by rules, and (like any strategy

A DataTree tracks the structured history of draws in some test function, across multiple ConjectureData objects. This information is use

Use a directory to store Hypothesis examples as files. Each test corresponds to a directory, and each example to a file within that directory

A compact and efficient representation of a set of ``(a, b)`` intervals. Can be treated like a set of integers, in that ``n in intervals`` wi

Class for storing a list of non-negative integers compactly. We store them as the smallest size integer array we can get away with. When we t

A file-based database loaded from a `GitHub Actions <https://docs.github.com/en/actions>`_ artifact. You can use this for sharing example da

A "copy" of a sequence that works by inserting a mask in front of the underlying sequence, so that you can mutate it without changing the unde

Store Hypothesis examples as sets in the given :class:`~redis.Redis` datastore. This is particularly useful for shared databases, as per the reci

The only concrete implementation of GenericCache we use outside of tests currently. Adopts a modified least-recently used eviction policy: It

A strategy which is defined purely by conversion to and from another strategy. Its parameter and distribution come from that other strategy.

Hypothesis had to resolve a type to a strategy, but this failed. Type inference is best-effort, so this only happens when an annotation exist

Raised when a test should stop running and return control to the Hypothesis engine, which should then continue normally.

Manages thread-local state. ThreadLocal forwards getattr and setattr to a threading.local() instance. The passed kwargs defines the available

Add an explicit input to a Hypothesis test, which Hypothesis will always try before generating random inputs. This combines the randomized na

Records sequences of choices made during shrinking so that we can track what parts of a pass has run. Used to create Chooser objects that are

Context manager that ensures there are at least N free stackframes (for a reasonable value of N).

Return constraints to the appropriate strategy, and the predicate if needed. For example:: integers().filter(lambda x: x >= 0) -

A Hypothesis database, for use in |settings.database|. Hypothesis automatically saves failures to the database set in |settings.database

Raised when a mutation method has been called on a ConjectureData object after freeze() has been called.

Generic parent class for exceptions thrown by Hypothesis.

Used to indicate that a class definition was not well put together and has something wrong with it.

A strategy which generates single character strings of text type.

Raised by alternative backends when a |PrimitiveProvider| cannot proceed. This is expected to occur inside one of the ``.draw_*()`` methods,

This is a drop-in replacement for a GenericCache (despite the lack of inheritance) in performance critical environments. It turns out that Ge

Implements a union of strategies. Given a number of strategies this generates values which could have come from any of them. The conditional

A wrapper to make the given database read-only. The implementation passes through ``fetch``, and turns ``save``, ``delete``, and ``move`` int

A strategy which samples from a set of elements. This is essentially equivalent to using a OneOfStrategy over Just strategies but may be more

A node, or collection of directly descended nodes, in a DataTree. We store the DataTree as a radix tree (https://en.wikipedia.org/wiki/Radix

A factory for sentinel objects with nice reprs.

A wrapper which defers writes on the given database to a background thread. Calls to :meth:`~hypothesis.database.ExampleDatabase.fetch` wait for

Observer class for recording the behaviour of a ConjectureData object, primarily used for tracking the behaviour in the tree cache.

Object that can be used to control a number of feature flags for a given test run. This enables an approach to data generation called swarm t

This function appears to fail non-deterministically: We have seen it fail when passed this example at least once, but a subsequent invocation

A wrapper around multiple databases. Each ``save``, ``fetch``, ``move``, or ``delete`` operation will be run against all of the wrapped datab

Utility class for collections. Bundles up the logic we use for "should I keep drawing more values?" and handles starting and stopping examples in

A strategy for floating point numbers.

mock_xp cannot be hashed and thus cannot be used in our cache. So just for the purposes of testing the cache, we wrap it with an unsafe hash

A |HealthCheck| is proactively raised by Hypothesis when Hypothesis detects that your test has performance problems, which may result in less

This object is provided as the .hypothesis attribute on @given tests. Downstream users can reassign its attributes to insert custom logic into

Attempts to find a smaller integer. Guaranteed things to try ``0``, ``1``, ``initial - 1``, ``initial - 2``. Plenty of optimisations beyond t

A strategy which always returns a single fixed value. It's implemented as a length-one SampledFromStrategy so that all our special-case logic

A strategy which is defined purely by conversion to and from another strategy. Its parameter and distribution come from that other strategy.

A shrinker that tries to make a sequence more sorted. Will not change the length or the contents, only tries to reorder the elements of the s

Maintains an approximate pareto front of ConjectureData objects. That is, we try to maintain a collection of objects such that no element of the

Options for the |settings.phases| argument to |@settings|.

Sampler based on Vose's algorithm for the alias method. See http://www.keithschwarz.com/darts-dice-coins/ for a good explanation. The general

A shrinker is a child object of a ConjectureRunner which is designed to manage the associated state of a particular shrink problem. That is, we

A strategy responsible for fixed length tuples based on heterogeneous strategies for each of their elements.

We ran out of time or examples before we could find enough examples which satisfy the assumptions of this hypothesis. This could be because t