Skip to content

Upgrading hypothesis 0.9 to 1

Unknown0.9.2 → 1.19.0

Fetching 43 releases from GitHub…0 / 43
UnknownUpgrade verdict

DepDelta is still reading the notes for this range, so breaking changes can't be ruled out yet.

  • DepDelta is still reading the release notes in this range, so it can't rule out breaking changes yet.
  • This page updates as the notes come in.
Still reading release notes

DepDelta is still reading the release notes in this range. This updates as they come in.

Generated by DepDelta from published Python source. Not mixed with prose notes.

  • added: export Verbosity
  • added: export __version__
  • added: export __version_info__
  • added: export example
  • added: export find
  • added: export note
  • added: export seed
  • added: export settings
  • added: function hypothesis_home_dir()
  • added: function mkdir_p(path)
  • added: function set_hypothesis_home_dir(directory)
  • added: function storage_directory(name)
  • added: class BuildContext(object)
  • added: constructor BuildContext(is_final=…, close_on_capture=…)
  • added: function cleanup(teardown)
  • added: function current_build_context()
  • added: function note(value)
  • added: method BuildContext.close()
  • added: method BuildContext.local()
  • added: method BuildContext.mark_captured()
  • removed: function assume(condition)
  • added: function best_satisfying_template(search_strategy, random, condition, settings, storage, tracker=…, max_parameter_tries=…, start_time=…)
  • added: function example(*args, **kwargs)
  • added: function find(specifier, condition, settings=…, random=…, storage=…)
  • added: function find_satisfying_template(search_strategy, random, condition, tracker, settings, storage=…, max_parameter_tries=…)
  • added: function new_random()
  • added: function reify_and_execute(search_strategy, template, test, print_example=…, record_repr=…, is_final=…)
  • added: function seed(seed)
  • added: function simplify_template_such_that(search_strategy, random, t, f, tracker, settings, start_time)
  • added: function test_is_flaky(test, expected_repr)
  • added: function time_to_call_it_a_day(settings, start_time)
  • added: variable Example
  • removed: export show
  • removed: export strategy
  • removed: method ExampleDatabase.storage_for(specifier)
  • changed: constructor Storage(backend, specifier, strategy, format, database) → constructor Storage(backend, key, format, database)
  • changed: method Storage.fetch() → method Storage.fetch(strategy)
  • changed: method Storage.save(value) → method Storage.save(value, strategy)
  • added: method ExampleDatabase.storage(key)
  • added: method Backend.close()
  • added: method SQLiteBackend.keys()
  • removed: class Exhausted(Unfalsifiable)
  • removed: class Unfalsifiable(HypothesisException)
  • removed: constructor Exhausted(hypothesis, n_examples)
  • removed: constructor Flaky(hypothesis, example)
  • removed: constructor Unfalsifiable(hypothesis, extra=…)
  • removed: constructor Unsatisfiable(hypothesis, examples, run_time)
  • changed: constructor UnsatisfiedAssumption() → constructor UnsatisfiedAssumption(*args, **kwargs)
  • added: class AbnormalExit(HypothesisException)
  • added: class BadTemplateDraw(HypothesisException)
  • added: class CleanupFailed(HypothesisException)
  • added: class DefinitelyNoSuchExample(NoSuchExample)
  • added: class FailedHealthCheck(HypothesisException, Warning)
  • added: class HypothesisDeprecationWarning(HypothesisException, DeprecationWarning)
  • added: class InvalidArgument(HypothesisException, TypeError)
  • added: class InvalidDefinition(HypothesisException, TypeError)
  • added: class NoExamples(HypothesisException)
  • added: class NoSuchExample(HypothesisException)
  • added: constructor DefinitelyNoSuchExample(condition_string, n_examples)
  • added: constructor NoSuchExample(condition_string, extra=…)
  • added: export default_executor
  • added: export executor
  • added: function attr_based_executor(runner)
  • added: function default_executor(function)
  • added: function setup_teardown_executor(setup, teardown)
  • added: variable executor
  • removed: function load_entry_points(name=…)
  • removed: variable loaded
  • added: class DateTimeTemplate(namedtuple('DateTimeTemplate', ('year', 'month', 'day', 'hour', 'minute', 'second', 'microsecond', 'tzinfo')))
  • added: class DatetimeStrategy(SearchStrategy)
  • added: constructor DatetimeStrategy(allow_naive, timezones, min_year=…, max_year=…)
  • added: field DatetimeStrategy.Parameter
  • added: function dates(min_year=…, max_year=…)
  • added: function datetime_specced_strategy(spec, settings)
  • added: function datetime_strategy(cls, settings)
  • added: function datetime_to_date(dt)
  • added: function datetime_to_time(dt)
  • added: function datetimes(allow_naive=…, timezones=…, min_year=…, max_year=…)
  • added: function maybe_zero_or(random, p, v)
  • added: function times(allow_naive=…, timezones=…)
  • added: method DateTimeTemplate.replace(**kwargs)
  • added: method DateTimeTemplate.to_datetime()
  • added: method DatetimeStrategy.draw_parameter(random)
  • added: method DatetimeStrategy.draw_template(random, pv)
  • added: method DatetimeStrategy.from_basic(values)
  • added: method DatetimeStrategy.reify(template)
  • added: method DatetimeStrategy.simplifiers(random, template)
  • added: method DatetimeStrategy.simplify_timezones(random, template)
  • added: method DatetimeStrategy.simplify_towards_2000(random, value)
  • added: method DatetimeStrategy.to_basic(value)
  • added: method DatetimeStrategy.year_in_bounds(year)
  • added: variable DatetimeSpec
  • added: variable any_datetime
  • added: variable naive_datetime
  • added: variable timezone_aware_datetime
  • added: class HypothesisTestCase(object)
  • added: class TestCase(HypothesisTestCase, dt.TestCase)
  • added: class TransactionTestCase(HypothesisTestCase, dt.TransactionTestCase)
  • added: method HypothesisTestCase.setup_example()
  • added: method HypothesisTestCase.teardown_example(example)
  • added: class Fixture(object)
  • added: constructor Fixture(strategy, constraint=…, execute=…, settings=…)
  • added: function active_fixtures()
  • added: function fixture(strategy, constraint=…, execute=…)
  • added: method Fixture.template_condition(template)
  • added: variable ALL_FIXTURES
  • added: class ModelNotSupported(Exception)
  • added: class ModelStrategy(MappedSearchStrategy)
  • added: constructor ModelStrategy(model, mappings)
  • added: function add_default_field_mapping(field_type, strategy)
  • added: function field_mappings()
  • added: function models(model, **extra)
  • added: function referenced_models(model, seen=…)
  • added: method ModelStrategy.pack(value)
  • added: class FakeFactoryStrategy(SearchStrategy)
  • added: constructor FakeFactoryStrategy(source, providers, locales)
  • added: function fake_factory(source, locale=…, locales=…, providers=…)
  • added: method FakeFactoryStrategy.basic_simplify(random, template)
  • added: method FakeFactoryStrategy.draw_parameter(random)
  • added: method FakeFactoryStrategy.draw_template(random, pv)
  • added: method FakeFactoryStrategy.factory_for(locale)
  • added: method FakeFactoryStrategy.from_basic(value)
  • added: method FakeFactoryStrategy.gen_example(random, locales)
  • added: method FakeFactoryStrategy.reify(template)
  • added: method FakeFactoryStrategy.strictly_simpler(x, y)
  • added: method FakeFactoryStrategy.to_basic(value)
  • added: class ArrayStrategy(SearchStrategy)
  • added: constructor ArrayStrategy(element_strategy, shape, dtype)
  • added: function arrays(dtype, shape, elements=…)
  • added: function from_dtype(dtype)
  • added: function is_scalar(spec)
  • added: method ArrayStrategy.draw_parameter(random)
  • added: method ArrayStrategy.draw_template(random, parameter_value)
  • added: method ArrayStrategy.from_basic(data)
  • added: method ArrayStrategy.indices_roughly_from_worst_to_best(random, x)
  • added: method ArrayStrategy.reify(template)
  • added: method ArrayStrategy.shared_indices(random, template)
  • added: method ArrayStrategy.shared_simplification(simplify)
  • added: method ArrayStrategy.simplifier_for_index(i, simplify)
  • added: method ArrayStrategy.simplifiers(random, template)
  • added: method ArrayStrategy.simplify_with_example_cloning(random, x)
  • added: method ArrayStrategy.strictly_simpler(x, y)
  • added: method ArrayStrategy.to_basic(template)
  • added: class StoringReporter(object)
  • added: constructor StoringReporter(config)
  • added: function load()
  • added: function pytest_addoption(parser)
  • added: function pytest_collection_modifyitems(items)
  • added: function pytest_configure(config)
  • added: function pytest_pyfunc_call(pyfuncitem)
  • added: function pytest_runtest_makereport(item, call)
  • added: variable LOAD_PROFILE_OPTION
  • added: variable PYTEST_VERSION
  • added: function ascii_tree()
  • added: function categories(tree)
  • added: function category_by_codepoint(tree, codepoint)
  • added: function codepoints(tree)
  • added: function codepoints_for_category(tree, category)
  • added: function filter_tree(tree, whitelist_categories=…, blacklist_categories=…, blacklist_characters=…, min_codepoint=…, max_codepoint=…)
  • added: function random_codepoint(tree, category, random)
  • added: function unicode_tree()
  • added: class chooser(object)
  • added: constructor chooser(weights)
  • added: method chooser.choose(random)
  • added: function a_good_encoding()
  • added: function escape_unicode_characters(s)
  • added: function float_to_decimal(f)
  • added: function hrange(start_or_finish, finish=…, step=…)
  • added: function isidentifier(s)
  • added: function qualname(f)
  • added: function quiet_raise(exc)
  • added: function signature_argspec(f)
  • added: function to_unicode(x)
  • added: function unicode_safe_repr(x)
  • added: function update_code_location(code, newfile, newlineno)
  • added: variable ArgSpec
  • added: variable CODE_FIELD_ORDER
  • added: variable FakeArgSpec
  • added: variable HAS_SIGNATURE
  • added: variable NO_ARGSPEC
  • added: variable PY2
  • added: variable PY26
  • added: variable PYPY
  • added: variable VALID_PYTHON_IDENTIFIER
  • added: variable WINDOWS
  • added: variable getargspec
  • added: variable importlib_invalidate_caches
  • added: variable reduce
  • added: class CatchableTimeout(Exception)
  • added: class Timeout(BaseException)
  • added: function minimal(definition, condition=…, settings=…, timeout_after=…, random=…)
  • added: function minimal_element(strategy, random)
  • added: function minimal_elements(strategy, random)
  • added: function some_template(spec, random=…)
  • added: function timeout(seconds=…)
  • added: function via_database(spec, strat, template)
  • removed: method ParameterSource.draw_parameter_score(i)
  • changed: constructor ParameterSource(context, strategy, min_parameters=…, min_tries=…) → constructor ParameterSource(random, strategy, max_tries=…)
  • removed: function add_directory_to_path(d)
  • removed: function find_offset(string, line, column)
  • removed: variable VALID_PYTHON_IDENTIFIER
  • changed: function arg_string(f, args, kwargs) → function arg_string(f, args, kwargs, reorder=…)
  • added: function fully_qualified_name(f)
  • added: function impersonate(target)
  • added: function nicerepr(v)
  • added: variable LINE_CONTINUATION
  • added: variable SPACE_FOLLOWS_OPEN_BRACKET
  • added: variable SPACE_PRECEDES_CLOSE_BRACKET
  • added: class StrategyExtMethod(ExtMethod)
  • added: constructor StrategyExtMethod(*args, **kwargs)
  • added: method StrategyExtMethod.load_deprecated_api()
  • added: variable strategy
  • changed: function flatten(x) → function flatten(o)
  • removed: class Verifier(object)
  • removed: constructor Verifier(random=…, settings=…)
  • removed: method Verifier.falsify(hypothesis, *argument_types, **kwargs)
  • added: function current_verbosity()
  • added: function debug_report(text)
  • added: function report(text)
  • added: function to_text(textish)
  • added: function verbose_report(text)
  • added: export BasicStrategy
  • added: class BasicSearchStrategy(SearchStrategy)
  • added: class BasicStrategy(object)
  • added: class BasicTemplate(object)
  • added: class Generated(BasicTemplate)
  • added: class Simplified(BasicTemplate)
  • added: constructor BasicSearchStrategy(user_generate, user_parameter=…, user_simplify=…, copy_value=…)
  • added: constructor BasicStrategy(settings=…)
  • added: constructor BasicTemplate(tracking_id)
  • added: constructor Generated(template_seed, parameter_seed)
  • added: constructor Simplified(seed, iteration, source)
  • added: field BasicSearchStrategy.MAX_DEPTH
  • added: function add_int_to_hasher(hasher, i)
  • added: function basic_strategy(generate, parameter=…, simplify=…, copy=…)
  • added: method BasicSearchStrategy.basic_simplify(random, template)
  • added: method BasicSearchStrategy.draw_parameter(random)
  • added: method BasicSearchStrategy.draw_template(random, parameter)
  • added: method BasicSearchStrategy.from_basic(data)
  • added: method BasicSearchStrategy.reify(template)
  • added: method BasicSearchStrategy.strictly_simpler(x, y)
  • added: method BasicSearchStrategy.to_basic(template)
  • added: method BasicStrategy.copy(value)
  • added: method BasicStrategy.generate(random, parameter_value)
  • added: method BasicStrategy.generate_parameter(random)
  • added: method BasicStrategy.simplify(random, value)
  • removed: class FrozenSetStrategy(MappedSearchStrategy)
  • removed: class SetStrategy(MappedSearchStrategy)
  • removed: class mix_generators(object)
  • removed: constructor FrozenSetStrategy(set_strategy)
  • removed: constructor SetStrategy(strategies, average_length=…)
  • removed: constructor mix_generators(generators)
  • removed: field SetStrategy.Parameter
  • removed: function define_dict_strategy(specifier, settings)
  • removed: function define_frozen_set_strategy(specifier, settings)
  • removed: function define_list_strategy(specifier, settings)
  • removed: function define_set_strategy(specifier, settings)
  • removed: function define_tuple_strategy(specifier, settings)
  • removed: method ListStrategy.produce_parameter(random)
  • removed: method ListStrategy.produce_template(context, pv)
  • removed: method ListStrategy.simplify(x)
  • removed: method SetStrategy.from_basic(value)
  • removed: method SetStrategy.produce_parameter(random)
  • removed: method SetStrategy.produce_template(context, pv)
  • removed: method SetStrategy.reify(value)
  • removed: method SetStrategy.simplify(x)
  • removed: method SetStrategy.to_basic(value)
  • removed: method TupleStrategy.produce_parameter(random)
  • removed: method TupleStrategy.produce_template(context, pv)
  • removed: method TupleStrategy.simplify(x)
  • removed: method mix_generators.next()
  • changed: constructor ListStrategy(strategies, average_length=…) → constructor ListStrategy(strategies, average_length=…, min_size=…, max_size=…)
  • added: class SingleElementListStrategy(MappedSearchStrategy)
  • added: class UniqueListStrategy(SearchStrategy)
  • added: class UniqueListTemplate(object)
  • added: constructor SingleElementListStrategy(element_strategy, length_strategy)
  • added: constructor UniqueListStrategy(elements, min_size, max_size, average_size, key)
  • added: constructor UniqueListTemplate(size, parameter_seed, parameter, template_seed, values)
  • added: field UniqueListStrategy.Parameter
  • added: function safe_mul(x, y)
  • added: method ListStrategy.draw_parameter(random)
  • added: method ListStrategy.draw_template(random, pv)
  • added: method ListStrategy.indices_roughly_from_worst_to_best(random, x)
  • added: method ListStrategy.shared_indices(template)
  • added: method ListStrategy.shared_simplification(simplify)
  • added: method ListStrategy.simplifier_for_index(i, simplify)
  • added: method ListStrategy.simplifiers(random, template)
  • added: method ListStrategy.simplify_arrange_by_pivot(random, x)
  • added: method ListStrategy.simplify_to_empty(random, x)
  • added: method ListStrategy.simplify_to_singletons(random, x)
  • added: method ListStrategy.simplify_with_example_cloning(random, x)
  • added: method ListStrategy.simplify_with_random_discards(random, x)
  • added: method ListStrategy.simplify_with_single_deletes(random, x)
  • added: method ListStrategy.strictly_simpler(x, y)
  • added: method ListStrategy.validate()
  • added: method SingleElementListStrategy.new_element()
  • added: method SingleElementListStrategy.pack(length)
  • added: method TupleStrategy.draw_parameter(random)
  • added: method TupleStrategy.draw_template(random, pv)
  • added: method TupleStrategy.simplifier_for_index(i, simplifier)
  • added: method TupleStrategy.simplifiers(random, template)
  • added: method TupleStrategy.strictly_simpler(x, y)
  • added: method TupleStrategy.validate()
  • added: method UniqueListStrategy.draw_parameter(random)
  • added: method UniqueListStrategy.draw_template(random, parameter)
  • added: method UniqueListStrategy.from_basic(data)
  • added: method UniqueListStrategy.reduce_size(random, template)
  • added: method UniqueListStrategy.reify(template)
  • added: method UniqueListStrategy.simplifiers(random, template)
  • added: method UniqueListStrategy.simplify_index(i)
  • added: method UniqueListStrategy.simplify_to_subsets(random, template)
  • added: method UniqueListStrategy.strictly_simpler(x, y)
  • added: method UniqueListStrategy.to_basic(template)
  • added: method UniqueListStrategy.validate()
  • added: class DeferredStrategy(SearchStrategy)
  • added: class reprmangledtuple(tuple)
  • added: constructor DeferredStrategy(function, args, kwargs)
  • added: function tupleize(x)
  • added: method DeferredStrategy.draw_parameter(random)
  • added: method DeferredStrategy.draw_template(random, pv)
  • added: method DeferredStrategy.from_basic(data)
  • added: method DeferredStrategy.reify(value)
  • added: method DeferredStrategy.simplifiers(random, template)
  • added: method DeferredStrategy.strictly_simpler(x, y)
  • added: method DeferredStrategy.to_basic(template)
  • added: method DeferredStrategy.validate()
  • added: property DeferredStrategy.template_upper_bound
  • added: property DeferredStrategy.wrapped_strategy
  • added: class FlatMapStrategy(MappedSearchStrategy)
  • added: constructor FlatMapStrategy(strategy, expand)
  • added: method FlatMapStrategy.pack(source_and_morpher)
  • removed: field BoolStrategy.size_lower_bound
  • removed: field BoolStrategy.size_upper_bound
  • removed: field JustStrategy.size_lower_bound
  • removed: field JustStrategy.size_upper_bound
  • removed: function bool_strategy(cls, settings)
  • removed: function define_just_strategy(specifier, settings)
  • removed: function define_none_strategy(specifier, settings)
  • removed: function define_random_strategy(specifier, settings)
  • removed: function define_sampled_strategy(specifier, settings)
  • removed: method BoolStrategy.produce_parameter(random)
  • removed: method BoolStrategy.produce_template(context, p)
  • removed: method JustStrategy.produce_parameter(random)
  • removed: method JustStrategy.produce_template(context, pv)
  • removed: method RandomStrategy.from_basic(data)
  • removed: method RandomStrategy.produce_parameter(random)
  • removed: method RandomStrategy.produce_template(context, pv)
  • removed: method RandomStrategy.reify(template)
  • removed: method RandomStrategy.to_basic(template)
  • removed: method SampledFromStrategy.produce_parameter(random)
  • removed: method SampledFromStrategy.produce_template(context, pv)
  • changed: class RandomStrategy(SearchStrategy) → class RandomStrategy(MappedSearchStrategy)
  • added: field BoolStrategy.template_upper_bound
  • added: field JustStrategy.template_upper_bound
  • added: method BoolStrategy.basic_simplify(random, value)
  • added: method BoolStrategy.draw_parameter(random)
  • added: method BoolStrategy.draw_template(random, p)
  • added: method BoolStrategy.strictly_simpler(x, y)
  • added: method JustStrategy.draw_parameter(random)
  • added: method JustStrategy.draw_template(random, pv)
  • added: method JustStrategy.simplifiers(random, template)
  • added: method RandomStrategy.pack(i)
  • added: method SampledFromStrategy.basic_simplify(random, template)
  • added: method SampledFromStrategy.draw_parameter(random)
  • added: method SampledFromStrategy.draw_template(random, pv)
  • added: method SampledFromStrategy.strictly_simpler(x, y)
  • added: class Morpher(object)
  • added: class MorpherParameter(object)
  • added: class MorpherStrategy(SearchStrategy)
  • added: constructor Morpher(parameter, template_seed, data=…)
  • added: constructor MorpherParameter(seed)
  • added: method Morpher.become(strategy)
  • added: method MorpherParameter.parameter(strategy)
  • added: method MorpherStrategy.convert_simplifier(strategy, simplifier)
  • added: method MorpherStrategy.draw_parameter(random)
  • added: method MorpherStrategy.draw_template(random, parameter)
  • added: method MorpherStrategy.from_basic(data)
  • added: method MorpherStrategy.reify(template)
  • added: method MorpherStrategy.simplifiers(random, morpher)
  • added: method MorpherStrategy.strictly_simpler(x, y)
  • added: method MorpherStrategy.to_basic(template)
  • removed: function nary_tree_strategy(specifier, settings)
  • removed: method NAryTreeStrategy.produce_parameter(random)
  • removed: method NAryTreeStrategy.produce_template(context, pv)
  • removed: method NAryTreeStrategy.simplify(template)
  • added: function n_ary_tree(*args, **kwargs)
  • added: method NAryTreeStrategy.basic_simplify(random, template)
  • added: method NAryTreeStrategy.draw_parameter(random)
  • added: method NAryTreeStrategy.draw_template(random, pv)
  • removed: class SmallFloats(FloatStrategy)
  • removed: field SmallFloats.Parameter
  • removed: field SmallFloats.max_exponent
  • removed: function define_complex_strategy(specifier, settings)
  • removed: function define_float_strategy(specifier, settings)
  • removed: function define_stragy_for_integer_Range(specifier, settings)
  • removed: function define_strategy_for_float_Range(specifier, settings)
  • removed: function int_strategy(specifier, settings)
  • removed: method BoundedFloatStrategy.produce_parameter(random)
  • removed: method BoundedFloatStrategy.produce_template(context, pv)
  • removed: method BoundedIntStrategy.produce_parameter(random)
  • removed: method BoundedIntStrategy.produce_template(context, parameter)
  • removed: method BoundedIntStrategy.simplify(x)
  • removed: method ExponentialFloatStrategy.produce_parameter(random)
  • removed: method ExponentialFloatStrategy.produce_template(context, pv)
  • removed: method FixedBoundedFloatStrategy.produce_parameter(random)
  • removed: method FixedBoundedFloatStrategy.produce_template(context, pv)
  • removed: method FixedBoundedFloatStrategy.simplify(value)
  • removed: method FloatStrategy.simplify(x)
  • removed: method FullRangeFloats.produce_parameter(random)
  • removed: method FullRangeFloats.produce_template(context, pv)
  • removed: method GaussianFloatStrategy.produce_parameter(random)
  • removed: method GaussianFloatStrategy.produce_template(context, mean)
  • removed: method IntStrategy.simplify(x)
  • removed: method JustIntFloats.produce_parameter(random)
  • removed: method JustIntFloats.produce_template(context, pv)
  • removed: method NastyFloats.reify(value)
  • removed: method RandomGeometricIntStrategy.produce_parameter(random)
  • removed: method RandomGeometricIntStrategy.produce_template(context, parameter)
  • removed: method SmallFloats.produce_parameter(random)
  • removed: method SmallFloats.produce_template(context, pv)
  • removed: method WrapperFloatStrategy.produce_parameter(random)
  • removed: method WrapperFloatStrategy.produce_template(context, pv)
  • changed: class NastyFloats(FloatStrategy, SampledFromStrategy) → class NastyFloats(SampledFromStrategy)
  • changed: constructor JustIntFloats(int_strategy) → constructor JustIntFloats()
  • changed: constructor NastyFloats() → constructor NastyFloats(allow_nan=…, allow_infinity=…)
  • added: class IntegersFromStrategy(SearchStrategy)
  • added: class WideRangeIntStrategy(IntStrategy)
  • added: constructor FullRangeFloats(allow_nan=…, allow_infinity=…)
  • added: constructor IntegersFromStrategy(lower_bound, average_size=…)
  • added: field WideRangeIntStrategy.Parameter
  • added: function integer_or_bad(data)
  • added: function is_integral(value)
  • added: method BoundedFloatStrategy.draw_parameter(random)
  • added: method BoundedFloatStrategy.draw_template(random, pv)
  • added: method BoundedIntStrategy.basic_simplify(random, x)
  • added: method BoundedIntStrategy.draw_parameter(random)
  • added: method BoundedIntStrategy.draw_template(random, parameter)
  • added: method BoundedIntStrategy.strictly_simpler(x, y)
  • added: method ExponentialFloatStrategy.draw_parameter(random)
  • added: method ExponentialFloatStrategy.draw_template(random, pv)
  • added: method FixedBoundedFloatStrategy.basic_simplify(random, value)
  • added: method FixedBoundedFloatStrategy.draw_parameter(random)
  • added: method FixedBoundedFloatStrategy.draw_template(random, pv)
  • added: method FixedBoundedFloatStrategy.from_basic(data)
  • added: method FixedBoundedFloatStrategy.simplifiers(random, template)
  • added: method FixedBoundedFloatStrategy.strictly_simpler(x, y)
  • added: method FloatStrategy.basic_simplify(random, x)
  • added: method FloatStrategy.push_towards_one(random, x)
  • added: method FloatStrategy.simplifiers(random, x)
  • added: method FloatStrategy.simplify_integral(simplify)
  • added: method FloatStrategy.simplify_weird_values(random, x)
  • added: method FloatStrategy.strictly_simpler(x, y)
  • added: method FullRangeFloats.draw_parameter(random)
  • added: method FullRangeFloats.draw_template(random, pv)
  • added: method GaussianFloatStrategy.draw_parameter(random)
  • added: method GaussianFloatStrategy.draw_template(random, param)
  • added: method IntStrategy.simplifiers(random, template)
  • added: method IntStrategy.strictly_simpler(x, y)
  • added: method IntStrategy.try_negate(random, x)
  • added: method IntStrategy.try_shrink(lo, hi)
  • added: method IntStrategy.try_small_numbers(random, x)
  • added: method IntegersFromStrategy.draw_parameter(random)
  • added: method IntegersFromStrategy.draw_template(random, parameter)
  • added: method IntegersFromStrategy.from_basic(data)
  • added: method IntegersFromStrategy.reify(template)
  • added: method IntegersFromStrategy.simplifiers(random, template)
  • added: method IntegersFromStrategy.simplify_to_lower_bound(random, template)
  • added: method IntegersFromStrategy.to_basic(template)
  • added: method IntegersFromStrategy.try_shrink(i)
  • added: method JustIntFloats.draw_parameter(random)
  • added: method JustIntFloats.draw_template(random, pv)
  • added: method RandomGeometricIntStrategy.draw_parameter(random)
  • added: method RandomGeometricIntStrategy.draw_template(random, parameter)
  • added: method WideRangeIntStrategy.draw_parameter(random)
  • added: method WideRangeIntStrategy.draw_template(random, parameter)
  • added: method WrapperFloatStrategy.draw_parameter(random)
  • added: method WrapperFloatStrategy.draw_template(random, pv)
  • added: variable STANDARD_NAN
  • added: class RecursiveStrategy(WrapperStrategy)
  • added: class TemplateLimitReached(BaseException)
  • added: class TemplateLimitedStrategy(WrapperStrategy)
  • added: constructor RecursiveStrategy(base, extend, max_leaves)
  • added: constructor TemplateLimitedStrategy(strategy)
  • added: method RecursiveStrategy.draw_template(random, pv)
  • added: method TemplateLimitedStrategy.capped(max_templates)
  • added: method TemplateLimitedStrategy.draw_template(random, parameter_value)
  • added: class ReprWrapperStrategy(WrapperStrategy)
  • added: constructor ReprWrapperStrategy(strategy, representation)
  • added: method ReprWrapperStrategy.draw_parameter(random)
  • added: method ReprWrapperStrategy.draw_template(random, pv)
  • added: method ReprWrapperStrategy.from_basic(data)
  • added: method ReprWrapperStrategy.reify(value)
  • added: method ReprWrapperStrategy.simplifiers(random, template)
  • added: method ReprWrapperStrategy.strictly_simpler(x, y)
  • added: method ReprWrapperStrategy.to_basic(template)
  • added: class SharedStrategy(SearchStrategy)
  • added: class SharedTemplate(object)
  • added: constructor SharedStrategy(base, key=…)
  • added: constructor SharedTemplate(base)
  • added: method SharedStrategy.convert_simplifier(simplifier)
  • added: method SharedStrategy.draw_parameter(random)
  • added: method SharedStrategy.draw_template(random, pv)
  • added: method SharedStrategy.from_basic(data)
  • added: method SharedStrategy.reify(value)
  • added: method SharedStrategy.simplifiers(random, template)
  • added: method SharedStrategy.strictly_simpler(x, y)
  • added: method SharedStrategy.to_basic(template)
  • added: variable SHARED_STRATEGY_ATTRIBUTE
  • removed: class BuildContext(object)
  • removed: class StrategyExtMethod(ExtMethod)
  • removed: constructor BuildContext(random)
  • removed: field SearchStrategy.size_lower_bound
  • removed: field SearchStrategy.size_upper_bound
  • removed: function strategy_for_one_of(oneof, settings)
  • removed: function strategy_strategy(strategy, settings)
  • removed: method MappedSearchStrategy.produce_parameter(random)
  • removed: method MappedSearchStrategy.produce_template(context, pv)
  • removed: method MappedSearchStrategy.simplify(value)
  • removed: method OneOfStrategy.produce_parameter(random)
  • removed: method OneOfStrategy.produce_template(context, pv)
  • removed: method OneOfStrategy.simplify(x)
  • removed: method SearchStrategy.produce_parameter(random)
  • removed: method SearchStrategy.produce_template(context, parameter_value)
  • removed: method SearchStrategy.simplify(template)
  • removed: method SearchStrategy.simplify_such_that(t, f)
  • removed: method SearchStrategy.size(template)
  • removed: variable strategy
  • changed: method SearchStrategy.draw_and_produce(context) → method SearchStrategy.draw_and_produce(random)
  • changed: method SearchStrategy.draw_template(context, parameter_value) → method SearchStrategy.draw_template(random, parameter_value)
  • changed: method SearchStrategy.example() → method SearchStrategy.example(random=…)
  • added: class FilteredStrategy(MappedSearchStrategy)
  • added: class LazyParameter(object)
  • added: constructor FilteredStrategy(strategy, condition)
  • added: constructor LazyParameter(strategy, random)
  • added: field SearchStrategy.template_upper_bound
  • added: function infinitish(x)
  • added: function strategy(spec, settings=…)
  • added: method FilteredStrategy.pack(value)
  • added: method MappedSearchStrategy.draw_parameter(random)
  • added: method MappedSearchStrategy.draw_template(random, pv)
  • added: method MappedSearchStrategy.simplifiers(random, template)
  • added: method MappedSearchStrategy.strictly_simpler(x, y)
  • added: method MappedSearchStrategy.validate()
  • added: method OneOfStrategy.draw_parameter(random)
  • added: method OneOfStrategy.draw_template(random, pv)
  • added: method OneOfStrategy.element_simplifier(s, simplifier)
  • added: method OneOfStrategy.redraw_simplifier(child)
  • added: method OneOfStrategy.simplifiers(random, template)
  • added: method OneOfStrategy.strictly_simpler(x, y)
  • added: method OneOfStrategy.validate()
  • added: method SearchStrategy.basic_simplify(random, template)
  • added: method SearchStrategy.filter(condition)
  • added: method SearchStrategy.flatmap(expand)
  • added: method SearchStrategy.full_simplify(random, template)
  • added: method SearchStrategy.simplifiers(random, template)
  • added: method SearchStrategy.strictly_simpler(x, y)
  • added: method SearchStrategy.validate()
  • added: property LazyParameter.value
  • added: variable EFFECTIVELY_INFINITE
  • added: class StreamStrategy(SearchStrategy)
  • added: class StreamTemplate(object)
  • added: constructor StreamStrategy(source_strategy)
  • added: constructor StreamTemplate(seed, parameter, generator, changed=…)
  • added: method StreamStrategy.draw_parameter(random)
  • added: method StreamStrategy.draw_template(random, parameter)
  • added: method StreamStrategy.from_basic(data)
  • added: method StreamStrategy.new_template(seed, parameter_seed)
  • added: method StreamStrategy.reify(template)
  • added: method StreamStrategy.simplifier_for_index(simplify, i)
  • added: method StreamStrategy.simplifiers(random, template)
  • added: method StreamStrategy.stream_shared_simplification(random, template)
  • added: method StreamStrategy.stream_simplify_with_example_cloning(random, x)
  • added: method StreamStrategy.strictly_simpler(x, y)
  • added: method StreamStrategy.to_basic(template)
  • added: method StreamTemplate.with_value(i, value)
  • added: method StreamTemplate.with_values(updates)
  • removed: field OneCharStringStrategy.ascii_characters
  • removed: function define_binary_strategy(specifier, settings)
  • removed: function define_text_type_strategy(specifier, settings)
  • removed: method BinaryStringStrategy.from_basic(data)
  • removed: method BinaryStringStrategy.to_basic(value)
  • removed: method OneCharStringStrategy.produce_parameter(random)
  • removed: method OneCharStringStrategy.produce_template(context, p)
  • removed: method OneCharStringStrategy.simplify(x)
  • removed: method StringStrategy.from_basic(c)
  • removed: method StringStrategy.to_basic(c)
  • added: constructor OneCharStringStrategy(whitelist_categories=…, blacklist_categories=…, blacklist_characters=…, min_codepoint=…, max_codepoint=…)
  • added: field OneCharStringStrategy.zero_point
  • added: method OneCharStringStrategy.draw_parameter(random)
  • added: method OneCharStringStrategy.draw_template(random, p)
  • added: method OneCharStringStrategy.from_basic(data)
  • added: method OneCharStringStrategy.is_good(char)
  • added: method OneCharStringStrategy.simplifiers(random, template)
  • added: method OneCharStringStrategy.to_basic(template)
  • added: method OneCharStringStrategy.try_ascii(random, template)
  • added: method OneCharStringStrategy.try_shrink(lo, hi)
  • added: class WrapperStrategy(SearchStrategy)
  • added: constructor WrapperStrategy(strategy)
  • added: method WrapperStrategy.draw_parameter(random)
  • added: method WrapperStrategy.draw_template(random, pv)
  • added: method WrapperStrategy.from_basic(data)
  • added: method WrapperStrategy.reify(value)
  • added: method WrapperStrategy.simplifiers(random, template)
  • added: method WrapperStrategy.strictly_simpler(x, y)
  • added: method WrapperStrategy.to_basic(template)
  • added: method WrapperStrategy.validate()
  • removed: class DefaultSettings(object)
  • removed: class Settings(object)
  • removed: class SettingsProperty(object)
  • removed: constructor Settings(**kwargs)
  • removed: constructor SettingsProperty(name)
  • removed: field Settings.default
  • removed: function field_name(setting_name)
  • removed: function get_class(obj, typ)
  • removed: function hypothesis_home_dir()
  • removed: function mkdir_p(path)
  • removed: function set_hypothesis_home_dir(directory)
  • removed: function storage_directory(name)
  • removed: method Settings.defaults_stack()
  • removed: property Settings.database
  • removed: static method Settings.define_setting(name, description, default)
  • removed: variable Setting
  • removed: variable all_settings
  • removed: variable databases
  • added: export Settings
  • added: export hypothesis_home_dir
  • added: export set_hypothesis_home_dir
  • added: export storage_directory
  • added: function dictionary(keys, values, dict_class=…)
  • added: function strings(alphabet)
  • added: variable Dictionary
  • added: variable IntegersFrom
  • added: variable Streaming
  • added: variable Strings
  • added: variable integers_from
  • added: variable positive_integers
  • added: variable streaming
  • added: class GenericStateMachine(object)
  • added: class RuleBasedStateMachine(GenericStateMachine)
  • added: class SimpleSampledFromStrategy(SampledFromStrategy)
  • added: class StateMachineRunner(object)
  • added: class StateMachineSearchStrategy(SearchStrategy)
  • added: class TestCaseProperty(object)
  • added: constructor RuleBasedStateMachine()
  • added: constructor StateMachineRunner(parameter_seed, template_seed, n_steps, record=…, templates=…)
  • added: constructor StateMachineSearchStrategy(settings=…)
  • added: field GenericStateMachine.TestCase
  • added: function find_breaking_runner(state_machine_factory, settings=…)
  • added: function precondition(precond)
  • added: function rule(targets=…, target=…, **kwargs)
  • added: function run_state_machine_as_test(state_machine_factory, settings=…)
  • added: function seeds(starting, n_steps)
  • added: method GenericStateMachine.execute_step(step)
  • added: method GenericStateMachine.print_step(step)
  • added: method GenericStateMachine.steps()
  • added: method GenericStateMachine.teardown()
  • added: method RuleBasedStateMachine.bundle(name)
  • added: method RuleBasedStateMachine.execute_step(step)
  • added: method RuleBasedStateMachine.new_name()
  • added: method RuleBasedStateMachine.print_step(step)
  • added: method RuleBasedStateMachine.steps()
  • added: method RuleBasedStateMachine.upcoming_name()
  • added: method SimpleSampledFromStrategy.draw_parameter(random)
  • added: method SimpleSampledFromStrategy.draw_template(random, parameter_value)
  • added: method StateMachineRunner.run(state_machine, print_steps=…)
  • added: method StateMachineSearchStrategy.convert_simplifier(strategy, simplifier, i)
  • added: method StateMachineSearchStrategy.cut_steps(random, template)
  • added: method StateMachineSearchStrategy.delete_elements(random, template)
  • added: method StateMachineSearchStrategy.draw_parameter(random)
  • added: method StateMachineSearchStrategy.draw_template(random, parameter_value)
  • added: method StateMachineSearchStrategy.from_basic(data)
  • added: method StateMachineSearchStrategy.random_discards(random, template)
  • added: method StateMachineSearchStrategy.reify(template)
  • added: method StateMachineSearchStrategy.simplifiers(random, template)
  • added: method StateMachineSearchStrategy.to_basic(template)
  • added: static method RuleBasedStateMachine.define_rule(targets, function, arguments, precondition=…, parent_rule=…)
  • added: static method RuleBasedStateMachine.rules()
  • added: variable Bundle
  • added: variable PRECONDITION_MARKER
  • added: variable RULE_MARKER
  • added: variable Rule
  • added: variable TOMBSTONE
  • added: variable VarReference
  • added: function basic(basic=…, generate_parameter=…, generate=…, simplify=…, copy=…)
  • added: function binary(min_size=…, average_size=…, max_size=…)
  • added: function booleans()
  • added: function builds(target, *args, **kwargs)
  • added: function characters(whitelist_categories=…, blacklist_categories=…, blacklist_characters=…, min_codepoint=…, max_codepoint=…)
  • added: function choices()
  • added: function complex_numbers()
  • added: function composite(f)
  • added: function decimals()
  • added: function dictionaries(keys, values, dict_class=…, min_size=…, average_size=…, max_size=…)
  • added: function fixed_dictionaries(mapping)
  • added: function floats(min_value=…, max_value=…, allow_nan=…, allow_infinity=…)
  • added: function fractions()
  • added: function frozensets(elements=…, min_size=…, average_size=…, max_size=…)
  • added: function integers(min_value=…, max_value=…)
  • added: function just(value)
  • added: function lists(elements=…, min_size=…, average_size=…, max_size=…, unique_by=…, unique=…)
  • added: function none()
  • added: function one_of(arg, *args)
  • added: function random_module()
  • added: function randoms()
  • added: function recursive(base, extend, max_leaves=…)
  • added: function sampled_from(elements)
  • added: function sets(elements=…, min_size=…, average_size=…, max_size=…)
  • added: function streaming(elements)
  • added: function text(alphabet=…, min_size=…, average_size=…, max_size=…)
  • added: function tuples(*args)
  • removed: method TemplatesStrategy.produce_parameter(random)
  • removed: method TemplatesStrategy.produce_template(context, pv)
  • removed: method TemplatesStrategy.simplify(template)
  • changed: function templates_for(specifier, settings) → function templates_for(strat)
  • added: class Rejected(Exception)
  • added: function mess_with_int(i, random)
  • added: function mess_with_list(ls, random)
  • added: function mess_with_none(n, random)
  • added: function mess_with_text(text, random)
  • added: function mutate_basic(basic, random)
  • added: function templates_for_strategy(specifier, settings)
  • added: function test_mess_with_anything(o, random)
  • added: method TemplatesStrategy.draw_parameter(random)
  • added: method TemplatesStrategy.draw_template(random, pv)
  • added: method TemplatesStrategy.simplifiers(random, template)
  • added: method TemplatesStrategy.strictly_simpler(x, y)
  • added: variable mess_with_basic_data
  • added: class ForkingTestCase(TestCase)
  • added: function report_to(w)
  • added: method ForkingTestCase.execute_example(function)
  • added: variable Error
  • added: variable Report
  • added: function contains(db, key, value)
  • added: function get_rows(cursor)
  • added: function main()
  • added: function merge_dbs(ancestor, current, other)
  • added: function merge_paths(ancestor, current, other)
  • added: variable Report
  • added: class Stream(object)
  • added: constructor Stream(generator=…)
  • added: method Stream.map(f)
  • added: method Stream.with_value(i, value)
  • added: method Stream.with_values(updates)
  • added: function clamp(lower, value, upper)