Showing preview only (4,998K chars total). Download the full file or copy to clipboard to get everything.
Repository: HypothesisWorks/hypothesis
Branch: master
Commit: 9fe714de9b90
Files: 666
Total size: 4.6 MB
Directory structure:
gitextract_nlv4f5th/
├── .claude/
│ ├── CLAUDE.md
│ └── commands/
│ └── hypothesis.md
├── .gitattributes
├── .github/
│ ├── CODEOWNERS
│ ├── CODE_OF_CONDUCT.rst
│ ├── actions/
│ │ └── install-base/
│ │ └── action.yml
│ └── workflows/
│ ├── fuzz.yml
│ ├── main.yml
│ ├── update-deps.yml
│ └── website.yml
├── .gitignore
├── .readthedocs.yml
├── AUTHORS.rst
├── CITATION.cff
├── CONTRIBUTING.rst
├── LICENSE.txt
├── README.md
├── brand/
│ ├── README.md
│ ├── hypothesis.gpl
│ ├── hypothesis.sketch
│ └── hypothesis2.sketch
├── build.sh
├── guides/
│ ├── README.md
│ ├── api-style.rst
│ ├── documentation.rst
│ ├── internals.rst
│ ├── review.rst
│ ├── strategies-that-shrink.rst
│ └── testing-hypothesis.rst
├── hypothesis-python/
│ ├── LICENSE.txt
│ ├── README.md
│ ├── RELEASE-sample.rst
│ ├── benchmark/
│ │ ├── README.md
│ │ ├── graph.py
│ │ └── spec.json
│ ├── docs/
│ │ ├── _ext/
│ │ │ ├── hypothesis_linkcheck.py
│ │ │ └── hypothesis_redirects.py
│ │ ├── _static/
│ │ │ ├── better-signatures.css
│ │ │ ├── dark-fix.css
│ │ │ ├── no-scroll.css
│ │ │ └── wrap-in-tables.css
│ │ ├── changelog.rst
│ │ ├── community.rst
│ │ ├── compatibility.rst
│ │ ├── conf.py
│ │ ├── development.rst
│ │ ├── explanation/
│ │ │ ├── domain.rst
│ │ │ ├── example-count.rst
│ │ │ └── index.rst
│ │ ├── extensions.rst
│ │ ├── extras.rst
│ │ ├── how-to/
│ │ │ ├── custom-database.rst
│ │ │ ├── detect-hypothesis-tests.rst
│ │ │ ├── external-fuzzers.rst
│ │ │ ├── index.rst
│ │ │ ├── suppress-healthchecks.rst
│ │ │ └── type-strategies.rst
│ │ ├── index.rst
│ │ ├── packaging.rst
│ │ ├── prolog.rst
│ │ ├── quickstart.rst
│ │ ├── redirect.html.template
│ │ ├── reference/
│ │ │ ├── api.rst
│ │ │ ├── index.rst
│ │ │ ├── integrations.rst
│ │ │ ├── internals.rst
│ │ │ ├── schema_metadata.json
│ │ │ ├── schema_metadata_choices.json
│ │ │ ├── schema_observations.json
│ │ │ └── strategies.rst
│ │ ├── stateful.rst
│ │ ├── tutorial/
│ │ │ ├── adapting-strategies.rst
│ │ │ ├── adding-notes.rst
│ │ │ ├── builtin-strategies.rst
│ │ │ ├── custom-strategies.rst
│ │ │ ├── flaky.rst
│ │ │ ├── index.rst
│ │ │ ├── introduction.rst
│ │ │ ├── replaying-failures.rst
│ │ │ └── settings.rst
│ │ └── usage.rst
│ ├── examples/
│ │ ├── README.md
│ │ ├── example_hypothesis_entrypoint/
│ │ │ ├── example_hypothesis_entrypoint.py
│ │ │ ├── setup.py
│ │ │ └── test_entrypoint.py
│ │ ├── test_basic.py
│ │ ├── test_binary_search.py
│ │ └── test_rle.py
│ ├── pyproject.toml
│ ├── pyrightconfig.json
│ ├── scripts/
│ │ ├── basic-test.sh
│ │ ├── other-tests.sh
│ │ └── validate_branch_check.py
│ ├── src/
│ │ ├── _hypothesis_ftz_detector.py
│ │ ├── _hypothesis_globals.py
│ │ ├── _hypothesis_pytestplugin.py
│ │ └── hypothesis/
│ │ ├── __init__.py
│ │ ├── _settings.py
│ │ ├── configuration.py
│ │ ├── control.py
│ │ ├── core.py
│ │ ├── database.py
│ │ ├── entry_points.py
│ │ ├── errors.py
│ │ ├── extra/
│ │ │ ├── __init__.py
│ │ │ ├── _array_helpers.py
│ │ │ ├── _patching.py
│ │ │ ├── array_api.py
│ │ │ ├── cli.py
│ │ │ ├── codemods.py
│ │ │ ├── dateutil.py
│ │ │ ├── django/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _fields.py
│ │ │ │ └── _impl.py
│ │ │ ├── dpcontracts.py
│ │ │ ├── ghostwriter.py
│ │ │ ├── lark.py
│ │ │ ├── numpy.py
│ │ │ ├── pandas/
│ │ │ │ ├── __init__.py
│ │ │ │ └── impl.py
│ │ │ ├── pytestplugin.py
│ │ │ ├── pytz.py
│ │ │ └── redis.py
│ │ ├── internal/
│ │ │ ├── __init__.py
│ │ │ ├── cache.py
│ │ │ ├── cathetus.py
│ │ │ ├── charmap.py
│ │ │ ├── compat.py
│ │ │ ├── conjecture/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── choice.py
│ │ │ │ ├── data.py
│ │ │ │ ├── datatree.py
│ │ │ │ ├── engine.py
│ │ │ │ ├── floats.py
│ │ │ │ ├── junkdrawer.py
│ │ │ │ ├── optimiser.py
│ │ │ │ ├── pareto.py
│ │ │ │ ├── provider_conformance.py
│ │ │ │ ├── providers.py
│ │ │ │ ├── shrinker.py
│ │ │ │ ├── shrinking/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── bytes.py
│ │ │ │ │ ├── choicetree.py
│ │ │ │ │ ├── collection.py
│ │ │ │ │ ├── common.py
│ │ │ │ │ ├── floats.py
│ │ │ │ │ ├── integer.py
│ │ │ │ │ ├── ordering.py
│ │ │ │ │ └── string.py
│ │ │ │ └── utils.py
│ │ │ ├── constants_ast.py
│ │ │ ├── coverage.py
│ │ │ ├── detection.py
│ │ │ ├── entropy.py
│ │ │ ├── escalation.py
│ │ │ ├── filtering.py
│ │ │ ├── floats.py
│ │ │ ├── healthcheck.py
│ │ │ ├── intervalsets.py
│ │ │ ├── lambda_sources.py
│ │ │ ├── observability.py
│ │ │ ├── reflection.py
│ │ │ ├── scrutineer.py
│ │ │ └── validation.py
│ │ ├── provisional.py
│ │ ├── py.typed
│ │ ├── reporting.py
│ │ ├── stateful.py
│ │ ├── statistics.py
│ │ ├── strategies/
│ │ │ ├── __init__.py
│ │ │ └── _internal/
│ │ │ ├── __init__.py
│ │ │ ├── attrs.py
│ │ │ ├── collections.py
│ │ │ ├── core.py
│ │ │ ├── datetime.py
│ │ │ ├── deferred.py
│ │ │ ├── featureflags.py
│ │ │ ├── flatmapped.py
│ │ │ ├── functions.py
│ │ │ ├── ipaddress.py
│ │ │ ├── lazy.py
│ │ │ ├── misc.py
│ │ │ ├── numbers.py
│ │ │ ├── random.py
│ │ │ ├── recursive.py
│ │ │ ├── regex.py
│ │ │ ├── shared.py
│ │ │ ├── strategies.py
│ │ │ ├── strings.py
│ │ │ ├── types.py
│ │ │ └── utils.py
│ │ ├── utils/
│ │ │ ├── __init__.py
│ │ │ ├── conventions.py
│ │ │ ├── deprecation.py
│ │ │ ├── dynamicvariables.py
│ │ │ ├── terminal.py
│ │ │ └── threading.py
│ │ ├── vendor/
│ │ │ ├── __init__.py
│ │ │ ├── pretty.py
│ │ │ └── tlds-alpha-by-domain.txt
│ │ └── version.py
│ ├── tests/
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── array_api/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── conftest.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_arrays.py
│ │ │ ├── test_from_dtype.py
│ │ │ ├── test_indices.py
│ │ │ ├── test_partial_adoptors.py
│ │ │ ├── test_pretty.py
│ │ │ ├── test_scalar_dtypes.py
│ │ │ └── test_strategies_namespace.py
│ │ ├── attrs/
│ │ │ ├── test_attrs.py
│ │ │ ├── test_inference.py
│ │ │ └── test_pretty.py
│ │ ├── codemods/
│ │ │ ├── test_codemod_cli.py
│ │ │ └── test_codemods.py
│ │ ├── common/
│ │ │ ├── __init__.py
│ │ │ ├── arguments.py
│ │ │ ├── costbounds.py
│ │ │ ├── debug.py
│ │ │ ├── setup.py
│ │ │ ├── strategies.py
│ │ │ └── utils.py
│ │ ├── conftest.py
│ │ ├── conjecture/
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── test_choice.py
│ │ │ ├── test_choice_tree.py
│ │ │ ├── test_data_tree.py
│ │ │ ├── test_engine.py
│ │ │ ├── test_float_encoding.py
│ │ │ ├── test_forced.py
│ │ │ ├── test_inquisitor.py
│ │ │ ├── test_intlist.py
│ │ │ ├── test_junkdrawer.py
│ │ │ ├── test_local_constants.py
│ │ │ ├── test_minimizer.py
│ │ │ ├── test_mutations.py
│ │ │ ├── test_optimiser.py
│ │ │ ├── test_order_shrinking.py
│ │ │ ├── test_pareto.py
│ │ │ ├── test_provider.py
│ │ │ ├── test_provider_contract.py
│ │ │ ├── test_shrinker.py
│ │ │ ├── test_shrinking_interface.py
│ │ │ ├── test_test_data.py
│ │ │ └── test_utils.py
│ │ ├── cover/
│ │ │ ├── __init__.py
│ │ │ ├── test_annotations.py
│ │ │ ├── test_arbitrary_data.py
│ │ │ ├── test_asyncio.py
│ │ │ ├── test_cache_implementation.py
│ │ │ ├── test_caching.py
│ │ │ ├── test_cathetus.py
│ │ │ ├── test_charmap.py
│ │ │ ├── test_compat.py
│ │ │ ├── test_complex_numbers.py
│ │ │ ├── test_composite.py
│ │ │ ├── test_composite_kwonlyargs.py
│ │ │ ├── test_constants_ast.py
│ │ │ ├── test_control.py
│ │ │ ├── test_core.py
│ │ │ ├── test_custom_reprs.py
│ │ │ ├── test_database_backend.py
│ │ │ ├── test_datetimes.py
│ │ │ ├── test_deadline.py
│ │ │ ├── test_debug_information.py
│ │ │ ├── test_deferred_strategies.py
│ │ │ ├── test_detection.py
│ │ │ ├── test_direct_strategies.py
│ │ │ ├── test_draw_example.py
│ │ │ ├── test_error_in_draw.py
│ │ │ ├── test_escalation.py
│ │ │ ├── test_example.py
│ │ │ ├── test_exceptiongroup.py
│ │ │ ├── test_executors.py
│ │ │ ├── test_explicit_examples.py
│ │ │ ├── test_falsifying_example_output.py
│ │ │ ├── test_feature_flags.py
│ │ │ ├── test_filestorage.py
│ │ │ ├── test_filter_rewriting.py
│ │ │ ├── test_filtered_strategy.py
│ │ │ ├── test_find.py
│ │ │ ├── test_flakiness.py
│ │ │ ├── test_float_nastiness.py
│ │ │ ├── test_float_utils.py
│ │ │ ├── test_functions.py
│ │ │ ├── test_fuzz_one_input.py
│ │ │ ├── test_given_error_conditions.py
│ │ │ ├── test_health_checks.py
│ │ │ ├── test_interactive_example.py
│ │ │ ├── test_internal_helpers.py
│ │ │ ├── test_intervalset.py
│ │ │ ├── test_lambda_formatting.py
│ │ │ ├── test_lazy_import.py
│ │ │ ├── test_lookup.py
│ │ │ ├── test_lookup_py310.py
│ │ │ ├── test_lookup_py314.py
│ │ │ ├── test_lookup_py37.py
│ │ │ ├── test_lookup_py38.py
│ │ │ ├── test_lookup_py39.py
│ │ │ ├── test_map.py
│ │ │ ├── test_mock.py
│ │ │ ├── test_monitoring.py
│ │ │ ├── test_nothing.py
│ │ │ ├── test_numerics.py
│ │ │ ├── test_observability.py
│ │ │ ├── test_one_of.py
│ │ │ ├── test_permutations.py
│ │ │ ├── test_phases.py
│ │ │ ├── test_posonly_args_py38.py
│ │ │ ├── test_pretty.py
│ │ │ ├── test_provisional_strategies.py
│ │ │ ├── test_random_module.py
│ │ │ ├── test_randoms.py
│ │ │ ├── test_recursive.py
│ │ │ ├── test_reflection.py
│ │ │ ├── test_regex.py
│ │ │ ├── test_regressions.py
│ │ │ ├── test_replay_logic.py
│ │ │ ├── test_reporting.py
│ │ │ ├── test_reproduce_failure.py
│ │ │ ├── test_runner_strategy.py
│ │ │ ├── test_sampled_from.py
│ │ │ ├── test_searchstrategy.py
│ │ │ ├── test_seed_printing.py
│ │ │ ├── test_settings.py
│ │ │ ├── test_setup_teardown.py
│ │ │ ├── test_shrink_budgeting.py
│ │ │ ├── test_sideeffect_warnings.py
│ │ │ ├── test_simple_characters.py
│ │ │ ├── test_simple_collections.py
│ │ │ ├── test_simple_strings.py
│ │ │ ├── test_slices.py
│ │ │ ├── test_slippage.py
│ │ │ ├── test_stateful.py
│ │ │ ├── test_statistical_events.py
│ │ │ ├── test_subnormal_floats.py
│ │ │ ├── test_targeting.py
│ │ │ ├── test_testdecorators.py
│ │ │ ├── test_threading.py
│ │ │ ├── test_traceback_elision.py
│ │ │ ├── test_type_lookup.py
│ │ │ ├── test_type_lookup_forward_ref.py
│ │ │ ├── test_typealias_py312.py
│ │ │ ├── test_unicode_identifiers.py
│ │ │ ├── test_unittest.py
│ │ │ ├── test_uuids.py
│ │ │ ├── test_validation.py
│ │ │ └── test_verbosity.py
│ │ ├── crosshair/
│ │ │ ├── test_conformance.py
│ │ │ └── test_crosshair.py
│ │ ├── datetime/
│ │ │ ├── __init__.py
│ │ │ ├── test_dateutil_timezones.py
│ │ │ ├── test_pytz_timezones.py
│ │ │ └── test_zoneinfo_timezones.py
│ │ ├── django/
│ │ │ ├── __init__.py
│ │ │ ├── manage.py
│ │ │ ├── toys/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── settings/
│ │ │ │ │ ├── no_urls.py
│ │ │ │ │ ├── settings.py
│ │ │ │ │ ├── settings_no_contrib.py
│ │ │ │ │ └── urls.py
│ │ │ │ └── wsgi.py
│ │ │ └── toystore/
│ │ │ ├── __init__.py
│ │ │ ├── admin.py
│ │ │ ├── forms.py
│ │ │ ├── models.py
│ │ │ ├── test_basic_configuration.py
│ │ │ ├── test_given_forms.py
│ │ │ ├── test_given_models.py
│ │ │ └── views.py
│ │ ├── dpcontracts/
│ │ │ ├── __init__.py
│ │ │ └── test_contracts.py
│ │ ├── ghostwriter/
│ │ │ ├── example_code/
│ │ │ │ ├── __init__.py
│ │ │ │ └── future_annotations.py
│ │ │ ├── recorded/
│ │ │ │ ├── add_custom_classes.txt
│ │ │ │ ├── addition_op_magic.txt
│ │ │ │ ├── addition_op_multimagic.txt
│ │ │ │ ├── base64_magic.txt
│ │ │ │ ├── division_binop_error_handler.txt
│ │ │ │ ├── division_fuzz_error_handler.txt
│ │ │ │ ├── division_operator.txt
│ │ │ │ ├── division_operator_with_annotations.txt
│ │ │ │ ├── division_roundtrip_arithmeticerror_handler.txt
│ │ │ │ ├── division_roundtrip_error_handler.txt
│ │ │ │ ├── division_roundtrip_error_handler_without_annotations.txt
│ │ │ │ ├── division_roundtrip_typeerror_handler.txt
│ │ │ │ ├── eval_equivalent.txt
│ │ │ │ ├── fuzz_classmethod.txt
│ │ │ │ ├── fuzz_sorted.txt
│ │ │ │ ├── fuzz_sorted_with_annotations.txt
│ │ │ │ ├── fuzz_staticmethod.txt
│ │ │ │ ├── fuzz_ufunc.txt
│ │ │ │ ├── fuzz_with_docstring.txt
│ │ │ │ ├── hypothesis_module_magic.txt
│ │ │ │ ├── invalid_types.txt
│ │ │ │ ├── magic_base64_roundtrip.txt
│ │ │ │ ├── magic_base64_roundtrip_with_annotations.txt
│ │ │ │ ├── magic_builtins.txt
│ │ │ │ ├── magic_class.txt
│ │ │ │ ├── magic_gufunc.txt
│ │ │ │ ├── magic_numpy.txt
│ │ │ │ ├── matmul_magic.txt
│ │ │ │ ├── merge_dicts.txt
│ │ │ │ ├── multiplication_magic.txt
│ │ │ │ ├── multiplication_operator.txt
│ │ │ │ ├── multiplication_operator_unittest.txt
│ │ │ │ ├── nothing_found.txt
│ │ │ │ ├── optional_parameter.txt
│ │ │ │ ├── optional_union_parameter.txt
│ │ │ │ ├── re_compile.txt
│ │ │ │ ├── re_compile_except.txt
│ │ │ │ ├── re_compile_unittest.txt
│ │ │ │ ├── sequence_from_collections.txt
│ │ │ │ ├── sorted_idempotent.txt
│ │ │ │ ├── sorted_self_equivalent.txt
│ │ │ │ ├── sorted_self_equivalent_with_annotations.txt
│ │ │ │ ├── sorted_self_error_equivalent_1error.txt
│ │ │ │ ├── sorted_self_error_equivalent_2error_unittest.txt
│ │ │ │ ├── sorted_self_error_equivalent_simple.txt
│ │ │ │ ├── sorted_self_error_equivalent_threefuncs.txt
│ │ │ │ ├── timsort_idempotent.txt
│ │ │ │ ├── timsort_idempotent_asserts.txt
│ │ │ │ └── union_sequence_parameter.txt
│ │ │ ├── test_expected_output.py
│ │ │ ├── test_ghostwriter.py
│ │ │ ├── test_ghostwriter_cli.py
│ │ │ └── try-writing-for-installed.py
│ │ ├── lark/
│ │ │ ├── __init__.py
│ │ │ └── test_grammar.py
│ │ ├── nocover/
│ │ │ ├── __init__.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_bad_repr.py
│ │ │ ├── test_baseexception.py
│ │ │ ├── test_boundary_exploration.py
│ │ │ ├── test_build_signature.py
│ │ │ ├── test_cache_implementation.py
│ │ │ ├── test_cacheable.py
│ │ │ ├── test_characters.py
│ │ │ ├── test_collective_minimization.py
│ │ │ ├── test_compat.py
│ │ │ ├── test_completion.py
│ │ │ ├── test_complex_numbers.py
│ │ │ ├── test_conjecture_engine.py
│ │ │ ├── test_conjecture_int_list.py
│ │ │ ├── test_conjecture_utils.py
│ │ │ ├── test_conventions.py
│ │ │ ├── test_database_agreement.py
│ │ │ ├── test_database_usage.py
│ │ │ ├── test_deferred_errors.py
│ │ │ ├── test_drypython_returns.py
│ │ │ ├── test_duplication.py
│ │ │ ├── test_dynamic_variable.py
│ │ │ ├── test_emails.py
│ │ │ ├── test_eval_as_source.py
│ │ │ ├── test_exceptiongroup.py
│ │ │ ├── test_explore_arbitrary_languages.py
│ │ │ ├── test_fancy_repr.py
│ │ │ ├── test_filtering.py
│ │ │ ├── test_find.py
│ │ │ ├── test_fixtures.py
│ │ │ ├── test_flatmap.py
│ │ │ ├── test_floating.py
│ │ │ ├── test_from_type_recipe.py
│ │ │ ├── test_given_error_conditions.py
│ │ │ ├── test_given_reuse.py
│ │ │ ├── test_health_checks.py
│ │ │ ├── test_imports.py
│ │ │ ├── test_integer_ranges.py
│ │ │ ├── test_interesting_origin.py
│ │ │ ├── test_labels.py
│ │ │ ├── test_large_examples.py
│ │ │ ├── test_limits.py
│ │ │ ├── test_modify_inner_test.py
│ │ │ ├── test_nesting.py
│ │ │ ├── test_precise_shrinking.py
│ │ │ ├── test_pretty_repr.py
│ │ │ ├── test_randomization.py
│ │ │ ├── test_recursive.py
│ │ │ ├── test_regex.py
│ │ │ ├── test_regressions.py
│ │ │ ├── test_reusable_values.py
│ │ │ ├── test_sampled_from.py
│ │ │ ├── test_scrutineer.py
│ │ │ ├── test_sets.py
│ │ │ ├── test_sharing.py
│ │ │ ├── test_simple_numbers.py
│ │ │ ├── test_simple_strings.py
│ │ │ ├── test_skipping.py
│ │ │ ├── test_stateful.py
│ │ │ ├── test_strategy_state.py
│ │ │ ├── test_subnormal_floats.py
│ │ │ ├── test_targeting.py
│ │ │ ├── test_testdecorators.py
│ │ │ ├── test_threading.py
│ │ │ ├── test_type_lookup.py
│ │ │ ├── test_type_lookup_forward_ref.py
│ │ │ ├── test_type_lookup_future_annotations.py
│ │ │ ├── test_unusual_settings_configs.py
│ │ │ └── test_uuids.py
│ │ ├── numpy/
│ │ │ ├── __init__.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_deprecation.py
│ │ │ ├── test_fill_values.py
│ │ │ ├── test_floor_ceil.py
│ │ │ ├── test_from_dtype.py
│ │ │ ├── test_from_type.py
│ │ │ ├── test_gen_data.py
│ │ │ ├── test_gufunc.py
│ │ │ ├── test_import.py
│ │ │ ├── test_narrow_floats.py
│ │ │ ├── test_randomness.py
│ │ │ └── test_sampled_from.py
│ │ ├── pandas/
│ │ │ ├── __init__.py
│ │ │ ├── helpers.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_data_frame.py
│ │ │ ├── test_indexes.py
│ │ │ └── test_series.py
│ │ ├── patching/
│ │ │ ├── __init__.py
│ │ │ ├── callables.py
│ │ │ ├── test_patching.py
│ │ │ └── toplevel.py
│ │ ├── pytest/
│ │ │ ├── test__pytest.py
│ │ │ ├── test_capture.py
│ │ │ ├── test_checks.py
│ │ │ ├── test_collection_warning.py
│ │ │ ├── test_compat.py
│ │ │ ├── test_constant_collection_timing.py
│ │ │ ├── test_doctest.py
│ │ │ ├── test_fixtures.py
│ │ │ ├── test_junit.py
│ │ │ ├── test_mark.py
│ │ │ ├── test_parametrized_db_keys.py
│ │ │ ├── test_profiles.py
│ │ │ ├── test_pytest_detection.py
│ │ │ ├── test_reporting.py
│ │ │ ├── test_runs.py
│ │ │ ├── test_seeding.py
│ │ │ ├── test_sideeffect_warnings.py
│ │ │ ├── test_skipping.py
│ │ │ └── test_statistics.py
│ │ ├── quality/
│ │ │ ├── __init__.py
│ │ │ ├── test_deferred_strategies.py
│ │ │ ├── test_discovery_ability.py
│ │ │ ├── test_float_shrinking.py
│ │ │ ├── test_integers.py
│ │ │ ├── test_poisoned_lists.py
│ │ │ ├── test_poisoned_trees.py
│ │ │ ├── test_shrink_quality.py
│ │ │ └── test_zig_zagging.py
│ │ ├── redis/
│ │ │ ├── __init__.py
│ │ │ └── test_redis_exampledatabase.py
│ │ ├── test_annotated_types.py
│ │ ├── typing_extensions/
│ │ │ ├── __init__.py
│ │ │ └── test_backported_types.py
│ │ └── watchdog/
│ │ ├── __init__.py
│ │ ├── test_database.py
│ │ └── test_database_cover.py
│ └── tox.ini
├── notebooks/
│ └── Designing a better simplifier.ipynb
├── paper.bib
├── paper.md
├── pyproject.toml
├── requirements/
│ ├── coverage.in
│ ├── coverage.txt
│ ├── crosshair.in
│ ├── crosshair.txt
│ ├── fuzzing.in
│ ├── fuzzing.txt
│ ├── test.in
│ ├── test.txt
│ ├── tools.in
│ └── tools.txt
├── tooling/
│ ├── README.md
│ ├── codespell-dict.txt
│ ├── codespell-ignore.txt
│ ├── scripts/
│ │ ├── common.sh
│ │ ├── ensure-python.sh
│ │ └── tool-hash.py
│ ├── setup.py
│ └── src/
│ └── hypothesistooling/
│ ├── __init__.py
│ ├── __main__.py
│ ├── installers.py
│ ├── junkdrawer.py
│ ├── projects/
│ │ ├── __init__.py
│ │ └── hypothesispython.py
│ ├── releasemanagement.py
│ └── scripts.py
├── website/
│ ├── archive-redirect.html
│ ├── content/
│ │ ├── 2016-04-15-economics-of-software-correctness.md
│ │ ├── 2016-04-15-getting-started-with-hypothesis.md
│ │ ├── 2016-04-16-anatomy-of-a-test.md
│ │ ├── 2016-04-16-encode-decode-invariant.md
│ │ ├── 2016-04-16-quickcheck-in-every-language.md
│ │ ├── 2016-04-16-the-purpose-of-hypothesis.md
│ │ ├── 2016-04-19-rule-based-stateful-testing.md
│ │ ├── 2016-04-29-testing-performance-optimizations.md
│ │ ├── 2016-05-02-referential-transparency.md
│ │ ├── 2016-05-11-generating-the-right-data.md
│ │ ├── 2016-05-13-what-is-property-based-testing.md
│ │ ├── 2016-05-26-exploring-voting-with-hypothesis.md
│ │ ├── 2016-05-29-testing-optimizers-with-hypothesis.md
│ │ ├── 2016-05-31-looking-for-guest-posts.md
│ │ ├── 2016-06-05-incremental-property-based-testing.md
│ │ ├── 2016-06-13-testing-configuration-parameters.md
│ │ ├── 2016-06-30-tests-as-complete-specifications.md
│ │ ├── 2016-07-04-calculating-the-mean.md
│ │ ├── 2016-07-09-hypothesis-3.4.1-release.md
│ │ ├── 2016-07-13-hypothesis-3.4.2-release.md
│ │ ├── 2016-07-23-what-is-hypothesis.md
│ │ ├── 2016-08-09-hypothesis-pytest-fixtures.md
│ │ ├── 2016-08-19-recursive-data.md
│ │ ├── 2016-08-31-how-many-tests.md
│ │ ├── 2016-09-04-hypothesis-vs-eris.md
│ │ ├── 2016-09-23-hypothesis-3.5.0-release.md
│ │ ├── 2016-10-01-pytest-integration-sponsorship.md
│ │ ├── 2016-10-17-canonical-serialization.md
│ │ ├── 2016-10-31-hypothesis-3.6.0-release.md
│ │ ├── 2016-12-05-integrated-shrinking.md
│ │ ├── 2016-12-08-compositional-shrinking.md
│ │ ├── 2016-12-10-how-hypothesis-works.md
│ │ ├── 2017-03-09-hypothesis-for-researchers.md
│ │ ├── 2017-04-05-how-not-to-die-hard-with-hypothesis.md
│ │ ├── 2017-07-16-types-and-properties.md
│ │ ├── 2017-09-14-multi-bug-discovery.md
│ │ ├── 2017-09-28-threshold-problem.md
│ │ ├── 2018-01-08-smarkets.md
│ │ ├── 2018-02-27-continuous-releases.md
│ │ ├── 2020-06-08-complex-data-strategies.md
│ │ ├── 2025-08-07-thread-safe.md
│ │ ├── 2025-11-01-claude-code-plugin.md
│ │ ├── 2025-11-16-introducing-hypofuzz.md
│ │ └── pages/
│ │ └── testimonials.md
│ ├── pelicanconf.py
│ └── theme/
│ ├── static/
│ │ ├── prism.css
│ │ ├── prism.js
│ │ └── style.css
│ └── templates/
│ ├── article-card.html
│ ├── article.html
│ ├── base.html
│ ├── category.html
│ ├── index.html
│ └── page.html
└── whole_repo_tests/
├── __init__.py
├── documentation/
│ ├── __init__.py
│ └── test_documentation.py
├── types/
│ ├── __init__.py
│ ├── revealed_types.py
│ ├── test_hypothesis.py
│ ├── test_mypy.py
│ └── test_pyright.py
└── whole_repo/
├── __init__.py
├── test_ci_config.py
├── test_deploy.py
├── test_release_files.py
├── test_release_management.py
├── test_requirements.py
├── test_rst_is_valid.py
├── test_shellcheck.py
└── test_validate_branch_check.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .claude/CLAUDE.md
================================================
# Hypothesis Development Guide
## Essential Reading
**Always read `CONTRIBUTING.rst` before starting work**, especially before writing tests or creating a PR.
## Testing
### Running Tests
Run tests using the build system:
- **Quick test run**: `./build.sh check-coverage` (curated subset with coverage verification)
- **Python version-specific**: `./build.sh check-py311` (replace with target version)
- **Fine-grained control**: `./build.sh tox py311-custom 3.11.3 -- [pytest args]`
- **Direct pytest** (after setup): `pytest hypothesis-python/tests/cover/`
### Writing Tests
**Never use `.example()` method in tests.** Instead:
- Use `@given` decorator directly for property-based tests
- Use helper functions from `tests.common.debug`:
- `minimal()` - find minimal failing example
- `find_any()` - find any example matching condition
- `assert_all_examples()` - verify all examples match predicate
- `assert_simple_property()` - verify simple properties with few examples
- `check_can_generate_examples()` - verify strategy can generate without error
## Changelog & Pull Requests
When creating a PR that changes `hypothesis-python/src/`:
1. Create `hypothesis-python/RELEASE.rst` with `RELEASE_TYPE: patch` (bugfixes) or `minor` (features)
2. See `RELEASE-sample.rst` for examples
3. **Imitate the style in `changelog.rst`** for consistency
4. Follow all changelog instructions in `CONTRIBUTING.rst`
**Note:** Test-only changes (no modifications to `src/`) do not require a RELEASE.rst file.
## Before Committing
1. Do a final edit pass on all code to ensure it is:
- **Concise** - remove unnecessary verbosity
- **Idiomatic** - follows Python and Hypothesis conventions
- **Minimally commented** - code should be self-documenting; only add comments where truly needed
2. **Run `./build.sh format; ./build.sh lint`** immediately before committing to auto-format and lint code
3. **Do not reference issues or PRs in commit messages** (e.g., avoid `Fixes #1234` or `See #5678`) - this clutters the issue timeline with unnecessary links
================================================
FILE: .claude/commands/hypothesis.md
================================================
---
description: Write property-based tests with Hypothesis
---
You are an expert developer of property-based tests, specifically using Hypothesis. Your goal is to identify and implement a small number of the most valuable Hypothesis tests that would benefit an existing codebase right now. You focus on clarity and maintainability, as your code will be reviewed by a developer. Your goal is to write precise tests, not comprehensive test suites.
Create and follow this todo list using the `Todo` tool:
1. [ ] Explore the provided code and identify valuable properties.
2. [ ] For each property, explore how its related code is used.
3. [ ] Write Hypothesis tests based on those properties.
4. [ ] Run the new Hypothesis tests, and reflect on the result.
## 1. Explore the code provided and identify valuable properties
First, explore the provided code, and identify valuable properties to test. A "valuable property" is an invariant or property about the code that is valuable to the codebase right now and that a knowledgeable developer for this codebase would have written a Hypothesis test for. The following are indicative of a valuable property:
- Would catch important bugs: Testing this property would reveal bugs that could cause serious issues.
- Documents important behavior: The property captures essential assumptions or guarantees that are important to future or current developers.
- Benefits significantly from Hypothesis: The property is concisely and powerfully expressed as a Hypothesis test, rather than a series of unit tests.
Keep the following in mind:
- Only identify properties that you strongly believe to be true and that are supported by evidence in the codebase, for example in docstrings, comments, code use patterns, type hints, etc. Do not include properties you are at all unsure about.
- Each property should provide a substantial improvement in testing power or clarity when expressed as a Hypothesis test, rather than a unit test. Properties which could have been equally well tested with a unit test are not particularly valuable.
- You may come across many possible properties. Your goal is to identify only a small number of the most valuable of those properties that would benefit the codebase right now.
If the provided code is large, focus on exploring in this order:
1. Public API functions/classes
2. Well-documented implementations of core functionality
3. Other implementations of core functionality
4. Internal/private helpers or utilities
Here are some examples of typical properties:
- Round-trip property: `decode(encode(x)) = x`, `parse(format(x)) = x`.
- Inverse relationship: `add/remove`, `push/pop`, `create/destroy`.
- Multiple equivalent implementations: Optimized vs reference implementation, complicated vs simple implementation.
- Mathematical property: Idempotence `f(f(x)) = f(x)`, commutativity `f(x, y) = f(y, x)`.
- Invariants: `len(filter(x)) <= len(x)`, `set(sort(x)) == set(x)`.
- Confluence: the order of function application doesn't matter (for example, in compiler optimization passes).
- Metamorphic property: some relationship between `f(x)` and `g(x)` holds for all x. For example, `sin(π − x) = sin(x)`.
- Single entry point. If a library has a narrow public API, a nice property-based test simply calls the library with valid inputs. Common in parsers.
While the following should generally not be tested:
- Obvious code wrappers
- Implementation details
The user has provided the following guidance for where and how to add Hypothesis tests: <user_input>$ARGUMENTS</user_input>.
- If the user has provided no direction, explore the entire codebase.
- If the user has provided a specific module, explore that module.
- If the user has provided a specific file, explore that file.
- If the user has provided a specific function, explore that function.
- If the user has given more complex guidance, follow that instead.
If you don't identify any valuable properties during exploration, that's fine; just tell the user as much, and then stop.
At the end of this step, you should tell the user the small list of the most valuable properties that you intend to test.
## 2. For each valuable property, explore how its related code is used
Before writing Hypothesis tests, explore how the codebase uses the related code of each valuable property. For example, if a property involves a function `some_function`, explore how the codebase calls `some_function`: what kinds of inputs are passed to it? in what context? etc. This helps correct any misunderstanding about the property before writing a test for it.
## 3. Write Hypothesis tests based on those properties.
For each property, write a new Hypothesis test for it, and add it to the codebase's test suite, following its existing testing conventions.
When writing Hypothesis tests, follow these guidelines:
- Each Hypothesis test should be both sound (tests only inputs the code can actually be called with) and complete (tests all inputs the code can actually be called with). Sometimes this is difficult. In those cases, prefer sound and mostly-complete tests; stopping at 90% completeness is better than over-complicating a test.
- Only place constraints on Hypothesis strategies if required by the code. For example, prefer `st.lists(...)` (with no size bound) to `st.lists(..., max_size=100)`, unless the property explicitly happens to only be valid for lists with no more than 100 elements.
## 4. Run the new Hypothesis tests, and reflect on the result.
Run the new Hypothesis tests that you just added. If any fail, reflect on why. Is the test failing because of a genuine bug, or because it's not testing the right thing? Often, when a new Hypothesis test fails, it's because the test generates inputs that the codebase assumes will never occur. If necessary, re-explore related parts of the codebase to check your understanding. You should only report that the codebase has a bug to the user if you are truly confident, and can justify why.
# Hypothesis Reference
Documentation reference (fetch with the `WebFetch` tool if required):
- **Strategies API reference**: https://hypothesis.readthedocs.io/en/latest/reference/strategies.html
- **Other API reference**: https://hypothesis.readthedocs.io/en/latest/reference/api.html
- Documents `@settings`, `@given`, etc.
These Hypothesis strategies are under-appreciated for how effective they are. Use them if they are a perfect or near-perfect fit for a property:
- `st.from_regex`
- `st.from_lark` - for context-free grammars
- `st.functions` - generates arbitrary callable functions
================================================
FILE: .gitattributes
================================================
* text eol=lf
# Denote all files that are truly binary and should not be modified.
*.png binary
*.jpg binary
*.gif binary
================================================
FILE: .github/CODEOWNERS
================================================
# Engine changes need to be approved by Zac-HD, as per
# https://github.com/HypothesisWorks/hypothesis/blob/master/guides/review.rst#engine-changes
/hypothesis-python/src/hypothesis/internal/conjecture/ @Zac-HD @Liam-DeVoe
# Changes to the paper also need to be approved by DRMacIver or Zac, as authors
/paper.md @DRMacIver @Zac-HD
/paper.bib @DRMacIver @Zac-HD
================================================
FILE: .github/CODE_OF_CONDUCT.rst
================================================
---------------
Code of conduct
---------------
Hypothesis's community is an inclusive space, and everyone in it is expected to abide by a code of conduct.
This applies in issues, pull requests, etc. as well as in the various Hypothesis community spaces.
At the high level the code of conduct goes like this:
1. Be kind
2. Be respectful
3. Be helpful
While it is impossible to enumerate everything that is unkind, disrespectful or unhelpful, here are some specific things that are definitely against the code of conduct:
1. -isms and -phobias (e.g. racism, sexism, transphobia and homophobia) are unkind, disrespectful *and* unhelpful. Just don't.
2. All software is broken. This is not a moral failing on the part of the authors. Don't give people a hard time for bad code.
3. It's OK not to know things. Everybody was a beginner once, nobody should be made to feel bad for it.
4. It's OK not to *want* to know something. If you think someone's question is fundamentally flawed, you should still ask permission before explaining what they should actually be asking.
5. Note that "I was just joking" is not a valid defence.
6. Don't suggest violence as a response to things, e.g. "People who do/think X should be Y-ed".
Even if you think it is obvious hyperbole and that it's very clear that no actual threat is meant,
it still contributes to a culture that makes people feel unsafe.
~~~~~~~~~~~~~~~~~~~~~~~~
Resolution of Violations
~~~~~~~~~~~~~~~~~~~~~~~~
David R. MacIver (the project lead) acts as the main point of contact and enforcer for code of conduct violations.
You can email him at david@drmaciver.com, or for violations on GitHub that you want to draw his attention to you can also mention him as @DRMacIver.
Other people (especially Hypothesis team members) should feel free to call people on code of conduct violations when they see them,
and it is appreciated but not required (especially if doing so would make you feel uncomfortable or unsafe).
We don't currently have a formal policy for resolutions and it's mostly based on subjective judgement calls,
but the high level intent is as follows:
* minor one-off infractions will just be met with a request not to repeat the behaviour and, where it would be useful,
for an apology.
* Major infractions and repeat offenders will be banned from the community.
If you disagree with David's judgement on any particular event, please feel free to tell him so.
Also, people who have a track record of bad behaviour outside of the Hypothesis community may be banned even
if they obey all these rules if their presence is making people uncomfortable.
================================================
FILE: .github/actions/install-base/action.yml
================================================
name: "Install"
description: "Install python, then cache"
inputs:
python-version:
description: "Python version"
required: true
python-architecture:
description: "Python architecture, if not default for platform"
task:
description: "Task name"
required: true
runs:
using: "composite"
steps:
- name: Set up Python ${{ inputs.python-version }} ${{ inputs.python-architecture }}
uses: actions/setup-python@v4
with:
python-version: ${{ inputs.python-version }}
architecture: ${{ inputs.python-architecture }}
- name: Install dotnet6 for Pyjion
if: ${{ endsWith(inputs.task, '-pyjion') }}
shell: bash
run: |
wget https://packages.microsoft.com/config/ubuntu/21.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
rm packages-microsoft-prod.deb
sudo apt-get update
sudo apt-get install -y apt-transport-https && \
sudo apt-get update && \
sudo apt-get install -y dotnet-sdk-6.0
- name: Restore cache
uses: actions/cache@v3
with:
path: |
.tox/
vendor/bundle
~/.cache
~/.local
~/appdata/local/pip/cache
~/Library/Caches/pip
~/wheelhouse
key: deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}-${{ inputs.python-version }}-${{ inputs.python-architecture }}-${{ inputs.task }}
restore-keys: |
deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}-${{ inputs.python-version }}-${{ inputs.python-architecture }}
deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}
deps-${{ runner.os }}
================================================
FILE: .github/workflows/fuzz.yml
================================================
name: Fuzzing
env:
# Tell pytest and other tools to produce coloured terminal output.
# Make sure this is also in the "passenv" section of the tox config.
PY_COLORS: 1
on:
# Run every six hours, for six hours each time
schedule:
- cron: '0 */6 * * *'
# Allow manual launching too so we can test any branch we like
workflow_dispatch:
# # Enable this and reduce the timeout below to check a PR is working
# pull_request:
# branches: [ master ]
jobs:
fuzz:
if: github.repository == 'HypothesisWorks/hypothesis' || github.event_name == 'workflow_dispatch'
# Keep all of this stuff synced with the setup in main.yml for CI
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Set up Python 3.14
uses: actions/setup-python@v4
with:
python-version: "3.14.2"
- name: Restore cache
uses: actions/cache@v3
with:
path: |
~/.cache
~/wheelhouse
~/.local
vendor/bundle
.tox/
key: deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}-${{ matrix.task }}
restore-keys: |
deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}
deps-${{ runner.os }}
# OK, on to the fuzzing-specific part.
# We're going to stick everything into a single run for now instead of
# sharding it, because we'd have to manually specify all the databases
# we want to multiplex across and that would be annoying to manage.
# TODO: revisit this later; a redis-like service would be so much nicer.
- name: Download example database
uses: dawidd6/action-download-artifact@v9
with:
name: hypothesis-example-db
path: .hypothesis/examples
if_no_artifact_found: warn
workflow_conclusion: completed
- name: Install dependencies
run: |
pip install --upgrade setuptools pip wheel
pip install -r requirements/fuzzing.txt
pip install hypothesis-python/[all]
- name: Run hypofuzz session
continue-on-error: true
# The timeout ensures that we finish all steps within the six-hour
# maximum runtime for Github Actions.
# Then run the fuzzer on everything, as for our Windows CI; avoiding
# the --no-dashboard option because that also disables .patch writing.
run: |
timeout --preserve-status 5.5h \
hypothesis fuzz -- hypothesis-python/tests/ \
--ignore=hypothesis-python/tests/quality/ \
--ignore=hypothesis-python/tests/ghostwriter/
- name: Upload patch files with covering and failing `@example()`s
uses: actions/upload-artifact@v4
if: always()
with:
name: explicit-example-patches
path: .hypothesis/patches/latest_hypofuzz_*.patch
# Upload the database so it'll be persisted between runs.
# Note that we can also pull it down to use locally via
# https://hypothesis.readthedocs.io/en/latest/database.html#hypothesis.database.GitHubArtifactDatabase
- name: Upload example database
uses: actions/upload-artifact@v4
if: always()
with:
name: hypothesis-example-db
path: .hypothesis/examples
================================================
FILE: .github/workflows/main.yml
================================================
name: Hypothesis CI
env:
# Tell pytest and other tools to produce coloured terminal output.
# Make sure this is also in the "passenv" section of the tox config.
PY_COLORS: 1
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
workflow_dispatch:
# Cancel in-progress PR builds if another commit is pushed.
# On non-PR builds, fall back to the globally-unique run_id and don't cancel.
concurrency:
group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
cancel-in-progress: true
jobs:
basic:
runs-on: ubuntu-latest
strategy:
matrix:
task:
- tox-cover
- tox-nocover
- tox-rest
- check-whole-repo-tests
- check-types-hypothesis
- lint
- check-format
fail-fast: false
env:
PYTHON_VERSION: "3.14"
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: "Install base for Python ${{ env.PYTHON_VERSION }}"
uses: ./.github/actions/install-base
with:
python-version: ${{ env.PYTHON_VERSION }}
task: ${{ matrix.task }}
- name: Install tox
if: ${{ startsWith(matrix.task, 'tox-') }}
run: |
pip install --upgrade setuptools pip wheel
pip install tox
- name: Run tests
run: |
export TASK=${{ matrix.task }}
if [[ $TASK == tox-* ]]; then
TOX_TASK="${TASK#tox-}"
cd hypothesis-python
tox -e $TOX_TASK
else
./build.sh
fi
req:
needs: [basic]
runs-on: ubuntu-latest
strategy:
matrix:
task:
- check-documentation
- check-types-api
- check-coverage
- check-conjecture-coverage
- check-py310-cover
- check-py310-nocover
- check-py310-niche
- check-pypy310-cover
# - check-py310-pyjion # see notes in tox.ini
- check-py311-cover
- check-py311-nocover
- check-py311-niche
- check-pypy311-cover
- check-py312-cover
- check-py312-nocover
- check-py312-niche
- check-py313-cover
- check-py313-nocover
- check-py313-niche
- check-py313t-cover
- check-py313t-nocover
- check-py313t-niche
- check-quality
- check-pytest9
- check-pytest84
- check-pytest74
- check-py311-pytest62
- check-django60
- check-django42
- check-py313-pandas22
- check-py312-pandas21
- check-py311-pandas20
- check-py311-pandas15
- check-py310-pandas14
- check-py310-pandas13
## FIXME: actions update means Python builds without eg _bz2, which was required
# - check-py310-pandas12
# - check-py310-pandas11
fail-fast: false
env:
PYTHON_VERSION: "3.14"
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: "Install base for Python ${{ env.PYTHON_VERSION }}"
uses: ./.github/actions/install-base
with:
python-version: ${{ env.PYTHON_VERSION }}
task: ${{ matrix.task }}
- name: Run tests
run: |
export TASK=${{ matrix.task }}
if [[ $TASK == check-crosshair-custom-* ]]; then
GROUP="${TASK#check-crosshair-custom-}"
./build.sh check-crosshair-custom -- -n auto $(cd hypothesis-python && echo tests/$GROUP | xargs -n1 echo | grep -Ev "_py312|_py314" | xargs)
else
./build.sh
fi
- name: Upload coverage data
uses: actions/upload-artifact@v4
# Invoke the magic `always` function to run on both success and failure.
if: ${{ always() && endsWith(matrix.task, '-coverage') }}
with:
name: ${{ matrix.task }}-data
include-hidden-files: true
path: |
hypothesis-python/.coverage*
!hypothesis-python/.coveragerc
hypothesis-python/branch-check*
nonreq:
needs: [basic]
runs-on: ubuntu-latest
strategy:
matrix:
task:
- check-py314-cover
- check-py314-nocover
# Blocked by a 3.14rc1 bug. see
# https://github.com/HypothesisWorks/hypothesis/pull/4490#issuecomment-3144989862.
# Can revisit in 3.14rc2.
# - check-py314-niche
- check-py314t-cover
- check-py314t-nocover
- check-py314t-niche
# - check-py315-cover
# - check-py315-nocover
# - check-py315-niche
# - check-py315t-cover
# - check-py315t-nocover
# - check-py315t-niche
- check-django52
## `-cover` is too slow under crosshair; use a custom split
- check-crosshair-custom-cover/test_[a-d]*
- check-crosshair-custom-cover/test_[e-i]*
- check-crosshair-custom-cover/test_[j-r]*
- check-crosshair-custom-cover/test_[s-z]*
- check-crosshair-custom-pytest/test_*
- check-crosshair-custom-nocover/test_[a-d]*
- check-crosshair-custom-nocover/test_[e-i]*
- check-crosshair-custom-nocover/test_[j-r]*
- check-crosshair-custom-nocover/test_[s-z]*
# - check-crosshair-niche
- check-threading
- check-py310-oldestnumpy
- check-numpy-nightly
fail-fast: false
env:
PYTHON_VERSION: "3.14"
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: "Install base for Python ${{ env.PYTHON_VERSION }}"
uses: ./.github/actions/install-base
with:
python-version: ${{ env.PYTHON_VERSION }}
task: ${{ matrix.task }}
- name: Run tests
run: |
export TASK=${{ matrix.task }}
if [[ $TASK == check-crosshair-custom-* ]]; then
GROUP="${TASK#check-crosshair-custom-}"
./build.sh check-crosshair-custom -- -n auto $(cd hypothesis-python && echo tests/$GROUP | xargs -n1 echo | grep -Ev "_py312|_py314" | xargs)
else
./build.sh
fi
cross:
needs: [basic]
strategy:
matrix:
os:
- windows-latest
- macos-latest
python-version:
- "3.11"
- "3.14"
python-architecture:
- null
- "x86"
task:
- cover
- nocover
- rest
- alt-nocover
- alt-rest
exclude:
- { os: macos-latest, python-architecture: "x86" }
- { python-version: "3.14", python-architecture: "x86" }
- { python-version: "3.11", task: nocover }
- { python-version: "3.11", task: rest }
- { python-version: "3.14", task: alt-nocover }
- { python-version: "3.14", task: alt-rest }
fail-fast: false
runs-on: ${{ matrix.os }}
env:
# Override default from tox.ini
PYTHONWARNDEFAULTENCODING: ""
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: "Install base for Python ${{ matrix.python-version }} ${{ matrix.python-architecture }}"
uses: ./.github/actions/install-base
with:
python-version: ${{ matrix.python-version }}
python-architecture: ${{ matrix.python-architecture }}
task: ${{ matrix.task }}
- name: Install tox
run: |
pip install --upgrade setuptools pip wheel
pip install tox
- name: Run tests
working-directory: ./hypothesis-python
run: |
tox -e ${{ matrix.task }}
# See https://pyodide.org/en/stable/usage/building-and-testing-packages.html
# and https://github.com/numpy/numpy/blob/9a650391651c8486d8cb8b27b0e75aed5d36033e/.github/workflows/emscripten.yml
test-pyodide:
needs: [basic]
runs-on: ubuntu-latest
env:
NODE_VERSION: 22
# Note that the versions below are updated by `update_pyodide_versions()` in our weekly cronjob.
# The versions of pyodide-build and the Pyodide runtime may differ.
PYODIDE_VERSION: 0.29.3
PYODIDE_BUILD_VERSION: 0.33.0
# pyodide 0.29.0 (latest at time of writing) doesn't yet support 3.14
PYTHON_VERSION: 3.13.2
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: "Install base for Python ${{ env.PYTHON_VERSION }}"
uses: ./.github/actions/install-base
with:
python-version: ${{ env.PYTHON_VERSION }}
task: pyodide
- name: Set up Node
uses: actions/setup-node@b39b52d1213e96004bfcb1c61a8a6fa8ab84f3e8 # v4.0.1
with:
node-version: ${{ env.NODE_VERSION }}
- name: Install pyodide-build and Pyodide cross-build environment
run: |
pip install pyodide-build==${{ env.PYODIDE_BUILD_VERSION }}
pyodide xbuildenv install ${{ env.PYODIDE_VERSION }}
- name: Set up Pyodide venv and install dependencies
run: |
pip install --upgrade setuptools pip wheel build
python -m build --wheel hypothesis-python --outdir dist/
pip download --dest=dist/ hypothesis-python/ pytest tzdata # fetch all the wheels
rm dist/packaging-*.whl # fails with `invalid metadata entry 'name'`
pyodide venv .venv-pyodide
source .venv-pyodide/bin/activate
pip install dist/*.whl
- name: Run tests
run: |
source .venv-pyodide/bin/activate
# pyodide can't run multiple processes internally, so parallelize explicitly over
# discovered test files instead (20 at a time)
TEST_FILES=$(ls hypothesis-python/tests/cover/test*.py | grep -v "_py314")
echo "test files: $TEST_FILES"
parallel --max-procs 100% --max-args 20 --keep-order --line-buffer \
python -m pytest -p no:cacheprovider <<< $TEST_FILES
check-required:
if: always()
needs: [basic, req, cross]
runs-on: ubuntu-latest
steps:
- name: Check required jobs
uses: re-actors/alls-green@release/v1
with:
jobs: ${{ toJSON(needs) }}
deploy:
if: "github.event_name == 'push' && github.repository == 'HypothesisWorks/hypothesis'"
runs-on: ubuntu-latest
needs: [check-required]
strategy:
matrix:
task:
- deploy
fail-fast: false
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
token: ${{ secrets.GH_TOKEN }}
- uses: ./.github/actions/install-base
with:
python-version: "3.14"
- name: Deploy package
env:
GH_TOKEN: ${{ secrets.GH_TOKEN }}
TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
run: |
TASK=${{ matrix.task }} ./build.sh
================================================
FILE: .github/workflows/update-deps.yml
================================================
name: Update pinned dependencies
on:
schedule:
- cron: 0 0 * * 0
workflow_dispatch:
jobs:
release:
name: Update pinned dependencies
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python 3.14
uses: actions/setup-python@v4
with:
python-version: '3.14'
- name: Update pinned dependencies
run: ./build.sh upgrade-requirements
- name: Open pull request
uses: peter-evans/create-pull-request@v7
with:
token: ${{secrets.GH_TOKEN}}
delete-branch: true
title: Update pinned dependencies
body: |
Automatically update pinned dependencies
commit-message: 'Update pinned dependencies'
committer: 'CI on behalf of the Hypothesis team <zac@zhd.dev>'
author: 'CI on behalf of the Hypothesis team <zac@zhd.dev>'
================================================
FILE: .github/workflows/website.yml
================================================
name: Build website & deploy to GitHub Pages
on:
# Runs on pushes targeting the default branch
push:
branches: ["master"]
# Allows you to run this workflow manually from the Actions tab
workflow_dispatch:
# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
permissions:
contents: read
pages: write
id-token: write
# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
concurrency:
group: "pages"
cancel-in-progress: false
jobs:
# Single deploy job since we're just deploying
deploy:
environment:
name: github-pages
url: ${{ steps.deployment.outputs.page_url }}
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Build website
run: ./build.sh website
- name: Upload artifact
uses: actions/upload-pages-artifact@v3
with:
path: 'website/output/'
- name: Deploy to GitHub Pages
id: deployment
uses: actions/deploy-pages@v4
================================================
FILE: .gitignore
================================================
# mypyc
*.so
# misc (editors, file systems, etc)
*.swo
*.swp
.idea
.vagrant
.DS_Store
.hypothesis
.vscode/
.claude/settings.local.json
# generic build components
.runtimes
/hypothesis-python/branch-check*
/pythonpython3.*
/pythonpypy3.*
.pyodide-xbuildenv
# python
*.pyc
*.pyo
venv*
.cache
.pytest_cache
.mypy_cache
docs/_build
*.egg-info
_build
.tox
.coverage
.coverage.*
.pypirc
htmlcov
build
dist
.doctrees/
.v*/
# encrypted files
secrets.tar
secrets
_site/
.sass-cache/
.docker
# =========================
# Operating System Files
# =========================
# OSX
# =========================
.AppleDouble
.LSOverride
# Thumbnails
._*
# Files that might appear on external disk
.Spotlight-V100
.Trashes
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
# Windows
# =========================
# Windows image file caches
Thumbs.db
ehthumbs.db
# Folder config file
Desktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Windows Installer files
*.cab
*.msi
*.msm
*.msp
# Windows shortcuts
*.lnk
sftp-config.json
# Vim files
*.sw*
__pycache__
.jekyll-metadata
HypothesisWorks.github.io.iml
jekyll.log
/website/output/
/t.py
================================================
FILE: .readthedocs.yml
================================================
# Read the Docs configuration file
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
# Required
version: 2
# Optionally build your docs in additional formats such as PDF and ePub
formats:
- htmlzip
- epub
# - pdf # busted by latex crash on unicode U+030A combining ring above, in text() docs
# Optionally set the version of Python and requirements required to build your docs
build:
os: ubuntu-22.04
tools:
python: "3.14"
python:
install:
- requirements: requirements/tools.txt
- path: hypothesis-python/
extra_requirements:
- all
sphinx:
configuration: hypothesis-python/docs/conf.py
================================================
FILE: AUTHORS.rst
================================================
--------------------
List of Contributors
--------------------
The primary author for most of Hypothesis is David R. MacIver (me). However the following
people have also contributed work. As well as my thanks, they also have copyright over
their individual contributions.
.. NOTE - this list is in alphabetical order by first name (or handle).
* `A. Jesse Jiryu Davis <https://github.com/ajdavis>`_
* `Aaron Meurer <https://github.com/asmeurer>`_
* `Adam Johnson <https://github.com/adamchainz>`_
* `Adam Matan <https://github.com/adamatan/adamatan>_`
* `Adam Sven Johnson <https://www.github.com/pkqk>`_
* `Afrida Tabassum <https://github.com/oxfordhalfblood>`_ (afrida@gmail.com)
* `Afonso Silva <https://github.com/ajcerejeira>`_ (ajcerejeira@gmail.com)
* `Agriya Khetarpal <https://github.com/agriyakhetarpal>`_
* `Agustín Covarrubias <https://github.com/agucova>`_ (gh@agucova.dev)
* `Akash Suresh <https://www.github.com/akash-suresh>`_ (akashsuresh36@gmail.com)
* `Alex Gaynor <https://github.com/alex>`_
* `Alex Stapleton <https://www.github.com/public>`_
* `Alex Willmer <https://github.com/moreati>`_ (alex@moreati.org.uk)
* `Andrea Pierré <https://www.github.com/kir0ul>`_
* `Andrea Reina <https://www.github.com/andreareina>`_
* `Andrew Sansom <https://www.github.com/qthequartermasterman>`_
* `Anne Archibald <https://www.github.com/td-anne>`_
* `Arjoonn Sharma <https://github.com/thesage21>`_
* `Ben Anhalt <https://github.com/benanhalt>`_
* `Ben Peterson <https://github.com/killthrush>`_ (killthrush@hotmail.com)
* `Benjamin Lee <https://github.com/Benjamin-Lee>`_ (benjamindlee@me.com)
* `Benjamin Palmer <https://github.com/benjpalmer>`_
* `Bex Dunn <https://github.com/BexDunn>`_ (bex.dunn@gmail.com)
* `Bill Tucker <https://github.com/imbilltucker>`_ (imbilltucker@gmail.com)
* `Brandon Chinn <https://github.com/brandonchinn178>`_
* `Bryant Eisenbach <https://github.com/fubuloubu>`_
* `Buck Evan, copyright Google LLC <https://github.com/bukzor>`_
* `Cameron McGill <https://www.github.com/Cameron-JM>`_
* `Carl Meyer <https://www.github.com/carljm>`_
* `Charles O'Farrell <https://www.github.com/charleso>`_
* `Charlie Tanksley <https://www.github.com/charlietanksley>`_
* `Chase Garner <https://www.github.com/chasegarner>`_ (chase@garner.red)
* `Cheuk Ting Ho <https://github.com/Cheukting>`_
* `Chris Down <https://chrisdown.name>`_
* `Chris van Dronkelaar <https://github.com/Chrisvandr>`_
* `Chris Wesseling <https://github.com/CharString>`_
* `Christopher Martin <https://www.github.com/chris-martin>`_ (ch.martin@gmail.com)
* `Claudio Jolowicz <https://github.com/cjolowicz>`_
* `Conrad Ho <https://www.github.com/conradho>`_ (conrad.alwin.ho@gmail.com)
* `Cory Benfield <https://www.github.com/Lukasa>`_
* `Cristi Cobzarenco <https://github.com/cristicbz>`_ (cristi@reinfer.io)
* `Damon Francisco <https://github.com/dtfrancisco>`_ (damontfrancisco@yahoo.com)
* `Daniel J. West <https://github.com/danieljwest>`_
* `Daniel Knell <https://github.com/danielknell>`_ (contact@danielknell.co.uk)
* `David Bonner <https://github.com/rascalking>`_ (dbonner@gmail.com)
* `David Chudzicki <https://github.com/dchudz>`_ (dchudz@gmail.com)
* `David Mascharka <https://github.com/davidmascharka>`_
* `Dawn E. Collett <https://github.com/lisushka>`_
* `Derek Gustafson <https://www.github.com/degustaf>`_
* `Dion Misic <https://www.github.com/kingdion>`_ (dion.misic@gmail.com)
* `Dmitry Dygalo <https://www.github.com/Stranger6667>`_
* `Ed Rogers <https://www.github.com/edrogers>`-
* `Eduardo Enriquez <https://www.github.com/eduzen>`_ (eduardo.a.enriquez@gmail.com)
* `El Awbery <https://www.github.com/ElAwbery>`_
* `Emmanuel Leblond <https://www.github.com/touilleMan>`_
* `Evan Tey <https://github.com/evantey14>`_
* `Felix Divo <https://www.github.com/felixdivo>`_
* `Felix Grünewald <https://www.github.com/fgruen>`_
* `Felix Sheldon <https://www.github.com/darkpaw>`_
* `Florian Bruhin <https://www.github.com/The-Compiler>`_
* `follower <https://www.github.com/follower>`_
* `Francesc Elies <https://www.github.com/FrancescElies>`_
* `Gabe Joseph <https://github.com/gjoseph92>`_
* `Gary Donovan <https://www.github.com/garyd203>`_
* `Genevieve Mendoza <https://www.github.com/genevieve-me>`_
* `George Macon <https://www.github.com/gmacon>`_
* `Glenn Lehman <https://www.github.com/glnnlhmn>`_
* `Graham Williamson <https://github.com/00willo>`_
* `Grant David Bachman <https://github.com/grantbachman>`_ (grantbachman@gmail.com)
* `Gregory Petrosyan <https://github.com/flyingmutant>`_
* `Grzegorz Zieba <https://github.com/gzaxel>`_ (g.zieba@erax.pl)
* `Grigorios Giannakopoulos <https://github.com/grigoriosgiann>`_
* `Hal Blackburn <https://github.com/h4l>`_
* `Hugo van Kemenade <https://github.com/hugovk>`_
* `Humberto Rocha <https://github.com/humrochagf>`_
* `Ilya Lebedev <https://github.com/melevir>`_ (melevir@gmail.com)
* `Israel Fruchter <https://github.com/fruch>`_
* `Ivan Tham <https://github.com/pickfire>`_
* `Iyassou Shimels <https://github.com/iyassou>`_
* `Jack Massey <https://github.com/massey101>`_
* `Jakub Nabaglo <https://github.com/nbgl>`_ (j@nab.gl)
* `James Lamb <https://github.com/jameslamb>`_
* `Jenny Rouleau <https://github.com/jennyrou>`_
* `Jens Heinrich <https://github.com/JensHeinrich>`_
* `Jens Tröger <https://github.com/jenstroeger>`_
* `Jeremy Thurgood <https://github.com/jerith>`_
* `J.J. Green <http://soliton.vm.bytemark.co.uk/pub/jjg/>`_
* `JP Viljoen <https://github.com/froztbyte>`_ (froztbyte@froztbyte.net)
* `Jochen Müller <https://github.com/jomuel>`_
* `Joseph Weston <https://github.com/jbweston>`_
* `Joey Tuong <https://github.com/tetrapus>`_
* `Jonathan Gayvallet <https://github.com/Meallia>`_ (jonathan.gayvallet@orange.com)
* `Jonty Wareing <https://www.github.com/Jonty>`_ (jonty@jonty.co.uk)
* `Joshua Boone <https://www.github.com/patchedwork>`_ (joshuaboone4190@gmail.com)
* `Joshua Munn <https://www.github.com/jams2>`_ (public@elysee-munn.family)
* `jmhsi <https://www.github.com/jmhsi>`_
* `Justus Magin <https://github.com/keewis>`_
* `jwg4 <https://www.github.com/jwg4>`_
* `Kai Chen <https://www.github.com/kx-chen>`_ (kaichen120@gmail.com)
* `Karthikeyan Singaravelan <https://www.github.com/tirkarthi>`_ (tir.karthi@gmail.com)
* `Katelyn Gigante <https://github.com/silasary>`_
* `Katrina Durance <https://github.com/kdurance>`_
* `kbara <https://www.github.com/kbara>`_
* `Keeri Tramm <keerilynn>`_
* `Kristian Glass <https://www.github.com/doismellburning>`_
* `Krzysztof Przybyła <https://github.com/kprzybyla>`_
* `Kyle Reeve <https://www.github.com/kreeve>`_ (krzw92@gmail.com)
* `Lampros Mountrakis <https://www.github.com/lmount>`_
* `Lea Provenzano <https://github.com/leaprovenzano>`_
* `Lee Begg <https://www.github.com/llnz2>`_
* `Liam DeVoe <https://github.com/tybug>`_
* `Libor Martínek <https://github.com/bibajz>`_
* `Lisa Goeller <https://www.github.com/lgoeller>`_
* `Louis Taylor <https://github.com/kragniz>`_
* `Luke Barone-Adesi <https://github.com/baluke>`_
* `Lundy Bernard <https://github.com/lundybernard>`_
* `Marco Ricci <https://github.com/the-13th-letter>`_
* `Marco Sirabella <https://www.github.com/mjsir911>`_
* `marekventur <https://www.github.com/marekventur>`_
* `Marius Gedminas <https://www.github.com/mgedmin>`_ (marius@gedmin.as)
* `Markus Unterwaditzer <https://github.com/untitaker>`_ (markus@unterwaditzer.net)
* `Mateusz Sokół <https://github.com/mtsokol>`_
* `Mathieu Paturel <https://github.com/math2001>`_ (mathieu.paturel@gmail.com)
* `Matt Bachmann <https://www.github.com/bachmann1234>`_ (bachmann.matt@gmail.com)
* `Matthew Barber <https://www.github.com/honno>`_ (quitesimplymatt@gmail.com)
* `Max Nordlund <https://www.github.com/maxnordlund>`_ (max.nordlund@gmail.com)
* `Maxim Kulkin <https://www.github.com/maximkulkin>`_ (maxim.kulkin@gmail.com)
* `Mel Seto <https://github.com/mel-seto>`_
* `Michel Alexandre Salim <https://github.com/michel-slm>`_ (michel@michel-slm.name)
* `mulkieran <https://www.github.com/mulkieran>`_
* `Munir Abdinur <https://www.github.com/mabdinur>`_
* `Nathan Goldbaum <https://www/github.com/ngoldbaum>`_
* `Nicholas Chammas <https://www.github.com/nchammas>`_
* `Nick Anyos <https://www.github.com/NickAnyos>`_
* `Nick Collins <https://github.com/nickcollins>` _
* `Nick Muoh <https://github.com/OdinTech3>`_ (nickspirit3@gmail.com)
* `Nicolas Erni <https://www.github.com/ThunderKey>`_
* `Nikita Sobolev <https://github.com/sobolevn>`_ (mail@sobolevn.me)
* `Oleg Höfling <https://github.com/hoefling>`_ (oleg.hoefling@gmail.com)
* `Paul Ganssle <https://ganssle.io>`_ (paul@ganssle.io)
* `Paul Kehrer <https://github.com/reaperhulk>`_
* `Paul Lorett Amazona <https://github.com/whatevergeek>`_
* `Paul Stiverson <https://github.com/thismatters>`_
* `Pax (R. Margret) W. <https://github.com/paxcodes>`_
* `Peadar Coyle <https://github.com/springcoil>`_ (peadarcoyle@gmail.com)
* `Petr Viktorin <https://github.com/encukou>`_
* `Phillip Schanely <https://github.com/pschanely>`_ (pschanely@gmail.com)
* `Pierre-Jean Campigotto <https://github.com/PJCampi>`_
* `Przemek Konopko <https://github.com/soutys>`_
* `Reagan Lee <https://github.com/reaganjlee>`_
* `Richard Boulton <https://www.github.com/rboulton>`_ (richard@tartarus.org)
* `Richard Scholtens <https://github.com/richardscholtens>`_ (richardscholtens2@gmail.com)
* `Robert Howlett <https://github.com/jebob>`_
* `Robert Knight <https://github.com/robertknight>`_ (robertknight@gmail.com)
* `Rodrigo Girão Serrão <https://github.com/rodrigogiraoserrao>`_ (rodrigo@mathspp.com)
* `Rónán Carrigan <https://www.github.com/rcarriga>`_ (rcarriga@tcd.ie)
* `Ruben Opdebeeck <https://github.com/ROpdebee>`_
* `Ryan Soklaski <https://www.github.com/rsokl>`_ (rsoklaski@gmail.com)
* `Ryan Turner <https://github.com/rdturnermtl>`_ (ryan.turner@uber.com)
* `Sam Bishop (TechDragon) <https://github.com/techdragon>`_ (sam@techdragon.io)
* `Sam Clamons <https://github.com/sclamons>`_ (sclamons@gmail.com)
* `Sam Hames <https://www.github.com/SamHames>`_
* `Sam Watts <https://www.github.com/sam-watts>`_
* `Sangarshanan <https://www.github.com/sangarshanan>`_ (sangarshanan1998@gmail.com)
* `Sanyam Khurana <https://github.com/CuriousLearner>`_
* `Saul Shanabrook <https://www.github.com/saulshanabrook>`_ (s.shanabrook@gmail.com)
* `Sebastiaan Zeeff <https://github.com/SebastiaanZ>`_ (sebastiaan.zeeff@ordina.nl)
* `Sharyar Memon <https://github.com/sharyar>`_ (smemon.cal@gmail.com)
* `Shaun Read <https://github.com/philastrophist>`_
* `Shlok Gandhi <https://github.com/shlok57>`_ (shlok.gandhi@gmail.com)
* `Sogata Ray <https://github.com/rayardinanda>`_ (rayardinanda@gmail.com)
* `Stuart Cook <https://www.github.com/Zalathar>`_
* `SuperStormer <https://github.com/SuperStormer>`_
* `Sushobhit <https://github.com/sushobhit27>`_ (sushobhitsolanki@gmail.com)
* `Tariq Khokhar <https://www.github.com/tkb>`_ (tariq@khokhar.net)
* `Tessa Bradbury <https://www.github.com/tessereth>`_
* `Thea Koutsoukis <https://www.github.com/theakaterina>`_
* `Thomas Ball <https://www.github.com/bomtall>`_ (bomtall1@hotmail.com)
* `Thomas Grainge <https://www.github.com/tgrainge>`_
* `Thomas Kluyver <https://www.github.com/takluyver>`_ (thomas@kluyver.me.uk)
* `Tim Martin <https://www.github.com/timmartin>`_ (tim@asymptotic.co.uk)
* `Tom McDermott <https://www.github.com/sponster-au>`_ (sponster@gmail.com)
* `Tom Milligan <https://www.github.com/tommilligan>`_ (code@tommilligan.net)
* `Tyler Gibbons <https://www.github.com/kavec>`_ (tyler.gibbons@flexport.com)
* `Tyler Nickerson <https://www.github.com/nmbrgts>`_
* `Vidya Rani <https://www.github.com/vidyarani-dg>`_ (vidyarani.d.g@gmail.com)
* `Vince Reuter <https://github.com/vreuter>`_ (vince.reuter@gmail.com)
* `Vincent Michel <https://www.github.com/vxgmichel>`_ (vxgmichel@gmail.com)
* `Viorel Pluta <https://github.com/viopl>`_ (viopluta@gmail.com)
* `Vytautas Strimaitis <https://www.github.com/vstrimaitis>`_
* `Will Hall <https://www.github.com/wrhall>`_ (wrsh07@gmail.com)
* `Will Thompson <https://www.github.com/wjt>`_ (will@willthompson.co.uk)
* `Wilfred Hughes <https://www.github.com/wilfred>`_
* `Yiyang Zhan <https://www.github.com/zhanpon>`_
* `Zac Hatfield-Dodds <https://www.github.com/Zac-HD>`_ (zac.hatfield.dodds@gmail.com)
* `Zebulun Arendsee <https://www.github.com/arendsee>`_ (zbwrnz@gmail.com)
================================================
FILE: CITATION.cff
================================================
cff-version: 1.2.0
message: |
If you use Hypothesis as part of a published research project,
please cite our paper in the Journal of Open Source Software:
Text:
MacIver et al., (2019). Hypothesis: A new approach to property-based testing.
Journal of Open Source Software, 4(43), 1891, https://doi.org/10.21105/joss.01891
BibTeX:
@article{MacIver2019Hypothesis,
journal = {Journal of Open Source Software},
doi = {10.21105/joss.01891},
issn = {2475-9066},
number = {43},
publisher = {The Open Journal},
title = {Hypothesis: A new approach to property-based testing},
url = {http://dx.doi.org/10.21105/joss.01891},
volume = {4},
author = {MacIver, David and Hatfield-Dodds, Zac and Contributors, Many},
pages = {1891},
date = {2019-11-21},
year = {2019},
month = {11},
day = {21},
}
To reference a particular version of Hypothesis as a software artifact,
you can use the version-specific DOIs we create for each release under
https://doi.org/10.5281/zenodo.1412597
preferred-citation:
title: 'Hypothesis: A new approach to property-based testing'
date-released: 2019-11-21
type: article
doi: 10.21105/joss.01891
authors:
- family-names: MacIver
given-names: David R.
orcid: https://orcid.org/0000-0002-8635-3223
affiliation: Imperial College London
- family-names: Hatfield-Dodds
given-names: Zac
orcid: https://orcid.org/0000-0002-8646-8362
affiliation: Australian National University
- name: "many other contributors"
# Citation metadata for the software itself, as required by the CFF spec
doi: 10.5281/zenodo.1412597 # Version-independent DOI for the software archive
title: 'Hypothesis: Property-Based Testing for Python'
repository-code: https://github.com/HypothesisWorks/hypothesis
license: MPL-2.0
authors:
- family-names: MacIver
given-names: David R.
orcid: https://orcid.org/0000-0002-8635-3223
affiliation: Imperial College London
- family-names: Hatfield-Dodds
given-names: Zac
orcid: https://orcid.org/0000-0002-8646-8362
affiliation: Australian National University
- name: "many other contributors"
================================================
FILE: CONTRIBUTING.rst
================================================
=============
Contributing
=============
First off: It's great that you want to contribute to Hypothesis! Thanks!
---------------------------------------
Just tell me how to make a pull request
---------------------------------------
1. Make your change and ensure it has adequate tests
2. Create ``hypothesis-python/RELEASE.rst`` with ``RELEASE_TYPE: patch``
for small bugfixes, or ``minor`` for new features. See ``RELEASE-sample.rst``
as an example.
3. Add yourself to the list in ``AUTHORS.rst`` and open a PR!
For more detail, read on; for even more, continue to the ``guides/`` directory!
------------------
Ways to Contribute
------------------
Hypothesis is a mature yet active project. This means that there are many
ways in which you can contribute.
For example, it's super useful and highly appreciated if you do any of:
* Submit bug reports
* Submit feature requests
* Write about Hypothesis
* Give a talk about Hypothesis
* Build libraries and tools on top of Hypothesis outside the main repo
* Submit PRs
If you build a Hypothesis strategy that you would like to be more widely known
please add it to the list of external strategies by preparing a PR against
the docs/strategies.rst file.
If you find an error in the documentation, please feel free to submit a PR that
fixes the error. Spot a tyop? Fix it up and send us a PR!
You can read more about how we document Hypothesis in ``guides/documentation.rst``
The process for submitting source code PRs is generally more involved
(don't worry, we'll help you through it), so do read the rest of this document.
If you're planning a larger change, the contributor guides (in the ``guides/``
directory) will make sure you're on the right track.
----------------------------------
Installing from source and testing
----------------------------------
If you want to install directly from the source code (e.g. because you want to
make changes and install the changed version) you can do this with:
.. code:: bash
pip install -r requirements/test.in
pip install -r requirements/tools.in
pip install -e hypothesis-python/
# You don't need to run the tests, but here's the command:
pytest hypothesis-python/tests/cover/
You may wish to do all of this in a
`virtualenv <https://docs.python.org/3/library/venv.html>`_. For example:
.. code:: bash
python3 -m venv .venv
source .venv/bin/activate
pip install hypothesis
Will create an isolated environment where you can install and try out
Hypothesis without affecting your system packages.
-----------------------
Copyright and Licensing
-----------------------
It's important to make sure that you own the rights to the work you are submitting.
If it is done on work time, or you have a particularly onerous contract, make sure
you've checked with your employer.
All work in Hypothesis is licensed under the terms of the
`Mozilla Public License, version 2.0 <https://mozilla.org/MPL/2.0/>`_. By
submitting a contribution you are agreeing to licence your work under those
terms.
Finally, if it is not there already, add your name (and a link to your GitHub
and email address if you want) to the list of contributors found in
AUTHORS.rst, in alphabetical order. It doesn't have to be your
"real" name (whatever that means), any sort of public identifier
is fine. In particular a GitHub account is sufficient.
-----------------------
The actual contribution
-----------------------
OK, so you want to make a contribution and have sorted out the legalese. What now?
First off: If you're planning on implementing a new feature, talk to us
first! Come `join us on the mailing list <https://hypothesis.readthedocs.io/en/latest/community.html#community>`_,
or open an issue. If it's really small feel free to open a work in progress pull request sketching
out the idea, but it's best to get feedback from the Hypothesis maintainers
before sinking a bunch of work into it.
If you're working on an existing issue, leave a comment so we can try to avoid
duplicating your work before you open a pull request.
In general work-in-progress pull requests are totally welcome if you want early feedback
or help with some of the tricky details. Don't be afraid to ask for help.
In order to get merged, a pull request will have to have a green build (naturally) and
to be approved by a Hypothesis maintainer (and, depending on what it is, possibly specifically
by DRMacIver). Most pull requests will also need to `write a changelog entry in
hypothesis-python/RELEASE.rst <guides/documentation.rst#changelog-entries>`_.
The review process is the same one that all changes to Hypothesis go through, regardless of
whether you're an established maintainer or entirely new to the project. It's very much
intended to be a collaborative one: It's not us telling you what we think is wrong with
your code, it's us working with you to produce something better together.
We have `a lengthy check list <guides/review.rst>`_ of things we look for in a review. Feel
free to have a read of it in advance and go through it yourself if you'd like to. It's not
required, but it might speed up the process.
Once your pull request has a green build and has passed review, it will be merged to
master fairly promptly. This will immediately trigger a release! Don't be scared. If that
breaks things, that's our fault not yours - the whole point of this process is to ensure
that problems get caught before we merge rather than after.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Pull request or external package?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
New strategies can be added to Hypothesis, or published as an external package
on PyPI - either is fine for most strategies. If in doubt, ask!
It's generally much easier to get things working outside, because there's
more freedom to experiment and fewer requirements in stability and API style.
We're happy to review and help with external packages as well as pull requests;
several parts of Hypothesis started life outside and were integrated later
(with permission, of course).
To help people find your package, please use the `Framework :: Hypothesis
<https://pypi.org/search/?c=Framework+%3A%3A+Hypothesis>`__ `trove classifier
<https://pypi.org/classifiers/>`__. We also recommend naming your package
in the pattern of ``hypothesis-graphql`` and ``hypothesis-protobuf`` on PyPI.
On the other hand, being inside gets you access to some deeper implementation
features (if you need them) and better long-term guarantees about maintenance.
We particularly encourage pull requests for new composable primitives that
make implementing other strategies easier, or for widely used types in the
Python standard library. Strategies for other things are also welcome;
anything with external dependencies just goes in ``hypothesis.extra``.
~~~~~~~~~
The build
~~~~~~~~~
The build is driven by a ``build.sh`` shell script, which delegates to a custom Python-based build system.
Actually running the tests is managed by `tox <https://tox.readthedocs.io/en/latest/>`_, but the build system
will call out to the relevant tox environments so you mostly don't have to know anything about that
unless you want to make changes to the test config. You also mostly don't need to know anything about the build system
except to type ``./build.sh`` followed by the name of the task you want to run.
All of it will be checked on CI so you don't *have* to run anything locally, but you might
find it useful to do so: A full CI run can take up to twenty minutes,
so running a smaller set of tests locally can be helpful.
The build system should be "fairly" portable, but is currently only known to work on Linux or macOS. It *might* work
on a BSD or on Windows with cygwin installed, but it hasn't been tried. Windows with WSL does work,
as for Linux, and since OS-specific issues are rare for Hypothesis that's pretty useful.
If you try it and find it doesn't work, please do submit patches to fix that.
Some notable commands:
``./build.sh check-coverage`` will verify 100% code coverage by running a
curated subset of the test suite.
``./build.sh check-py311`` (etc.) will run most of the test suite against a
particular python version.
``./build.sh format`` will reformat your code according to the Hypothesis coding style. You should use this before each
commit ideally, but you only really have to use it when you want your code to be ready to merge.
You can also use ``./build.sh check-format``, which will run format and some linting and will then error if you have a
git diff. Note: This will error even if you started with a git diff, so if you've got any uncommitted changes
this will necessarily report an error.
Run ``./build.sh tasks`` for a list of all supported build task names.
Note: The build requires a lot of different versions of python, so rather than have you install them yourself,
the build system will install them itself in a local directory. This means that the first time you run a task you
may have to wait a while as the build downloads and installs the right version of python for you.
~~~~~~~~~~~~~
Running Tests
~~~~~~~~~~~~~
The tasks described above will run all of the tests (e.g. ``check-py311``). But
the ``tox`` task will give finer-grained control over the test runner. At a
high level, the task takes the form:
.. code-block::
./build.sh tox py311-custom 3.11.3 [tox args] -- [pytest args]
Namely, first provide the tox environment (see ``tox.ini``), then the python
version to test with, then any ``tox`` or ``pytest`` args as needed. For
example, to run all of the tests in the file
``tests/nocover/test_conjecture_engine.py`` with python 3.12:
.. code-block::
./build.sh tox py312-custom 3.12.7 -- tests/nocover/test_conjecture_engine.py
See the ``tox`` docs and ``pytest`` docs for more information:
* https://docs.pytest.org/en/latest/how-to/usage.html
* https://tox.wiki/en/latest/config.html#cli
^^^^^^^^^^^
Test Layout
^^^^^^^^^^^
See ``hypothesis-python/tests/README.rst``
^^^^^^^^^^^^^^^^
Useful Arguments
^^^^^^^^^^^^^^^^
Some useful arguments to pytest include:
* You can pass ``-n 0`` to turn off ``pytest-xdist``'s parallel test execution.
Sometimes for running just a small number of tests its startup time is longer
than the time it saves (this will vary from system to system), so this can
be helpful if you find yourself waiting on test runners to start a lot.
* You can use ``-k`` to select a subset of tests to run. This matches on substrings
of the test names. For example ``-kfoo`` will only run tests that have "foo" as
a substring of their name. You can also use composite expressions here.
e.g. ``-k'foo and not bar'`` will run anything containing foo that doesn't
also contain bar. `More information on how to select tests to run can be found
in the pytest documentation <https://docs.pytest.org/en/latest/usage.html#specifying-tests-selecting-tests>`__.
================================================
FILE: LICENSE.txt
================================================
Copyright (c) 2013, David R. MacIver
All code in this repository except where explicitly noted otherwise is released
under the Mozilla Public License v 2.0. You can obtain a copy at https://mozilla.org/MPL/2.0/.
Some code in this repository comes from other projects. Where applicable, the
original copyright and license are noted and any modifications made are released
dual licensed with the original license.
================================================
FILE: README.md
================================================
<div align="center">
<img src="https://raw.githubusercontent.com/HypothesisWorks/hypothesis/master/brand/dragonfly-rainbow.svg" width="300">
</div>
# Hypothesis
* [Website](https://hypothesis.works/)
* [Documentation](https://hypothesis.readthedocs.io/en/latest/)
* [Source code](https://github.com/hypothesisWorks/hypothesis/)
* [Contributing](https://github.com/HypothesisWorks/hypothesis/blob/master/CONTRIBUTING.rst)
* [Community](https://hypothesis.readthedocs.io/en/latest/community.html)
Hypothesis is the property-based testing library for Python. With Hypothesis, you write tests which should pass for all inputs in whatever range you describe, and let Hypothesis randomly choose which of those inputs to check - including edge cases you might not have thought about. For example:
```python
from hypothesis import given, strategies as st
@given(st.lists(st.integers()))
def test_matches_builtin(ls):
assert sorted(ls) == my_sort(ls)
```
This randomized testing can catch bugs and edge cases that you didn't think of and wouldn't have found. In addition, when Hypothesis does find a bug, it doesn't just report any failing example — it reports the simplest possible one. This makes property-based tests a powerful tool for debugging, as well as testing.
For instance,
```python
def my_sort(ls):
return sorted(set(ls))
```
fails with the simplest possible failing example:
```
Falsifying example: test_matches_builtin(ls=[0, 0])
```
### Installation
To install Hypothesis:
```
pip install hypothesis
```
There are also [optional extras available](https://hypothesis.readthedocs.io/en/latest/extras.html).
================================================
FILE: brand/README.md
================================================
# Logos and other pretty things
Hypothesis has a beautiful logo, thanks to the generous work of Libby Berrie in [issue #1519](https://github.com/HypothesisWorks/hypothesis/issues/1519). The [CogWorks class of 2019](https://github.com/CogWorksBWSI) named the dragonfly "Scout", as a job description and after *To Kill a Mockingbird*.
General guidelines:
- Prefer vector (`.svg`) formats to raster formats (`.png`) wherever possible. However, some viewers don't handle the layers well - e.g. the left eye might be drawn in front of the head - in which case you might prefer `.png`.
- We consider the rainbow version to be canonical. The blue variant is provided for cases such as monochrome versions or printing with a limited palette.
With that in mind, you are welcome to use these logos to refer to Hypothesis - and if you're not sure whether a specific use is OK, please get in touch and ask!
For example, we often bring Hypothesis stickers to conferences but can't make it to everything. If you want to print your own Hypothesis stickers, upload `sticker.png` to [StickerMule](https://www.stickermule.com/custom-stickers) and pick one of the die-cut vinyl options - that's how we get ours!
## Colour palette in GIMP format
A [colour palette in GIMP format](hypothesis.gpl) (`.gpl`) is also provided with the intent of making it easier to produce graphics and documents which reuse the colours in the Hypothesis Dragonfly logo by Libby Berrie.
The `hypothesis.gpl` file should be copied or imported to the appropriate location on your filesystem. For example:
- `/usr/share/inkscape/palettes/` for Inkscape on Ubuntu 18.08
- Edit -> Colors -> Import... then select the `hypothesis.gpl` file in Scribus on Ubuntu 18.08
- Windows -> Dockable Dialogs -> Palettes -> Palettes Menu -> Add Palette -> Import from file... then select the `hypothesis.gpl` file in GIMP on Ubuntu 18.08
Once imported, the colour palette is then available for easy manipulation of colours within the user interface.
Inkscape:
GIMP:
================================================
FILE: brand/hypothesis.gpl
================================================
GIMP Palette
Name: Hypothesis Palette
Columns: 1
# generated by @kathyreid <kathy@kathyreid.id.au>
# from the Dragonfly logo created by @libbyberrie
# the purpose of this file is to make it easy to import colours into
# Inkscape, GIMP, Scribus etc
# Colours deliberately prefixed with `Hypothesis.xxx` to appear grouped in apps
0 0 0 Black (#000000)
255 255 255 White (#FFFFFF)
165 100 250 Hypothesis.Violet (#A564FA)
98 183 255 Hypothesis.DuckEggBlue (#62B7FF)
136 255 127 Hypothesis.AppleGreen (#88FF7F)
255 252 54 Hypothesis.WarmYellow (#FFFC36)
255 202 120 Hypothesis.Apricot (#FFCA78)
255 128 128 Hypothesis.LightCoral (#FF8080)
163 255 247 Hypothesis.Turquoise (#A3FFF7)
163 233 255 Hypothesis.SkyBlue (#A3E9FF)
128 211 231 Hypothesis.DarkSky (#80D3E7)
101 195 213 Hypothesis.MediumTeal (#65C3D5)
92 201 236 Hypothesis.OceanBlue (#5CC9EC)
39 135 178 Hypothesis.DarkTeal (#2787B2)
87 83 139 Hypothesis.OceanPurple (#57538B)
68 66 95 Hypothesis.DarkOceanPurple (#44425F)
================================================
FILE: build.sh
================================================
#!/usr/bin/env bash
# This script is here to bootstrap the Hypothesis build process into a working
# version of Python, then hand over to the actual Hypothesis build runner (which
# is written in Python instead of bash).
if [ -n "${CI:-}" ] ; then echo "::group::Build setup" ; fi
set -o xtrace
set -o errexit
set -o nounset
ROOT="$(git -C "$(dirname "$0")" rev-parse --show-toplevel)"
export HYPOTHESIS_ROOT="$ROOT"
SCRIPTS="$ROOT/tooling/scripts"
# shellcheck source=tooling/scripts/common.sh
source "$SCRIPTS/common.sh"
PYTHON_VERSION="3.14.3"
if [ -n "${GITHUB_ACTIONS-}" ] || [ -n "${CODESPACES-}" ] || [ -n "${CLAUDECODE-}" ] ; then
# We're on GitHub Actions, Codespaces, or Claude Code and already have a suitable Python
PYTHON=$(command -v python3 || command -v python)
else
# Otherwise, we install it from scratch
# NOTE: tooling keeps this version in sync with ci_version in tooling
"$SCRIPTS/ensure-python.sh" "$PYTHON_VERSION"
PYTHON=$(pythonloc "$PYTHON_VERSION")/bin/python
fi
TOOL_REQUIREMENTS="$ROOT/requirements/tools.txt"
# append PYTHON_VERSION to bust caches when we upgrade versions
TOOL_HASH=$( (cat "$TOOL_REQUIREMENTS" && echo "$PYTHON_VERSION") | "$PYTHON" "$SCRIPTS/tool-hash.py")
TOOL_VIRTUALENV="$VIRTUALENVS/build-$TOOL_HASH"
TOOL_PYTHON="$TOOL_VIRTUALENV/bin/python"
export PYTHONPATH="$ROOT/tooling/src"
if ! "$TOOL_PYTHON" -m hypothesistooling check-installed ; then
rm -rf "$TOOL_VIRTUALENV"
if [ -n "${CLAUDECODE-}" ] ; then
# Claude Code: use venv (available) and skip pip upgrades (debian-managed)
"$PYTHON" -m venv "$TOOL_VIRTUALENV"
else
"$PYTHON" -m pip install --upgrade pip
"$PYTHON" -m pip install --upgrade virtualenv
"$PYTHON" -m virtualenv "$TOOL_VIRTUALENV"
fi
"$TOOL_PYTHON" -m pip install --no-warn-script-location -r requirements/tools.txt
fi
if [ -n "${CI:-}" ] ; then echo "::endgroup::" ; fi
"$TOOL_PYTHON" -m hypothesistooling "$@"
================================================
FILE: guides/README.md
================================================
# Guides for Hypothesis Development
This is a general collection of useful documentation for people working on Hypothesis.
It is separate from the main documentation because it is not much use if you are merely *using* Hypothesis. It's purely for working on it, and aimed more at maintainers than casual contributors.
================================================
FILE: guides/api-style.rst
================================================
===============
House API Style
===============
Here are some guidelines for how to write APIs so that they "feel" like
a Hypothesis API. This is particularly focused on writing new strategies, as
that's the major place where we add APIs, but also applies more generally.
Note that it is not a guide to *code* style, only API design.
The Hypothesis style evolves over time, and earlier strategies in particular
may not be consistent with this style, and we've tried some experiments
that didn't work out, so this style guide is more normative than descriptive
and existing APIs may not match it. Where relevant, backwards compatibility is
much more important than conformance to the style.
We also encourage `third-party extensions <https://hypothesis.readthedocs.io/en/latest/strategies.html>`_
to follow this style guide, for consistent and user-friendly testing APIs,
or get in touch to discuss changing it if it doesn't fit their domain.
~~~~~~~~~~~~~~~~~~
General Guidelines
~~~~~~~~~~~~~~~~~~
* When writing extras modules, consistency with Hypothesis trumps consistency
with the library you're integrating with.
* *Absolutely no subclassing as part of the public API*
* We should not strive too hard to be pythonic, but if an API seems weird to a
normal Python user we should see if we can come up with an API we like as
much but is less weird.
* Code which adds a dependency on a third party package should be put in a
hypothesis.extra module.
* Complexity should not be pushed onto the user. An easy to use API is more
important than a simple implementation.
~~~~~~~~~~~~~~~~~~~~~~~~~
Guidelines for strategies
~~~~~~~~~~~~~~~~~~~~~~~~~
* A strategy function should be somewhere between a recipe for how to build a
value and a range of valid values.
* It should not include distribution hints. The arguments should only specify
how to produce a valid value, not statistical properties of values.
* Strategies should try to paper over non-uniformity in the underlying types
as much as possible (e.g. ``hypothesis.extra.numpy`` has a number of
workarounds for numpy's odd behaviour around object arrays).
* Strategies should usually default to allowing generation of any example they
can support. The only exceptions should be cases where certain inputs would
trigger test failures which are almost never of interest: currently just
non-UTF8 characters in ``st.text()``, and Numpy array shapes with zero
dimensions or sides of length zero. In each case opting in should be trivial.
~~~~~~~~~~~~~~~~~
Argument handling
~~~~~~~~~~~~~~~~~
We have a reasonably distinctive style when it comes to handling arguments:
* Arguments must be validated to the greatest extent possible. Hypothesis
should reject bad arguments with an InvalidArgument error, not fail with an
internal exception.
* We make extensive use of default arguments. If an argument could reasonably
have a default, it should.
* Exception to the above: strategies for collection types should *not* have a
default argument for element strategies.
* Arguments which have a default value should also be keyword-only, with the
exception of ``min_value`` and ``max_value`` (see "Argument Names" below).
* ``min_value`` and ``max_value`` should default to None for unbounded types
such as integers, and the minimal or maximal values for bounded types such
as datetimes. ``floats()`` is an explicit exception to this rule due to
special handling for infinities and not-a-number.
* Interacting arguments (e.g. arguments that must be in a particular order, or
where at most one is valid, or where one argument restricts the valid range
of the other) are fine, but when this happens the behaviour of defaults
should automatically be adjusted. e.g. if the normal default of an argument
would become invalid, the function should still do the right thing if that
default is used.
* Where the actual default used depends on other arguments, the default parameter
should be None.
* It's worth thinking about the order of arguments: the first one or two
arguments are likely to be passed positionally, so try to put values there
where this is useful and not too confusing.
* When adding arguments to strategies, think carefully about whether the user
is likely to want that value to vary often. If so, make it a strategy instead
of a value. In particular if it's likely to be common that they would want to
write ``some_strategy.flatmap(lambda x: my_new_strategy(argument=x))`` then
it should be a strategy.
* Arguments should not be "a value or a strategy for generating that value".
If you find yourself inclined to write something like that, instead make it
take a strategy. If a user wants to pass a value they can wrap it in a call
to ``just``.
* If a combination of arguments make it impossible to generate anything,
``raise InvalidArgument`` instead of ``return nothing()``. Returning the
null strategy is conceptually nice, but can lead to silently dropping parts
from composed strategies and thus unexpectedly weak tests.
~~~~~~~~~~~~~~
Function Names
~~~~~~~~~~~~~~
We don't have any real consistency here. The rough approach we follow is:
* Names are `snake_case` as is standard in Python.
* Strategies for a particular type are typically named as a plural name for
that type. Where that type has some truncated form (e.g. int, str) we use a
longer form name.
* Other strategies have no particular common naming convention.
~~~~~~~~~~~~~~
Argument Names
~~~~~~~~~~~~~~
We should try to use the same argument names and orders across different
strategies wherever possible. In particular:
* For collection types, the element strategy (or strategies) should always be
the first arguments. Where there is only one element strategy it should be
called ``elements`` (but e.g. ``dictionaries`` has element strategies named
``keys`` and ``values`` and that's fine).
* For ordered types, the first two arguments should be a lower and an upper
bound. They should be called ``min_value`` and ``max_value``.
* Collection types should have a ``min_size`` and a ``max_size`` parameter that
controls the range of their size. ``min_size`` should default to zero and
``max_size`` to ``None`` (even if internally it is bounded).
~~~~~~~~~~~~~~~
Deferred Errors
~~~~~~~~~~~~~~~
As far as is reasonable, functions should raise errors when the test is run
(typically by deferring them until you try to draw from the strategy),
not when they are called.
This mostly applies to strategy functions and some error conditions in
``@given`` itself.
Generally speaking this should be taken care of automatically by use of the
``@defines_strategy`` decorator.
We do not currently do this for the ``TypeError`` that you will get from
calling the function incorrectly (e.g. with invalid keyword arguments or
missing required arguments).
In principle we could, but it would result in much harder to read function
signatures, so we would be trading off one form of comprehensibility for
another, and so far that hasn't seemed to be worth it.
The main reasons for preferring this style are:
* Errors at test import time tend to throw people and be correspondingly hard
for them to debug.
There's an expectation that errors in your test code result in failures in
your tests, and the fact that that test code happens to be defined in a
decorator doesn't seem to change that expectation for people.
* Things like deprecation warnings etc. localize better when they happen
inside the test - test runners will often swallow them or put them in silly
places if they're at import time, but will attach any output that happens
in the test to the test itself.
* There are a lot of cases where raising an error, deprecation warning, etc.
is *only* possible in a test - e.g. if you're using the inline style with
`data <https://hypothesis.readthedocs.io/en/latest/data.html#drawing-interactively-in-tests>`_,
or if you're using
`flatmap <https://hypothesis.readthedocs.io/en/latest/data.html#chaining-strategies-together>`_
or
`@composite <https://hypothesis.readthedocs.io/en/latest/data.html#composite-strategies>`_
then the strategy won't actually get evaluated until we run the test,
so that's the only place they can happen.
It's nice to be consistent, and it's weird if sometimes strategy errors result in
definition time errors and sometimes they result in test errors.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Inferring strategies from specifications
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Functions which infer a strategy from some specification or schema are both
convenient for users, and offer a single source of truth about what inputs
are allegedly valid and actually tested for correctness.
* Such functions should be named "``from_foo()``" and the first argument should
be the thing from which a strategy is inferred - like ``st.from_type()``,
``st.from_regex()``, ``extra.lark.from_lark()``, ``extra.numpy.from_dtype()``,
etc. Any other arguments should be optional keyword-only parameters.
* There should be a smooth path to customise *parts* of an inferred strategy,
i.e. not require the user to start from scratch if they need something a
little more specific. ``from_dtype()`` does this well; ``from_type()`` supports
it by `pointing users to builds() instead <https://hypothesis.works/articles/types-and-properties/>`_.
* Where practical, ensure that the ``repr`` of the returned strategy shows
how it was constructed - only using e.g. ``@st.composite`` if required.
For example, ``repr(from_type(int)) == "integers()"``.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A catalogue of current violations
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The following are places where we currently deviate from this style. Some of
these should be considered targets for deprecation and/or improvement.
* ``hypothesis.extra.numpy`` has some arguments which can be either
strategies or values.
* ``hypothesis.extra.numpy`` assumes arrays are fixed size and doesn't have
``min_size`` and ``max_size`` arguments (but this is probably OK because of
more complicated shapes of array).
* ``hypothesis.stateful`` is a great big subclassing based train wreck.
================================================
FILE: guides/documentation.rst
================================================
=====================================
The Hypothesis Documentation Handbook
=====================================
Good documentation can make the difference between good code and useful code -
and Hypothesis is written to be used, as widely as possible.
This is a working document-in-progress with some tips for how we try to write
our docs, with a little of the what and a bigger chunk of the how.
If you have ideas about how to improve these suggestions, meta issues or pull
requests are just as welcome as for docs or code :D
----------------------------
What docs should be written?
----------------------------
All public APIs should be comprehensively described. If the docs are
confusing to new users, incorrect or out of date, or simply incomplete - we
consider all of those to be bugs; if you see them please raise an issue and
perhaps submit a pull request.
That's not much advice, but it's what we have so far.
------------
Using Sphinx
------------
We use `the Sphinx documentation system <http://sphinx-doc.org>`_ to
convert the .rst files into html with formatting and
cross-references. Without repeating the docs for Sphinx, here are some tips:
- When documenting a Python object (function, class, module, etc.), you can
use autodoc to insert and interpret the docstring.
- When referencing a function, you can insert a reference to a function as
(eg) ``:func:`hypothesis.given`\``, which will appear as
``hypothesis.given()`` with a hyperlink to the appropriate docs. You can
show only the last part (unqualified name) by adding a tilde at the start,
like ``:func:`~hypothesis.given`\ `` -> ``given()``. Finally, you can give
it alternative link text in the usual way:
``:func:`other text <hypothesis.given>`\ `` -> ``other text``.
- For the formatting and also hyperlinks, all cross-references should use the
Sphinx cross-referencing syntax rather than plain text.
-----------------
Changelog Entries
-----------------
`Hypothesis does continuous deployment <https://github.com/HypothesisWorks/hypothesis-python/issues/555>`_,
where every pull request that touches ``./src`` results in a new release.
That means every contributor gets to write their changelog!
A changelog entry should be written in a new ``RELEASE.rst`` file in
the `hypothesis-python` directory. The first line of the file specifies the component
of the version number that will be updated, according to our
`semantic versioning <https://semver.org/>`_ policy.
- ``RELEASE_TYPE: major`` is for breaking changes, and will only be used by the
core team after extensive discussion.
- ``RELEASE_TYPE: minor`` is for anything that adds to the public (ie documented)
API, changes an argument signature, or adds a new deprecation or health check.
Minor (or patch) releases **must not** cause errors in any code that runs
without errors on an earlier version of Hypothesis, using only the public API.
Silent errors *may* be converted to noisy errors, but generally we prefer
to issue a deprecation warning and use the new behaviour if possible.
This stability policy only applies to use of Hypothesis itself, not the
results of user-written tests that use Hypothesis.
- ``RELEASE_TYPE: patch`` is for changes that are not visible in the public
interface, from improving a docstring to backwards-compatible improvements
in shrinking behaviour.
This first line will be removed from the final change log entry.
The remaining lines are the actual changelog text for this release,
which should:
- concisely describe what changed and why
- use Sphinx cross-references to any functions or classes mentioned
- if closing an issue, mention it with the ``:issue:`` role to generate a link
- finish with a note of thanks from the maintainers:
"Thanks to <your name> for this bug fix / feature / contribution"
(depending on which it is). If this is your first contribution,
don't forget to add yourself to AUTHORS.rst!
================================================
FILE: guides/internals.rst
================================================
===================================
How to Work on Hypothesis Internals
===================================
This is a guide to how to work on Hypothesis internals,
with a particular focus on helping people who are new to it.
Right now it is very rudimentary and is intended primarily for people who are
looking to get started writing shrink passes as part of our `current outreach
program to get more people doing that <https://github.com/HypothesisWorks/hypothesis/issues/1093>`_,
but it will expand over time.
------------------------
Bird's Eye View Concepts
------------------------
The core engine of Hypothesis is called Conjecture.
The "fundamental idea" of Conjecture is that you can represent an arbitrary
randomized test case as the sequence of bytes read from the pseudo-random
number generator (PRNG) that produced it.
Whenever the test did something "random" it actually read the next bytes and
did what they told it to do.
But those bytes didn't *have* to come from a PRNG, and we can run the test
given any byte sequence we like. By manipulating the choice of bytes, we can achieve
more interesting effects than pure randomness would allow us to do, while
retaining the power and ease of use of random testing.
The greatest strength of this idea is that we have a single source of truth
for what an example should look like: Every byte sequence is one that *could*
have come from a PRNG, and thus is a valid thing to try for our test.
The only ways it can fail to be a valid test input are for it to be too short
or for it to not satisfy one of the test's preconditions, and both are easily
detectable.
The idea of shrinking in particular is that once we have this representation,
we can shrink arbitrary test cases based on it. We try to produce a string that
is *shortlex minimal*. What this means is that it has the shortest possible
length and among those strings of minimal length is lexicographically (i.e. the
normal order on strings - find the first byte at which they differ and use that
to decide) smallest.
Ideally we could think of the shrinker as a generic function that takes a
string satisfying some predicate and returns the shortlex minimal string that
also satisfies it.
We depart from this ideal in two ways:
* we can only *approximate* such a minimal string. Finding the actual minimum is
intractable in general.
* we are only interested in minimizing things where the predicate goes through
the Hypothesis API, which lets us track how the data is used and use that to
guide the process.
We then use a number of different transformations of the string to try and
reduce our input. These vary from principled general transformations to shameless
hacks that special case something we need to work well.
One such example of a hack is the handling of floating point numbers. There are
a couple of lexicographic shrinks that are always valid but only really make
sense for our particular encoding of floats. We check if we're working
on something that is of the right size to be a float and apply those
transformations regardless of whether it is actually meant to be a float.
Worst case scenario it's not a float and they don't work, and we've run a few
extra test cases.
--------------------------
Useful Files to Know About
--------------------------
The code associated with Conjecture lives in
`src/hypothesis/internal/conjecture <https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-python/src/hypothesis/internal/conjecture>`_.
There are a number of files in there,
but the most important ones are ``engine.py`` and ``data.py``.
``data.py`` defines the core type that is used to represent test cases,
and ``engine.py`` contains the main driver for deciding what test cases to run.
There is also ``minimizer.py``, which contains a general purpose lexicographic
minimizer. This is responsible for taking some byte string and a predicate over
byte strings and producing a string of the same length which is lexicographically
smaller. Unlike the shrinker in general, this *is* supposed to work on arbitrary
predicates and doesn't know anything about the testing API. We typically apply
this to subsets of the bytes for a test input with a predicate that knows how
to integrate those subsets into a larger test. This is the part of the code
that means we can do things like replacing an integer with a smaller one.
-------
Testing
-------
For general information about how to test Hypothesis, take a look at
the `testing guide <testing-hypothesis.rst>`_, but there are a couple
of areas that it's worth specifically highlighting for making changes
to the engine:
The first is `tests/conjecture/ <https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-python/tests/conjecture>`_,
which is a set of unit tests designed to put the engine into particular scenarios to exercise specific behaviours,
with a goal of achieving 100% coverage on it in isolation (though it currently does not quite achieve that for some specific edge cases.
We may fix and enforce this later).
The other set of tests that are worth knowing about are the quality tests,
in `tests/quality <https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-python/tests/quality>`_.
These assert specific hard to satisfy properties about the examples that Hypothesis finds -
either their existence, or something about the final shrunk result.
-----------------------
Engine Design Specifics
-----------------------
There are a couple of code patterns that are mostly peculiar to Conjecture that
you may not have encountered before and are worth being aware of.
~~~~~~~~~~~~~~~~~~~~
Search State Objects
~~~~~~~~~~~~~~~~~~~~
There are a number of cases where we find ourself with a user-provided function
(where the "user" might still be something that is entirely our code) and we
want to pass a whole bunch of different examples to it in order to achieve some
result. Currently this includes each of the main engine, the Shrinker (in
``engine.py``) and the minimizer, but there are likely to be more in future.
We typically organise such things in terms of an object that you create with
the function and possibly an initial argument that stores these on self and
has some ``run`` or similar method. They then run for a while, repeatedly
calling the function they were given.
Generally speaking they do not call the function directly, but instead wrap
calls to it. This allows them to implement a certain amount of decision caching,
e.g. avoiding trying the same shrink twice, but also gives us a place where we
can update metadata about the search process.
For objects whose goal is some form of optimisation (Shrinker, Minimizer) one
of the pieces of metadata they will typically track is a "current target". This
is typically the best example they have seen so far. By wrapping every call to
the predicate, we ensure that we never miss an example even when we're passing
through other things.
For objects whose goal is some broader form of search (currently only
``ConjectureRunner``) this also allows them to keep track of *other* examples
of interest. For example, as part of our multiple bug discovery,
``ConjectureRunner`` keeps track of the smallest example of each distinct
failure that it has seen, and updates this automatically each time the test
function is called. This means that if during shrinking we "slip" and find a
different bug than the one we started with, we will *not* shrink to that, but
it will get remembered by the runner if it was either novel or better than our
current example.
~~~~~~~~~~~
Weird Loops
~~~~~~~~~~~
The loops inside a lot of the engine look very strange and unidiomatic. For
example:
.. code-block:: python
i = 0
while i < len(self.intervals):
u, v = self.intervals[i]
if not self.incorporate_new_buffer(
self.shrink_target.buffer[:u] + self.shrink_target.buffer[v:]
):
i += 1
The more natural way to write this in Python would be:
.. code-block:: python
for u, v in self.intervals:
self.incorporate_new_buffer(
self.shrink_target.buffer[:u] + self.shrink_target.buffer[v:]
)
This is not equivalent in this case, and would exhibit the wrong behaviour.
Every time ``incorporate_new_buffer`` succeeds, it changes the shape of the
current shrink target. This consequently changes the shape of intervals, both
its particular values and its current length - on each loop iteration the loop
might stop either because ``i`` increases or because ``len(self.intervals)``
decreases.
We do not reset ``i`` to zero on success, as this would cause us to retry deleting
things that we have already tried. This *might* work, but is less likely to.
In the event that none of the earlier deletions succeed, this causes us to do
retry the entire prefix uselessly, which can result in a pass taking O(n^2) time
to do O(n) deletions.
An additional quirk is that we only increment ``i`` on failure. The reason for
this is that if we successfully deleted the current interval then the interval
in position ``i`` has been replaced with something else, which is probably the
next thing we would have tried deleting if we hadn't succeeded (or something
like it), so we don't want to advance past it.
This is specific to deletion: If we are just replacing the contents of
something then we expect it to still be in the same place, so there we increment
unconditionally.
Examples of this include ``zero_draws`` and ``minimize_individual_blocks``.
------------
The Shrinker
------------
The shrinking part of Hypothesis is organised into a single class called ``Shrinker``
that lives in ``hypothesis/internal/conjecture/shrinker.py``.
Its job is to take an initial ``ConjectureData`` object and some predicate that
it satisfies, and to try to produce a simpler ``ConjectureData`` object that
also satisfies that predicate.
The search process mostly happens in the ``shrink`` method, which tries various
shrink passes in the ``greedy_shrink`` method and then reports on the outcome.
For details, you are strongly encouraged to read the source code. It is very
well commented, and as the subject of active research often has newer techniques
than are documented here.
~~~~~~~~~~~~~
Search Passes
~~~~~~~~~~~~~
Search passes are methods on the ``Shrinker`` class. They are
designed to take the current shrink target and try a number of things that might
be sensible shrinks of it.
Typically the design of a search pass is that it should always try to run to
completion rather than exiting as soon as it's found something good, but that
it shouldn't retry things that are too like stuff it has already tried just
because something worked. So for example in the above loop, we try deleting
each interval (these roughly correspond to regions of the input that are
responsible for some particular value or small number of adjacent values).
When we succeed, we keep going and try deleting more intervals, but we don't
try to delete any intervals before the current index.
The reason for this is that retrying things from the beginning might work but
probably won't. Thus if we restarted every time we made a change we would end
up doing a lot of useless work. Additionally, they are *more* likely to work
after other shrink passes have run because frequently other changes are likely
to unlock changes in the current pass that were previously impossible. e.g.
when we reorder some examples we might make a big region deletable that
previously contained something critical to the relevant behaviour of the test
but is now just noise.
Because the shrinker runs in a big loop, if we've made progress the shrink pass
will always be run again (assuming we don't hit some limit that terminates the
shrink early, but by making the shrinker better we try to ensure that that
never happens).
This means that we will always get an opportunity to start again later if we
made progress, and if we didn't make progress we've tried everything anyway.
~~~~~~~~~~~~~~~~~~~~~~~
Expensive Shrink Passes
~~~~~~~~~~~~~~~~~~~~~~~
We have a bunch of search passes that are considered "expensive". Typically
this means "quadratic or worse complexity". When shrinking we initially don't
run these, and the first time that we get to the end of our main passes and
have failed to make the input any smaller, we then turn them on.
This allows the shrinker to switch from a good but slightly timid mode while its
input is large into a more aggressive DELETE ALL THE THINGS mode once that stops
working. By that point we've usually made our input small enough that quadratic
complexity is acceptable.
We turn these on once and then they stay on. The reason for this is to avoid a
"flip-flopping" scenario where an expensive pass unlocks one trivial change that
the cheap passes can find and then they get stuck again and have to do an extra
useless run through the passes to prove that.
~~~~~~~~~~~~~~~~~~~~~~
Adaptive Shrink Passes
~~~~~~~~~~~~~~~~~~~~~~
A useful trick that some of the shrink passes use is to try a thing and if it
doesn't work take a look at what the test function did to guess *why* it didn't
work and try to repair that.
Two example such passes are ``zero_examples`` and the various passes that try to
minimize individual blocks lexicographically.
What happens in ``zero_examples`` is that we try replacing the region corresponding
to a draw with all zero bytes. If that doesn't work, we check if that was because
of changing the size of the example (e.g. doing that with a list will make the
list much shorter) and messing up the byte stream after that point. If this
was what happened then we try again with a sequence of zeroes that corresponds
to the size of the draw call in the version we tried that didn't work.
The logic for what we do with block minimization is in ``try_shrinking_blocks``.
When it tries shrinking a block and it doesn't work, it checks if the sized
changed. If it does then it tries deleting the number of bytes that were lost
immediately after the shrunk block to see if it helps.
--------------
Playing Around
--------------
I often find that it is informative to watch the shrink process in action using
Hypothesis's verbosity settings. This can give you an idea of what the format
of your data is, and how the shrink process transforms it.
In particular, it is often useful to run a test with the flag ``-s`` to tell it
not to hide output and the environment variable ``HYPOTHESIS_VERBOSITY_LEVEL=debug``.
This will give you a very detailed log of what the testing process is running,
along with information about what passes in the shrinker rare running and how
they transform it.
---------------
Getting Started
---------------
The best way of getting started on working on the engine is to work on the
shrinker. This is because it has the most well defined problems, the best
documented code among the engine, and it's generally fun to work on.
If you have not already done so, check out `Issue #1093 <https://github.com/HypothesisWorks/hypothesis/issues/1093>`_,
which collates a number of other issues about shrink quality that are good starting
points for people.
The best place to get started thus is to take a look at those linked issues and
jump in and try things! Find one that you think sounds fun. Note that some
of them suggest not doing these as your first foray into the shrinker, as some
are harder than others.
*Please* ask questions if you have any - either the main issue for general
purpose questions or specific issues for questions about a particular problem -
if you get stuck or if anything doesn't make sense. We're trying to make this
process easier for everyone to work on, so asking us questions is actively
helpful to us and we will be very grateful to you for doing so.
================================================
FILE: guides/review.rst
================================================
===================================
The Hypothesis Code Review Handbook
===================================
This document outlines the process for reviewing changes to Hypothesis. It's
partly descriptive, partly prescriptive, and entirely prone to change in
response to circumstance and need. We're still figuring this thing out!
-----------------
What Needs Review
-----------------
All changes must be signed off by at least one person
with write access to the repo other than the author of the change.
----------------
How Review Works
----------------
Once the build is green and a reviewer has approved the change, anyone on the
maintainer team may merge the request.
More than one maintainer *may* review a change if they wish to, but it's
not required. Any maintainer may block a pull request by requesting changes.
Consensus on a review is best but not required. If some reviewers have
approved a pull request and some have requested changes, ideally you
would try to address all of the changes, but it is OK to dismiss dissenting
reviews if you feel it appropriate.
We've not tested the case of differing opinions much in practice yet, so
we may grow firmer guidelines on what to do there over time.
------------
Review Goals
------------
At a high level, the two things we're looking for in review are answers
to the following questions:
1. Is this change going to make users' lives worse?
2. Is this change going to make the maintainers' lives worse?
Code review is a collaborative process between the author and the
reviewer to try to ensure that the answer to both of those questions
is no.
Ideally of course the change should also make one or both of the users'
and our lives *better*, but it's OK for changes to be mostly neutral.
The author should be presumed to have a good reason for submitting the
change in the first place, so neutral is good enough!
--------------
Social Factors
--------------
* Always thank external contributors. Thank maintainers too, ideally!
* Remember that the `Code of Conduct <https://hypothesis.readthedocs.io/en/latest/community.html#code-of-conduct>`_
applies to pull requests and issues too. Feel free to throw your weight
around to enforce this if necessary.
* Anyone, maintainer or not, is welcome to do a code review. Only official
maintainers have the ability to actually approve and merge a pull
request, but outside review is also welcome.
------------
Requirements
------------
The rest of this document outlines specific things reviewers should
focus on in aid of this, broken up by sections according to their area
of applicability.
All of these conditions must be satisfied for merge. Where the reviewer
thinks this conflicts with the above higher level goals, they may make
an exception if both the author and another maintainer agree.
~~~~~~~~~~~~~
Orthogonality
~~~~~~~~~~~~~
For all minor or patch releases, we enforce a hard and fast rule that they
contain no more than one user-visible change. Major releases are allowed
to bundle multiple changes together, but these should be structured as
smaller pull requests into some tracking branch.
We are currently very bad at this, so reviewers should feel empowered
to be extra strict and provide a lot of push back on this.
What counts as a user visible change is somewhat up to individual
judgement, but you should err in the direction of assuming that
if it might count then it does count.
A good rule of thumb is that if the ``RELEASE.rst`` uses the words "additionally"
or needs bullet points to be clear, it is likely too large.
Ideally changes that are not user visible should also be self-contained
into their own releases, but a certain amount of leniency is permitted -
it's certainly OK to do a moderate amount of refactoring while you're
in the area, and if a pull request involves no release at all then the same
level of orthogonality is not required (but is still desirable).
~~~~~~~~~~~~~~~~~~~~~~
Clarity of Description
~~~~~~~~~~~~~~~~~~~~~~
The ``RELEASE.rst`` should contain a description of the change that
makes clear:
1. The motivation for the change
2. The likely consequences of the change
This doesn't have to be an essay. If you're following the orthogonality
requirements a paragraph or two is likely sufficient.
Any additional information that is useful to reviewers should be provided
in the pull request comment. This can include e.g. background, why the
particular approach was taken, references to internals that are unlikely
to be of interest to users.
~~~~~~~~~~~~~~~~~~~~~
Functionality Changes
~~~~~~~~~~~~~~~~~~~~~
This section applies to any changes in Hypothesis's behaviour, regardless
of their nature. A good rule of thumb is that if it touches a file in
src then it counts.
1. The code should be clear in its intent and behaviour.
2. Behaviour changes should come with appropriate tests to demonstrate
the new behaviour.
3. Hypothesis must never be *flaky*. Flakiness here is
defined as anything where a test fails and this does not indicate
a bug in Hypothesis or in the way the user wrote the code or the test.
4. The changelog (in ``RELEASE.rst``) should bump the minor or patch version
(see guides/documentation.rst for details), accurately describe the
changes, and shouldn't refer to internal-only APIs. For complicated
markup, consider building the docs and manually checking the changelog
for formatting errors that didn't result in a compilation error.
~~~~~~~~~~~
API Changes
~~~~~~~~~~~
Public API changes require the most careful scrutiny of all reviews,
because they are the ones we are stuck with for the longest: Hypothesis
follows semantic versioning, and we don't release new major versions
very often.
Public API changes must satisfy the following:
1. All public API changes must be well documented. If it's not documented,
it doesn't count as public API!
2. Changes must be backwards compatible. Where this is not possible, they
must first introduce a deprecation warning, then once the major version
is bumped the deprecation warning and the functionality may be removed.
3. If an API is deprecated, the deprecation warning must make it clear
how the user should modify their code to adapt to this change (
possibly by referring to documentation).
If the required code change could be automated, the deprecation should have either
`a codemod to fix it <https://github.com/HypothesisWorks/hypothesis/issues/2705>`__
or a tracking issue to write one (see "asking for more work" below).
4. If it is likely that we will want to make backwards incompatible changes
to an API later, to whatever extent possible these should be made immediately
when it is introduced instead.
5. APIs should give clear and helpful error messages in response to invalid inputs.
In particular error messages should always display
the value that triggered the error, and ideally be specific about the
relevant feature of it that caused this failure (e.g. the type).
6. Incorrect usage should never "fail silently" - when a user accidentally
misuses an API this should result in an explicit error.
7. Functionality should be limited to that which is easy to support in the
long-term. In particular functionality which is very tied to the
current Hypothesis internals should be avoided.
8. `DRMacIver <https://github.com/DRMacIver>`_ or
`Zac-HD <https://github.com/Zac-HD>`_ must approve the changes
though other maintainers are welcome and likely to chip in to review as
well.
9. We have a separate guide for `house API style <api-style.rst>`_ which should
be followed.
~~~~~~~~~
Bug Fixes
~~~~~~~~~
1. All bug fixes must come with a test that demonstrates the bug on master and
which is fixed in this branch. An exception *may* be made here if the submitter
can convincingly argue that testing this would be prohibitively difficult.
2. Where possible, a fix that makes it impossible for similar bugs to occur is
better.
3. Where possible, a test that will catch both this bug and a more general class
of bug that contains it is better.
~~~~~~~~~~~~~~~~
Settings Changes
~~~~~~~~~~~~~~~~
Note: This section currently only applies to the Python version.
It is tempting to use the Hypothesis settings object as a dumping ground for
anything and everything that you can think of to control Hypothesis. This
rapidly gets confusing for users and should be carefully avoided.
New settings should:
1. Be something that the user can meaningfully have an opinion on. Many of the
settings that have been added to Hypothesis are just cases where Hypothesis
is abdicating responsibility to do the right thing to the user.
2. Make sense without reference to Hypothesis internals.
3. Correspond to behaviour which can meaningfully differ between tests - either
between two different tests or between two different runs of the same test
(e.g. one use case is the profile system, where you might want to run Hypothesis
differently in CI and development). If you would never expect a test suite to
have more than one value for a setting across any of its runs, it should be
some sort of global configuration, not a setting.
When deprecating a setting for later removal, we prefer to change the default
value of the setting to a private singleton (``not_set``), and implement the
future behaviour immediately. Passing any other value triggers a deprecation
warning, but is otherwise a no-op (i.e. we still use the future behaviour).
For settings where this would be especially disruptive, we have also prefixed
that deprecation process with a process where we emit a warning, add a special
value that can be passed to opt-in to the future behaviour, and then in the
following major release we deprecate *that*, make it an no-op, and make it an
error to pass any other value.
~~~~~~~~~~~~~~
Engine Changes
~~~~~~~~~~~~~~
Engine changes are anything that change a "fundamental" of how Hypothesis
works. A good rule of thumb is that an engine change is anything that touches
a file in ``hypothesis.internal.conjecture`` (Python version).
All such changes should:
1. Be approved (or authored) by DRMacIver or Zac-HD.
2. Be approved (or authored) by someone who *isn't* DRMacIver (a major problem
with this section of the code is that there is too much that only DRMacIver
understands properly and we want to fix this).
3. If appropriate, come with a test in test_discovery_ability.py showing new
examples that were previously hard to discover.
4. If appropriate, come with a test in test_shrink_quality.py showing how they
improve the shrinker.
~~~~~~~~~~~~~~~~~~~~~~
Non-Blocking Questions
~~~~~~~~~~~~~~~~~~~~~~
These questions should *not* block merge, but may result in additional
issues or changes being opened, either by the original author or by the
reviewer.
1. Is this change well covered by the review items and is there
anything that could usefully be added to the guidelines to improve
that?
2. Were any of the review items confusing or annoying when reviewing this
change? Could they be improved?
3. Are there any more general changes suggested by this, and do they have
appropriate issues and/or pull requests associated with them?
~~~~~~~~~~~~~~~~~~~~
Asking for more work
~~~~~~~~~~~~~~~~~~~~
Reviewers should in general not request changes that expand the scope of
a pull request beyond its original intended goal. The primary design
philosophy of our work-flow is that making correct changes should be cheap,
and scope creep on pull requests works against that - If you can't touch
something without having to touch a number of related areas as well,
changing things becomes expensive again.
This of course doesn't cover things where additional work is required to
ensure the change is actually correct - for example, if you change public
functionality you certainly need to update its documentation. That isn't
scope creep, that's just the normal scope.
If a pull request suggests additional work then between the reviewer and the
author people should ensure that there are relevant tracking issues for that
work (as per question 3 in "Non-Blocking Questions" above), but there is no
obligation for either of them to actually do any of the work on those issues.
By default it is the reviewer who should open these issues, but the author
is welcome to as well.
That being said, it's legitimate to expand the scope of a pull request in
some cases. For example:
* If not doing so is likely to cause problems later. For example, because
of backwards compatibility requirements it might make sense to ask for some
additional functionality that is likely to be added later so that the arguments
to a function are in a more sensible order.
* Cases where the added functionality feels extremely incomplete in some
way without an additional change. The litmus test here should be "this will
almost never be useful because...". This is still fairly subjective, but at
least one good use case where the change is a clear improvement over the status
quo is enough to indicate that this doesn't apply.
If it's unclear, the reviewer should feel free to suggest additional work
(but if the author is someone new, please make sure that it's clear that this
is a suggestion and not a requirement!), but the author of the pull request should
feel equally free to decline the suggestion.
================================================
FILE: guides/strategies-that-shrink.rst
================================================
===================================
Designing strategies to shrink well
===================================
Reducing test cases to a minimal example is a great feature of Hypothesis,
the implementation of which depends on both the shrinking engine and the
structure of the strategy (or combination of strategies) which created the
example to reduce.
This document is organised into three parts:
1. How to tell if you need to think about shrinking (you probably don't!)
2. Designing for shrinking 'above' the Hypothesis public API
3. Implementation tricks used in our internals, for interested contributors
It is written for people implementing complex third-party strategies (such
as `hypothesis-networkx <https://pypi.org/project/hypothesis-networkx/>`__),
current or potential contributors to Hypothesis itself, and anyone interested
in how this works under the hood.
------------------------------------
Do you need to design for shrinking?
------------------------------------
You should only attempt to tune custom strategies for better shrinking
behaviour if more time would otherwise be spent reducing examples by hand
or debugging more complex examples. It *may* be worthwhile if:
- Your custom strategy will be used by many people, so that spending
the same effort tuning the strategy has much larger benefits, or
- You have personally spent time debugging failures which better example
shrinking could have avoided and think this might happen again.
If neither of these apply to you, relax! Hypothesis' test-case reduction
is among the best in the world, and our built-in strategies are carefully
designed to work well with it as discussed below.
------------------------------------
Shrinking for third-party strategies
------------------------------------
That is, strategies built out of other strategies until you get down to
Hypothesis' public API. These often but not always use ``@composite``.
Composition of shrinking
~~~~~~~~~~~~~~~~~~~~~~~~
The first and most important rule is that Hypothesis shrinks from the
'bottom up'. If any component of your strategy is replaced with a simpler
example, the end result should also become simpler. We usually try to define
"simpler" here to match a reasonable intuition about the strategy, and avoid
weird edge cases when it's combined with another strategy or predicate.
`Issue #1076 <https://github.com/HypothesisWorks/hypothesis/issues/1076>`_,
where magnitude constraints were added to the ``complex_numbers`` strategy,
makes a nice case study. We wanted to continue shrinking the real and
imaginary parts like ``builds(complex, floats(), floats())``.
In a worst-case scenario, the performance of filtering could be arbitrarily
bad, while a 'generate and scale' approach would mean that simple inputs
could lead to irrational outputs. Instead, we choose an imaginary part
between +/- max_magnitude, then calculate the resulting bounds on the real
part and draw it from a strategy that will always be valid. This ensures
that the imaginary part shrinks to zero first, as we think real-valued
complex numbers are simpler than imaginary-valued complex numbers.
Let generation be lucky
~~~~~~~~~~~~~~~~~~~~~~~
Sometimes, it's worth searching for a particularly nasty value to try.
This trick should be used sparingly, and always behind a branch that the
shrinker can decide not to take such as ``if draw(booleans()):``, but might
occasionally worth trying. Measure the results before you keep it!
`Issue #69 <https://github.com/HypothesisWorks/hypothesis/issues/69>`_ provides
a nice case study: when generating tz-aware datetimes, we would like to generate
instants that are skipped or repeated due to a daylight-savings transition more
often than by chance. Of course, there may or may not be any such moments
allowed by the bounds and tz strategy!
Eliding much of the detail, a key part is to find such a moment between two
endpoints, when we can only check whether one or more exists. The traditional
approach would be to use a binary search, but this would be relatively expensive
to shrink as we would pay the log-n cost on every attempted shrink.
Instead of choosing the midpoint, we draw a *random* point between our known
endpoints, and repeat this until we find a satisfactory moment. This allows
the shrinker to delete all the intermediate draws - and appear lucky enough
to find the moment we were looking for on the first guess!
Keep things local
~~~~~~~~~~~~~~~~~
Hypothesis' shrinking engine sees every example as a labelled tree of choices,
with possible reductions represented as operations on the tree. An attempted
shrink succeeds if the new tree can be converted into an example, and the
resulting example triggers the same bug in the test function.
The most common way we see users breaking data locality is by drawing a size,
then drawing a collection of that size. This is tempting because it's simple
and it _works_, but it's often much slower than the alternatives.
.. code:: python
# Both of these strategies can generate exactly the same kind of examples,
# but the second has better performance as well as style.
integers(0, 10).flatmap(lambda n: st.lists(..., min_size=n, max_size=n))
st.lists(..., min_size=1, max_size=10)
Another easy way to keep things local is to ensure that any ``.filter(...)``
or ``assume(...)`` calls you use are as close as possible to the relevant part
of the strategy. That way, Hypothesis can retry just the part that failed
instead of the entire strategy, which might be much slower.
For efficient shrinking, local operations on the tree should correspond with
valid (and preferably local) shrinks to the final example. For example:
.. code:: python
# This form of loop is hard to shrink, because we'd have to reduce `n` and
# delete something in the loop simultaneously. It's equivalent to the
# `.flatmap` example above. We _do_ shrink this, but much more slowly.
n = draw(integers(0, 10))
for _ in range(n):
...
draw(...)
...
# In this form, the shrinker can see a repeated structure of labels
# and delete one loop iteration without touching anything else.
# We use a variant of this trick to generate collections internally!
while draw(integers(0, x)) > threshold:
...
draw(...)
...
Similarly, it's better to draw all the attributes or inputs you need for an
object at the same time, again so they can be modified or deleted together.
The exact behaviour of the shrinking is a topic of active research and
development, so if you are interested in the details we recommend reading
the `internals guide <https://github.com/HypothesisWorks/hypothesis/blob/master/guides/internals.rst>`_
and the well-commented source code in
``hypothesis.internal.conjecture`` as well as David's ECOOP 2020 paper
`Test-Case Reduction via Test-Case Generation: Insights From the Hypothesis Reducer
<https://2020.ecoop.org/details/ecoop-2020-papers/13/Test-Case-Reduction-via-Test-Case-Generation-Insights-From-the-Hypothesis-Reducer>`__.
-------------------------------------
Shrinking in the Hypothesis internals
-------------------------------------
The last section is for current or prospective Hypothesis contributors only.
These tricks rely on implementation details that are not available to
third-party libraries or users, **and can change in any patch release**.
Occasionally they are also indispensable to get good performance in underlying
primitives, so please contact us if the public API is not enough and we may
be able to work something out.
What do internals get you?
~~~~~~~~~~~~~~~~~~~~~~~~~~
Using the low-level, internal APIs complements, rather than changing, the
principles above. The bytestream-level view has some important advantages:
Because we operate at the level of bits, the relationship between a value and
the corresponding buffer is much more obvious. If we're careful, that means
we can calculate the value we want and then write the corresponding buffer
to recreate it when the test case is shrunk or replayed.
A small step up from bits, we can also see the spans that indicate a subset
of the buffer to consider for various transformations such as transposition
or deletion.
Sometimes these features are the only way to maintain acceptable performance
in very rare or even pathological cases - consider shrinking a complex number
with a single allowed magnitude - but it's almost certain that someone will
need the core strategies to do just that.
However, using low-level APIs also comes at a cost - they are verbose and
generally more difficult to use, and can violate key invariants of the engine
if misused.
Internally, our strategies mostly use the public API or something that looks
a lot like ``@composite``, so it's fairly easy to follow along. There are
just a few tricks enabled by those low-level advantages that we wanted to
name and document, so we can recognise them discuss them and invent more...
Make your own luck
~~~~~~~~~~~~~~~~~~
This is the simplest trick that uses our ability to write choices to the
buffer. We use it for ``sampled_from(...).filter(...)``, after trying an
initial draw with the usual rejection sampling technique, and added the
``SearchStrategy.do_filtered_draw`` method so other strategies can opt-in
as we design similar tricks for their structure.
It was originally designed for stateful testing, where "lucky generation"
might be inefficient if there are many rules but only a few allowed by their
preconditions. Here's how it works for stateful testing:
1. Draw an index into the unfiltered list of rules. Return the corresponding
rule if it's allowed - we got lucky! (or someone set us up...)
2. Create a list of allowed rules, and choose one from that shortlist instead.
3. Find the index of the chosen rule *in the unfiltered list*, and write that
index to the buffer. Finally, return the chosen rule.
When the shrinker tries to delete the first two draws, the resulting buffer
will lead to the same rule being chosen at step *one* instead. We've made
our own luck!
This trick is especially useful when we want to avoid rejection sampling
(the ``.filter`` method, ``assume``) for performance reasons, but also
need to give the shrinker the same low-level representation for each instance
of a repeated choice.
Flags "shrink open"
~~~~~~~~~~~~~~~~~~~
An important insight from `Swarm Testing (PDF) <https://www.cs.utah.edu/~regehr/papers/swarm12.pdf>`__
is that randomly disabling some features can actually reduce the expected time
before finding a bug, because some bugs may be suppressed by otherwise common
features or attributes of the data.
As discussed on `issue #1401 <https://github.com/HypothesisWorks/hypothesis/issues/1401>`__,
there are a few points to keep in mind when implementing shrinkable swarm testing:
- You need swarm flags to "shrink open" so that once the shrinker has run to
completion, all flags are enabled. e.g. you could do this by generating a
set of banned flags.
- You need to use rejection sampling rather than anything more clever, or at
least look like it to the shrinker. (see e.g. *Make your own luck*, above)
Taking Unicode as an example, we'd like to use our knowledge of Unicode
categories to generate more complex examples, but shrink the generated string
without reference to categories. While we haven't actually implemented this
yet - it's pretty hairy - the simple version of the idea goes like this:
1. Generate a set of banned categories.
2. Use ``characters().filter(category_is_not_banned)``
When shrinking, we start by removing categories from the banned set, after
which characters in the string can be reduced as usual. In a serious version,
the make-your-own-luck approach would be essential to make the filter
reasonably efficient, but that's not a problem internally.
In more complicated structures, it would be nice to generate the flags on first
use rather than up front before we know if we need them. The trick there is
to write each flag to the buffer every time we check it, in such a way that if
we delete the first use the second turns into an initialisation.
Explicit example boundaries
~~~~~~~~~~~~~~~~~~~~~~~~~~~
This is almost always handled implicitly, e.g. by ``cu.many``, but *sometimes*
it can be useful to explicitly insert boundaries around draws that should be
deleted simultaneously using ``data.start_span``. This is used to group
the value and sign of floating-point numbers, for example, which we split up
in order to provide a more natural shrinking order.
Explicit example management can also be useful to delineate variably-sized
draws, such as our internal helper ``cu.biased_coin``, which makes eliminating
dead bytes much cheaper. Finally, labelling otherwise indistinguishable draws
means the shrinker can attempt to swap only the like values.
================================================
FILE: guides/testing-hypothesis.rst
================================================
==================
Testing Hypothesis
==================
Note: This guide is currently entirely specific to the Python version of
Hypothesis.
This is a guide to the process of testing Hypothesis itself, both how to
run its tests and how to write new ones.
--------------------------
General Testing Philosophy
--------------------------
The test suite for Hypothesis is unusually powerful - as you might hope! -
but the secret is actually more about attitude than technology.
The key is that we treat any bug in Hypothesis as a bug in our test suite
too - and think about the kinds of bugs that might not be caught, then write
tests that would catch them.
We also use a variety of tools to check our code automatically, including
formatting, import order, linting, and typing our API with Mypy.
All of this is checked in CI - which means that once the build is
green, humans can all focus on meaningful review rather than nitpicking
operator spacing.
Similarly, we require all code to have tests with 100% branch coverage - as
a starting point, not the final goal.
- Requiring full coverage can't guarantee that we've written all the tests
worth writing (for example, maybe we left off a useful assertion about the
result), but less than full coverage guarantees that there's some code we're
not testing at all.
- Tests beyond full coverage generally aim to demonstrate that a particular
feature works, or that some subtle failure case is not present - often
because when it was found and fixed, someone wrote a test to make sure it
couldn't come back!
The ``hypothesis-python/tests/`` directory has some notes in the README file on where various
kinds of tests can be found or added. Go there for the practical stuff, or
just ask one of the maintainers for help on a pull request!
Further reading: How `SQLite is tested <https://sqlite.org/testing.html>`_,
`how the Space Shuttle was tested <https://www.fastcompany.com/28121/they-write-right-stuff>`_,
`how to misuse code coverage <http://www.exampler.com/testing-com/writings/coverage.pdf>`_
(for inspiration, *not* implementation).
Dan Luu writes about `fuzz testing <https://danluu.com/testing/>`_ and
`broken processes <https://danluu.com/wat/>`_, among other things.
-------------
Running Tests
-------------
Tests are run via ``build.sh``. See ``CONTRIBUTING.rst`` for more details.
================================================
FILE: hypothesis-python/LICENSE.txt
================================================
Copyright (c) 2013, David R. MacIver
All code in this repository except where explicitly noted otherwise is released
under the Mozilla Public License v 2.0. You can obtain a copy at https://mozilla.org/MPL/2.0/.
Some code in this repository comes from other projects. Where applicable, the
original copyright and license are noted and any modifications made are released
dual licensed with the original license.
Mozilla Public License Version 2.0
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
(a) that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
(b) that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
(a) any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
(b) any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
(b) under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
(a) for any code that a Contributor has removed from Covered Software;
or
(b) for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
(c) under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
(a) such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
(b) You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
************************************************************************
* *
* 6. Disclaimer of Warranty *
* ------------------------- *
* *
* Covered Software is provided under this License on an "as is" *
* basis, without warranty of any kind, either expressed, implied, or *
* statutory, including, without limitation, warranties that the *
* Covered Software is free of defects, merchantable, fit for a *
* particular purpose or non-infringing. The entire risk as to the *
* quality and performance of the Covered Software is with You. *
* Should any Covered Software prove defective in any respect, You *
* (not any Contributor) assume the cost of any necessary servicing, *
* repair, or correction. This disclaimer of warranty constitutes an *
* essential part of this License. No use of any Covered Software is *
* authorized under this License except under this disclaimer. *
* *
************************************************************************
************************************************************************
* *
* 7. Limitation of Liability *
* -------------------------- *
* *
* Under no circumstances and under no legal theory, whether tort *
* (including negligence), contract, or otherwise, shall any *
* Contributor, or anyone who distributes Covered Software as *
* permitted above, be liable to You for any direct, indirect, *
* special, incidental, or consequential damages of any character *
* including, without limitation, damages for lost profits, loss of *
* goodwill, work stoppage, computer failure or malfunction, or any *
* and all other commercial damages or losses, even if such party *
* shall have been informed of the possibility of such damages. This *
* limitation of liability shall not apply to liability for death or *
* personal injury resulting from such party's negligence to the *
* extent applicable law prohibits such limitation. Some *
* jurisdictions do not allow the exclusion or limitation of *
* incidental or consequential damages, so this exclusion and *
* limitation may not apply to You. *
* *
************************************************************************
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at https://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to look
for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
This Source Code Form is "Incompatible With Secondary Licenses", as
defined by the Mozilla Public License, v. 2.0.
================================================
FILE: hypothesis-python/README.md
================================================
The Hypothesis python readme has moved to [the main readme](../README.md)!
================================================
FILE: hypothesis-python/RELEASE-sample.rst
================================================
RELEASE_TYPE: patch
This patch improves import-detection in :doc:`the Ghostwriter <ghostwriter>`
(:issue:`3884`), particularly for :func:`~hypothesis.strategies.from_type`
and strategies from ``hypothesis.extra.*``.
Thanks to <contributor's name or handle> for this <contribution/fix/feature>!
---
In the example above, "patch" on the first line should be replaced by
"minor" if changes are visible in the public API, or "major" if there are
breaking changes. Note that only maintainers should ever make a major
release.
The remaining lines are the actual changelog text for this release,
which should:
- concisely describe what changed _in the public API_, and why.
Internal-only changes can be documented as e.g. "This release improves
an internal invariant." (the complete changelog for version 6.99.11)
- use ``double backticks`` for verbatim code,
- use Sphinx cross-references to any functions or classes mentioned:
- :pypi:`package` for links to external packages.
- :func:`package.function` for link to functions, where the link text will
be ``package.function``, or :func:`~package.function` to show ``function``.
- :class:`package.class` for link to classes (abbreviated as above).
- :issue:`issue-number` for referencing issues.
- Similarly, :pull:`pr-number` can be used for PRs, but it's usually
preferred to refer to version numbers with :v:`6.98.9`,
as they are meaningful to end users.
- :doc:`link text <chapter#anchor>` for documentation references.
- `link text <https://hypothesis.readthedocs.io/en/latest/chapter.html#anchor>`__
is the same link, for general web addresses.
- finish with a note of thanks from the maintainers. If this is your first
contribution, don't forget to add yourself to AUTHORS.rst!
After the PR is merged, the contents of this file (except the first line)
are automatically added to ``docs/changelog.rst``. More examples can be found
in that file.
================================================
FILE: hypothesis-python/benchmark/README.md
================================================
This directory contains plotting code for our shrinker benchmarking. The code for collecting the data is in `conftest.py`. This directory handles plotting the results.
The plotting script (but not collecting benchmark data) requires additional dependencies: `pip install scipy vl-convert-python`.
To run a benchmark:
- `pytest tests/ -n auto --hypothesis-benchmark-shrinks new --hypothesis-benchmark-output data.json` (starting on the newer version)
- `pytest tests/ -n auto --hypothesis-benchmark-shrinks old --hypothesis-benchmark-output data.json` (after switching to the old version)
- Use the same `data.json` path, the benchmark will append data. You can append `-k ...` for both commands to subset the benchmark.
- `python benchmark/graph.py data.json shrinking.png`
This hooks any `minimal()` calls any reports the number of shrinks. Default (and currently unchangeable) number of iterations is 5 per test.
================================================
FILE: hypothesis-python/benchmark/graph.py
================================================
# This file is part of Hypothesis, which may be found at
# https://github.com/HypothesisWorks/hypothesis/
#
# Copyright the Hypothesis Authors.
# Individual contributors are listed in AUTHORS.rst and the git log.
#
# This Source Code Form is subject to the terms of the Mozilla Public License,
# v. 2.0. If a copy of the MPL was not distributed with this file, You can
# obtain one at https://mozilla.org/MPL/2.0/.
import json
import math
import statistics
from pathlib import Path
import click
def plot_vega(vega_spec, data, *, to, parameters=None):
import vl_convert
parameters = parameters or {}
spec = json.loads(vega_spec.read_text())
spec["data"].insert(0, {"name": "source", "values": data})
if "signals" not in spec:
spec["signals"] = []
for key, value in parameters.items():
spec["signals"].append({"name": key, "value": value})
with open(to, "wb") as f:
# default ppi is 72, which is somewhat blurry.
f.write(vl_convert.vega_to_png(spec, ppi=200))
def _mean_difference_ci(n1, n2, *, confidence):
from scipy import stats
var1 = statistics.variance(n1)
var2 = statistics.variance(n2)
df = len(n1) + len(n2) - 2
# this assumes equal variances between the populations of n1 and n2. This
# is not necessarily true (new might be more consistent than old), but it's
# good enough.
pooled_std = math.sqrt(((len(n1) - 1) * var1 + (len(n2) - 1) * var2) / df)
se = pooled_std * math.sqrt(1 / len(n1) + 1 / len(n2))
t_crit = stats.t.ppf((1 + confidence) / 2, df)
return t_crit * se
def _process_benchmark_data(data):
assert set(data) == {"old", "new"}
old_calls = data["old"]["calls"]
new_calls = data["new"]["calls"]
assert set(old_calls) == set(new_calls), set(old_calls).symmetric_difference(
set(new_calls)
)
graph_data = []
def _diff_times(old, new):
if old == 0 and new == 0:
return 0
if old == 0:
# there aren't any great options here, but 0 is more reasonable than inf.
return 0
v = (old - new) / old
if 0 < v < 1:
v = (1 / (1 - v)) - 1
return v
sums = {"old": 0, "new": 0}
for node_id in old_calls:
old = old_calls[node_id]
new = new_calls[node_id]
if (
set(old) | set(new) == {0}
or len(old) != len(new)
or len(old) == len(new) == 0
):
print(f"skipping {node_id}")
continue
sums["old"] += statistics.mean(old)
sums["new"] += statistics.mean(new)
diffs = [n_old - n_new for n_old, n_new in zip(old, new, strict=True)]
diffs_times = [
_diff_times(n_old, n_new) for n_old, n_new in zip(old, new, strict=True)
]
ci_shrink = (
_mean_difference_ci(old, new, confidence=0.95) if len(old) > 1 else 0
)
graph_data.append(
{
"node_id": node_id,
"absolute": statistics.mean(diffs),
"absolute_ci_lower": ci_shrink,
"absolute_ci_upper": ci_shrink,
"nx": statistics.mean(diffs_times),
"nx_ci_lower": 0,
"nx_ci_upper": 0,
}
)
graph_data = sorted(graph_data, key=lambda d: d["absolute"])
return graph_data, sums
@click.command()
@click.argument("data", type=click.Path(exists=True, path_type=Path))
@click.argument("out", type=click.Path(path_type=Path))
def plot(data, out):
data = json.loads(data.read_text())
data, sums = _process_benchmark_data(data)
plot_vega(
Path(__file__).parent / "spec.json",
data=data,
to=out,
parameters={
"title": "Shrinking benchmark (calls)",
"sum_old": sums["old"],
"sum_new": sums["new"],
"absolute_axis_title": ("shrink call change (old - new, larger is good)"),
},
)
if __name__ == "__main__":
plot()
================================================
FILE: hypothesis-python/benchmark/spec.json
================================================
{
"$schema": "https://vega.github.io/schema/vega/v5.json",
"width": 1600,
"height": 800,
"padding": 5,
"background": "#ffffff",
"title": {
"text": {"signal": "title"},
"fontSize": 18
},
"data": [
{
"name": "example",
"values": [
{"node_id": "test_node_1", "absolute": 100, "absolute_ci_lower": 10, "absolute_ci_upper": 15, "nx": 0.5, "nx_ci_lower": 0.05, "nx_ci_upper": 0.07},
{"node_id": "test_node_2", "absolute": -50, "absolute_ci_lower": 5, "absolute_ci_upper": 8, "nx": -0.2, "nx_ci_lower": 0.02, "nx_ci_upper": 0.03},
{"node_id": "test_node_3", "absolute": 150, "absolute_ci_lower": 15, "absolute_ci_upper": 20, "nx": 0.6, "nx_ci_lower": 0.04, "nx_ci_upper": 0.09},
{"node_id": "test_node_4", "absolute": -120, "absolute_ci_lower": 10, "absolute_ci_upper": 12, "nx": -0.4, "nx_ci_lower": 0.03, "nx_ci_upper": 0.05},
{"node_id": "test_node_5", "absolute": 80, "absolute_ci_lower": 8, "absolute_ci_upper": 10, "nx": 0.3, "nx_ci_lower": 0.02, "nx_ci_upper": 0.04}
]
},
{
"name": "shrink_stats",
"source": "source",
"transform": [
{
"type": "aggregate",
"fields": ["absolute", "absolute", "nx", "nx"],
"ops": ["mean", "sum", "mean", "sum"],
"as": ["mean_shrink", "sum_shrink", "mean_nx", "sum_nx"]
}
]
},
{
"name": "shrink_domain",
"source": "source",
"transform": [
{
"type": "aggregate",
"fields": ["absolute", "absolute", "absolute_ci_lower", "absolute_ci_upper"],
"ops": ["min", "max", "min", "max"],
"as": ["min_value", "max_value", "min_ci", "max_ci"]
},
{
"type": "formula",
"expr": "datum.min_value - datum.min_ci",
"as": "domain_min"
},
{
"type": "formula",
"expr": "datum.max_value + datum.max_ci",
"as": "domain_max"
}
]
},
{
"name": "nx_domain",
"source": "source",
"transform": [
{
"type": "aggregate",
"fields": ["nx", "nx", "nx_ci_lower", "nx_ci_upper"],
"ops": ["min", "max", "min", "max"],
"as": ["min_value", "max_value", "min_ci", "max_ci"]
},
{
"type": "formula",
"expr": "datum.min_value - datum.min_ci",
"as": "domain_min"
},
{
"type": "formula",
"expr": "datum.max_value + datum.max_ci",
"as": "domain_max"
}
]
}
],
"scales": [
{
"name": "x",
"type": "band",
"domain": {"data": "source", "field": "node_id"},
"range": "width",
"padding": 0.2
},
{
"name": "y",
"type": "linear",
"domain": {"data": "shrink_domain", "fields": ["domain_min", "domain_max"]},
"range": "height",
"nice": true,
"zero": true
},
{
"name": "y2",
"type": "linear",
"domain": {"data": "nx_domain", "fields": ["domain_min", "domain_max"]},
"range": "height",
"nice": true,
"zero": true
},
{
"name": "color",
"type": "ordinal",
"domain": ["shrink call change", "n× change"],
"range": ["#4285F4", "#DB4437"]
}
],
"axes": [
{
"orient": "bottom",
"scale": "x",
"labelAngle": -90,
"labelAlign": "right",
"labelBaseline": "middle",
"labelLimit": 300
},
{
"orient": "left",
"scale": "y",
"title": {"signal": "absolute_axis_title"},
"titleColor": "#4285F4",
"tickColor": "#4285F4",
"labelColor": "#4285F4",
"grid": true,
"gridColor": "#e0e0e0",
"gridOpacity": 0.5,
"titleFontSize": 15,
"tickCount": 25
},
{
"orient": "right",
"scale": "y2",
"title": "n× change",
"titleColor": "#DB4437",
"tickColor": "#DB4437",
"labelColor": "#DB4437",
"titleFontSize": 15,
"tickCount": 25
}
],
"marks": [
{
"type": "rule",
"encode": {
"enter": {
"y": {"scale": "y", "value": 0},
"x": {"value": 0},
"x2": {"field": {"group": "width"}},
"stroke": {"value": "#4285F4"},
"strokeWidth": {"value": 1},
"strokeOpacity": {"value": 0.7}
}
}
},
{
"type": "rule",
"encode": {
"enter": {
"y": {"scale": "y2", "value": 0},
"x": {"value": 0},
"x2": {"field": {"group": "width"}},
"stroke": {"value": "#DB4437"},
"strokeWidth": {"value": 1},
"strokeOpacity": {"value": 0.7}
}
}
},
{
"type": "rule",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5},
"y": {"scale": "y", "field": "absolute", "offset": {"signal": "-datum.absolute_ci_lower * height / (domain('y')[1] - domain('y')[0])"}},
"y2": {"scale": "y", "field": "absolute", "offset": {"signal": "datum.absolute_ci_upper * height / (domain('y')[1] - domain('y')[0])"}},
"stroke": {"value": "#4285F4"},
"strokeOpacity": {"value": 0.5}
}
}
},
{
"type": "rect",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5, "offset": -5},
"width": {"value": 10},
"y": {"scale": "y", "field": "absolute", "offset": {"signal": "-datum.absolute_ci_lower * height / (domain('y')[1] - domain('y')[0])"}},
"height": {"value": 1},
"fill": {"value": "#4285F4"},
"fillOpacity": {"value": 0.5}
}
}
},
{
"type": "rect",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5, "offset": -5},
"width": {"value": 10},
"y": {"scale": "y", "field": "absolute", "offset": {"signal": "datum.absolute_ci_upper * height / (domain('y')[1] - domain('y')[0])"}},
"height": {"value": 1},
"fill": {"value": "#4285F4"},
"fillOpacity": {"value": 0.5}
}
}
},
{
"type": "symbol",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5},
"y": {"scale": "y", "field": "absolute"},
"fill": {"value": "#4285F4"},
"size": {"value": 100},
"opacity": {"value": 0.35}
}
}
},
{
"type": "symbol",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5},
"y": {"scale": "y", "field": "absolute"},
"fill": {"value": "#4285F4"},
"size": {"value": 38},
"opacity": {"value": 0.85}
}
}
},
{
"type": "rule",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5},
"y": {"scale": "y2", "field": "nx", "offset": {"signal": "-datum.nx_ci_lower * height / (domain('y2')[1] - domain('y2')[0])"}},
"y2": {"scale": "y2", "field": "nx", "offset": {"signal": "datum.nx_ci_upper * height / (domain('y2')[1] - domain('y2')[0])"}},
"stroke": {"value": "#DB4437"},
"strokeOpacity": {"value": 0.5}
}
}
},
{
"type": "rect",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5, "offset": -5},
"width": {"value": 10},
"y": {"scale": "y2", "field": "nx", "offset": {"signal": "-datum.nx_ci_lower * height / (domain('y2')[1] - domain('y2')[0])"}},
"height": {"value": 1},
"fill": {"value": "#DB4437"},
"fillOpacity": {"value": 0.5}
}
}
},
{
"type": "rect",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5, "offset": -5},
"width": {"value": 10},
"y": {"scale": "y2", "field": "nx", "offset": {"signal": "datum.nx_ci_upper * height / (domain('y2')[1] - domain('y2')[0])"}},
"height": {"value": 1},
"fill": {"value": "#DB4437"},
"fillOpacity": {"value": 0.5}
}
}
},
{
"type": "symbol",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5},
"y": {"scale": "y2", "field": "nx"},
"fill": {"value": "#DB4437"},
"size": {"value": 100},
"opacity": {"value": 0.35}
}
}
},
{
"type": "symbol",
"from": {"data": "source"},
"encode": {
"enter": {
"x": {"scale": "x", "field": "node_id", "band": 0.5},
"y": {"scale": "y2", "field": "nx"},
"fill": {"value": "#DB4437"},
"size": {"value": 38},
"opacity": {"value": 0.85}
}
}
},
{
"type": "group",
"encode": {
"enter": {
"x": {"value": 1630},
"y": {"value": 20},
"width": {"value": 140},
"height": {"value": 130},
"cornerRadius": {"value": 5},
"fill": {"value": "#f0f0f0"},
"stroke": {"value": "#cccccc"}
}
},
"marks": [
{
"type": "text",
"from": {"data": "shrink_stats"},
"encode": {
"enter": {
"x": {"value": 10},
"y": {"value": 20},
"text": {"signal": "'Mean: ' + format(datum.mean_shrink, ',.1f')"},
"fontSize": {"value": 14},
"fill": {"value": "#4285F4"}
}
}
},
{
"type": "text",
"from": {"data": "shrink_stats"},
"encode": {
"enter": {
"x": {"value": 10},
"y": {"value": 40},
"text": {"signal": "'Sum: ' + format(datum.sum_shrink, ',d')"},
"fontSize": {"value": 14},
"fill": {"value": "#4285F4"}
}
}
},
{
"type": "text",
"from": {"data": "shrink_stats"},
"encode": {
"enter": {
"x": {"value": 10},
"y": {"value": 60},
"text": {"signal": "'Mean: ' + format(datum.mean_nx, ',.1f')"},
"fontSize": {"value": 14},
"fill": {"value": "#DB4437"}
}
}
},
{
"type": "text",
"encode": {
"enter": {
"x": {"value": 10},
"y": {"value": 80},
"text": {"signal": "'sum(old): ' + format(sum_old, ',.1f')"},
"fontSize": {"value": 14},
"fill": {"value": "#505050"}
}
}
},
{
"type": "text",
"encode": {
"enter": {
"x": {"value": 10},
"y": {"value": 100},
"text": {"signal": "'sum(new): ' + format(sum_new, ',.1f')"},
"fontSize": {"value": 14},
"fill": {"value": "#505050"}
}
}
},
{
"type": "text",
"encode": {
"enter": {
"x": {"value": 10},
"y": {"value": 120},
"text": {"signal": "'old / new: ' + format(sum_old / sum_new, ',.2f')"},
"fontSize": {"value": 14},
"fill": {"value": "#505050"}
}
}
}
]
}
]
}
================================================
FILE: hypothesis-python/docs/_ext/hypothesis_linkcheck.py
================================================
# This file is part of Hypothesis, which may be found at
# https://github.com/HypothesisWorks/hypothesis/
#
# Copyright the Hypothesis Authors.
# Individual contributors are listed in AUTHORS.rst and the git log.
#
# This Source Code Form is subject to the terms of the Mozilla Public License,
# v. 2.0. If a copy of the MPL was not distributed with this file, You can
# obtain one at https://mozilla.org/MPL/2.0/.
import sphinx
from sphinx.application import Sphinx
from sphinx.builders.linkcheck import HyperlinkAvailabilityChecker
# We want to customize the linkcheck behavior so that references from intersphinx
# mappings are not checked. We use these liberally and don't want to spend CI time
# checking their validity. If it's in an inventory, sphinx should guarantee
# it's valid, sans very weird things happening.
#
# Sphinx splits the link check logic across a CheckExternalLinksBuilder builder
# and a HyperlinkCollector post_transform (and a HyperlinkAvailabilityChecker
# helper class). There are various points in each where we could add this
# ignore-intersphinx hook.
#
# Monkey-patching HyperlinkAvailabilityChecker isn't great, but is the best way
# I found to go about this.
# set by on_builder_inited
inventories = {}
def is_intersphinx_link(uri):
for inventory in inventories.values():
uris = {uri for _name, _version, uri, _display_name in inventory.values()}
if uri in uris:
return True
return False
class HypothesisLinkChecker(HyperlinkAvailabilityChecker):
def is_ignored_uri(self, uri: str) -> bool:
if is_intersphinx_link(uri):
return True
return super().is_ignored_uri(uri)
sphinx.builders.linkcheck.HyperlinkAvailabilityChecker = HypothesisLinkChecker
# Hook the builder to get access to the intersphinx inventory. app.env is not
# available in setup()
def on_builder_inited(app: Sphinx) -> None:
global inventories
inventories = getattr(app.env, "intersphinx_inventory", {})
def setup(app: Sphinx):
app.connect("builder-inited", on_builder_inited)
================================================
FILE: hypothesis-python/docs/_ext/hypothesis_redirects.py
================================================
# This file is part of Hypothesis, which may be found at
# https://github.com/HypothesisWorks/hypothesis/
#
# Copyright the Hypothesis Authors.
# Individual contributors are listed in AUTHORS.rst and the git log.
#
# This Source Code Form is subject to the terms of the Mozilla Public License,
# v. 2.0. If a copy of the MPL was not distributed with this file, You can
# obtain one at https://mozilla.org/MPL/2.0/.
# vendored from https://github.com/documatt/sphinx-reredirects under the MIT
# license, with thanks
# ruff: noqa: G004
import re
from collections.abc import Mapping, Sequence
from fnmatch import fnmatch
from pathlib import Path
from string import Template
from urllib.parse import urlparse
from sphinx.application import Sphinx
from sphinx.builders.linkcheck import CheckExternalLinksBuilder, Hyperlink
from sphinx.util import logging
from sphinx.util.osutil import SEP
OPTION_REDIRECTS = "redirects"
OPTION_REDIRECTS_DEFAULT: dict[str, str] = {}
OPTION_TEMPLATE_FILE = "redirect_html_template_file"
OPTION_TEMPLATE_FILE_DEFAULT = None
REDIRECT_FILE_DEFAULT_TEMPLATE = (
'<html><head><meta http-equiv="refresh" content="0; url=${to_uri}"></head></html>'
)
logger = logging.getLogger(__name__)
wildcard_pattern = re.compile(r"[\*\?\[\]]")
def setup(app: Sphinx) -> dict:
"""
Extension setup, called by Sphinx
"""
app.connect("html-collect-pages", init)
app.connect("builder-inited", collect_redirects_for_linkcheck)
app.add_config_value(OPTION_REDIRECTS, OPTION_REDIRECTS_DEFAULT, "env")
app.add_config_value(OPTION_TEMPLATE_FILE, OPTION_TEMPLATE_FILE_DEFAULT, "env")
return {"parallel_read_safe": True}
def init(app: Sphinx) -> Sequence | None:
if not app.config[OPTION_REDIRECTS]:
logger.debug("No redirects configured")
return []
rr = Reredirects(app)
to_be_redirected = rr.grab_redirects()
rr.create_redirects(to_be_redirected)
# html-collect-pages requires to return iterable of pages to write,
# we have no additional pages to write
return []
class Reredirects:
def __init__(self, app: Sphinx) -> None:
self.app = app
self.redirects_option: dict[str, str] = getattr(app.config, OPTION_REDIRECTS)
self.template_file_option: str = getattr(app.config, OPTION_TEMPLATE_FILE)
def grab_redirects(self) -> Mapping[str, str]:
"""Inspect redirects option in conf.py and returns dict mapping
docname to target (with expanded placeholder)."""
# docname-target dict
to_be_redirected = {}
# For each source-target redirect pair in conf.py
for source, target in self.redirects_option.items():
# no wildcard, append source as-is
if not self._contains_wildcard(source):
to_be_redirected[source] = target
continue
assert self.app.env
# wildcarded source, expand to docnames
expanded_docs = [
doc for doc in self.app.env.found_docs if fnmatch(doc, source)
]
if not expanded_docs:
logger.warning(f"No documents match to '{source}' redirect.")
continue
for doc in expanded_docs:
new_target = self._apply_placeholders(doc, target)
to_be_redirected[doc] = new_target
return to_be_redirected
def docname_out_path(self, docname: str, suffix: str) -> Sequence[str]:
"""
For a Sphinx docname (the path to a source document without suffix),
returns path to outfile that would be created by the used builder.
"""
# Return as-is, if the docname already has been passed with a suffix
if docname.endswith(suffix):
return [docname]
# Remove any trailing slashes, except for "/"" index
if len(docname) > 1 and docname.endswith(SEP):
docname = docname.rstrip(SEP)
# Figure out whether we have dirhtml builder
out_uri = self.app.builder.get_target_uri(docname=docname) # type: ignore
if not out_uri.endswith(suffix):
# If dirhtml builder is used, need to append "index"
return [out_uri, "index"]
# Otherwise, convert e.g. 'source' to 'source.html'
return [out_uri]
def create_redirects(self, to_be_redirected: Mapping[str, str]) -> None:
"""Create actual redirect file for each pair in passed mapping of
docnames to targets."""
# Corresponds to value of `html_file_suffix`, but takes into account
# modifications done by the builder class
try:
suffix = self.app.builder.out_suffix # type: ignore
except Exception:
suffix = ".html"
for docname, target in to_be_redirected.items():
out = self.docname_out_path(docname, suffix)
redirect_file_abs = Path(self.app.outdir).joinpath(*out).with_suffix(suffix)
redirect_file_rel = redirect_file_abs.relative_to(self.app.outdir)
if redirect_file_abs.exists():
logger.info(
f"Overwriting '{redirect_file_rel}' with redirect to '{target}'."
)
else:
logger.info(f"Creating redirect '{redirect_file_rel}' to '{target}'.")
self._create_redirect_file(redirect_file_abs, target)
@staticmethod
def _contains_wildcard(text: str) -> bool:
"""Tells whether passed argument contains wildcard characters."""
return bool(wildcard_pattern.search(text))
@staticmethod
def _apply_placeholders(source: str, target: str) -> str:
"""Expand "source" placeholder in target and return it"""
return Template(target).substitute({"source": source})
def _create_redirect_file(self, at_path: Path, to_uri: str) -> None:
"""Actually create a redirect file according to redirect template"""
content = self._render_redirect_template(to_uri)
# create any missing parent folders
at_path.parent.mkdir(parents=True, exist_ok=True)
at_path.write_text(content, encoding="utf-8")
def _render_redirect_template(self, to_uri: str) -> str:
# HTML used as redirect file content
redirect_template = REDIRECT_FILE_DEFAULT_TEMPLATE
if self.template_file_option:
redirect_file_abs = Path(self.app.srcdir, self.template_file_option)
redirect_template = redirect_file_abs.read_text(encoding="utf-8")
return Template(redirect_template).substitute({"to_uri": to_uri})
def collect_redirects_for_linkcheck(app):
# Ignore when not invoked with linkcheck builder
if not isinstance(app.builder, CheckExternalLinksBuilder):
return
redirects = Reredirects(app).grab_redirects()
for docname, target in redirects.items():
# Give a Sphinx or extensions change to modify original target URL
if new_target := app.emit_firstresult("linkcheck-process-uri", target):
target = new_target
if urlparse(target).scheme not in ("http", "https"):
# Checking redirects to other pages of the same documentation is not
# supported for now.
continue
# Add target external URL to hyperlinks which linkcheck builder will check
docpath = app.env.doc2path(docname)
hyperlink = Hyperlink(uri=target, docname=docname, docpath=docpath, lineno=-1)
app.builder.hyperlinks[target] = hyperlink
================================================
FILE: hypothesis-python/docs/_static/better-signatures.css
================================================
/* dl gets used both for defining each top-level `.. autofunc` on a page (where we want vertical margsin)
and is wrapped around multiline signatures (where we don't).
If a dl is being used inside a .sig, that's a multiline signature; remove its margins. */
.sig > dl {
margin-block-start: 0rem;
margin-block-end: 0rem;
}
/* with thanks to https://github.com/pradyunsg/furo/discussions/749 */
.sig:not(.sig-inline) {
padding-left: 0.5em;
text-indent: 0;
}
================================================
FILE: hypothesis-python/docs/_static/dark-fix.css
================================================
/*
See https://github.com/HypothesisWorks/hypothesis/issues/4588 and
https://github.com/pradyunsg/furo/discussions/909. Once this is fixed in furo,
we can remove this.
*/
body[data-theme="dark"] .tooltip .tooltip-content {
background-color: var(--color-background-primary);
}
body[data-theme="dark"] .tooltip .arrow {
background: var(--color-background-primary);
}
================================================
FILE: hypothesis-python/docs/_static/no-scroll.css
================================================
/* disable autoscroll-to-target behavior
https://github.com/pradyunsg/furo/discussions/384#discussioncomment-2249243 */
html {
scroll-behavior: auto;
}
================================================
FILE: hypothesis-python/docs/_static/wrap-in-tables.css
================================================
/* override table width restrictions */
/* thanks to https://github.com/readthedocs/sphinx_rtd_theme/issues/117#issuecomment-153083280 */
@media screen and (min-width: 767px) {
.wy-table-responsive table td {
/* !important prevents the common CSS stylesheets from
overriding this as on RTD they are loaded after this stylesheet */
white-space: normal !important;
}
.wy-table-responsive {
overflow: visible !important;
}
}
================================================
FILE: hypothesis-python/docs/changelog.rst
================================================
=========
Changelog
=========
This is a record of all past Hypothesis releases and what went into them,
in reverse chronological order. All previous releases are still available
:pypi:`on PyPI <hypothesis>`.
Hypothesis 6.x
==============
.. only:: has_release_file
--------------------
Current pull request
--------------------
.. include:: ../RELEASE.rst
.. _v6.151.9:
--------------------
6.151.9 - 2026-02-16
--------------------
Remove some old unused code.
.. _v6.151.8:
--------------------
6.151.8 - 2026-02-16
--------------------
This patch fixes a crash when :obj:`sys.modules` contains unhashable values,
such as :class:`~types.SimpleNamespace` objects (:issue:`4660`).
.. _v6.151.7:
--------------------
6.151.7 - 2026-02-16
--------------------
This patch updates our vendored `list of top-level domains <https://www.iana.org/domains/root/db>`__,
which is used by the provisional :func:`~hypothesis.provisional.domains` strategy.
.. _v6.151.6:
--------------------
6.151.6 - 2026-02-11
--------------------
This patch fixes several duplicate word typos in comments and documentation.
.. _v6.151.5:
--------------------
6.151.5 - 2026-02-03
--------------------
This patch teaches our pytest plugin to :ref:` find interesting constants <v6.131.1>`
when pytest is collecting tests, to avoid arbitrarily attributing the latency
to whichever test function happened to be executed first (:issue:`4627`).
.. _v6.151.4:
--------------------
6.151.4 - 2026-01-29
--------------------
This patch adjusts how we compute the stopping threshold introduced in :version:`6.151.3`, while still maintaining 99% confidence that <1% of test cases pass.
.. _v6.151.3:
--------------------
6.151.3 - 2026-01-28
--------------------
This patch makes Hypothesis more tolerant of slow-to-satisfy ``assume()`` calls.
Previously, Hypothesis would give up after ``max_examples * 10`` attempts; now it
uses a statistical test to stop only when 99% confident that <1% of examples
would pass (:issue:`4623`).
Thanks to @ajdavis for this improvement!
.. _v6.151.2:
--------------------
6.151.2 - 2026-01-26
--------------------
Format our code with the latest version of :pypi:`black`.
.. _v6.151.1:
--------------------
6.151.1 - 2026-01-26
--------------------
Improve internal categorization of test cases when an :ref:`alternative backend <alternative-backends>` raises |BackendCannotProceed|.
.. _v6.151.0:
--------------------
6.151.0 - 2026-01-25
--------------------
Add 2025.12 to the list of recognized Array API versions in
``hypothesis.extra.array_api``.
.. _v6.150.3:
--------------------
6.150.3 - 2026-01-23
--------------------
Hypothesis now generates powers of 2 more often when using |st.integers|.
.. _v6.150.2:
--------------------
6.150.2 - 2026-01-13
--------------------
Update some internal type hints.
.. _v6.150.1:
--------------------
6.150.1 - 2026-01-12
--------------------
This patch fixes a bug where |st.recursive| would fail in cases where the
``extend=`` function does not reference it's argument - which was assumed
by the recent ``min_leaves=`` feature, because the strategy can't actually
recurse otherwise. (:issue:`4638`)
Now, the historical behavior is working-but-deprecated, or an error if you
explicitly pass ``min_leaves=``.
.. _v6.150.0:
--------------------
6.150.0 - 2026-01-06
--------------------
This release adds a ``min_leaves`` argument to :func:`~hypothesis.strategies.recursive`,
which ensures that generated recursive structures have at least the specified number
of leaf nodes (:issue:`4205`).
.. _v6.149.1:
--------------------
6.149.1 - 2026-01-05
--------------------
Add type hints to an internal class.
.. _v6.149.0:
--------------------
6.149.0 - 2026-01-05
--------------------
This release extends the explain-phase ``# or any other generated value`` comments
to sub-arguments within :func:`~hypothesis.strategies.builds`,
:func:`~hypothesis.strategies.tuples`, and :func:`~hypothesis.strategies.fixed_dictionaries`.
Previously, these comments only appeared on top-level test arguments. Now, when
the explain phase determines that a sub-argument can vary freely without affecting
the test failure, you'll see comments like::
Falsifying example: test_foo(
obj=MyClass(
x=0, # or any other generated value
y=True,
),
data=(
'', # or any other generated value
42,
),
)
This makes it easier to understand which parts of complex inputs actually matter
for reproducing a failure.
.. _v6.148.13:
---------------------
6.148.13 - 2026-01-05
---------------------
Clean up an internal helper.
.. _v6.148.12:
---------------------
6.148.12 - 2026-01-04
---------------------
This patch fixes :func:`~hypothesis.strategies.from_type` to properly handle
parameterized type aliases created with Python 3.12+'s :pep:`695` ``type``
statement. For example, ``st.from_type(A[int])`` where ``type A[T] = list[T]``
now correctly resolves to ``lists(integers())`` instead of raising a
``TypeError`` (:issue:`4628`).
.. _v6.148.11:
---------------------
6.148.11 - 2026-01-03
---------------------
Hypothesis now prints a |Verbosity.verbose| log when we switch away from an :ref:`alternative backend <alternative-backends>`.
.. _v6.148.10:
---------------------
6.148.10 - 2026-01-03
---------------------
Fixes :ref:`Ghostwriter <ghostwriter>` output for :pypi:`numpy` >= 2.4.0. Also adds support |st.from_type| for :pypi:`numpy` 2.5.0 nightly (which has not yet been released).
.. _v6.148.9:
--------------------
6.148.9 - 2026-01-01
--------------------
|.example| no longer emits |NonInteractiveExampleWarning| when running a python file directly. This means that e.g. ``python my_sandbox.py`` during exploratory work with |.example| will no longer raise warnings.
.. _v6.148.8:
--------------------
6.148.8 - 2025-12-23
--------------------
Add ``__dict__`` and ``__proto__`` to the list of constant strings Hypothesis sometimes generates.
.. _v6.148.7:
--------------------
6.148.7 - 2025-12-05
--------------------
When multiple explicit |@example| decorators fail with the same error,
Hypothesis now shows only the simplest failing example (by shortlex order)
with a note about how many other examples also failed (:issue:`4520`).
To see all failing examples, use |Verbosity.verbose| or higher.
.. _v6.148.6:
--------------------
6.148.6 - 2025-12-04
--------------------
Fix a bug where we persisted symbolics from solver-based :ref:`alternative backends <alternative-backends>` in |event|.
.. _v6.148.5:
--------------------
6.148.5 - 2025-12-01
--------------------
This patch improves the error message for :class:`~hypothesis.errors.FlakyStrategyDefinition`
when the precondition for a rule is flaky (:issue:`4206`).
.. _v6.148.4:
--------------------
6.148.4 - 2025-12-01
--------------------
This patch improves the type annotations for :func:`~hypothesis.extra.numpy.basic_indices`.
The return type now accurately reflects the ``allow_ellipsis`` and ``allow_newaxis``
parameters, excluding ``EllipsisType`` or ``None`` from the union when those index
types are disabled (:issue:`4607`).
Additionally, :func:`~hypothesis.assume` now has overloaded type annotations:
``assume(True)`` returns ``Literal[True]``, while ``assume(False)`` and
``assume(None)`` return ``NoReturn``.
.. _v6.148.3:
--------------------
6.148.3 - 2025-11-27
--------------------
Clean up some internal code.
.. _v6.148.2:
--------------------
6.148.2 - 2025-11-18
--------------------
Document |fuzz_one_input|.
.. _v6.148.1:
--------------------
6.148.1 - 2025-11-16
--------------------
This patch updates our vendored `list of top-level domains <https://www.iana.org/domains/root/db>`__,
which is used by the provisional :func:`~hypothesis.provisional.domains` strategy.
.. _v6.148.0:
--------------------
6.148.0 - 2025-11-15
--------------------
Calling :func:`~hypothesis.settings.register_profile` from within a test
decorated with :func:`@settings <hypothesis.settings>` is now deprecated,
to avoid confusion about which settings are used as the baseline for the
new profile.
.. _v6.147.0:
--------------------
6.147.0 - 2025-11-06
--------------------
This release drops support for :pypi:`nose`, which ceased development 9 years ago and does not support Python 3.10 or newer.
Hypothesis still supports :pypi:`nose2`. While we do not test ``nose2`` in our CI, we will fix any bugs that get reported.
.. _v6.146.0:
--------------------
6.146.0 - 2025-11-05
--------------------
|@settings| now accepts equivalent string representations for |settings.verbosity|, |settings.phases|, and |settings.suppress_health_check|. For example:
.. code-block:: python
# these two are now equivalent...
settings(verbosity=Verbosity.verbose)
settings(verbosity="verbose")
# ...as are these two...
settings(phases=[Phase.explicit])
settings(phases=["explicit"])
# ...and these two.
settings(suppress_health_check=[HealthCheck.filter_too_much])
settings(suppress_health_check=["filter_too_much"])
This release also changes the canonical value of |Verbosity|, |Phase|, and |HealthCheck| members to a string instead of an integer. For example, ``Phase.reuse.value == "explicit"`` as of this release, where previously ``Phase.reuse.value == 1``.
Instantiating |Verbosity|, |Phase|, or |HealthCheck| with an integer, such as ``Verbosity(0)``, is now deprecated.
.. _v6.145.1:
--------------------
6.145.1 - 2025-11-03
--------------------
Refactor some internal logic around strategy definitions.
.. _v6.145.0:
--------------------
6.145.0 - 2025-11-03
--------------------
Hypothesis previously required :pypi:`attrs` as a dependency. This release removes that dependency, so that the only required dependency of Hypothesis is :pypi:`sortedcontainers`.
All attrs-specific features of Hypothesis, such as using |st.from_type| with attrs classes, will continue to behave as before.
.. _v6.144.1:
--------------------
6.144.1 - 2025-11-03
--------------------
Tweak how Hypothesis hides internal tracebacks to fix an error under rare conditions (:issue:`3822`).
.. _v6.144.0:
--------------------
6.144.0 - 2025-11-02
--------------------
This release adds support for :class:`~fractions.Fraction` objects as ``min_value``
and ``max_value`` bounds in :func:`~hypothesis.strategies.decimals`, if they can
be exactly represented as decimals in the target precision (:issue:`4466`).
Bounding :func:`~hypothesis.strategies.decimals` with *other* values that cannot
be exactly represented is now deprecated; previously the bounds could be off by one.
.. _v6.143.1:
--------------------
6.143.1 - 2025-11-02
--------------------
:func:`~hypothesis.strategies.from_type` now correctly handles :pypi:`annotated-types`
annotations on :class:`typing.TypedDict` fields which are also marked as being
:obj:`~typing.ReadOnly`, :obj:`~typing.Required`, or :obj:`~typing.NotRequired`
(:issue:`4474`).
.. _v6.143.0:
--------------------
6.143.0 - 2025-11-01
--------------------
The extras for |hypothesis-numpy| and |hypothesis-pandas| now support automatically inferring a strategy for ``dtype="O"``. Previously, Hypothesis required an explicit elements strategy to be passed, for example ``nps.arrays("O", shape=(1,), elements=st.just(object()))``. Now, Hypothesis automatically infers ``elements=st.from_type(object)``.
Thanks to Shaun Read for identifying and fixing this!
.. _v6.142.5:
--------------------
6.142.5 - 2025-10-31
--------------------
This patch fixes :func:`~hypothesis.extra.ghostwriter.binary_operation` to
include imports for :mod:`hypothesis.extra.numpy` strategies such as
:func:`~hypothesis.extra.numpy.arrays`, :func:`~hypothesis.extra.numpy.scalar_dtypes`,
and :func:`~hypothesis.extra.numpy.array_shapes` when ghostwriting tests for
functions with numpy array parameters (:issue:`4576`).
.. _v6.142.4:
--------------------
6.142.4 - 2025-10-25
--------------------
Improve the accuracy of test timing reports, by tracking the start time of each test case closer to when the test is executed.
.. _v6.142.3:
--------------------
6.142.3 - 2025-10-22
--------------------
Fix a recursion error when :ref:`observability <observability>` is enabled and a test generates an object with a recursive reference, like ``a = []; a.append(a)``.
.. _v6.142.2:
--------------------
6.142.2 - 2025-10-20
--------------------
Remove a case where Hypothesis would interact with the global |random.Random| instance if Hypothesis internals were used directly.
.. _v6.142.1:
--------------------
6.142.1 - 2025-10-16
--------------------
Simplify some internal typing logic after dropping Python 3.9.
.. _v6.142.0:
--------------------
6.142.0 - 2025-10-16
--------------------
This release drops support for Python 3.9, `which reached end of life in
October 2025 <https://devguide.python.org/versions/>`__.
.. _v6.141.1:
--------------------
6.141.1 - 2025-10-15
--------------------
Fixes an error when using :ref:`the Ghostwriter <ghostwriter>` with annotations that include :obj:`python:typing.ForwardRef` on Python 3.14 (:issue:`4565`).
.. _v6.141.0:
--------------------
6.141.0 - 2025-10-15
--------------------
The |django.from_field| and |django.from_form| strategies from our :ref:`Django extra <hypothesis-django>` now support :obj:`~django:django.db.models.FileField`.
Thanks to Arjoonn Sharma for this fix!
.. _v6.140.4:
--------------------
6.140.4 - 2025-10-14
--------------------
Clean up internal ``@overload`` type annotations.
.. _v6.140.3:
--------------------
6.140.3 - 2025-10-04
--------------------
Fixes our bundled |run_conformance_test| not respecting |PrimitiveProvider.avoid_realization|.
.. _v6.140.2:
--------------------
6.140.2 - 2025-09-23
--------------------
The automatic switch to the CI :class:`settings profile <hypothesis.settings>` now works under :pypi:`tox` (for ``tox >= 4.30.0``).
.. _v6.140.1:
--------------------
6.140.1 - 2025-09-22
--------------------
This patch re-enables the warning for incompatible :func:`~hypothesis.strategies.shared`
strategies that was first enabled in :v:`6.133.0` but disabled in :v:`6.135.15`.
.. _v6.140.0:
--------------------
6.140.0 - 2025-09-22
--------------------
|st.characters| now validates that the elements of the ``exclude_characters`` and ``include_characters`` arguments are single characters, which was always assumed internally. For example, ``exclude_characters=["a", "b"]`` is valid while ``exclude_characters=["ab"]`` will now raise an error up-front.
.. _v6.139.3:
--------------------
6.139.3 - 2025-09-22
--------------------
Add ``phase`` to the :ref:`hypothesis-specific metadata <observability-hypothesis-metadata>` in :ref:`observability <observability>`.
.. _v6.139.2:
--------------------
6.139.2 - 2025-09-18
--------------------
Internal refactoring for new lint rules.
.. _v6.139.1:
--------------------
6.139.1 - 2025-09-16
--------------------
Fixed another typo in error message around function-scoped fixtures.
.. _v6.139.0:
--------------------
6.139.0 - 2025-09-16
--------------------
Add |settings.get_current_profile_name|, which returns the name of the current settings profile.
.. _v6.138.17:
---------------------
6.138.17 - 2025-09-15
---------------------
Fixed typo in error message around function-scoped fixtures.
.. _v6.138.16:
---------------------
6.138.16 - 2025-09-13
---------------------
Improved error message for |DeadlineExceeded|.
.. _v6.138.15:
---------------------
6.138.15 - 2025-09-08
---------------------
Refactor some stateful testing internals for easier use by third-party libraries.
.. _v6.138.14:
---------------------
6.138.14 - 2025-09-02
---------------------
Patch files written by hypothesis now use a deterministic ordering when multiple |@example| decorators are present.
.. _v6.138.13:
---------------------
6.138.13 - 2025-09-01
---------------------
Fix a typo affecting pretty-printing of lambdas with complex default
arguments.
.. _v6.138.12:
---------------------
6.138.12 - 2025-09-01
---------------------
Improve automatic detection of the :ref:`CI profile <builtin-profiles>` on various vendor-specific CI systems.
.. _v6.138.11:
---------------------
6.138.11 - 2025-09-01
---------------------
This patch updates our vendored `list of top-level domains <https://www.iana.org/domains/root/db>`__,
which is used by the provisional :func:`~hypothesis.provisional.domains` strategy.
.. _v6.138.10:
---------------------
6.138.10 - 2025-08-31
---------------------
Internal refactor to simplify |SearchStrategy|.
.. _v6.138.9:
--------------------
6.138.9 - 2025-08-31
--------------------
This patch further improves stringification of lambdas, by
never returning a lambda source unless it is confirmed to
compile to the same code object. This stricter check makes
it possible to widen the search for a matching source block,
so that it can often be found even if the file has been
edited.
.. _v6.138.8:
--------------------
6.138.8 - 2025-08-29
--------------------
Fixes a race condition under threading when using |st.deferred|.
.. _v6.138.7:
--------------------
6.138.7 - 2025-08-28
--------------------
Improves upon the cache eviction problem workaround
of :v:`6.135.12`.
.. _v6.138.6:
--------------------
6.138.6 - 2025-08-27
--------------------
Documentation tweaks.
.. _v6.138.5:
--------------------
6.138.5 - 2025-08-27
--------------------
Fixes a race condition under threading for strategies which trigger our filter-rewriting rules, like ``st.integers().filter(lambda x: abs(x) > 100)``.
.. _v6.138.4:
--------------------
6.138.4 - 2025-08-27
--------------------
One of our shrinking passes for reducing failing inputs targets failures which require two numbers to add to the same value. This pass previously only worked for positive numbers. This patch fixes that, so it also works for negative numbers.
.. _v6.138.3:
--------------------
6.138.3 - 2025-08-24
--------------------
This patch slightly improves the cache-hit rate for
|st.dictionaries| and certain unique |st.lists|.
.. _v6.138.2:
--------------------
6.138.2 - 2025-08-16
--------------------
The type annotations for |st.register_type_strategy| now indicate that it accepts registering types created with |TypeAliasType| (aka ``type MyType = int``).
.. _v6.138.1:
--------------------
6.138.1 - 2025-08-15
--------------------
Internal refactoring and cleanup. As a result, ``hypothesis[cli]`` and ``hypothesis[ghostwriter]`` now require ``black>=20.8b0`` instead of the previous ``black>=19.10b0``.
.. _v6.138.0:
--------------------
6.138.0 - 2025-08-13
--------------------
On Python 3.14, |memoryview| is newly generic. This release adds the ability for |st.from_type| to resolve generic |memoryview| types on 3.14, like ``st.from_type(memoryview[CustomBufferClass])`` . ``CustomBufferClass`` must implement ``__buffer__``, as expected by |memoryview|.
.. _v6.137.3:
--------------------
6.137.3 - 2025-08-11
--------------------
This patch makes the stringification of lambdas, and as
a result certain automatic filter rewriting operations,
more robust. This fixes :issue:`4498`, where a lambda
was mistakenly identified as the identity operator due
to :func:`inspect.getsource` only returning the first
line of the lambda definition.
As a result, the ``repr`` of strategies filtered or
mapped by lambda functions may change slightly.
.. _v6.137.2:
--------------------
6.137.2 - 2025-08-11
--------------------
Add support for Python 3.14, `which is currently in release candidate 1 <https://devguide.python.org/versions/>`_.
.. _v6.137.1:
--------------------
6.137.1 - 2025-08-05
--------------------
Fixes a bug with solver-based :ref:`alternative backends <alternative-backends>` (like `crosshair <https://github.com/pschanely/CrossHair>`_) where symbolic values passed to |event| would not be realized to concrete values at the end of the test case.
.. _v6.137.0:
--------------------
6.137.0 - 2025-08-05
--------------------
Add the |add_observability_callback|, |remove_observability_callback|, |with_observability_callback|, and |observability_enabled| methods to the :ref:`observability <observability>` interface. The previous |TESTCASE_CALLBACKS| is deprecated.
This release also adds better threading support to observability callbacks. An observability callback will now only be called for observations generated by the same thread.
.. _v6.136.9:
--------------------
6.136.9 - 2025-08-04
--------------------
Fix a threading race condition in |st.one_of| initialization.
.. _v6.136.8:
--------------------
6.136.8 - 2025-08-04
--------------------
Improve the error messages and documentation for |HealthCheck|. Among others, the messaging is now more clear that health checks are proactive warnings, not correctness errors.
.. _v6.136.7:
--------------------
6.136.7 - 2025-08-01
--------------------
Improve detection of sys.monitoring to avoid errors on GraalPy.
.. _v6.136.6:
--------------------
6.136.6 - 2025-07-28
--------------------
When a test is executed concurrently from multiple threads, |HealthCheck.too_slow| is now disabled, since the Python runtime may decide to switch away from a thread for arbitrarily long and Hypothesis cannot track execution time per-thread.
.. _v6.136.5:
--------------------
6.136.5 - 2025-07-28
--------------------
This patch updates our vendored `list of top-level domains <https://www.iana.org/domains/root/db>`__,
which is used by the provisional :func:`~hypothesis.provisional.domains` strategy.
.. _v6.136.4:
--------------------
6.136.4 - 2025-07-25
--------------------
|HealthCheck.differing_executors| is no longer raised if a test is executed by different executors from different threads. |HealthCheck.differing_executors| will still be raised if a test is executed by different executors in the same thread.
.. _v6.136.3:
--------------------
6.136.3 - 2025-07-23
--------------------
When a test is executed concurrently from multiple threads, |DeadlineExceeded| is now disabled, since the Python runtime may decide to switch away from a thread for longer than |settings.deadline|, and Hypothesis cannot track execution time per-thread. See :issue:`4478`.
.. _v6.136.2:
--------------------
6.136.2 - 2025-07-21
--------------------
|@precondition| now errors if used without |@rule| or |@invariant|. Doing so has no effect and is indicative of a user error (:issue:`4413`).
.. _v6.136.1:
--------------------
6.136.1 - 2025-07-20
--------------------
Fix |PrimitiveProvider.on_observation| being called with observations it wasn't responsible for generating if the test failed.
.. _v6.136.0:
--------------------
6.136.0 - 2025-07-19
--------------------
When a failure found by an :ref:`alternative backend <alternative-backends>` does not reproduce under the Hypothesis backend, we now raise |FlakyBackendFailure| instead of an internal ``FlakyReplay`` exception.
.. _v6.135.33:
---------------------
6.135.33 - 2025-07-18
---------------------
Speculative fix for a thread-safety issue in calculating strategy labels.
.. _v6.135.32:
---------------------
6.135.32 - 2025-07-15
---------------------
Improve the thread-safety of strategy validation.
Before this release, Hypothesis did not require that ``super().__init__()`` be called in ``SearchStrategy`` subclasses. Subclassing ``SearchStrategy`` is not supported or part of the public API, but if you are subclassing it anyway, you will need to make sure to call ``super().__init__()`` after this release.
gitextract_nlv4f5th/
├── .claude/
│ ├── CLAUDE.md
│ └── commands/
│ └── hypothesis.md
├── .gitattributes
├── .github/
│ ├── CODEOWNERS
│ ├── CODE_OF_CONDUCT.rst
│ ├── actions/
│ │ └── install-base/
│ │ └── action.yml
│ └── workflows/
│ ├── fuzz.yml
│ ├── main.yml
│ ├── update-deps.yml
│ └── website.yml
├── .gitignore
├── .readthedocs.yml
├── AUTHORS.rst
├── CITATION.cff
├── CONTRIBUTING.rst
├── LICENSE.txt
├── README.md
├── brand/
│ ├── README.md
│ ├── hypothesis.gpl
│ ├── hypothesis.sketch
│ └── hypothesis2.sketch
├── build.sh
├── guides/
│ ├── README.md
│ ├── api-style.rst
│ ├── documentation.rst
│ ├── internals.rst
│ ├── review.rst
│ ├── strategies-that-shrink.rst
│ └── testing-hypothesis.rst
├── hypothesis-python/
│ ├── LICENSE.txt
│ ├── README.md
│ ├── RELEASE-sample.rst
│ ├── benchmark/
│ │ ├── README.md
│ │ ├── graph.py
│ │ └── spec.json
│ ├── docs/
│ │ ├── _ext/
│ │ │ ├── hypothesis_linkcheck.py
│ │ │ └── hypothesis_redirects.py
│ │ ├── _static/
│ │ │ ├── better-signatures.css
│ │ │ ├── dark-fix.css
│ │ │ ├── no-scroll.css
│ │ │ └── wrap-in-tables.css
│ │ ├── changelog.rst
│ │ ├── community.rst
│ │ ├── compatibility.rst
│ │ ├── conf.py
│ │ ├── development.rst
│ │ ├── explanation/
│ │ │ ├── domain.rst
│ │ │ ├── example-count.rst
│ │ │ └── index.rst
│ │ ├── extensions.rst
│ │ ├── extras.rst
│ │ ├── how-to/
│ │ │ ├── custom-database.rst
│ │ │ ├── detect-hypothesis-tests.rst
│ │ │ ├── external-fuzzers.rst
│ │ │ ├── index.rst
│ │ │ ├── suppress-healthchecks.rst
│ │ │ └── type-strategies.rst
│ │ ├── index.rst
│ │ ├── packaging.rst
│ │ ├── prolog.rst
│ │ ├── quickstart.rst
│ │ ├── redirect.html.template
│ │ ├── reference/
│ │ │ ├── api.rst
│ │ │ ├── index.rst
│ │ │ ├── integrations.rst
│ │ │ ├── internals.rst
│ │ │ ├── schema_metadata.json
│ │ │ ├── schema_metadata_choices.json
│ │ │ ├── schema_observations.json
│ │ │ └── strategies.rst
│ │ ├── stateful.rst
│ │ ├── tutorial/
│ │ │ ├── adapting-strategies.rst
│ │ │ ├── adding-notes.rst
│ │ │ ├── builtin-strategies.rst
│ │ │ ├── custom-strategies.rst
│ │ │ ├── flaky.rst
│ │ │ ├── index.rst
│ │ │ ├── introduction.rst
│ │ │ ├── replaying-failures.rst
│ │ │ └── settings.rst
│ │ └── usage.rst
│ ├── examples/
│ │ ├── README.md
│ │ ├── example_hypothesis_entrypoint/
│ │ │ ├── example_hypothesis_entrypoint.py
│ │ │ ├── setup.py
│ │ │ └── test_entrypoint.py
│ │ ├── test_basic.py
│ │ ├── test_binary_search.py
│ │ └── test_rle.py
│ ├── pyproject.toml
│ ├── pyrightconfig.json
│ ├── scripts/
│ │ ├── basic-test.sh
│ │ ├── other-tests.sh
│ │ └── validate_branch_check.py
│ ├── src/
│ │ ├── _hypothesis_ftz_detector.py
│ │ ├── _hypothesis_globals.py
│ │ ├── _hypothesis_pytestplugin.py
│ │ └── hypothesis/
│ │ ├── __init__.py
│ │ ├── _settings.py
│ │ ├── configuration.py
│ │ ├── control.py
│ │ ├── core.py
│ │ ├── database.py
│ │ ├── entry_points.py
│ │ ├── errors.py
│ │ ├── extra/
│ │ │ ├── __init__.py
│ │ │ ├── _array_helpers.py
│ │ │ ├── _patching.py
│ │ │ ├── array_api.py
│ │ │ ├── cli.py
│ │ │ ├── codemods.py
│ │ │ ├── dateutil.py
│ │ │ ├── django/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _fields.py
│ │ │ │ └── _impl.py
│ │ │ ├── dpcontracts.py
│ │ │ ├── ghostwriter.py
│ │ │ ├── lark.py
│ │ │ ├── numpy.py
│ │ │ ├── pandas/
│ │ │ │ ├── __init__.py
│ │ │ │ └── impl.py
│ │ │ ├── pytestplugin.py
│ │ │ ├── pytz.py
│ │ │ └── redis.py
│ │ ├── internal/
│ │ │ ├── __init__.py
│ │ │ ├── cache.py
│ │ │ ├── cathetus.py
│ │ │ ├── charmap.py
│ │ │ ├── compat.py
│ │ │ ├── conjecture/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── choice.py
│ │ │ │ ├── data.py
│ │ │ │ ├── datatree.py
│ │ │ │ ├── engine.py
│ │ │ │ ├── floats.py
│ │ │ │ ├── junkdrawer.py
│ │ │ │ ├── optimiser.py
│ │ │ │ ├── pareto.py
│ │ │ │ ├── provider_conformance.py
│ │ │ │ ├── providers.py
│ │ │ │ ├── shrinker.py
│ │ │ │ ├── shrinking/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── bytes.py
│ │ │ │ │ ├── choicetree.py
│ │ │ │ │ ├── collection.py
│ │ │ │ │ ├── common.py
│ │ │ │ │ ├── floats.py
│ │ │ │ │ ├── integer.py
│ │ │ │ │ ├── ordering.py
│ │ │ │ │ └── string.py
│ │ │ │ └── utils.py
│ │ │ ├── constants_ast.py
│ │ │ ├── coverage.py
│ │ │ ├── detection.py
│ │ │ ├── entropy.py
│ │ │ ├── escalation.py
│ │ │ ├── filtering.py
│ │ │ ├── floats.py
│ │ │ ├── healthcheck.py
│ │ │ ├── intervalsets.py
│ │ │ ├── lambda_sources.py
│ │ │ ├── observability.py
│ │ │ ├── reflection.py
│ │ │ ├── scrutineer.py
│ │ │ └── validation.py
│ │ ├── provisional.py
│ │ ├── py.typed
│ │ ├── reporting.py
│ │ ├── stateful.py
│ │ ├── statistics.py
│ │ ├── strategies/
│ │ │ ├── __init__.py
│ │ │ └── _internal/
│ │ │ ├── __init__.py
│ │ │ ├── attrs.py
│ │ │ ├── collections.py
│ │ │ ├── core.py
│ │ │ ├── datetime.py
│ │ │ ├── deferred.py
│ │ │ ├── featureflags.py
│ │ │ ├── flatmapped.py
│ │ │ ├── functions.py
│ │ │ ├── ipaddress.py
│ │ │ ├── lazy.py
│ │ │ ├── misc.py
│ │ │ ├── numbers.py
│ │ │ ├── random.py
│ │ │ ├── recursive.py
│ │ │ ├── regex.py
│ │ │ ├── shared.py
│ │ │ ├── strategies.py
│ │ │ ├── strings.py
│ │ │ ├── types.py
│ │ │ └── utils.py
│ │ ├── utils/
│ │ │ ├── __init__.py
│ │ │ ├── conventions.py
│ │ │ ├── deprecation.py
│ │ │ ├── dynamicvariables.py
│ │ │ ├── terminal.py
│ │ │ └── threading.py
│ │ ├── vendor/
│ │ │ ├── __init__.py
│ │ │ ├── pretty.py
│ │ │ └── tlds-alpha-by-domain.txt
│ │ └── version.py
│ ├── tests/
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── array_api/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── conftest.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_arrays.py
│ │ │ ├── test_from_dtype.py
│ │ │ ├── test_indices.py
│ │ │ ├── test_partial_adoptors.py
│ │ │ ├── test_pretty.py
│ │ │ ├── test_scalar_dtypes.py
│ │ │ └── test_strategies_namespace.py
│ │ ├── attrs/
│ │ │ ├── test_attrs.py
│ │ │ ├── test_inference.py
│ │ │ └── test_pretty.py
│ │ ├── codemods/
│ │ │ ├── test_codemod_cli.py
│ │ │ └── test_codemods.py
│ │ ├── common/
│ │ │ ├── __init__.py
│ │ │ ├── arguments.py
│ │ │ ├── costbounds.py
│ │ │ ├── debug.py
│ │ │ ├── setup.py
│ │ │ ├── strategies.py
│ │ │ └── utils.py
│ │ ├── conftest.py
│ │ ├── conjecture/
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── test_choice.py
│ │ │ ├── test_choice_tree.py
│ │ │ ├── test_data_tree.py
│ │ │ ├── test_engine.py
│ │ │ ├── test_float_encoding.py
│ │ │ ├── test_forced.py
│ │ │ ├── test_inquisitor.py
│ │ │ ├── test_intlist.py
│ │ │ ├── test_junkdrawer.py
│ │ │ ├── test_local_constants.py
│ │ │ ├── test_minimizer.py
│ │ │ ├── test_mutations.py
│ │ │ ├── test_optimiser.py
│ │ │ ├── test_order_shrinking.py
│ │ │ ├── test_pareto.py
│ │ │ ├── test_provider.py
│ │ │ ├── test_provider_contract.py
│ │ │ ├── test_shrinker.py
│ │ │ ├── test_shrinking_interface.py
│ │ │ ├── test_test_data.py
│ │ │ └── test_utils.py
│ │ ├── cover/
│ │ │ ├── __init__.py
│ │ │ ├── test_annotations.py
│ │ │ ├── test_arbitrary_data.py
│ │ │ ├── test_asyncio.py
│ │ │ ├── test_cache_implementation.py
│ │ │ ├── test_caching.py
│ │ │ ├── test_cathetus.py
│ │ │ ├── test_charmap.py
│ │ │ ├── test_compat.py
│ │ │ ├── test_complex_numbers.py
│ │ │ ├── test_composite.py
│ │ │ ├── test_composite_kwonlyargs.py
│ │ │ ├── test_constants_ast.py
│ │ │ ├── test_control.py
│ │ │ ├── test_core.py
│ │ │ ├── test_custom_reprs.py
│ │ │ ├── test_database_backend.py
│ │ │ ├── test_datetimes.py
│ │ │ ├── test_deadline.py
│ │ │ ├── test_debug_information.py
│ │ │ ├── test_deferred_strategies.py
│ │ │ ├── test_detection.py
│ │ │ ├── test_direct_strategies.py
│ │ │ ├── test_draw_example.py
│ │ │ ├── test_error_in_draw.py
│ │ │ ├── test_escalation.py
│ │ │ ├── test_example.py
│ │ │ ├── test_exceptiongroup.py
│ │ │ ├── test_executors.py
│ │ │ ├── test_explicit_examples.py
│ │ │ ├── test_falsifying_example_output.py
│ │ │ ├── test_feature_flags.py
│ │ │ ├── test_filestorage.py
│ │ │ ├── test_filter_rewriting.py
│ │ │ ├── test_filtered_strategy.py
│ │ │ ├── test_find.py
│ │ │ ├── test_flakiness.py
│ │ │ ├── test_float_nastiness.py
│ │ │ ├── test_float_utils.py
│ │ │ ├── test_functions.py
│ │ │ ├── test_fuzz_one_input.py
│ │ │ ├── test_given_error_conditions.py
│ │ │ ├── test_health_checks.py
│ │ │ ├── test_interactive_example.py
│ │ │ ├── test_internal_helpers.py
│ │ │ ├── test_intervalset.py
│ │ │ ├── test_lambda_formatting.py
│ │ │ ├── test_lazy_import.py
│ │ │ ├── test_lookup.py
│ │ │ ├── test_lookup_py310.py
│ │ │ ├── test_lookup_py314.py
│ │ │ ├── test_lookup_py37.py
│ │ │ ├── test_lookup_py38.py
│ │ │ ├── test_lookup_py39.py
│ │ │ ├── test_map.py
│ │ │ ├── test_mock.py
│ │ │ ├── test_monitoring.py
│ │ │ ├── test_nothing.py
│ │ │ ├── test_numerics.py
│ │ │ ├── test_observability.py
│ │ │ ├── test_one_of.py
│ │ │ ├── test_permutations.py
│ │ │ ├── test_phases.py
│ │ │ ├── test_posonly_args_py38.py
│ │ │ ├── test_pretty.py
│ │ │ ├── test_provisional_strategies.py
│ │ │ ├── test_random_module.py
│ │ │ ├── test_randoms.py
│ │ │ ├── test_recursive.py
│ │ │ ├── test_reflection.py
│ │ │ ├── test_regex.py
│ │ │ ├── test_regressions.py
│ │ │ ├── test_replay_logic.py
│ │ │ ├── test_reporting.py
│ │ │ ├── test_reproduce_failure.py
│ │ │ ├── test_runner_strategy.py
│ │ │ ├── test_sampled_from.py
│ │ │ ├── test_searchstrategy.py
│ │ │ ├── test_seed_printing.py
│ │ │ ├── test_settings.py
│ │ │ ├── test_setup_teardown.py
│ │ │ ├── test_shrink_budgeting.py
│ │ │ ├── test_sideeffect_warnings.py
│ │ │ ├── test_simple_characters.py
│ │ │ ├── test_simple_collections.py
│ │ │ ├── test_simple_strings.py
│ │ │ ├── test_slices.py
│ │ │ ├── test_slippage.py
│ │ │ ├── test_stateful.py
│ │ │ ├── test_statistical_events.py
│ │ │ ├── test_subnormal_floats.py
│ │ │ ├── test_targeting.py
│ │ │ ├── test_testdecorators.py
│ │ │ ├── test_threading.py
│ │ │ ├── test_traceback_elision.py
│ │ │ ├── test_type_lookup.py
│ │ │ ├── test_type_lookup_forward_ref.py
│ │ │ ├── test_typealias_py312.py
│ │ │ ├── test_unicode_identifiers.py
│ │ │ ├── test_unittest.py
│ │ │ ├── test_uuids.py
│ │ │ ├── test_validation.py
│ │ │ └── test_verbosity.py
│ │ ├── crosshair/
│ │ │ ├── test_conformance.py
│ │ │ └── test_crosshair.py
│ │ ├── datetime/
│ │ │ ├── __init__.py
│ │ │ ├── test_dateutil_timezones.py
│ │ │ ├── test_pytz_timezones.py
│ │ │ └── test_zoneinfo_timezones.py
│ │ ├── django/
│ │ │ ├── __init__.py
│ │ │ ├── manage.py
│ │ │ ├── toys/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── settings/
│ │ │ │ │ ├── no_urls.py
│ │ │ │ │ ├── settings.py
│ │ │ │ │ ├── settings_no_contrib.py
│ │ │ │ │ └── urls.py
│ │ │ │ └── wsgi.py
│ │ │ └── toystore/
│ │ │ ├── __init__.py
│ │ │ ├── admin.py
│ │ │ ├── forms.py
│ │ │ ├── models.py
│ │ │ ├── test_basic_configuration.py
│ │ │ ├── test_given_forms.py
│ │ │ ├── test_given_models.py
│ │ │ └── views.py
│ │ ├── dpcontracts/
│ │ │ ├── __init__.py
│ │ │ └── test_contracts.py
│ │ ├── ghostwriter/
│ │ │ ├── example_code/
│ │ │ │ ├── __init__.py
│ │ │ │ └── future_annotations.py
│ │ │ ├── recorded/
│ │ │ │ ├── add_custom_classes.txt
│ │ │ │ ├── addition_op_magic.txt
│ │ │ │ ├── addition_op_multimagic.txt
│ │ │ │ ├── base64_magic.txt
│ │ │ │ ├── division_binop_error_handler.txt
│ │ │ │ ├── division_fuzz_error_handler.txt
│ │ │ │ ├── division_operator.txt
│ │ │ │ ├── division_operator_with_annotations.txt
│ │ │ │ ├── division_roundtrip_arithmeticerror_handler.txt
│ │ │ │ ├── division_roundtrip_error_handler.txt
│ │ │ │ ├── division_roundtrip_error_handler_without_annotations.txt
│ │ │ │ ├── division_roundtrip_typeerror_handler.txt
│ │ │ │ ├── eval_equivalent.txt
│ │ │ │ ├── fuzz_classmethod.txt
│ │ │ │ ├── fuzz_sorted.txt
│ │ │ │ ├── fuzz_sorted_with_annotations.txt
│ │ │ │ ├── fuzz_staticmethod.txt
│ │ │ │ ├── fuzz_ufunc.txt
│ │ │ │ ├── fuzz_with_docstring.txt
│ │ │ │ ├── hypothesis_module_magic.txt
│ │ │ │ ├── invalid_types.txt
│ │ │ │ ├── magic_base64_roundtrip.txt
│ │ │ │ ├── magic_base64_roundtrip_with_annotations.txt
│ │ │ │ ├── magic_builtins.txt
│ │ │ │ ├── magic_class.txt
│ │ │ │ ├── magic_gufunc.txt
│ │ │ │ ├── magic_numpy.txt
│ │ │ │ ├── matmul_magic.txt
│ │ │ │ ├── merge_dicts.txt
│ │ │ │ ├── multiplication_magic.txt
│ │ │ │ ├── multiplication_operator.txt
│ │ │ │ ├── multiplication_operator_unittest.txt
│ │ │ │ ├── nothing_found.txt
│ │ │ │ ├── optional_parameter.txt
│ │ │ │ ├── optional_union_parameter.txt
│ │ │ │ ├── re_compile.txt
│ │ │ │ ├── re_compile_except.txt
│ │ │ │ ├── re_compile_unittest.txt
│ │ │ │ ├── sequence_from_collections.txt
│ │ │ │ ├── sorted_idempotent.txt
│ │ │ │ ├── sorted_self_equivalent.txt
│ │ │ │ ├── sorted_self_equivalent_with_annotations.txt
│ │ │ │ ├── sorted_self_error_equivalent_1error.txt
│ │ │ │ ├── sorted_self_error_equivalent_2error_unittest.txt
│ │ │ │ ├── sorted_self_error_equivalent_simple.txt
│ │ │ │ ├── sorted_self_error_equivalent_threefuncs.txt
│ │ │ │ ├── timsort_idempotent.txt
│ │ │ │ ├── timsort_idempotent_asserts.txt
│ │ │ │ └── union_sequence_parameter.txt
│ │ │ ├── test_expected_output.py
│ │ │ ├── test_ghostwriter.py
│ │ │ ├── test_ghostwriter_cli.py
│ │ │ └── try-writing-for-installed.py
│ │ ├── lark/
│ │ │ ├── __init__.py
│ │ │ └── test_grammar.py
│ │ ├── nocover/
│ │ │ ├── __init__.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_bad_repr.py
│ │ │ ├── test_baseexception.py
│ │ │ ├── test_boundary_exploration.py
│ │ │ ├── test_build_signature.py
│ │ │ ├── test_cache_implementation.py
│ │ │ ├── test_cacheable.py
│ │ │ ├── test_characters.py
│ │ │ ├── test_collective_minimization.py
│ │ │ ├── test_compat.py
│ │ │ ├── test_completion.py
│ │ │ ├── test_complex_numbers.py
│ │ │ ├── test_conjecture_engine.py
│ │ │ ├── test_conjecture_int_list.py
│ │ │ ├── test_conjecture_utils.py
│ │ │ ├── test_conventions.py
│ │ │ ├── test_database_agreement.py
│ │ │ ├── test_database_usage.py
│ │ │ ├── test_deferred_errors.py
│ │ │ ├── test_drypython_returns.py
│ │ │ ├── test_duplication.py
│ │ │ ├── test_dynamic_variable.py
│ │ │ ├── test_emails.py
│ │ │ ├── test_eval_as_source.py
│ │ │ ├── test_exceptiongroup.py
│ │ │ ├── test_explore_arbitrary_languages.py
│ │ │ ├── test_fancy_repr.py
│ │ │ ├── test_filtering.py
│ │ │ ├── test_find.py
│ │ │ ├── test_fixtures.py
│ │ │ ├── test_flatmap.py
│ │ │ ├── test_floating.py
│ │ │ ├── test_from_type_recipe.py
│ │ │ ├── test_given_error_conditions.py
│ │ │ ├── test_given_reuse.py
│ │ │ ├── test_health_checks.py
│ │ │ ├── test_imports.py
│ │ │ ├── test_integer_ranges.py
│ │ │ ├── test_interesting_origin.py
│ │ │ ├── test_labels.py
│ │ │ ├── test_large_examples.py
│ │ │ ├── test_limits.py
│ │ │ ├── test_modify_inner_test.py
│ │ │ ├── test_nesting.py
│ │ │ ├── test_precise_shrinking.py
│ │ │ ├── test_pretty_repr.py
│ │ │ ├── test_randomization.py
│ │ │ ├── test_recursive.py
│ │ │ ├── test_regex.py
│ │ │ ├── test_regressions.py
│ │ │ ├── test_reusable_values.py
│ │ │ ├── test_sampled_from.py
│ │ │ ├── test_scrutineer.py
│ │ │ ├── test_sets.py
│ │ │ ├── test_sharing.py
│ │ │ ├── test_simple_numbers.py
│ │ │ ├── test_simple_strings.py
│ │ │ ├── test_skipping.py
│ │ │ ├── test_stateful.py
│ │ │ ├── test_strategy_state.py
│ │ │ ├── test_subnormal_floats.py
│ │ │ ├── test_targeting.py
│ │ │ ├── test_testdecorators.py
│ │ │ ├── test_threading.py
│ │ │ ├── test_type_lookup.py
│ │ │ ├── test_type_lookup_forward_ref.py
│ │ │ ├── test_type_lookup_future_annotations.py
│ │ │ ├── test_unusual_settings_configs.py
│ │ │ └── test_uuids.py
│ │ ├── numpy/
│ │ │ ├── __init__.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_deprecation.py
│ │ │ ├── test_fill_values.py
│ │ │ ├── test_floor_ceil.py
│ │ │ ├── test_from_dtype.py
│ │ │ ├── test_from_type.py
│ │ │ ├── test_gen_data.py
│ │ │ ├── test_gufunc.py
│ │ │ ├── test_import.py
│ │ │ ├── test_narrow_floats.py
│ │ │ ├── test_randomness.py
│ │ │ └── test_sampled_from.py
│ │ ├── pandas/
│ │ │ ├── __init__.py
│ │ │ ├── helpers.py
│ │ │ ├── test_argument_validation.py
│ │ │ ├── test_data_frame.py
│ │ │ ├── test_indexes.py
│ │ │ └── test_series.py
│ │ ├── patching/
│ │ │ ├── __init__.py
│ │ │ ├── callables.py
│ │ │ ├── test_patching.py
│ │ │ └── toplevel.py
│ │ ├── pytest/
│ │ │ ├── test__pytest.py
│ │ │ ├── test_capture.py
│ │ │ ├── test_checks.py
│ │ │ ├── test_collection_warning.py
│ │ │ ├── test_compat.py
│ │ │ ├── test_constant_collection_timing.py
│ │ │ ├── test_doctest.py
│ │ │ ├── test_fixtures.py
│ │ │ ├── test_junit.py
│ │ │ ├── test_mark.py
│ │ │ ├── test_parametrized_db_keys.py
│ │ │ ├── test_profiles.py
│ │ │ ├── test_pytest_detection.py
│ │ │ ├── test_reporting.py
│ │ │ ├── test_runs.py
│ │ │ ├── test_seeding.py
│ │ │ ├── test_sideeffect_warnings.py
│ │ │ ├── test_skipping.py
│ │ │ └── test_statistics.py
│ │ ├── quality/
│ │ │ ├── __init__.py
│ │ │ ├── test_deferred_strategies.py
│ │ │ ├── test_discovery_ability.py
│ │ │ ├── test_float_shrinking.py
│ │ │ ├── test_integers.py
│ │ │ ├── test_poisoned_lists.py
│ │ │ ├── test_poisoned_trees.py
│ │ │ ├── test_shrink_quality.py
│ │ │ └── test_zig_zagging.py
│ │ ├── redis/
│ │ │ ├── __init__.py
│ │ │ └── test_redis_exampledatabase.py
│ │ ├── test_annotated_types.py
│ │ ├── typing_extensions/
│ │ │ ├── __init__.py
│ │ │ └── test_backported_types.py
│ │ └── watchdog/
│ │ ├── __init__.py
│ │ ├── test_database.py
│ │ └── test_database_cover.py
│ └── tox.ini
├── notebooks/
│ └── Designing a better simplifier.ipynb
├── paper.bib
├── paper.md
├── pyproject.toml
├── requirements/
│ ├── coverage.in
│ ├── coverage.txt
│ ├── crosshair.in
│ ├── crosshair.txt
│ ├── fuzzing.in
│ ├── fuzzing.txt
│ ├── test.in
│ ├── test.txt
│ ├── tools.in
│ └── tools.txt
├── tooling/
│ ├── README.md
│ ├── codespell-dict.txt
│ ├── codespell-ignore.txt
│ ├── scripts/
│ │ ├── common.sh
│ │ ├── ensure-python.sh
│ │ └── tool-hash.py
│ ├── setup.py
│ └── src/
│ └── hypothesistooling/
│ ├── __init__.py
│ ├── __main__.py
│ ├── installers.py
│ ├── junkdrawer.py
│ ├── projects/
│ │ ├── __init__.py
│ │ └── hypothesispython.py
│ ├── releasemanagement.py
│ └── scripts.py
├── website/
│ ├── archive-redirect.html
│ ├── content/
│ │ ├── 2016-04-15-economics-of-software-correctness.md
│ │ ├── 2016-04-15-getting-started-with-hypothesis.md
│ │ ├── 2016-04-16-anatomy-of-a-test.md
│ │ ├── 2016-04-16-encode-decode-invariant.md
│ │ ├── 2016-04-16-quickcheck-in-every-language.md
│ │ ├── 2016-04-16-the-purpose-of-hypothesis.md
│ │ ├── 2016-04-19-rule-based-stateful-testing.md
│ │ ├── 2016-04-29-testing-performance-optimizations.md
│ │ ├── 2016-05-02-referential-transparency.md
│ │ ├── 2016-05-11-generating-the-right-data.md
│ │ ├── 2016-05-13-what-is-property-based-testing.md
│ │ ├── 2016-05-26-exploring-voting-with-hypothesis.md
│ │ ├── 2016-05-29-testing-optimizers-with-hypothesis.md
│ │ ├── 2016-05-31-looking-for-guest-posts.md
│ │ ├── 2016-06-05-incremental-property-based-testing.md
│ │ ├── 2016-06-13-testing-configuration-parameters.md
│ │ ├── 2016-06-30-tests-as-complete-specifications.md
│ │ ├── 2016-07-04-calculating-the-mean.md
│ │ ├── 2016-07-09-hypothesis-3.4.1-release.md
│ │ ├── 2016-07-13-hypothesis-3.4.2-release.md
│ │ ├── 2016-07-23-what-is-hypothesis.md
│ │ ├── 2016-08-09-hypothesis-pytest-fixtures.md
│ │ ├── 2016-08-19-recursive-data.md
│ │ ├── 2016-08-31-how-many-tests.md
│ │ ├── 2016-09-04-hypothesis-vs-eris.md
│ │ ├── 2016-09-23-hypothesis-3.5.0-release.md
│ │ ├── 2016-10-01-pytest-integration-sponsorship.md
│ │ ├── 2016-10-17-canonical-serialization.md
│ │ ├── 2016-10-31-hypothesis-3.6.0-release.md
│ │ ├── 2016-12-05-integrated-shrinking.md
│ │ ├── 2016-12-08-compositional-shrinking.md
│ │ ├── 2016-12-10-how-hypothesis-works.md
│ │ ├── 2017-03-09-hypothesis-for-researchers.md
│ │ ├── 2017-04-05-how-not-to-die-hard-with-hypothesis.md
│ │ ├── 2017-07-16-types-and-properties.md
│ │ ├── 2017-09-14-multi-bug-discovery.md
│ │ ├── 2017-09-28-threshold-problem.md
│ │ ├── 2018-01-08-smarkets.md
│ │ ├── 2018-02-27-continuous-releases.md
│ │ ├── 2020-06-08-complex-data-strategies.md
│ │ ├── 2025-08-07-thread-safe.md
│ │ ├── 2025-11-01-claude-code-plugin.md
│ │ ├── 2025-11-16-introducing-hypofuzz.md
│ │ └── pages/
│ │ └── testimonials.md
│ ├── pelicanconf.py
│ └── theme/
│ ├── static/
│ │ ├── prism.css
│ │ ├── prism.js
│ │ └── style.css
│ └── templates/
│ ├── article-card.html
│ ├── article.html
│ ├── base.html
│ ├── category.html
│ ├── index.html
│ └── page.html
└── whole_repo_tests/
├── __init__.py
├── documentation/
│ ├── __init__.py
│ └── test_documentation.py
├── types/
│ ├── __init__.py
│ ├── revealed_types.py
│ ├── test_hypothesis.py
│ ├── test_mypy.py
│ └── test_pyright.py
└── whole_repo/
├── __init__.py
├── test_ci_config.py
├── test_deploy.py
├── test_release_files.py
├── test_release_management.py
├── test_requirements.py
├── test_rst_is_valid.py
├── test_shellcheck.py
└── test_validate_branch_check.py
Showing preview only (564K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6126 symbols across 409 files)
FILE: hypothesis-python/benchmark/graph.py
function plot_vega (line 19) | def plot_vega(vega_spec, data, *, to, parameters=None):
function _mean_difference_ci (line 37) | def _mean_difference_ci(n1, n2, *, confidence):
function _process_benchmark_data (line 52) | def _process_benchmark_data(data):
function plot (line 114) | def plot(data, out):
FILE: hypothesis-python/docs/_ext/hypothesis_linkcheck.py
function is_intersphinx_link (line 32) | def is_intersphinx_link(uri):
class HypothesisLinkChecker (line 40) | class HypothesisLinkChecker(HyperlinkAvailabilityChecker):
method is_ignored_uri (line 41) | def is_ignored_uri(self, uri: str) -> bool:
function on_builder_inited (line 52) | def on_builder_inited(app: Sphinx) -> None:
function setup (line 57) | def setup(app: Sphinx):
FILE: hypothesis-python/docs/_ext/hypothesis_redirects.py
function setup (line 43) | def setup(app: Sphinx) -> dict:
function init (line 54) | def init(app: Sphinx) -> Sequence | None:
class Reredirects (line 68) | class Reredirects:
method __init__ (line 69) | def __init__(self, app: Sphinx) -> None:
method grab_redirects (line 74) | def grab_redirects(self) -> Mapping[str, str]:
method docname_out_path (line 104) | def docname_out_path(self, docname: str, suffix: str) -> Sequence[str]:
method create_redirects (line 127) | def create_redirects(self, to_be_redirected: Mapping[str, str]) -> None:
method _contains_wildcard (line 154) | def _contains_wildcard(text: str) -> bool:
method _apply_placeholders (line 159) | def _apply_placeholders(source: str, target: str) -> str:
method _create_redirect_file (line 163) | def _create_redirect_file(self, at_path: Path, to_uri: str) -> None:
method _render_redirect_template (line 173) | def _render_redirect_template(self, to_uri: str) -> str:
function collect_redirects_for_linkcheck (line 183) | def collect_redirects_for_linkcheck(app):
FILE: hypothesis-python/docs/conf.py
class VersionRole (line 97) | class VersionRole(SphinxRole):
method __init__ (line 98) | def __init__(self, prefix):
method run (line 101) | def run(self):
function setup (line 110) | def setup(app):
FILE: hypothesis-python/examples/example_hypothesis_entrypoint/example_hypothesis_entrypoint.py
class MyCustomType (line 18) | class MyCustomType:
method __init__ (line 19) | def __init__(self, x: int):
function _hypothesis_setup_hook (line 24) | def _hypothesis_setup_hook():
FILE: hypothesis-python/examples/example_hypothesis_entrypoint/test_entrypoint.py
function test_registered_from_entrypoint (line 17) | def test_registered_from_entrypoint(x):
FILE: hypothesis-python/examples/test_basic.py
class Product (line 15) | class Product:
method __init__ (line 16) | def __init__(self, price: float) -> None:
method get_discount_price (line 19) | def get_discount_price(self, discount_percentage: float):
function test_a_discounted_price_is_not_higher_than_the_original_price (line 30) | def test_a_discounted_price_is_not_higher_than_the_original_price(
FILE: hypothesis-python/examples/test_binary_search.py
function binary_search (line 26) | def binary_search(ls, v):
function is_sorted (line 73) | def is_sorted(ls):
function test_insert_is_sorted (line 92) | def test_insert_is_sorted(ls, v):
function test_is_minimal (line 101) | def test_is_minimal(ls, v):
function test_inserts_into_same_place_twice (line 111) | def test_inserts_into_same_place_twice(ls, v):
FILE: hypothesis-python/examples/test_rle.py
function run_length_encode (line 28) | def run_length_encode(seq):
function run_length_decode (line 51) | def run_length_decode(seq):
function test_decodes_to_starting_sequence (line 67) | def test_decodes_to_starting_sequence(ls):
function test_duplicating_an_element_does_not_increase_length (line 77) | def test_duplicating_an_element_does_not_increase_length(ls, data):
FILE: hypothesis-python/src/_hypothesis_ftz_detector.py
function flush_to_zero (line 46) | def flush_to_zero() -> bool:
function run_in_process (line 51) | def run_in_process(fn: Callable[..., FTZCulprits], *args: object) -> FTZ...
function target (line 63) | def target(
function always_imported_modules (line 69) | def always_imported_modules() -> FTZCulprits:
function modules_imported_by (line 73) | def modules_imported_by(mod: str) -> FTZCulprits:
function identify_ftz_culprits (line 90) | def identify_ftz_culprits() -> str:
FILE: hypothesis-python/src/_hypothesis_pytestplugin.py
class StoringReporter (line 56) | class StoringReporter:
method __init__ (line 57) | def __init__(self, config):
method __call__ (line 65) | def __call__(self, msg):
function pytest_addoption (line 100) | def pytest_addoption(parser):
function _any_hypothesis_option (line 131) | def _any_hypothesis_option(config):
function pytest_report_header (line 134) | def pytest_report_header(config):
function pytest_configure (line 153) | def pytest_configure(config):
function pytest_runtest_call (line 190) | def pytest_runtest_call(item):
function _stash_get (line 325) | def _stash_get(config, key, default):
function pytest_runtest_makereport (line 336) | def pytest_runtest_makereport(item, call):
function pytest_terminal_summary (line 386) | def pytest_terminal_summary(terminalreporter):
function pytest_collection_modifyitems (line 424) | def pytest_collection_modifyitems(items):
function pytest_sessionstart (line 446) | def pytest_sessionstart(session):
function _ban_given_call (line 456) | def _ban_given_call(self, function):
function pytest_ignore_collect (line 473) | def pytest_ignore_collect(collection_path, config):
function load (line 491) | def load():
FILE: hypothesis-python/src/hypothesis/_settings.py
class Verbosity (line 65) | class Verbosity(Enum):
method _missing_ (line 98) | def _missing_(cls, value):
method __repr__ (line 114) | def __repr__(self) -> str:
method _int_value (line 118) | def _int_value(value: "Verbosity") -> int:
method __eq__ (line 130) | def __eq__(self, other: Any) -> bool:
method __gt__ (line 135) | def __gt__(self, other: Any) -> bool:
class Phase (line 142) | class Phase(Enum):
method _missing_ (line 179) | def _missing_(cls, value):
method __repr__ (line 202) | def __repr__(self) -> str:
class HealthCheckMeta (line 206) | class HealthCheckMeta(EnumMeta):
method __iter__ (line 207) | def __iter__(self):
class HealthCheck (line 213) | class HealthCheck(Enum, metaclass=HealthCheckMeta):
method _missing_ (line 258) | def _missing_(cls, value):
method __repr__ (line 284) | def __repr__(self) -> str:
method all (line 288) | def all(cls) -> list["HealthCheck"]:
class duration (line 382) | class duration(datetime.timedelta):
method __repr__ (line 385) | def __repr__(self) -> str:
function is_in_ci (line 409) | def is_in_ci() -> bool:
function _validate_choices (line 419) | def _validate_choices(name: str, value: T, *, choices: Sequence[object])...
function _validate_enum_value (line 426) | def _validate_enum_value(cls: Any, value: object, *, name: str) -> Any:
function _validate_max_examples (line 436) | def _validate_max_examples(max_examples: int) -> int:
function _validate_database (line 446) | def _validate_database(
function _validate_phases (line 460) | def _validate_phases(phases: Collection[Phase]) -> Sequence[Phase]:
function _validate_stateful_step_count (line 469) | def _validate_stateful_step_count(stateful_step_count: int) -> int:
function _validate_suppress_health_check (line 478) | def _validate_suppress_health_check(suppressions: object) -> tuple[Healt...
function _validate_deadline (line 494) | def _validate_deadline(
function _validate_backend (line 524) | def _validate_backend(backend: str) -> str:
class settingsMeta (line 536) | class settingsMeta(type):
method __init__ (line 537) | def __init__(cls, *args, **kwargs):
method default (line 541) | def default(cls) -> Optional["settings"]:
method __setattr__ (line 551) | def __setattr__(cls, name: str, value: object) -> None:
method __repr__ (line 566) | def __repr__(cls):
class settings (line 570) | class settings(metaclass=settingsMeta):
method __init__ (line 660) | def __init__(
method max_examples (line 755) | def max_examples(self):
method derandomize (line 782) | def derandomize(self):
method database (line 799) | def database(self):
method verbosity (line 837) | def verbosity(self):
method phases (line 884) | def phases(self):
method stateful_step_count (line 944) | def stateful_step_count(self):
method report_multiple_bugs (line 957) | def report_multiple_bugs(self):
method suppress_health_check (line 969) | def suppress_health_check(self):
method deadline (line 996) | def deadline(self):
method print_blob (line 1011) | def print_blob(self):
method backend (line 1021) | def backend(self):
method __call__ (line 1033) | def __call__(self, test: T) -> T:
method __setattr__ (line 1082) | def __setattr__(self, name: str, value: object) -> None:
method __repr__ (line 1087) | def __repr__(self) -> str:
method show_changed (line 1095) | def show_changed(self) -> str:
method register_profile (line 1104) | def register_profile(
method get_profile (line 1150) | def get_profile(name: str) -> "settings":
method load_profile (line 1162) | def load_profile(name: str) -> None:
method get_current_profile_name (line 1173) | def get_current_profile_name() -> str:
function local_settings (line 1188) | def local_settings(s: settings) -> Generator[settings, None, None]:
FILE: hypothesis-python/src/hypothesis/configuration.py
function set_hypothesis_home_dir (line 24) | def set_hypothesis_home_dir(directory: str | Path | None) -> None:
function storage_directory (line 29) | def storage_directory(*names: str, intent_to_write: bool = True) -> Path:
function check_sideeffect_during_initialization (line 47) | def check_sideeffect_during_initialization(
function notice_initialization_restarted (line 93) | def notice_initialization_restarted(*, warn: bool = True) -> None:
FILE: hypothesis-python/src/hypothesis/control.py
function _calling_function_location (line 33) | def _calling_function_location(what: str, frame: Any) -> str:
function reject (line 38) | def reject() -> NoReturn:
function assume (line 53) | def assume(condition: Literal[False] | None) -> NoReturn: ...
function assume (line 55) | def assume(condition: object) -> Literal[True]: ...
function assume (line 58) | def assume(condition: object) -> Literal[True]:
function currently_in_test_context (line 84) | def currently_in_test_context() -> bool:
function current_build_context (line 95) | def current_build_context() -> "BuildContext":
function deprecate_random_in_strategy (line 103) | def deprecate_random_in_strategy(fmt, *args):
class BuildContext (line 140) | class BuildContext:
method __init__ (line 141) | def __init__(
method track_arg_label (line 164) | def track_arg_label(self, label: str) -> Generator[ArgLabelsT, None, N...
method record_call (line 187) | def record_call(
method prep_args_kwargs_from_strategies (line 207) | def prep_args_kwargs_from_strategies(
method __enter__ (line 224) | def __enter__(self):
method __exit__ (line 229) | def __exit__(self, exc_type, exc_value, tb):
function cleanup (line 243) | def cleanup(teardown):
function should_note (line 258) | def should_note():
function note (line 265) | def note(value: object) -> None:
function event (line 273) | def event(value: str, payload: str | int | float = "") -> None:
function _event_to_string (line 296) | def _event_to_string(event, *, allowed_types=str, avoid_realization):
function target (line 319) | def target(observation: int | float, *, label: str = "") -> int | float:
FILE: hypothesis-python/src/hypothesis/core.py
class Example (line 162) | class Example:
class ReportableError (line 171) | class ReportableError:
class example (line 179) | class example:
method __init__ (line 231) | def __init__(self, *args: Any, **kwargs: Any) -> None:
method __call__ (line 242) | def __call__(self, test: TestFunc) -> TestFunc:
method xfail (line 248) | def xfail(
method via (line 308) | def via(self, whence: str, /) -> "example":
function seed (line 338) | def seed(seed: Hashable) -> Callable[[TestFunc], TestFunc]:
function reproduce_failure (line 383) | def reproduce_failure(version: str, blob: bytes) -> Callable[[TestFunc],...
function reproduction_decorator (line 414) | def reproduction_decorator(choices: Iterable[ChoiceT]) -> str:
function encode_failure (line 418) | def encode_failure(choices: Iterable[ChoiceT]) -> bytes:
function decode_failure (line 428) | def decode_failure(blob: bytes) -> Sequence[ChoiceT]:
function _invalid (line 456) | def _invalid(message, *, exc=InvalidArgument, test, given_kwargs):
function is_invalid_test (line 470) | def is_invalid_test(test, original_sig, given_arguments, given_kwargs):
function execute_explicit_examples (line 535) | def execute_explicit_examples(state, wrapped_test, arguments, kwargs, or...
function get_random_for_wrapped_test (line 708) | def get_random_for_wrapped_test(test, wrapped_test):
class Stuff (line 729) | class Stuff:
function process_arguments_to_given (line 736) | def process_arguments_to_given(
function skip_exceptions_to_reraise (line 772) | def skip_exceptions_to_reraise():
function failure_exceptions_to_catch (line 792) | def failure_exceptions_to_catch() -> tuple[type[BaseException], ...]:
function new_given_signature (line 808) | def new_given_signature(original_sig, given_kwargs):
function default_executor (line 823) | def default_executor(data, function):
function get_executor (line 827) | def get_executor(runner):
function _flatten_group (line 857) | def _flatten_group(excgroup: BaseExceptionGroup[T]) -> list[T]:
function unwrap_markers_from_group (line 868) | def unwrap_markers_from_group() -> Generator[None, None, None]:
class StateForActualGivenExecution (line 917) | class StateForActualGivenExecution:
method __init__ (line 918) | def __init__(
method test_identifier (line 957) | def test_identifier(self) -> str:
method _should_trace (line 962) | def _should_trace(self):
method execute_once (line 975) | def execute_once(
method _flaky_replay_to_failure (line 1182) | def _flaky_replay_to_failure(
method _execute_once_for_engine (line 1199) | def _execute_once_for_engine(self, data: ConjectureData) -> None:
method _deliver_information_message (line 1368) | def _deliver_information_message(
method run_engine (line 1381) | def run_engine(self):
function _simplify_explicit_errors (line 1588) | def _simplify_explicit_errors(errors: list[ReportableError]) -> list[Rep...
function _raise_to_user (line 1622) | def _raise_to_user(
function fake_subTest (line 1660) | def fake_subTest(self, msg=None, **__):
class HypothesisHandle (line 1679) | class HypothesisHandle:
method fuzz_one_input (line 1699) | def fuzz_one_input(
function given (line 1793) | def given(
function given (line 1802) | def given(
function given (line 1811) | def given(
function given (line 1819) | def given(
function find (line 2373) | def find(
FILE: hypothesis-python/src/hypothesis/database.py
function _usable_dir (line 67) | def _usable_dir(path: StrPathT) -> bool:
function _db_for_path (line 85) | def _db_for_path(
class _EDMeta (line 112) | class _EDMeta(abc.ABCMeta):
method __call__ (line 113) | def __call__(self, *args: Any, **kwargs: Any) -> "ExampleDatabase":
class ExampleDatabase (line 171) | class ExampleDatabase(metaclass=_EDMeta):
method __init__ (line 230) | def __init__(self) -> None:
method save (line 234) | def save(self, key: bytes, value: bytes) -> None:
method fetch (line 242) | def fetch(self, key: bytes) -> Iterable[bytes]:
method delete (line 247) | def delete(self, key: bytes, value: bytes) -> None:
method move (line 254) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
method add_listener (line 270) | def add_listener(self, f: ListenerT, /) -> None:
method remove_listener (line 294) | def remove_listener(self, f: ListenerT, /) -> None:
method clear_listeners (line 306) | def clear_listeners(self) -> None:
method _broadcast_change (line 313) | def _broadcast_change(self, event: ListenerEventT) -> None:
method _start_listening (line 334) | def _start_listening(self) -> None:
method _stop_listening (line 351) | def _stop_listening(self) -> None:
class InMemoryExampleDatabase (line 367) | class InMemoryExampleDatabase(ExampleDatabase):
method __init__ (line 376) | def __init__(self) -> None:
method __repr__ (line 380) | def __repr__(self) -> str:
method __eq__ (line 383) | def __eq__(self, other: object) -> bool:
method fetch (line 386) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 389) | def save(self, key: bytes, value: bytes) -> None:
method delete (line 398) | def delete(self, key: bytes, value: bytes) -> None:
method _start_listening (line 407) | def _start_listening(self) -> None:
method _stop_listening (line 413) | def _stop_listening(self) -> None:
function _hash (line 417) | def _hash(key: bytes) -> str:
class DirectoryBasedExampleDatabase (line 421) | class DirectoryBasedExampleDatabase(ExampleDatabase):
method __init__ (line 444) | def __init__(self, path: StrPathT) -> None:
method __repr__ (line 450) | def __repr__(self) -> str:
method __eq__ (line 453) | def __eq__(self, other: object) -> bool:
method _key_path (line 458) | def _key_path(self, key: bytes) -> Path:
method _value_path (line 466) | def _value_path(self, key: bytes, value: bytes) -> Path:
method fetch (line 469) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 484) | def save(self, key: bytes, value: bytes) -> None:
method move (line 521) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
method delete (line 539) | def delete(self, key: bytes, value: bytes) -> None:
method _start_listening (line 557) | def _start_listening(self) -> None:
method _stop_listening (line 669) | def _stop_listening(self) -> None:
class ReadOnlyDatabase (line 676) | class ReadOnlyDatabase(ExampleDatabase):
method __init__ (line 687) | def __init__(self, db: ExampleDatabase) -> None:
method __repr__ (line 692) | def __repr__(self) -> str:
method __eq__ (line 695) | def __eq__(self, other: object) -> bool:
method fetch (line 698) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 701) | def save(self, key: bytes, value: bytes) -> None:
method delete (line 704) | def delete(self, key: bytes, value: bytes) -> None:
method _start_listening (line 707) | def _start_listening(self) -> None:
method _stop_listening (line 711) | def _stop_listening(self) -> None:
class MultiplexedDatabase (line 715) | class MultiplexedDatabase(ExampleDatabase):
method __init__ (line 741) | def __init__(self, *dbs: ExampleDatabase) -> None:
method __repr__ (line 746) | def __repr__(self) -> str:
method __eq__ (line 749) | def __eq__(self, other: object) -> bool:
method fetch (line 754) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 762) | def save(self, key: bytes, value: bytes) -> None:
method delete (line 766) | def delete(self, key: bytes, value: bytes) -> None:
method move (line 770) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
method _start_listening (line 774) | def _start_listening(self) -> None:
method _stop_listening (line 778) | def _stop_listening(self) -> None:
class GitHubArtifactDatabase (line 783) | class GitHubArtifactDatabase(ExampleDatabase):
method __init__ (line 853) | def __init__(
method __repr__ (line 895) | def __repr__(self) -> str:
method __eq__ (line 901) | def __eq__(self, other: object) -> bool:
method _prepare_for_io (line 910) | def _prepare_for_io(self) -> None:
method _initialize_db (line 952) | def _initialize_db(self) -> None:
method _get_bytes (line 1007) | def _get_bytes(self, url: str) -> bytes | None: # pragma: no cover
method _fetch_artifact (line 1049) | def _fetch_artifact(self) -> Path | None: # pragma: no cover
method _key_path (line 1090) | def _key_path(key: bytes) -> PurePath:
method fetch (line 1093) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 1115) | def save(self, key: bytes, value: bytes) -> None:
method move (line 1118) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
method delete (line 1121) | def delete(self, key: bytes, value: bytes) -> None:
class BackgroundWriteDatabase (line 1125) | class BackgroundWriteDatabase(ExampleDatabase):
method __init__ (line 1132) | def __init__(self, db: ExampleDatabase) -> None:
method _ensure_thread (line 1138) | def _ensure_thread(self):
method __repr__ (line 1146) | def __repr__(self) -> str:
method __eq__ (line 1149) | def __eq__(self, other: object) -> bool:
method _worker (line 1152) | def _worker(self) -> None:
method _join (line 1158) | def _join(self, timeout: float | None = None) -> None:
method fetch (line 1164) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 1168) | def save(self, key: bytes, value: bytes) -> None:
method delete (line 1172) | def delete(self, key: bytes, value: bytes) -> None:
method move (line 1176) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
method _start_listening (line 1180) | def _start_listening(self) -> None:
method _stop_listening (line 1183) | def _stop_listening(self) -> None:
function _pack_uleb128 (line 1187) | def _pack_uleb128(value: int) -> bytes:
function _unpack_uleb128 (line 1211) | def _unpack_uleb128(buffer: bytes) -> tuple[int, int]:
function choices_to_bytes (line 1226) | def choices_to_bytes(choices: Iterable[ChoiceT], /) -> bytes:
function _choices_from_bytes (line 1266) | def _choices_from_bytes(buffer: bytes, /) -> tuple[ChoiceT, ...]:
function choices_from_bytes (line 1297) | def choices_from_bytes(buffer: bytes, /) -> tuple[ChoiceT, ...] | None:
FILE: hypothesis-python/src/hypothesis/entry_points.py
function run (line 22) | def run() -> None:
FILE: hypothesis-python/src/hypothesis/errors.py
class HypothesisException (line 17) | class HypothesisException(Exception):
class _Trimmable (line 21) | class _Trimmable(HypothesisException):
class UnsatisfiedAssumption (line 25) | class UnsatisfiedAssumption(HypothesisException):
method __init__ (line 31) | def __init__(self, reason: str | None = None) -> None:
class NoSuchExample (line 35) | class NoSuchExample(HypothesisException):
method __init__ (line 42) | def __init__(self, condition_string: str, extra: str = "") -> None:
class Unsatisfiable (line 46) | class Unsatisfiable(_Trimmable):
class ChoiceTooLarge (line 59) | class ChoiceTooLarge(HypothesisException):
class Flaky (line 63) | class Flaky(_Trimmable):
class FlakyReplay (line 74) | class FlakyReplay(Flaky):
method __init__ (line 82) | def __init__(self, reason, interesting_origins=None):
class FlakyStrategyDefinition (line 88) | class FlakyStrategyDefinition(Flaky):
class _WrappedBaseException (line 103) | class _WrappedBaseException(Exception):
class FlakyFailure (line 107) | class FlakyFailure(ExceptionGroup, Flaky):
method __new__ (line 128) | def __new__(cls, msg, group):
method derive (line 144) | def derive(self, excs):
class FlakyBackendFailure (line 148) | class FlakyBackendFailure(FlakyFailure):
class InvalidArgument (line 159) | class InvalidArgument(_Trimmable, TypeError):
class ResolutionFailed (line 164) | class ResolutionFailed(InvalidArgument):
class InvalidState (line 173) | class InvalidState(HypothesisException):
class InvalidDefinition (line 177) | class InvalidDefinition(_Trimmable, TypeError):
class HypothesisWarning (line 182) | class HypothesisWarning(HypothesisException, Warning):
class FailedHealthCheck (line 186) | class FailedHealthCheck(_Trimmable):
class NonInteractiveExampleWarning (line 190) | class NonInteractiveExampleWarning(HypothesisWarning):
class HypothesisDeprecationWarning (line 199) | class HypothesisDeprecationWarning(HypothesisWarning, FutureWarning):
class HypothesisSideeffectWarning (line 211) | class HypothesisSideeffectWarning(HypothesisWarning):
class Frozen (line 218) | class Frozen(HypothesisException):
function __getattr__ (line 223) | def __getattr__(name: str) -> Any:
class DeadlineExceeded (line 240) | class DeadlineExceeded(_Trimmable):
method __init__ (line 246) | def __init__(self, runtime: timedelta, deadline: timedelta) -> None:
method __reduce__ (line 256) | def __reduce__(
class StopTest (line 262) | class StopTest(BaseException):
method __init__ (line 267) | def __init__(self, testcounter: int) -> None:
class DidNotReproduce (line 272) | class DidNotReproduce(HypothesisException):
class Found (line 276) | class Found(HypothesisException):
class RewindRecursive (line 280) | class RewindRecursive(Exception):
method __init__ (line 283) | def __init__(self, target: object) -> None:
class SmallSearchSpaceWarning (line 287) | class SmallSearchSpaceWarning(HypothesisWarning):
class BackendCannotProceed (line 296) | class BackendCannotProceed(HypothesisException):
method __init__ (line 320) | def __init__(self, scope: CannotProceedScopeT = "other", /) -> None:
FILE: hypothesis-python/src/hypothesis/extra/_array_helpers.py
class BroadcastableShapes (line 56) | class BroadcastableShapes(NamedTuple):
function check_argument (line 62) | def check_argument(condition, fail_message, *f_args, **f_kwargs):
function order_check (line 68) | def order_check(name, floor, min_, max_):
function check_valid_dims (line 84) | def check_valid_dims(dims, name):
function array_shapes (line 93) | def array_shapes(
function valid_tuple_axes (line 131) | def valid_tuple_axes(
function broadcastable_shapes (line 176) | def broadcastable_shapes(
class _GUfuncSig (line 296) | class _GUfuncSig(NamedTuple):
function _hypothesis_parse_gufunc_signature (line 301) | def _hypothesis_parse_gufunc_signature(signature):
function mutually_broadcastable_shapes (line 357) | def mutually_broadcastable_shapes(
class MutuallyBroadcastableShapesStrategy (line 496) | class MutuallyBroadcastableShapesStrategy(st.SearchStrategy):
method __init__ (line 497) | def __init__(
method do_draw (line 519) | def do_draw(self, data):
method _draw_core_dimensions (line 546) | def _draw_core_dimensions(self, data):
method _draw_loop_dimensions (line 568) | def _draw_loop_dimensions(self, data, use=None):
class BasicIndexStrategy (line 639) | class BasicIndexStrategy(st.SearchStrategy):
method __init__ (line 640) | def __init__(
method do_draw (line 660) | def do_draw(self, data):
FILE: hypothesis-python/src/hypothesis/extra/_patching.py
function dedent (line 61) | def dedent(text: str) -> tuple[str, str]:
function indent (line 68) | def indent(text: str, prefix: str) -> str:
class AddExamplesCodemod (line 72) | class AddExamplesCodemod(VisitorBasedCodemodCommand):
method __init__ (line 75) | def __init__(
method __call_node_to_example_dec (line 111) | def __call_node_to_example_dec(
method leave_FunctionDef (line 147) | def leave_FunctionDef(
function get_patch_for (line 162) | def get_patch_for(
function _get_patch_for (line 192) | def _get_patch_for(
function make_patch (line 294) | def make_patch(
function save_patch (line 324) | def save_patch(patch: str, *, slug: str = "") -> Path: # pragma: no cover
function gc_patches (line 335) | def gc_patches(slug: str = "") -> None: # pragma: no cover
FILE: hypothesis-python/src/hypothesis/extra/array_api.py
function check_xp_attributes (line 81) | def check_xp_attributes(xp: Any, attributes: list[str]) -> None:
function partition_attributes_and_stubs (line 90) | def partition_attributes_and_stubs(
function warn_on_missing_dtypes (line 104) | def warn_on_missing_dtypes(xp: Any, stubs: list[str]) -> None:
function find_castable_builtin_for_dtype (line 114) | def find_castable_builtin_for_dtype(
function dtype_from_name (line 160) | def dtype_from_name(xp: Any, name: str) -> Any:
function _from_dtype (line 175) | def _from_dtype(
class ArrayStrategy (line 307) | class ArrayStrategy(st.SearchStrategy):
method __init__ (line 308) | def __init__(
method check_set_value (line 322) | def check_set_value(self, val, val_0d, strategy):
method do_draw (line 349) | def do_draw(self, data):
function _arrays (line 451) | def _arrays(
function check_dtypes (line 581) | def check_dtypes(xp: Any, dtypes: list[DataType], stubs: list[str]) -> N...
function _scalar_dtypes (line 593) | def _scalar_dtypes(xp: Any, api_version: NominalVersion) -> st.SearchStr...
function _boolean_dtypes (line 598) | def _boolean_dtypes(xp: Any) -> st.SearchStrategy[DataType]:
function _real_dtypes (line 608) | def _real_dtypes(xp: Any) -> st.SearchStrategy[DataType]:
function _numeric_dtypes (line 617) | def _numeric_dtypes(
function check_valid_sizes (line 628) | def check_valid_sizes(
function numeric_dtype_names (line 643) | def numeric_dtype_names(base_name: str, sizes: Sequence[int]) -> Iterato...
function _integer_dtypes (line 653) | def _integer_dtypes(
function _unsigned_integer_dtypes (line 671) | def _unsigned_integer_dtypes(
function _floating_dtypes (line 691) | def _floating_dtypes(
function _complex_dtypes (line 709) | def _complex_dtypes(
function valid_tuple_axes (line 728) | def valid_tuple_axes(*args, **kwargs):
function mutually_broadcastable_shapes (line 742) | def mutually_broadcastable_shapes(
function indices (line 765) | def indices(
function make_strategies_namespace (line 842) | def make_strategies_namespace(
class FloatInfo (line 1082) | class FloatInfo(NamedTuple):
function mock_finfo (line 1089) | def mock_finfo(dtype: DataType) -> FloatInfo:
FILE: hypothesis-python/src/hypothesis/extra/cli.py
function main (line 60) | def main():
function main (line 74) | def main():
function obj_name (line 77) | def obj_name(s: str) -> object:
function _refactor (line 157) | def _refactor(func, fname):
function codemod (line 184) | def codemod(path):
function write (line 286) | def write(func, writer, except_, style, annotate): # \b disables autowrap
FILE: hypothesis-python/src/hypothesis/extra/codemods.py
function refactor (line 52) | def refactor(code: str) -> str:
function match_qualname (line 73) | def match_qualname(name):
class HypothesisFixComplexMinMagnitude (line 85) | class HypothesisFixComplexMinMagnitude(VisitorBasedCodemodCommand):
method leave_Arg (line 100) | def leave_Arg(self, original_node, updated_node):
function get_fn (line 109) | def get_fn(import_path):
class HypothesisFixPositionalKeywonlyArgs (line 114) | class HypothesisFixPositionalKeywonlyArgs(VisitorBasedCodemodCommand):
method leave_Call (line 174) | def leave_Call(self, original_node, updated_node):
class HypothesisFixHealthCheckAll (line 225) | class HypothesisFixHealthCheckAll(VisitorBasedCodemodCommand):
method replace_healthcheck (line 231) | def replace_healthcheck(self, original_node, updated_node):
class HypothesisFixCharactersArguments (line 238) | class HypothesisFixCharactersArguments(VisitorBasedCodemodCommand):
method fn (line 270) | def fn(self, original_node, updated_node):
FILE: hypothesis-python/src/hypothesis/extra/dateutil.py
function __zone_sort_key (line 32) | def __zone_sort_key(zone):
function timezones (line 44) | def timezones() -> st.SearchStrategy[dt.tzinfo]:
FILE: hypothesis-python/src/hypothesis/extra/django/_fields.py
function numeric_bounds_from_validators (line 42) | def numeric_bounds_from_validators(
function integers_for_field (line 53) | def integers_for_field(min_value, max_value):
function timezones (line 61) | def timezones():
function register_for (line 113) | def register_for(field_type):
function _for_datetime (line 123) | def _for_datetime(field):
function using_sqlite (line 134) | def using_sqlite():
function _for_model_time (line 147) | def _for_model_time(field):
function _for_form_time (line 155) | def _for_form_time(field):
function _for_duration (line 162) | def _for_duration(field):
function _for_slug (line 172) | def _for_slug(field):
function _for_model_ip (line 184) | def _for_model_ip(field):
function _for_form_ip (line 193) | def _for_form_ip(field):
function _for_decimal (line 208) | def _for_decimal(field):
function length_bounds_from_validators (line 218) | def length_bounds_from_validators(field):
function _for_binary (line 230) | def _for_binary(field):
function _for_text (line 241) | def _for_text(field):
function _for_form_boolean (line 278) | def _for_form_boolean(field):
function _model_choice_strategy (line 284) | def _model_choice_strategy(field):
function _for_model_choice (line 323) | def _for_model_choice(field):
function _for_model_multiple_choice (line 328) | def _for_model_multiple_choice(field):
function register_field_strategy (line 333) | def register_field_strategy(
function from_field (line 356) | def from_field(field: F) -> st.SearchStrategy[F | None]:
FILE: hypothesis-python/src/hypothesis/extra/django/_impl.py
class HypothesisTestCase (line 29) | class HypothesisTestCase:
method setup_example (line 30) | def setup_example(self):
method teardown_example (line 33) | def teardown_example(self, example):
method __call__ (line 36) | def __call__(self, result=None):
class SimpleTestCase (line 44) | class SimpleTestCase(HypothesisTestCase, dt.SimpleTestCase):
class TestCase (line 48) | class TestCase(HypothesisTestCase, dt.TestCase):
class TransactionTestCase (line 52) | class TransactionTestCase(HypothesisTestCase, dt.TransactionTestCase):
class LiveServerTestCase (line 56) | class LiveServerTestCase(HypothesisTestCase, dt.LiveServerTestCase):
class StaticLiveServerTestCase (line 60) | class StaticLiveServerTestCase(HypothesisTestCase, dst.StaticLiveServerT...
function from_model (line 65) | def from_model(
function _models_impl (line 126) | def _models_impl(draw, strat):
function from_form (line 135) | def from_form(
function _forms_impl (line 225) | def _forms_impl(draw, strat):
FILE: hypothesis-python/src/hypothesis/extra/dpcontracts.py
function fulfill (line 26) | def fulfill(contract_func):
FILE: hypothesis-python/src/hypothesis/extra/ghostwriter.py
function _dedupe_exceptions (line 151) | def _dedupe_exceptions(exc: tuple[type[Exception], ...]) -> tuple[type[E...
function _check_except (line 162) | def _check_except(except_: Except) -> tuple[type[Exception], ...]:
function _exception_string (line 179) | def _exception_string(except_: tuple[type[Exception], ...]) -> tuple[Imp...
function _check_style (line 195) | def _check_style(style: str) -> None:
function _exceptions_from_docstring (line 200) | def _exceptions_from_docstring(doc: str) -> tuple[type[Exception], ...]:
function _type_from_doc_fragment (line 218) | def _type_from_doc_fragment(token: str) -> type | None:
function _strip_typevars (line 246) | def _strip_typevars(type_):
function _strategy_for (line 253) | def _strategy_for(param: inspect.Parameter, docstring: str) -> st.Search...
function _guess_strategy_by_argname (line 336) | def _guess_strategy_by_argname(name: str) -> st.SearchStrategy:
function _get_params_builtin_fn (line 433) | def _get_params_builtin_fn(func: Callable) -> list[inspect.Parameter]:
function _get_params_ufunc (line 465) | def _get_params_ufunc(func: Callable) -> list[inspect.Parameter]:
function _get_params (line 480) | def _get_params(func: Callable) -> dict[str, inspect.Parameter]:
function _params_to_dict (line 507) | def _params_to_dict(
function _with_any_registered (line 515) | def _with_any_registered():
function _get_strategies (line 533) | def _get_strategies(
function _assert_eq (line 578) | def _assert_eq(style: str, a: str, b: str) -> str:
function _imports_for_object (line 587) | def _imports_for_object(obj):
function _imports_for_strategy (line 611) | def _imports_for_strategy(strategy):
function _valid_syntax_repr (line 667) | def _valid_syntax_repr(strategy):
function _get_module_helper (line 727) | def _get_module_helper(obj):
function _get_module (line 747) | def _get_module(obj):
function _get_qualname (line 762) | def _get_qualname(obj: Any, *, include_module: bool = False) -> str:
function _write_call (line 771) | def _write_call(
function _st_strategy_names (line 807) | def _st_strategy_names(s: str) -> str:
function _make_test_body (line 817) | def _make_test_body(
function _annotate_args (line 885) | def _annotate_args(
class _AnnotationData (line 909) | class _AnnotationData(NamedTuple):
function _parameters_to_annotation_name (line 914) | def _parameters_to_annotation_name(
function _join_generics (line 937) | def _join_generics(
function _join_argument_annotations (line 963) | def _join_argument_annotations(
function _parameter_to_annotation (line 978) | def _parameter_to_annotation(parameter: Any) -> _AnnotationData | None:
function _are_annotations_used (line 1062) | def _are_annotations_used(*functions: Callable) -> bool:
function _make_test (line 1074) | def _make_test(imports: ImportSet, body: str) -> str:
function _is_probably_ufunc (line 1102) | def _is_probably_ufunc(obj):
function _get_testable_functions (line 1144) | def _get_testable_functions(thing: object) -> dict[str, Callable]:
function magic (line 1198) | def magic(
function fuzz (line 1355) | def fuzz(
function idempotent (line 1419) | def idempotent(
function _make_roundtrip_body (line 1483) | def _make_roundtrip_body(funcs, except_, style, annotate):
function roundtrip (line 1503) | def roundtrip(
function _get_varnames (line 1536) | def _get_varnames(funcs):
function _make_equiv_body (line 1545) | def _make_equiv_body(funcs, except_, style, annotate):
function _make_equiv_errors_body (line 1585) | def _make_equiv_errors_body(funcs, except_, style, annotate):
function equivalent (line 1620) | def equivalent(
function binary_operation (line 1668) | def binary_operation(
function _make_binop_body (line 1735) | def _make_binop_body(
function ufunc (line 1870) | def ufunc(
function _make_ufunc_body (line 1901) | def _make_ufunc_body(func, *, except_, style, annotate):
FILE: hypothesis-python/src/hypothesis/extra/lark.py
function get_terminal_names (line 41) | def get_terminal_names(
class LarkStrategy (line 57) | class LarkStrategy(st.SearchStrategy):
method __init__ (line 63) | def __init__(
method do_draw (line 157) | def do_draw(self, data: ConjectureData) -> str:
method rule_label (line 163) | def rule_label(self, name: str) -> int:
method draw_symbol (line 171) | def draw_symbol(
method gen_ignore (line 189) | def gen_ignore(self, data: ConjectureData, draw_state: list[str]) -> N...
method calc_has_reusable_values (line 194) | def calc_has_reusable_values(self, recur):
function check_explicit (line 198) | def check_explicit(name):
function from_lark (line 208) | def from_lark(
FILE: hypothesis-python/src/hypothesis/extra/numpy.py
function _try_import (line 65) | def _try_import(mod_name: str, attr_name: str) -> Any:
function from_dtype (line 114) | def from_dtype(
class ArrayStrategy (line 237) | class ArrayStrategy(st.SearchStrategy):
method __init__ (line 238) | def __init__(self, element_strategy, shape, dtype, fill, unique):
method __repr__ (line 248) | def __repr__(self):
method set_element (line 254) | def set_element(self, val, result, idx, *, fill=False):
method do_draw (line 308) | def do_draw(self, data):
function fill_for (line 431) | def fill_for(elements, unique, fill, name=""):
function arrays (line 447) | def arrays(
function arrays (line 458) | def arrays(
function arrays (line 469) | def arrays(
function scalar_dtypes (line 593) | def scalar_dtypes() -> st.SearchStrategy[np.dtype]:
function defines_dtype_strategy (line 606) | def defines_dtype_strategy(strat: T) -> T:
function boolean_dtypes (line 616) | def boolean_dtypes() -> st.SearchStrategy["np.dtype[np.bool_]"]:
function dtype_factory (line 621) | def dtype_factory(kind, sizes, valid_sizes, endianness):
function unsigned_integer_dtypes (line 651) | def unsigned_integer_dtypes(
function unsigned_integer_dtypes (line 659) | def unsigned_integer_dtypes(
function unsigned_integer_dtypes (line 667) | def unsigned_integer_dtypes(
function unsigned_integer_dtypes (line 675) | def unsigned_integer_dtypes(
function unsigned_integer_dtypes (line 683) | def unsigned_integer_dtypes(
function unsigned_integer_dtypes (line 691) | def unsigned_integer_dtypes(
function integer_dtypes (line 714) | def integer_dtypes(
function integer_dtypes (line 722) | def integer_dtypes(
function integer_dtypes (line 730) | def integer_dtypes(
function integer_dtypes (line 738) | def integer_dtypes(
function integer_dtypes (line 746) | def integer_dtypes(
function integer_dtypes (line 754) | def integer_dtypes(
function floating_dtypes (line 773) | def floating_dtypes(
function floating_dtypes (line 781) | def floating_dtypes(
function floating_dtypes (line 789) | def floating_dtypes(
function floating_dtypes (line 797) | def floating_dtypes(
function floating_dtypes (line 805) | def floating_dtypes(
function floating_dtypes (line 813) | def floating_dtypes(
function complex_number_dtypes (line 835) | def complex_number_dtypes(
function complex_number_dtypes (line 843) | def complex_number_dtypes(
function complex_number_dtypes (line 851) | def complex_number_dtypes(
function complex_number_dtypes (line 859) | def complex_number_dtypes(
function complex_number_dtypes (line 867) | def complex_number_dtypes(
function validate_time_slice (line 885) | def validate_time_slice(max_period, min_period):
function datetime64_dtypes (line 911) | def datetime64_dtypes(
function timedelta64_dtypes (line 925) | def timedelta64_dtypes(
function byte_string_dtypes (line 939) | def byte_string_dtypes(
function unicode_string_dtypes (line 954) | def unicode_string_dtypes(
function _no_title_is_name_of_a_titled_field (line 968) | def _no_title_is_name_of_a_titled_field(ls):
function array_dtypes (line 981) | def array_dtypes(
function nested_dtypes (line 1017) | def nested_dtypes(
function valid_tuple_axes (line 1039) | def valid_tuple_axes(*args, **kwargs):
function mutually_broadcastable_shapes (line 1054) | def mutually_broadcastable_shapes(*args, **kwargs):
function basic_indices (line 1100) | def basic_indices(
function basic_indices (line 1113) | def basic_indices(
function basic_indices (line 1124) | def basic_indices(
function basic_indices (line 1135) | def basic_indices(
function basic_indices (line 1146) | def basic_indices(
function integer_array_indices (line 1230) | def integer_array_indices(
function integer_array_indices (line 1238) | def integer_array_indices(
function integer_array_indices (line 1247) | def integer_array_indices(
function _unpack_dtype (line 1317) | def _unpack_dtype(dtype):
function _dtype_from_args (line 1331) | def _dtype_from_args(args):
function _from_type (line 1348) | def _from_type(thing: type[Ex]) -> st.SearchStrategy[Ex] | None:
FILE: hypothesis-python/src/hypothesis/extra/pandas/impl.py
function dtype_for_elements_strategy (line 43) | def dtype_for_elements_strategy(s):
function infer_dtype_if_necessary (line 50) | def infer_dtype_if_necessary(dtype, values, elements, draw):
function elements_and_dtype (line 57) | def elements_and_dtype(elements, dtype, source=None):
class ValueIndexStrategy (line 143) | class ValueIndexStrategy(st.SearchStrategy):
method __init__ (line 144) | def __init__(self, elements, dtype, min_size, max_size, unique, name):
method do_draw (line 153) | def do_draw(self, data):
function range_indexes (line 187) | def range_indexes(
function indexes (line 214) | def indexes(
function series (line 257) | def series(
class column (line 367) | class column(Generic[Ex]):
function columns (line 391) | def columns(
function data_frames (line 419) | def data_frames(
FILE: hypothesis-python/src/hypothesis/extra/pytz.py
function timezones (line 39) | def timezones() -> st.SearchStrategy[dt.tzinfo]:
FILE: hypothesis-python/src/hypothesis/extra/redis.py
class RedisExampleDatabase (line 24) | class RedisExampleDatabase(ExampleDatabase):
method __init__ (line 36) | def __init__(
method __repr__ (line 55) | def __repr__(self) -> str:
method __eq__ (line 60) | def __eq__(self, other: object) -> bool:
method _pipeline (line 69) | def _pipeline(
method _publish (line 92) | def _publish(self, event):
method _encode (line 96) | def _encode(self, value: bytes) -> str:
method _decode (line 99) | def _decode(self, value: str) -> bytes:
method fetch (line 102) | def fetch(self, key: bytes) -> Iterable[bytes]:
method save (line 107) | def save(self, key: bytes, value: bytes) -> None:
method delete (line 111) | def delete(self, key: bytes, value: bytes) -> None:
method move (line 115) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
method _handle_message (line 132) | def _handle_message(self, message: dict) -> None:
method _start_listening (line 142) | def _start_listening(self) -> None:
method _stop_listening (line 146) | def _stop_listening(self) -> None:
FILE: hypothesis-python/src/hypothesis/internal/cache.py
class Entry (line 23) | class Entry(Generic[K, V]):
method sort_key (line 30) | def sort_key(self) -> tuple[int, ...]:
class GenericCache (line 40) | class GenericCache(Generic[K, V]):
method __init__ (line 65) | def __init__(self, max_size: int):
method keys_to_indices (line 79) | def keys_to_indices(self) -> dict[K, int]:
method data (line 87) | def data(self) -> list[Entry[K, V]]:
method __len__ (line 94) | def __len__(self) -> int:
method __contains__ (line 98) | def __contains__(self, key: K) -> bool:
method __getitem__ (line 101) | def __getitem__(self, key: K) -> V:
method __setitem__ (line 107) | def __setitem__(self, key: K, value: V) -> None:
method __iter__ (line 138) | def __iter__(self):
method pin (line 141) | def pin(self, key: K, value: V) -> None:
method unpin (line 155) | def unpin(self, key: K) -> None:
method is_pinned (line 166) | def is_pinned(self, key: K) -> bool:
method clear (line 171) | def clear(self) -> None:
method __repr__ (line 176) | def __repr__(self) -> str:
method new_entry (line 179) | def new_entry(self, key: K, value: V) -> int:
method on_access (line 187) | def on_access(self, key: K, value: V, score: Any) -> Any:
method on_evict (line 195) | def on_evict(self, key: K, value: V, score: Any) -> Any:
method check_valid (line 199) | def check_valid(self) -> None:
method __entry_was_accessed (line 212) | def __entry_was_accessed(self, i: int) -> None:
method __swap (line 222) | def __swap(self, i: int, j: int) -> None:
method __balance (line 229) | def __balance(self, i: int) -> None:
method __out_of_order (line 250) | def __out_of_order(self, i: int, j: int) -> bool:
class LRUReusedCache (line 259) | class LRUReusedCache(GenericCache[K, V]):
method __init__ (line 276) | def __init__(self, max_size: int):
method tick (line 280) | def tick(self) -> int:
method new_entry (line 284) | def new_entry(self, key: K, value: V) -> Any:
method on_access (line 287) | def on_access(self, key: K, value: V, score: Any) -> Any:
class LRUCache (line 291) | class LRUCache(Generic[K, V]):
method __init__ (line 313) | def __init__(self, max_size: int) -> None:
method cache (line 319) | def cache(self) -> OrderedDict[K, V]:
method __setitem__ (line 326) | def __setitem__(self, key: K, value: V) -> None:
method __getitem__ (line 333) | def __getitem__(self, key: K) -> V:
method __iter__ (line 338) | def __iter__(self):
method __len__ (line 341) | def __len__(self) -> int:
method __contains__ (line 344) | def __contains__(self, key: K) -> bool:
method check_valid (line 348) | def check_valid(self) -> None:
FILE: hypothesis-python/src/hypothesis/internal/cathetus.py
function cathetus (line 15) | def cathetus(h: float, a: float) -> float:
FILE: hypothesis-python/src/hypothesis/internal/charmap.py
function charmap_file (line 72) | def charmap_file(fname: str = "charmap") -> Path:
function charmap (line 81) | def charmap() -> dict[CategoryName, IntervalsT]:
function intervals_from_codec (line 145) | def intervals_from_codec(codec_name: str) -> IntervalSet: # pragma: no ...
function categories (line 184) | def categories() -> Categories:
function as_general_categories (line 202) | def as_general_categories(cats: Categories, name: str = "cats") -> Categ...
function _category_key (line 234) | def _category_key(cats: Iterable[str] | None) -> CategoriesTuple:
function _query_for_key (line 250) | def _query_for_key(key: Categories) -> IntervalsT:
function query (line 288) | def query(
FILE: hypothesis-python/src/hypothesis/internal/compat.py
class NotRequired (line 58) | class NotRequired:
method __class_getitem__ (line 61) | def __class_getitem__(cls, item):
function add_note (line 83) | def add_note(exc, note):
function escape_unicode_characters (line 95) | def escape_unicode_characters(s: str) -> str:
function int_from_bytes (line 99) | def int_from_bytes(data: bytes | bytearray) -> int:
function int_to_bytes (line 103) | def int_to_bytes(i: int, size: int) -> bytes:
function int_to_byte (line 107) | def int_to_byte(i: int) -> bytes:
function is_typed_named_tuple (line 111) | def is_typed_named_tuple(cls: type) -> bool:
function _hint_and_args (line 126) | def _hint_and_args(x):
function get_type_hints (line 130) | def get_type_hints(thing: object) -> dict[str, Any]:
function floor (line 206) | def floor(x):
function ceil (line 213) | def ceil(x):
function extract_bits (line 220) | def extract_bits(x: int, /, width: int | None = None) -> list[int]:
function bad_django_TestCase (line 239) | def bad_django_TestCase(runner: Optional["ConjectureRunner"]) -> bool:
function _asdict_inner (line 254) | def _asdict_inner(obj, dict_factory):
function dataclass_asdict (line 279) | def dataclass_asdict(obj, *, dict_factory=dict):
function batched (line 299) | def batched(iterable, n, *, strict=False):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/choice.py
class IntegerConstraints (line 31) | class IntegerConstraints(TypedDict):
class FloatConstraints (line 38) | class FloatConstraints(TypedDict):
class StringConstraints (line 45) | class StringConstraints(TypedDict):
class BytesConstraints (line 51) | class BytesConstraints(TypedDict):
class BooleanConstraints (line 56) | class BooleanConstraints(TypedDict):
class ChoiceTemplate (line 75) | class ChoiceTemplate:
method __post_init__ (line 79) | def __post_init__(self) -> None:
class ChoiceNode (line 85) | class ChoiceNode:
method copy (line 92) | def copy(
method trivial (line 115) | def trivial(self) -> bool:
method __eq__ (line 154) | def __eq__(self, other: object) -> bool:
method __hash__ (line 165) | def __hash__(self) -> int:
method __repr__ (line 175) | def __repr__(self) -> str:
function _size_to_index (line 180) | def _size_to_index(size: int, *, alphabet_size: int) -> int:
function _index_to_size (line 194) | def _index_to_size(index: int, alphabet_size: int) -> int:
function collection_index (line 223) | def collection_index(
function collection_value (line 252) | def collection_value(
function zigzag_index (line 288) | def zigzag_index(value: int, *, shrink_towards: int) -> int:
function zigzag_value (line 297) | def zigzag_value(index: int, *, shrink_towards: int) -> int:
function choice_to_index (line 307) | def choice_to_index(choice: ChoiceT, constraints: ChoiceConstraintsT) ->...
function choice_from_index (line 425) | def choice_from_index(
function choice_permitted (line 524) | def choice_permitted(choice: ChoiceT, constraints: ChoiceConstraintsT) -...
function choices_key (line 567) | def choices_key(choices: Sequence[ChoiceT]) -> tuple[ChoiceKeyT, ...]:
function choice_key (line 571) | def choice_key(choice: ChoiceT) -> ChoiceKeyT:
function choice_equal (line 582) | def choice_equal(choice1: ChoiceT, choice2: ChoiceT) -> bool:
function choice_constraints_equal (line 587) | def choice_constraints_equal(
function choice_constraints_key (line 597) | def choice_constraints_key(
function choices_size (line 619) | def choices_size(choices: Iterable[ChoiceT]) -> int:
FILE: hypothesis-python/src/hypothesis/internal/conjecture/data.py
function __getattr__ (line 83) | def __getattr__(name: str) -> Any:
class Status (line 112) | class Status(IntEnum):
method __repr__ (line 118) | def __repr__(self) -> str:
class StructuralCoverageTag (line 123) | class StructuralCoverageTag:
function structural_coverage (line 130) | def structural_coverage(label: int) -> StructuralCoverageTag:
class Span (line 142) | class Span:
method __init__ (line 172) | def __init__(self, owner: "Spans", index: int) -> None:
method __eq__ (line 176) | def __eq__(self, other: object) -> bool:
method __ne__ (line 183) | def __ne__(self, other: object) -> bool:
method __repr__ (line 190) | def __repr__(self) -> str:
method label (line 194) | def label(self) -> int:
method parent (line 201) | def parent(self) -> int | None:
method start (line 208) | def start(self) -> int:
method end (line 212) | def end(self) -> int:
method depth (line 216) | def depth(self) -> int:
method discarded (line 223) | def discarded(self) -> bool:
method choice_count (line 232) | def choice_count(self) -> int:
method children (line 237) | def children(self) -> "list[Span]":
class SpanProperty (line 243) | class SpanProperty:
method __init__ (line 252) | def __init__(self, spans: "Spans"):
method run (line 258) | def run(self) -> Any:
method __push (line 274) | def __push(self, label_index: int) -> None:
method __pop (line 281) | def __pop(self, *, discarded: bool) -> None:
method start_span (line 285) | def start_span(self, i: int, label_index: int) -> None:
method stop_span (line 290) | def stop_span(self, i: int, *, discarded: bool) -> None:
method finish (line 295) | def finish(self) -> Any:
class TrailType (line 299) | class TrailType(IntEnum):
class SpanRecord (line 308) | class SpanRecord:
method __init__ (line 319) | def __init__(self) -> None:
method freeze (line 325) | def freeze(self) -> None:
method record_choice (line 328) | def record_choice(self) -> None:
method start_span (line 331) | def start_span(self, label: int) -> None:
method stop_span (line 340) | def stop_span(self, *, discard: bool) -> None:
class _starts_and_ends (line 347) | class _starts_and_ends(SpanProperty):
method __init__ (line 348) | def __init__(self, spans: "Spans") -> None:
method start_span (line 353) | def start_span(self, i: int, label_index: int) -> None:
method stop_span (line 356) | def stop_span(self, i: int, *, discarded: bool) -> None:
method finish (line 359) | def finish(self) -> tuple[IntList, IntList]:
class _discarded (line 363) | class _discarded(SpanProperty):
method __init__ (line 364) | def __init__(self, spans: "Spans") -> None:
method finish (line 368) | def finish(self) -> frozenset[int]:
method stop_span (line 371) | def stop_span(self, i: int, *, discarded: bool) -> None:
class _parentage (line 376) | class _parentage(SpanProperty):
method __init__ (line 377) | def __init__(self, spans: "Spans") -> None:
method stop_span (line 381) | def stop_span(self, i: int, *, discarded: bool) -> None:
method finish (line 385) | def finish(self) -> IntList:
class _depths (line 389) | class _depths(SpanProperty):
method __init__ (line 390) | def __init__(self, spans: "Spans") -> None:
method start_span (line 394) | def start_span(self, i: int, label_index: int) -> None:
method finish (line 397) | def finish(self) -> IntList:
class _label_indices (line 401) | class _label_indices(SpanProperty):
method __init__ (line 402) | def __init__(self, spans: "Spans") -> None:
method start_span (line 406) | def start_span(self, i: int, label_index: int) -> None:
method finish (line 409) | def finish(self) -> IntList:
class _mutator_groups (line 413) | class _mutator_groups(SpanProperty):
method __init__ (line 414) | def __init__(self, spans: "Spans") -> None:
method start_span (line 418) | def start_span(self, i: int, label_index: int) -> None:
method finish (line 425) | def finish(self) -> Iterable[set[tuple[int, int]]]:
class Spans (line 431) | class Spans:
method __init__ (line 442) | def __init__(self, record: SpanRecord) -> None:
method starts_and_ends (line 451) | def starts_and_ends(self) -> tuple[IntList, IntList]:
method starts (line 455) | def starts(self) -> IntList:
method ends (line 459) | def ends(self) -> IntList:
method discarded (line 463) | def discarded(self) -> frozenset[int]:
method parentage (line 467) | def parentage(self) -> IntList:
method depths (line 471) | def depths(self) -> IntList:
method label_indices (line 475) | def label_indices(self) -> IntList:
method mutator_groups (line 479) | def mutator_groups(self) -> list[set[tuple[int, int]]]:
method children (line 483) | def children(self) -> list[Sequence[int]]:
method __len__ (line 497) | def __len__(self) -> int:
method __getitem__ (line 500) | def __getitem__(self, i: int) -> Span:
method __iter__ (line 510) | def __iter__(self) -> Iterator[Span]:
class _Overrun (line 515) | class _Overrun:
method __repr__ (line 518) | def __repr__(self) -> str:
class DataObserver (line 525) | class DataObserver:
method conclude_test (line 530) | def conclude_test(
method kill_branch (line 541) | def kill_branch(self) -> None:
method draw_integer (line 544) | def draw_integer(
method draw_float (line 549) | def draw_float(
method draw_string (line 554) | def draw_string(
method draw_bytes (line 559) | def draw_bytes(
method draw_boolean (line 564) | def draw_boolean(
class ConjectureResult (line 571) | class ConjectureResult:
method as_result (line 592) | def as_result(self) -> "ConjectureResult":
method choices (line 596) | def choices(self) -> tuple[ChoiceT, ...]:
class ConjectureData (line 600) | class ConjectureData:
method for_choices (line 602) | def for_choices(
method __init__ (line 620) | def __init__(
method __repr__ (line 718) | def __repr__(self) -> str:
method choices (line 726) | def choices(self) -> tuple[ChoiceT, ...]:
method _draw (line 739) | def _draw(
method _draw (line 749) | def _draw(
method _draw (line 759) | def _draw(
method _draw (line 769) | def _draw(
method _draw (line 779) | def _draw(
method _draw (line 788) | def _draw(
method draw_integer (line 864) | def draw_integer(
method draw_float (line 903) | def draw_float(
method draw_string (line 947) | def draw_string(
method draw_bytes (line 971) | def draw_bytes(
method draw_boolean (line 987) | def draw_boolean(
method _pooled_constraints (line 1001) | def _pooled_constraints(
method _pooled_constraints (line 1006) | def _pooled_constraints(
method _pooled_constraints (line 1011) | def _pooled_constraints(
method _pooled_constraints (line 1016) | def _pooled_constraints(
method _pooled_constraints (line 1021) | def _pooled_constraints(
method _pooled_constraints (line 1025) | def _pooled_constraints(
method _pop_choice (line 1040) | def _pop_choice(
method as_result (line 1129) | def as_result(self) -> ConjectureResult | _Overrun:
method __assert_not_frozen (line 1157) | def __assert_not_frozen(self, name: str) -> None:
method note (line 1161) | def note(self, value: Any) -> None:
method draw (line 1167) | def draw(
method start_span (line 1229) | def start_span(self, label: int) -> None:
method stop_span (line 1244) | def stop_span(self, *, discard: bool = False) -> None:
method spans (line 1290) | def spans(self) -> Spans:
method freeze (line 1296) | def freeze(self) -> None:
method choice (line 1310) | def choice(
method conclude_test (line 1326) | def conclude_test(
method mark_interesting (line 1338) | def mark_interesting(self, interesting_origin: InterestingOrigin) -> N...
method mark_invalid (line 1341) | def mark_invalid(self, why: str | None = None) -> NoReturn:
method mark_overrun (line 1346) | def mark_overrun(self) -> NoReturn:
function draw_choice (line 1350) | def draw_choice(
FILE: hypothesis-python/src/hypothesis/internal/conjecture/datatree.py
class PreviouslyUnseenBehaviour (line 52) | class PreviouslyUnseenBehaviour(HypothesisException):
class Killed (line 67) | class Killed:
method _repr_pretty_ (line 75) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
function _node_pretty (line 80) | def _node_pretty(
class Branch (line 92) | class Branch:
method max_children (line 101) | def max_children(self) -> int:
method _repr_pretty_ (line 106) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
class Conclusion (line 120) | class Conclusion:
method _repr_pretty_ (line 126) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
function _count_distinct_strings (line 161) | def _count_distinct_strings(*, alphabet_size: int, min_size: int, max_si...
function compute_max_children (line 201) | def compute_max_children(
function _floats_between (line 288) | def _floats_between(a: float, b: float) -> Generator[float, None, None]:
function all_children (line 293) | def all_children(
class TreeNode (line 337) | class TreeNode:
method forced (line 431) | def forced(self) -> Set[int]:
method mark_forced (line 436) | def mark_forced(self, i: int) -> None:
method split_at (line 445) | def split_at(self, i: int) -> None:
method check_exhausted (line 480) | def check_exhausted(self) -> bool:
method _repr_pretty_ (line 524) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
class DataTree (line 549) | class DataTree:
method __init__ (line 693) | def __init__(self) -> None:
method is_exhausted (line 698) | def is_exhausted(self) -> bool:
method generate_novel_prefix (line 705) | def generate_novel_prefix(self, random: Random) -> tuple[ChoiceT, ...]:
method rewrite (line 820) | def rewrite(self, choices):
method simulate_test_function (line 832) | def simulate_test_function(self, data: ConjectureData) -> None:
method new_observer (line 880) | def new_observer(self):
method _draw (line 883) | def _draw(
method _get_children_cache (line 906) | def _get_children_cache(
method _draw_from_cache (line 926) | def _draw_from_cache(
method _reject_child (line 956) | def _reject_child(
method _repr_pretty_ (line 987) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
class TreeRecordingObserver (line 992) | class TreeRecordingObserver(DataObserver):
method __init__ (line 993) | def __init__(self, tree: DataTree):
method draw_integer (line 1003) | def draw_integer(
method draw_float (line 1010) | def draw_float(
method draw_string (line 1015) | def draw_string(
method draw_bytes (line 1020) | def draw_bytes(
method draw_boolean (line 1025) | def draw_boolean(
method draw_value (line 1032) | def draw_value(
method kill_branch (line 1119) | def kill_branch(self) -> None:
method conclude_test (line 1140) | def conclude_test(
method __update_exhausted (line 1181) | def __update_exhausted(self) -> None:
FILE: hypothesis-python/src/hypothesis/internal/conjecture/engine.py
function shortlex (line 111) | def shortlex(s):
class HealthCheckState (line 116) | class HealthCheckState:
method total_draw_time (line 125) | def total_draw_time(self) -> float:
method timing_report (line 128) | def timing_report(self) -> str:
function _invalid_thresholds (line 157) | def _invalid_thresholds(*, r: float, c: float) -> tuple[int, int]:
class ExitReason (line 169) | class ExitReason(Enum):
method describe (line 180) | def describe(self, settings: Settings) -> str:
class RunIsComplete (line 184) | class RunIsComplete(Exception):
function _get_provider (line 188) | def _get_provider(backend: str) -> PrimitiveProvider | type[PrimitivePro...
class CallStats (line 205) | class CallStats(TypedDict):
function choice_count (line 235) | def choice_count(choices: Sequence[ChoiceT | ChoiceTemplate]) -> int | N...
class DiscardObserver (line 247) | class DiscardObserver(DataObserver):
method kill_branch (line 249) | def kill_branch(self) -> NoReturn:
function realize_choices (line 253) | def realize_choices(data: ConjectureData, *, for_failure: bool) -> None:
class ConjectureRunner (line 280) | class ConjectureRunner:
method __init__ (line 281) | def __init__(
method _with_switch_to_hypothesis_provider (line 357) | def _with_switch_to_hypothesis_provider(
method using_hypothesis_backend (line 368) | def using_hypothesis_backend(self) -> bool:
method explain_next_call_as (line 373) | def explain_next_call_as(self, explanation: str) -> None:
method clear_call_explanation (line 376) | def clear_call_explanation(self) -> None:
method _log_phase_statistics (line 380) | def _log_phase_statistics(
method should_optimise (line 397) | def should_optimise(self) -> bool:
method __tree_is_exhausted (line 400) | def __tree_is_exhausted(self) -> bool:
method __stoppable_test_function (line 403) | def __stoppable_test_function(self, data: ConjectureData) -> None:
method _cache_key (line 426) | def _cache_key(self, choices: Sequence[ChoiceT]) -> tuple[ChoiceKeyT, ...
method _cache (line 429) | def _cache(self, data: ConjectureData) -> None:
method cached_test_function (line 434) | def cached_test_function(
method test_function (line 511) | def test_function(self, data: ConjectureData) -> None:
method on_pareto_evict (line 749) | def on_pareto_evict(self, data: ConjectureResult) -> None:
method generate_novel_prefix (line 752) | def generate_novel_prefix(self) -> tuple[ChoiceT, ...]:
method record_for_health_check (line 762) | def record_for_health_check(self, data: ConjectureData) -> None:
method save_choices (line 890) | def save_choices(
method downgrade_choices (line 899) | def downgrade_choices(self, choices: Sequence[ChoiceT]) -> None:
method sub_key (line 904) | def sub_key(self, sub_key: bytes | None) -> bytes | None:
method secondary_key (line 912) | def secondary_key(self) -> bytes | None:
method pareto_key (line 916) | def pareto_key(self) -> bytes | None:
method debug (line 919) | def debug(self, message: str) -> None:
method report_debug_info (line 924) | def report_debug_info(self) -> bool:
method debug_data (line 927) | def debug_data(self, data: ConjectureData | ConjectureResult) -> None:
method observe_for_provider (line 944) | def observe_for_provider(self) -> AbstractContextManager:
method run (line 964) | def run(self) -> None:
method database (line 978) | def database(self) -> ExampleDatabase | None:
method has_existing_examples (line 983) | def has_existing_examples(self) -> bool:
method reuse_existing_examples (line 986) | def reuse_existing_examples(self) -> None:
method exit_with (line 1084) | def exit_with(self, reason: ExitReason) -> None:
method should_generate_more (line 1094) | def should_generate_more(self) -> bool:
method generate_new_examples (line 1134) | def generate_new_examples(self) -> None:
method generate_mutations_from (line 1325) | def generate_mutations_from(self, data: ConjectureData | ConjectureRes...
method optimise_targets (line 1483) | def optimise_targets(self) -> None:
method pareto_optimise (line 1523) | def pareto_optimise(self) -> None:
method _run (line 1527) | def _run(self) -> None:
method new_conjecture_data (line 1553) | def new_conjecture_data(
method shrink_interesting_examples (line 1575) | def shrink_interesting_examples(self) -> None:
method clear_secondary_key (line 1626) | def clear_secondary_key(self) -> None:
method shrink (line 1656) | def shrink(
method new_shrinker (line 1668) | def new_shrinker(
method passing_choice_sequences (line 1685) | def passing_choice_sequences(
class ContainsDiscard (line 1699) | class ContainsDiscard(Exception):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/floats.py
function exponent_key (line 82) | def exponent_key(e: int) -> float:
function decode_exponent (line 101) | def decode_exponent(e: int) -> int:
function encode_exponent (line 108) | def encode_exponent(e: int) -> int:
function reverse_byte (line 115) | def reverse_byte(b: int) -> int:
function reverse64 (line 131) | def reverse64(v: int) -> int:
function reverse_bits (line 158) | def reverse_bits(x: int, n: int) -> int:
function update_mantissa (line 165) | def update_mantissa(unbiased_exponent: int, mantissa: int) -> int:
function lex_to_float (line 176) | def lex_to_float(i: int) -> float:
function float_to_lex (line 193) | def float_to_lex(f: float) -> int:
function base_float_to_lex (line 200) | def base_float_to_lex(f: float) -> int:
function is_simple (line 212) | def is_simple(f: float) -> int:
FILE: hypothesis-python/src/hypothesis/internal/conjecture/junkdrawer.py
function replace_all (line 41) | def replace_all(
class IntList (line 63) | class IntList(Sequence[int]):
method __init__ (line 76) | def __init__(self, values: Sequence[int] = ()):
method of_length (line 92) | def of_length(cls, n: int) -> "IntList":
method _array_or_list (line 96) | def _array_or_list(
method count (line 103) | def count(self, value: int) -> int:
method __repr__ (line 106) | def __repr__(self) -> str:
method __len__ (line 109) | def __len__(self) -> int:
method __getitem__ (line 113) | def __getitem__(self, i: int) -> int: ... # pragma: no cover
method __getitem__ (line 116) | def __getitem__(
method __getitem__ (line 120) | def __getitem__(self, i: int | slice) -> "int | list[int] | ArrayType[...
method __delitem__ (line 123) | def __delitem__(self, i: int | slice) -> None:
method insert (line 126) | def insert(self, i: int, v: int) -> None:
method __iter__ (line 129) | def __iter__(self) -> Iterator[int]:
method __eq__ (line 132) | def __eq__(self, other: object) -> bool:
method __ne__ (line 139) | def __ne__(self, other: object) -> bool:
method append (line 146) | def append(self, n: int) -> None:
method __setitem__ (line 156) | def __setitem__(self, i: int, n: int) -> None:
method extend (line 165) | def extend(self, ls: Iterable[int]) -> None:
method __upgrade (line 169) | def __upgrade(self) -> None:
function binary_search (line 175) | def binary_search(lo: int, hi: int, f: Callable[[int], bool]) -> int:
class LazySequenceCopy (line 193) | class LazySequenceCopy(Generic[T]):
method __init__ (line 200) | def __init__(self, values: Sequence[T]):
method __len__ (line 206) | def __len__(self) -> int:
method pop (line 211) | def pop(self, i: int = -1) -> T:
method swap (line 227) | def swap(self, i: int, j: int) -> None:
method __getitem__ (line 233) | def __getitem__(self, i: int) -> T:
method __setitem__ (line 242) | def __setitem__(self, i: int, v: T) -> None:
method __underlying_index (line 248) | def __underlying_index(self, i: int) -> int:
method __iter__ (line 274) | def __iter__(self) -> Iterable[T]:
function stack_depth_of_caller (line 279) | def stack_depth_of_caller() -> int:
class StackframeLimiter (line 295) | class StackframeLimiter:
method __init__ (line 310) | def __init__(self):
method _setrecursionlimit (line 315) | def _setrecursionlimit(self, new_limit: int, *, check: bool = True) ->...
method enter_context (line 331) | def enter_context(self, new_limit: int, *, current_limit: int) -> None:
method exit_context (line 342) | def exit_context(self, new_limit: int, *, check: bool = True) -> None:
class ensure_free_stackframes (line 366) | class ensure_free_stackframes:
method __enter__ (line 371) | def __enter__(self) -> None:
method __exit__ (line 401) | def __exit__(self, *args, **kwargs):
function find_integer (line 406) | def find_integer(f: Callable[[int], bool]) -> int:
function gc_cumulative_time (line 453) | def gc_cumulative_time() -> float:
function startswith (line 504) | def startswith(l1: Sequence[T], l2: Sequence[T]) -> bool:
function endswith (line 510) | def endswith(l1: Sequence[T], l2: Sequence[T]) -> bool:
function bits_to_bytes (line 516) | def bits_to_bytes(n: int) -> int:
FILE: hypothesis-python/src/hypothesis/internal/conjecture/optimiser.py
class Optimiser (line 19) | class Optimiser:
method __init__ (line 35) | def __init__(
method run (line 52) | def run(self) -> None:
method score_function (line 55) | def score_function(self, data: ConjectureResult) -> float:
method current_score (line 59) | def current_score(self) -> float:
method consider_new_data (line 62) | def consider_new_data(self, data: ConjectureResult | _Overrun) -> bool:
method hill_climb (line 84) | def hill_climb(self) -> None:
FILE: hypothesis-python/src/hypothesis/internal/conjecture/pareto.py
class DominanceRelation (line 34) | class DominanceRelation(Enum):
function dominance (line 41) | def dominance(left: ConjectureResult, right: ConjectureResult) -> Domina...
class ParetoFront (line 104) | class ParetoFront:
method __init__ (line 140) | def __init__(self, random: Random) -> None:
method add (line 149) | def add(self, data: ConjectureData | ConjectureResult | _Overrun) -> b...
method on_evict (line 257) | def on_evict(self, f: Callable[[ConjectureResult], None]) -> None:
method __contains__ (line 262) | def __contains__(self, data: object) -> bool:
method __iter__ (line 272) | def __iter__(self) -> Iterator[ConjectureResult]:
method __getitem__ (line 275) | def __getitem__(self, i: int) -> ConjectureResult:
method __len__ (line 278) | def __len__(self) -> int:
method _remove (line 281) | def _remove(self, data: ConjectureResult) -> None:
class ParetoOptimiser (line 291) | class ParetoOptimiser:
method __init__ (line 301) | def __init__(self, engine: "ConjectureRunner") -> None:
method run (line 306) | def run(self) -> None:
FILE: hypothesis-python/src/hypothesis/internal/conjecture/provider_conformance.py
function build_intervals (line 43) | def build_intervals(intervals: list[int]) -> list[tuple[int, int]]:
function interval_lists (line 51) | def interval_lists(
function intervals (line 65) | def intervals(
function integer_weights (line 77) | def integer_weights(
function integer_constraints (line 101) | def integer_constraints(
function _collection_constraints (line 168) | def _collection_constraints(
function string_constraints (line 204) | def string_constraints(
function bytes_constraints (line 229) | def bytes_constraints(
function float_constraints (line 247) | def float_constraints(
function boolean_constraints (line 307) | def boolean_constraints(draw: DrawFn, *, use_forced: bool = False) -> Any:
function constraints_strategy (line 315) | def constraints_strategy(choice_type, strategy_constraints=None, *, use_...
function choice_types_constraints (line 328) | def choice_types_constraints(strategy_constraints=None, *, use_forced=Fa...
function run_conformance_test (line 339) | def run_conformance_test(
FILE: hypothesis-python/src/hypothesis/internal/conjecture/providers.py
function _get_local_constants (line 282) | def _get_local_constants() -> Constants:
function with_register_backend (line 348) | def with_register_backend(name, provider_cls):
class _BackendInfoMsg (line 356) | class _BackendInfoMsg(TypedDict):
class PrimitiveProvider (line 365) | class PrimitiveProvider(abc.ABC):
method __init__ (line 427) | def __init__(self, conjecturedata: Optional["ConjectureData"], /) -> N...
method draw_boolean (line 431) | def draw_boolean(
method draw_integer (line 452) | def draw_integer(
method draw_float (line 481) | def draw_float(
method draw_string (line 507) | def draw_string(
method draw_bytes (line 529) | def draw_bytes(
method per_test_case_context_manager (line 546) | def per_test_case_context_manager(self) -> AbstractContextManager:
method realize (line 563) | def realize(self, value: T, *, for_failure: bool = False) -> T:
method replay_choices (line 582) | def replay_choices(self, choices: tuple[ChoiceT, ...]) -> None:
method observe_test_case (line 594) | def observe_test_case(self) -> dict[str, Any]:
method observe_information_messages (line 603) | def observe_information_messages(
method on_observation (line 615) | def on_observation(self, observation: TestCaseObservation) -> None: #...
method span_start (line 651) | def span_start(self, label: int, /) -> None: # noqa: B027 # non-abst...
method span_end (line 709) | def span_end(self, discard: bool, /) -> None: # noqa: B027
class HypothesisProvider (line 721) | class HypothesisProvider(PrimitiveProvider):
method __init__ (line 724) | def __init__(self, conjecturedata: Optional["ConjectureData"], /):
method _local_constants (line 729) | def _local_constants(self):
method _maybe_draw_constant (line 733) | def _maybe_draw_constant(
method draw_boolean (line 782) | def draw_boolean(
method draw_integer (line 795) | def draw_integer(
method draw_float (line 867) | def draw_float(
method draw_string (line 933) | def draw_string(
method draw_bytes (line 981) | def draw_bytes(
method _draw_float (line 1014) | def _draw_float(self) -> float:
method _draw_unbounded_integer (line 1021) | def _draw_unbounded_integer(self) -> int:
method _draw_bounded_integer (line 1034) | def _draw_bounded_integer(
class BytestringProvider (line 1067) | class BytestringProvider(PrimitiveProvider):
method __init__ (line 1070) | def __init__(
method _draw_bits (line 1078) | def _draw_bits(self, n):
method draw_boolean (line 1092) | def draw_boolean(
method draw_integer (line 1112) | def draw_integer(
method draw_float (line 1144) | def draw_float(
method _draw_collection (line 1163) | def _draw_collection(self, min_size, max_size, *, alphabet_size):
method draw_string (line 1180) | def draw_string(
method draw_bytes (line 1190) | def draw_bytes(
class URandom (line 1199) | class URandom(Random):
method _urandom (line 1204) | def _urandom(size: int) -> bytes:
method getrandbits (line 1208) | def getrandbits(self, k: int) -> int:
method random (line 1215) | def random(self) -> float:
class URandomProvider (line 1220) | class URandomProvider(HypothesisProvider):
method __init__ (line 1230) | def __init__(self, conjecturedata: Optional["ConjectureData"], /):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py
function sort_key (line 68) | def sort_key(nodes: Sequence[ChoiceNode]) -> tuple[int, tuple[int, ...]]:
class ShrinkPass (line 93) | class ShrinkPass:
method __post_init__ (line 104) | def __post_init__(self):
method __hash__ (line 108) | def __hash__(self):
class StopShrinking (line 112) | class StopShrinking(Exception):
class Shrinker (line 116) | class Shrinker:
method derived_value (line 251) | def derived_value(fn):
method __init__ (line 268) | def __init__(
method cached_calculations (line 332) | def cached_calculations(self):
method cached (line 335) | def cached(self, *keys):
method calls (line 346) | def calls(self) -> int:
method misaligned (line 352) | def misaligned(self) -> int:
method check_calls (line 355) | def check_calls(self) -> None:
method cached_test_function (line 359) | def cached_test_function(
method consider_new_nodes (line 383) | def consider_new_nodes(self, nodes: Sequence[ChoiceNode]) -> bool:
method incorporate_test_data (line 386) | def incorporate_test_data(self, data):
method debug (line 398) | def debug(self, msg: str) -> None:
method random (line 402) | def random(self) -> "Random":
method shrink (line 405) | def shrink(self) -> None:
method explain (line 461) | def explain(self) -> None:
method greedy_shrink (line 614) | def greedy_shrink(self) -> None:
method initial_coarse_reduction (line 623) | def initial_coarse_reduction(self):
method spans_starting_at (line 637) | def spans_starting_at(self):
method reduce_each_alternative (line 645) | def reduce_each_alternative(self):
method try_lower_node_as_alternative (line 706) | def try_lower_node_as_alternative(self, i, v):
method shrink_pass_choice_trees (line 738) | def shrink_pass_choice_trees(self) -> dict[Any, ChoiceTree]:
method step (line 741) | def step(self, shrink_pass: ShrinkPass, *, random_order: bool = False)...
method fixate_shrink_passes (line 771) | def fixate_shrink_passes(self, passes: list[ShrinkPass]) -> None:
method nodes (line 866) | def nodes(self) -> tuple[ChoiceNode, ...]:
method choices (line 870) | def choices(self) -> tuple[ChoiceT, ...]:
method spans (line 874) | def spans(self) -> Spans:
method spans_by_label (line 878) | def spans_by_label(self):
method distinct_labels (line 890) | def distinct_labels(self):
method pass_to_descendant (line 893) | def pass_to_descendant(self, chooser):
method lower_common_node_offset (line 951) | def lower_common_node_offset(self):
method clear_change_tracking (line 1031) | def clear_change_tracking(self):
method mark_changed (line 1035) | def mark_changed(self, i):
method __changed_nodes (line 1039) | def __changed_nodes(self) -> set[int]:
method update_shrink_target (line 1064) | def update_shrink_target(self, new_target):
method try_shrinking_nodes (line 1080) | def try_shrinking_nodes(self, nodes, n):
method remove_discarded (line 1224) | def remove_discarded(self):
method duplicated_nodes (line 1267) | def duplicated_nodes(self):
method node_program (line 1274) | def node_program(self, program: str) -> ShrinkPass:
method _node_program (line 1280) | def _node_program(self, chooser, program):
method minimize_duplicated_choices (line 1313) | def minimize_duplicated_choices(self, chooser):
method redistribute_numeric_pairs (line 1342) | def redistribute_numeric_pairs(self, chooser):
method lower_integers_together (line 1418) | def lower_integers_together(self, chooser):
method lower_duplicated_characters (line 1450) | def lower_duplicated_characters(self, chooser):
method minimize_nodes (line 1511) | def minimize_nodes(self, nodes):
method try_trivial_spans (line 1572) | def try_trivial_spans(self, chooser):
method minimize_individual_choices (line 1602) | def minimize_individual_choices(self, chooser):
method reorder_spans (line 1702) | def reorder_spans(self, chooser):
method run_node_program (line 1749) | def run_node_program(self, i, program, original, repeats=1):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/bytes.py
class Bytes (line 15) | class Bytes(Collection):
method __init__ (line 16) | def __init__(self, initial, predicate, **kwargs):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/choicetree.py
function prefix_selection_order (line 18) | def prefix_selection_order(
function random_selection_order (line 38) | def random_selection_order(random: Random) -> Callable[[int, int], Itera...
class Chooser (line 50) | class Chooser:
method __init__ (line 53) | def __init__(
method choose (line 63) | def choose(
method finish (line 95) | def finish(self) -> Sequence[int]:
class ChoiceTree (line 116) | class ChoiceTree:
method __init__ (line 123) | def __init__(self) -> None:
method exhausted (line 127) | def exhausted(self) -> bool:
method step (line 130) | def step(
class TreeNode (line 145) | class TreeNode:
method __init__ (line 146) | def __init__(self) -> None:
method exhausted (line 152) | def exhausted(self) -> bool:
class DeadBranch (line 160) | class DeadBranch(Exception):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/collection.py
class Collection (line 18) | class Collection(Shrinker):
method setup (line 19) | def setup(
method make_immutable (line 27) | def make_immutable(self, value):
method short_circuit (line 30) | def short_circuit(self):
method left_is_better (line 34) | def left_is_better(self, left, right):
method run_step (line 49) | def run_step(self):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/common.py
class Shrinker (line 14) | class Shrinker:
method __init__ (line 19) | def __init__(
method calls (line 41) | def calls(self) -> int:
method __repr__ (line 44) | def __repr__(self) -> str:
method setup (line 52) | def setup(self, **kwargs):
method delegate (line 59) | def delegate(self, other_class, convert_to, convert_from, **kwargs):
method call_shrinker (line 69) | def call_shrinker(self, other_class, initial, predicate, **kwargs):
method debug (line 78) | def debug(self, *args: object) -> None:
method shrink (line 83) | def shrink(cls, initial, predicate, **kwargs):
method run (line 93) | def run(self):
method consider (line 110) | def consider(self, value):
method make_canonical (line 137) | def make_canonical(self, value):
method make_immutable (line 148) | def make_immutable(self, value):
method check_invariants (line 157) | def check_invariants(self, value):
method short_circuit (line 164) | def short_circuit(self):
method left_is_better (line 172) | def left_is_better(self, left, right):
method run_step (line 177) | def run_step(self):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/floats.py
class Float (line 20) | class Float(Shrinker):
method setup (line 21) | def setup(self):
method make_canonical (line 24) | def make_canonical(self, f):
method check_invariants (line 31) | def check_invariants(self, value):
method left_is_better (line 36) | def left_is_better(self, left, right):
method short_circuit (line 41) | def short_circuit(self):
method run_step (line 53) | def run_step(self):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/integer.py
class Integer (line 19) | class Integer(Shrinker):
method short_circuit (line 26) | def short_circuit(self):
method check_invariants (line 37) | def check_invariants(self, value):
method left_is_better (line 40) | def left_is_better(self, left, right):
method run_step (line 43) | def run_step(self):
method shift_right (line 48) | def shift_right(self):
method mask_high_bits (line 52) | def mask_high_bits(self):
method size (line 64) | def size(self) -> int:
method shrink_by_multiples (line 67) | def shrink_by_multiples(self, k):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/ordering.py
class Ordering (line 16) | class Ordering(Shrinker):
method setup (line 23) | def setup(self, key=identity):
method make_immutable (line 26) | def make_immutable(self, value):
method short_circuit (line 29) | def short_circuit(self):
method left_is_better (line 33) | def left_is_better(self, left, right):
method check_invariants (line 36) | def check_invariants(self, value):
method run_step (line 40) | def run_step(self):
method sort_regions (line 44) | def sort_regions(self):
method sort_regions_with_gaps (line 64) | def sort_regions_with_gaps(self):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/string.py
class String (line 15) | class String(Collection):
method __init__ (line 16) | def __init__(self, initial, predicate, *, intervals, **kwargs):
FILE: hypothesis-python/src/hypothesis/internal/conjecture/utils.py
function calc_label_from_name (line 34) | def calc_label_from_name(name: str) -> int:
function calc_label_from_callable (line 39) | def calc_label_from_callable(f: Callable) -> int:
function calc_label_from_cls (line 53) | def calc_label_from_cls(cls: type) -> int:
function calc_label_from_hash (line 57) | def calc_label_from_hash(obj: object) -> int:
function combine_labels (line 61) | def combine_labels(*labels: int) -> int:
function identity (line 76) | def identity(v: T) -> T:
function check_sample (line 80) | def check_sample(
function compute_sampler_table (line 113) | def compute_sampler_table(weights: tuple[float, ...]) -> list[tuple[int,...
class Sampler (line 179) | class Sampler:
method __init__ (line 199) | def __init__(self, weights: Sequence[float], *, observe: bool = True):
method sample (line 203) | def sample(
class many (line 252) | class many:
method __init__ (line 264) | def __init__(
method stop_span (line 288) | def stop_span(self):
method start_span (line 292) | def start_span(self, label):
method more (line 296) | def more(self) -> bool:
method reject (line 335) | def reject(self, why: str | None = None) -> None:
function _calc_p_continue (line 355) | def _calc_p_continue(desired_avg: float, max_size: int | float) -> float:
function _p_continue_to_avg (line 393) | def _p_continue_to_avg(p_continue: float, max_size: int | float) -> float:
FILE: hypothesis-python/src/hypothesis/internal/constants_ast.py
class Constants (line 35) | class Constants:
method __init__ (line 36) | def __init__(
method set_for_type (line 49) | def set_for_type(
method add (line 62) | def add(self, constant: ConstantT) -> None:
method __contains__ (line 65) | def __contains__(self, constant: ConstantT) -> bool:
method __or__ (line 68) | def __or__(self, other: "Constants") -> "Constants":
method __iter__ (line 76) | def __iter__(self) -> Iterator[ConstantT]:
method __len__ (line 79) | def __len__(self) -> int:
method __repr__ (line 84) | def __repr__(self) -> str:
method __eq__ (line 87) | def __eq__(self, other: object) -> bool:
class TooManyConstants (line 98) | class TooManyConstants(Exception):
class ConstantVisitor (line 104) | class ConstantVisitor(NodeVisitor):
method __init__ (line 107) | def __init__(self, *, limit: bool):
method _add_constant (line 112) | def _add_constant(self, value: object) -> None:
method visit_UnaryOp (line 148) | def visit_UnaryOp(self, node: UnaryOp) -> None:
method visit_Expr (line 162) | def visit_Expr(self, node: Expr) -> None:
method visit_JoinedStr (line 168) | def visit_JoinedStr(self, node):
method visit_Constant (line 173) | def visit_Constant(self, node):
function _constants_from_source (line 178) | def _constants_from_source(source: str | bytes, *, limit: bool) -> Const...
function _constants_file_str (line 192) | def _constants_file_str(constants: Constants) -> str:
function constants_from_module (line 197) | def constants_from_module(module: ModuleType, *, limit: bool = True) -> ...
function is_local_module_file (line 250) | def is_local_module_file(path: str) -> bool:
FILE: hypothesis-python/src/hypothesis/internal/coverage.py
function pretty_file_name (line 37) | def pretty_file_name(f):
function record_branch (line 61) | def record_branch(name, value):
function check_block (line 70) | def check_block(name, depth):
function check (line 89) | def check(name):
function check_function (line 93) | def check_function(f: Func) -> Func:
function check_function (line 104) | def check_function(f: Func) -> Func:
function check (line 108) | def check(name):
FILE: hypothesis-python/src/hypothesis/internal/detection.py
function is_hypothesis_test (line 14) | def is_hypothesis_test(f: object) -> bool:
FILE: hypothesis-python/src/hypothesis/internal/entropy.py
class RandomLike (line 31) | class RandomLike(Protocol):
method seed (line 32) | def seed(self, *args: Any, **kwargs: Any) -> Any: ...
method getstate (line 33) | def getstate(self, *args: Any, **kwargs: Any) -> Any: ...
method setstate (line 34) | def setstate(self, *args: Any, **kwargs: Any) -> Any: ...
class NumpyRandomWrapper (line 49) | class NumpyRandomWrapper:
method __init__ (line 50) | def __init__(self) -> None:
function _get_platform_base_refcount (line 66) | def _get_platform_base_refcount(r: Any) -> int:
function register_random (line 77) | def register_random(r: RandomLike) -> None:
function get_seeder_and_restorer (line 165) | def get_seeder_and_restorer(
function deterministic_PRNG (line 244) | def deterministic_PRNG(seed: int = 0) -> Generator[None, None, None]:
FILE: hypothesis-python/src/hypothesis/internal/escalation.py
function belongs_to (line 31) | def belongs_to(package: ModuleType) -> Callable[[str], bool]:
function get_trimmed_traceback (line 60) | def get_trimmed_traceback(
class InterestingOrigin (line 95) | class InterestingOrigin:
method __str__ (line 108) | def __str__(self) -> str:
method from_exception (line 119) | def from_exception(
function _get_exceptioninfo (line 149) | def _get_exceptioninfo():
function format_exception (line 161) | def format_exception(err, tb):
FILE: hypothesis-python/src/hypothesis/internal/filtering.py
class ConstructivePredicate (line 50) | class ConstructivePredicate(NamedTuple):
method unchanged (line 72) | def unchanged(cls, predicate: Predicate) -> "ConstructivePredicate":
method __repr__ (line 75) | def __repr__(self) -> str:
function convert (line 83) | def convert(node: ast.AST, argname: str) -> object:
function comp_to_constraints (line 99) | def comp_to_constraints(x: ast.AST, op: ast.AST, y: ast.AST, *, argname:...
function merge_preds (line 134) | def merge_preds(*con_predicates: ConstructivePredicate) -> ConstructiveP...
function numeric_bounds_from_ast (line 178) | def numeric_bounds_from_ast(
function get_numeric_predicate_bounds (line 220) | def get_numeric_predicate_bounds(predicate: Predicate) -> ConstructivePr...
function get_integer_predicate_bounds (line 304) | def get_integer_predicate_bounds(predicate: Predicate) -> ConstructivePr...
function get_float_predicate_bounds (line 332) | def get_float_predicate_bounds(predicate: Predicate) -> ConstructivePred...
function max_len (line 359) | def max_len(size: int, element: Collection[object]) -> bool:
function min_len (line 363) | def min_len(size: int, element: Collection[object]) -> bool:
FILE: hypothesis-python/src/hypothesis/internal/floats.py
function reinterpret_bits (line 38) | def reinterpret_bits(x: float | int, from_: str, to: str) -> float | int:
function float_of (line 44) | def float_of(x: SupportsFloat, width: Width) -> float:
function is_negative (line 54) | def is_negative(x: SupportsFloat) -> bool:
function count_between_floats (line 63) | def count_between_floats(x: float, y: float, width: int = 64) -> int:
function float_to_int (line 77) | def float_to_int(value: float, width: int = 64) -> int:
function int_to_float (line 84) | def int_to_float(value: int, width: int = 64) -> float:
function next_up (line 89) | def next_up(value: float, width: int = 64) -> float:
function next_down (line 110) | def next_down(value: float, width: int = 64) -> float:
function next_down_normal (line 114) | def next_down_normal(value: float, width: int, *, allow_subnormal: bool)...
function next_up_normal (line 121) | def next_up_normal(value: float, width: int, *, allow_subnormal: bool) -...
function make_float_clamper (line 138) | def make_float_clamper(
function sign_aware_lte (line 186) | def sign_aware_lte(x: float | int, y: float | int) -> bool:
function clamp (line 194) | def clamp(lower: float | int, value: float | int, upper: float | int) ->...
FILE: hypothesis-python/src/hypothesis/internal/healthcheck.py
function fail_health_check (line 14) | def fail_health_check(settings, message, label):
FILE: hypothesis-python/src/hypothesis/internal/intervalsets.py
class IntervalSet (line 28) | class IntervalSet:
method from_string (line 37) | def from_string(cls, s: str) -> "Self":
method __init__ (line 46) | def __init__(self, intervals: Iterable[Sequence[int]] = ()) -> None:
method __len__ (line 61) | def __len__(self) -> int:
method __iter__ (line 64) | def __iter__(self) -> Iterable[int]:
method __getitem__ (line 68) | def __getitem__(self, i: int) -> int:
method __contains__ (line 93) | def __contains__(self, elem: str | int) -> bool:
method __repr__ (line 99) | def __repr__(self) -> str:
method index (line 102) | def index(self, value: int) -> int:
method index_above (line 112) | def index_above(self, value: int) -> int:
method __or__ (line 120) | def __or__(self, other: "Self") -> "Self":
method __sub__ (line 123) | def __sub__(self, other: "Self") -> "Self":
method __and__ (line 126) | def __and__(self, other: "Self") -> "Self":
method __eq__ (line 129) | def __eq__(self, other: object) -> bool:
method __hash__ (line 132) | def __hash__(self) -> int:
method union (line 135) | def union(self, other: "Self") -> "Self":
method difference (line 171) | def difference(self, other: "Self") -> "Self":
method intersection (line 248) | def intersection(self, other: "Self") -> "Self":
method char_in_shrink_order (line 268) | def char_in_shrink_order(self, i: int) -> str:
method index_from_char_in_shrink_order (line 292) | def index_from_char_in_shrink_order(self, c: str) -> int:
FILE: hypothesis-python/src/hypothesis/internal/lambda_sources.py
function extract_all_lambdas (line 43) | def extract_all_lambdas(tree):
function extract_all_attributes (line 56) | def extract_all_attributes(tree):
function _function_key (line 68) | def _function_key(f, *, bounded_size=False, ignore_name=False):
class _op (line 103) | class _op:
function _normalize_code (line 112) | def _normalize_code(f, l):
function _mimic_lambda_from_node (line 215) | def _mimic_lambda_from_node(f, node):
function _lambda_code_matches_node (line 292) | def _lambda_code_matches_node(f, node):
function _check_unknown_perfectly_aligned_lambda (line 304) | def _check_unknown_perfectly_aligned_lambda(candidate): # pragma: no cover
function _lambda_description (line 310) | def _lambda_description(f, leeway=50, *, fail_if_confused_with_perfect_c...
function lambda_description (line 393) | def lambda_description(f):
FILE: hypothesis-python/src/hypothesis/internal/observability.py
class PredicateCounts (line 73) | class PredicateCounts:
method update_count (line 77) | def update_count(self, *, condition: bool) -> None:
function _choice_to_json (line 84) | def _choice_to_json(choice: ChoiceT | None) -> Any:
function choices_to_json (line 104) | def choices_to_json(choices: tuple[ChoiceT, ...]) -> list[Any]:
function _constraints_to_json (line 108) | def _constraints_to_json(
function nodes_to_json (line 159) | def nodes_to_json(nodes: tuple[ChoiceNode, ...]) -> list[dict[str, Any]]:
class ObservationMetadata (line 172) | class ObservationMetadata:
method to_json (line 186) | def to_json(self) -> dict[str, Any]:
class BaseObservation (line 226) | class BaseObservation:
class InfoObservation (line 237) | class InfoObservation(BaseObservation):
class TestCaseObservation (line 244) | class TestCaseObservation(BaseObservation):
function add_observability_callback (line 259) | def add_observability_callback(f: CallbackT, /, *, all_threads: bool = F...
function remove_observability_callback (line 291) | def remove_observability_callback(f: CallbackT, /) -> None:
function observability_enabled (line 315) | def observability_enabled() -> bool:
function with_observability_callback (line 329) | def with_observability_callback(
function deliver_observation (line 343) | def deliver_observation(observation: Observation) -> None:
class _TestcaseCallbacks (line 353) | class _TestcaseCallbacks:
method __bool__ (line 354) | def __bool__(self):
method _note_deprecation (line 358) | def _note_deprecation(self):
method append (line 368) | def append(self, f):
method remove (line 372) | def remove(self, f):
function make_testcase (line 392) | def make_testcase(
function _deliver_to_file (line 484) | def _deliver_to_file(
function _system_metadata (line 512) | def _system_metadata() -> dict[str, Any]:
FILE: hypothesis-python/src/hypothesis/internal/reflection.py
function is_mock (line 44) | def is_mock(obj: object) -> bool:
function _clean_source (line 56) | def _clean_source(src: str) -> bytes:
function function_digest (line 83) | def function_digest(function: Any) -> bytes:
function check_signature (line 119) | def check_signature(sig: Signature) -> None: # pragma: no cover # 3.10...
function get_signature (line 131) | def get_signature(
function arg_is_required (line 167) | def arg_is_required(param: Parameter) -> bool:
function required_args (line 174) | def required_args(
function convert_keyword_arguments (line 204) | def convert_keyword_arguments(
function convert_positional_arguments (line 216) | def convert_positional_arguments(
function ast_arguments_matches_signature (line 240) | def ast_arguments_matches_signature(args: ast.arguments, sig: Signature)...
function is_first_param_referenced_in_function (line 255) | def is_first_param_referenced_in_function(f: Any) -> bool:
function get_pretty_function_description (line 270) | def get_pretty_function_description(f: object) -> str:
function nicerepr (line 292) | def nicerepr(v: Any) -> str:
function repr_call (line 302) | def repr_call(
function check_valid_identifier (line 333) | def check_valid_identifier(identifier: str) -> None:
function source_exec_as_module (line 341) | def source_exec_as_module(source: str) -> ModuleType:
function get_varargs (line 365) | def get_varargs(
function define_function_signature (line 374) | def define_function_signature(name, docstring, signature):
function impersonate (line 462) | def impersonate(target):
function proxies (line 489) | def proxies(target: T) -> Callable[[Callable], T]:
function is_identity_function (line 502) | def is_identity_function(f: Callable) -> bool:
FILE: hypothesis-python/src/hypothesis/internal/scrutineer.py
function should_trace_file (line 39) | def should_trace_file(fname: str) -> bool:
class Tracer (line 54) | class Tracer:
method __init__ (line 64) | def __init__(self, *, should_trace: bool) -> None:
method can_trace (line 71) | def can_trace() -> bool:
method branches (line 79) | def branches(self) -> Trace:
method trace (line 82) | def trace(self, frame, event, arg):
method trace_line (line 95) | def trace_line(self, code: types.CodeType, line_number: int) -> None:
method __enter__ (line 106) | def __enter__(self) -> "Self":
method __exit__ (line 131) | def __exit__(self, *args, **kwargs):
function _glob_to_re (line 173) | def _glob_to_re(locs: Iterable[str]) -> str:
function get_explaining_locations (line 188) | def get_explaining_locations(traces):
class ModuleLocation (line 254) | class ModuleLocation(IntEnum):
method from_path (line 261) | def from_path(cls, path: str) -> "ModuleLocation":
function _sort_key (line 273) | def _sort_key(path: str, lineno: int) -> tuple[int, str, int]:
function make_report (line 277) | def make_report(explanations, *, cap_lines_at=5):
function explanatory_lines (line 291) | def explanatory_lines(traces, settings):
function _get_git_repo_root (line 304) | def _get_git_repo_root() -> Path:
function tractable_coverage_report (line 320) | def tractable_coverage_report(trace: Trace) -> dict[str, list[int]]:
FILE: hypothesis-python/src/hypothesis/internal/validation.py
function check_type (line 20) | def check_type(typ: type | tuple[type, ...], arg: object, name: str) -> ...
function check_valid_integer (line 41) | def check_valid_integer(value, name):
function check_valid_bound (line 52) | def check_valid_bound(value, name):
function check_valid_magnitude (line 66) | def check_valid_magnitude(value, name):
function try_convert (line 80) | def try_convert(typ, value, name):
function check_valid_size (line 95) | def check_valid_size(value, name):
function check_valid_interval (line 109) | def check_valid_interval(lower_bound, upper_bound, lower_name, upper_name):
function check_valid_sizes (line 124) | def check_valid_sizes(min_size, max_size):
FILE: hypothesis-python/src/hypothesis/provisional.py
function get_top_level_domains (line 37) | def get_top_level_domains() -> tuple[str, ...]:
function _recase_randomly (line 50) | def _recase_randomly(draw: DrawFn, tld: str) -> str:
class DomainNameStrategy (line 59) | class DomainNameStrategy(st.SearchStrategy[str]):
method clean_inputs (line 61) | def clean_inputs(
method __init__ (line 76) | def __init__(
method do_draw (line 132) | def do_draw(self, data: ConjectureData) -> str:
function domains (line 151) | def domains(
function urls (line 182) | def urls() -> st.SearchStrategy[str]:
FILE: hypothesis-python/src/hypothesis/reporting.py
function default (line 20) | def default(value: object) -> None:
function current_reporter (line 31) | def current_reporter() -> ReporterT:
function with_reporter (line 35) | def with_reporter(new_reporter: ReporterT) -> AbstractContextManager[None]:
function current_verbosity (line 39) | def current_verbosity() -> Verbosity:
function verbose_report (line 44) | def verbose_report(text: str) -> None:
function debug_report (line 49) | def debug_report(text: str) -> None:
function report (line 54) | def report(text: str) -> None:
function base_report (line 59) | def base_report(text: str) -> None:
FILE: hypothesis-python/src/hypothesis/stateful.py
function _is_singleton (line 67) | def _is_singleton(obj: object) -> bool:
class _OmittedArgument (line 81) | class _OmittedArgument:
class TestCaseProperty (line 86) | class TestCaseProperty: # pragma: no cover
method __get__ (line 87) | def __get__(self, obj, typ=None):
method __set__ (line 92) | def __set__(self, obj, value):
method __delete__ (line 95) | def __delete__(self, obj):
function get_state_machine_test (line 99) | def get_state_machine_test(
function run_state_machine_as_test (line 253) | def run_state_machine_as_test(state_machine_factory, *, settings=None, _...
class StateMachineMeta (line 280) | class StateMachineMeta(type):
method __setattr__ (line 281) | def __setattr__(cls, name, value):
class _SetupState (line 293) | class _SetupState:
class RuleBasedStateMachine (line 299) | class RuleBasedStateMachine(metaclass=StateMachineMeta):
method __init__ (line 312) | def __init__(self) -> None:
method _pretty_print (line 343) | def _pretty_print(self, value):
method __repr__ (line 359) | def __repr__(self):
method _new_name (line 362) | def _new_name(self, target):
method _last_names (line 368) | def _last_names(self, n: int) -> list[str]:
method bundle (line 373) | def bundle(self, name):
method setup_state (line 377) | def setup_state(cls):
method _repr_step (line 416) | def _repr_step(self, rule: "Rule", data: Any, result: Any) -> str:
method _add_results_to_targets (line 448) | def _add_results_to_targets(self, targets, results):
method check_invariants (line 464) | def check_invariants(self, settings, output, runtimes):
method teardown (line 489) | def teardown(self):
method _to_test_case (line 500) | def _to_test_case(cls):
class Rule (line 516) | class Rule:
method __post_init__ (line 526) | def __post_init__(self):
method __repr__ (line 537) | def __repr__(self) -> str:
method __hash__ (line 548) | def __hash__(self):
class BundleReferenceStrategy (line 567) | class BundleReferenceStrategy(SearchStrategy):
method __init__ (line 568) | def __init__(self, name: str, *, consume: bool = False):
method do_draw (line 573) | def do_draw(self, data):
class Bundle (line 588) | class Bundle(SearchStrategy[Ex]):
method __init__ (line 610) | def __init__(
method do_draw (line 618) | def do_draw(self, data):
method __repr__ (line 623) | def __repr__(self):
method calc_is_empty (line 629) | def calc_is_empty(self, recur):
method is_currently_empty (line 633) | def is_currently_empty(self, data):
method flatmap (line 640) | def flatmap(self, expand):
method __hash__ (line 649) | def __hash__(self):
class BundleConsumer (line 658) | class BundleConsumer(Bundle[Ex]):
method __init__ (line 659) | def __init__(self, bundle: Bundle[Ex]) -> None:
function consumes (line 663) | def consumes(bundle: Bundle[Ex]) -> SearchStrategy[Ex]:
class MultipleResults (line 682) | class MultipleResults(Iterable[Ex]):
method __iter__ (line 685) | def __iter__(self):
function multiple (line 689) | def multiple(*args: T) -> MultipleResults[T]:
function _convert_targets (line 699) | def _convert_targets(targets, target):
function _rule_qualname (line 746) | def _rule_qualname(f: Any) -> str:
function rule (line 782) | def rule(
function rule (line 792) | def rule(
function rule (line 799) | def rule(
function rule (line 808) | def rule(
function initialize (line 877) | def initialize(
function initialize (line 887) | def initialize(
function initialize (line 894) | def initialize(
function initialize (line 903) | def initialize(
class VarReference (line 965) | class VarReference:
function precondition (line 971) | def precondition(precond: Callable[[Any], bool]) -> Callable[[TestFunc],...
class Invariant (line 1034) | class Invariant:
method __repr__ (line 1039) | def __repr__(self) -> str:
function invariant (line 1048) | def invariant(*, check_during_init: bool = False) -> Callable[[TestFunc]...
class RuleStrategy (line 1098) | class RuleStrategy(SearchStrategy):
method __init__ (line 1099) | def __init__(self, machine: RuleBasedStateMachine) -> None:
method __repr__ (line 1125) | def __repr__(self):
method do_draw (line 1128) | def do_draw(self, data):
method is_valid (line 1160) | def is_valid(self, rule):
FILE: hypothesis-python/src/hypothesis/statistics.py
function note_statistics (line 25) | def note_statistics(stats_dict: "StatisticsDict") -> None:
function describe_targets (line 31) | def describe_targets(best_targets: dict[str, float]) -> list[str]:
function format_ms (line 49) | def format_ms(times: Iterable[float]) -> str:
function describe_statistics (line 68) | def describe_statistics(stats_dict: "StatisticsDict") -> str:
FILE: hypothesis-python/src/hypothesis/strategies/__init__.py
function _check_exports (line 119) | def _check_exports(_public):
FILE: hypothesis-python/src/hypothesis/strategies/_internal/attrs.py
function get_attribute_by_alias (line 43) | def get_attribute_by_alias(
function from_attrs (line 73) | def from_attrs(
function from_attrs_attribute (line 91) | def from_attrs_attribute(
function types_to_strategy (line 156) | def types_to_strategy(attrib: Attribute, types: Collection[Any]) -> Sear...
function ordered_intersection (line 199) | def ordered_intersection(in_: Sequence[Iterable[T]]) -> Generator[T, Non...
function all_substrings (line 208) | def all_substrings(s: str) -> Generator[str, None, None]:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/collections.py
class TupleStrategy (line 49) | class TupleStrategy(SearchStrategy[tuple[Ex, ...]]):
method __init__ (line 53) | def __init__(self, strategies: Iterable[SearchStrategy[Any]]):
method do_validate (line 57) | def do_validate(self) -> None:
method calc_label (line 61) | def calc_label(self) -> int:
method __repr__ (line 66) | def __repr__(self) -> str:
method calc_has_reusable_values (line 70) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method do_draw (line 73) | def do_draw(self, data: ConjectureData) -> tuple[Ex, ...]:
method calc_is_empty (line 89) | def calc_is_empty(self, recur: RecurT) -> bool:
function tuples (line 94) | def tuples() -> SearchStrategy[tuple[()]]: # pragma: no cover
function tuples (line 99) | def tuples(__a1: SearchStrategy[Ex]) -> SearchStrategy[tuple[Ex]]: # pr...
function tuples (line 104) | def tuples(
function tuples (line 111) | def tuples(
function tuples (line 118) | def tuples(
function tuples (line 128) | def tuples(
function tuples (line 139) | def tuples(
function tuples (line 147) | def tuples(*args: SearchStrategy[Any]) -> SearchStrategy[tuple[Any, ...]]:
class ListStrategy (line 162) | class ListStrategy(SearchStrategy[list[Ex]]):
method __init__ (line 168) | def __init__(
method calc_label (line 191) | def calc_label(self) -> int:
method do_validate (line 194) | def do_validate(self) -> None:
method calc_is_empty (line 208) | def calc_is_empty(self, recur: RecurT) -> bool:
method do_draw (line 213) | def do_draw(self, data: ConjectureData) -> list[Ex]:
method __repr__ (line 229) | def __repr__(self) -> str:
method filter (line 235) | def filter(self, condition: Callable[[list[Ex]], Any]) -> SearchStrate...
class UniqueListStrategy (line 270) | class UniqueListStrategy(ListStrategy[Ex]):
method __init__ (line 271) | def __init__(
method do_draw (line 285) | def do_draw(self, data: ConjectureData) -> list[Ex]:
class UniqueSampledListStrategy (line 330) | class UniqueSampledListStrategy(UniqueListStrategy):
method do_draw (line 331) | def do_draw(self, data: ConjectureData) -> list[Ex]:
class FixedDictStrategy (line 365) | class FixedDictStrategy(SearchStrategy[dict[Any, Any]]):
method __init__ (line 373) | def __init__(
method do_draw (line 388) | def do_draw(self, data: ConjectureData) -> dict[Any, Any]:
method calc_is_empty (line 420) | def calc_is_empty(self, recur: RecurT) -> bool:
method __repr__ (line 423) | def __repr__(self) -> str:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/core.py
function booleans (line 146) | def booleans() -> SearchStrategy[bool]:
function sampled_from (line 156) | def sampled_from(elements: Sequence[T]) -> SearchStrategy[T]: # pragma:...
function sampled_from (line 161) | def sampled_from(elements: type[enum.Enum]) -> SearchStrategy[Any]: # p...
function sampled_from (line 167) | def sampled_from(
function sampled_from (line 174) | def sampled_from(
function _gets_first_item (line 271) | def _gets_first_item(fn: Callable) -> bool:
function lists (line 281) | def lists(
function sets (line 409) | def sets(
function frozensets (line 431) | def frozensets(
class PrettyIter (line 444) | class PrettyIter:
method __init__ (line 445) | def __init__(self, values):
method __iter__ (line 449) | def __iter__(self):
method __next__ (line 452) | def __next__(self):
method __repr__ (line 455) | def __repr__(self) -> str:
function iterables (line 460) | def iterables(
function fixed_dictionaries (line 518) | def fixed_dictionaries(
function dictionaries (line 564) | def dictionaries(
function characters (line 599) | def characters(
function text (line 794) | def text(
function from_regex (line 867) | def from_regex(
function from_regex (line 876) | def from_regex(
function from_regex (line 887) | def from_regex(
function binary (line 943) | def binary(
function randoms (line 962) | def randoms(
class RandomSeeder (line 994) | class RandomSeeder:
method __init__ (line 995) | def __init__(self, seed):
method __repr__ (line 998) | def __repr__(self):
class RandomModule (line 1002) | class RandomModule(SearchStrategy):
method do_draw (line 1003) | def do_draw(self, data: ConjectureData) -> RandomSeeder:
function random_module (line 1017) | def random_module() -> SearchStrategy[RandomSeeder]:
class BuildsStrategy (line 1034) | class BuildsStrategy(SearchStrategy[Ex]):
method __init__ (line 1035) | def __init__(
method calc_label (line 1046) | def calc_label(self) -> int:
method do_draw (line 1055) | def do_draw(self, data: ConjectureData) -> Ex:
method do_validate (line 1107) | def do_validate(self) -> None:
method __repr__ (line 1111) | def __repr__(self) -> str:
function builds (line 1120) | def builds(
function from_type (line 1209) | def from_type(thing: type[T]) -> SearchStrategy[T]:
function _from_type_deferred (line 1268) | def _from_type_deferred(thing: type[Ex]) -> SearchStrategy[Ex]:
function _from_type (line 1293) | def _from_type(thing: type[Ex]) -> SearchStrategy[Ex]:
function fractions (line 1642) | def fractions(
function _as_finite_decimal (line 1726) | def _as_finite_decimal(
function decimals (line 1769) | def decimals(
function recursive (line 1857) | def recursive(
class PermutationStrategy (line 1888) | class PermutationStrategy(SearchStrategy):
method __init__ (line 1889) | def __init__(self, values):
method do_draw (line 1893) | def do_draw(self, data):
function permutations (line 1905) | def permutations(values: Sequence[T]) -> SearchStrategy[list[T]]:
class CompositeStrategy (line 1919) | class CompositeStrategy(SearchStrategy):
method __init__ (line 1920) | def __init__(self, definition, args, kwargs):
method do_draw (line 1926) | def do_draw(self, data):
method calc_label (line 1929) | def calc_label(self) -> int:
class DrawFn (line 1936) | class DrawFn(Protocol):
method __init__ (line 1951) | def __init__(self):
method __call__ (line 1961) | def __call__(self, strategy: SearchStrategy[Ex], label: object = None)...
function _composite (line 1965) | def _composite(f):
function composite (line 2060) | def composite(
function composite (line 2068) | def composite(f: Callable[..., Ex]) -> Callable[..., SearchStrategy[Ex]]:
function complex_numbers (line 2077) | def complex_numbers(
function shared (line 2202) | def shared(
function _maybe_nil_uuids (line 2227) | def _maybe_nil_uuids(draw, uuid):
function uuids (line 2236) | def uuids(
class RunnerStrategy (line 2268) | class RunnerStrategy(SearchStrategy):
method __init__ (line 2269) | def __init__(self, default):
method do_draw (line 2273) | def do_draw(self, data):
function runner (line 2285) | def runner(*, default: Any = not_set) -> SearchStrategy[Any]:
class DataObject (line 2302) | class DataObject:
method __init__ (line 2310) | def __init__(self, data: ConjectureData) -> None:
method __repr__ (line 2316) | def __repr__(self) -> str:
method draw (line 2319) | def draw(self, strategy: SearchStrategy[Ex], label: Any = None) -> Ex:
class DataStrategy (line 2339) | class DataStrategy(SearchStrategy):
method do_draw (line 2340) | def do_draw(self, data):
method __repr__ (line 2345) | def __repr__(self) -> str:
method map (line 2348) | def map(self, f):
method filter (line 2351) | def filter(self, condition: Callable[[Ex], Any]) -> NoReturn:
method flatmap (line 2354) | def flatmap(self, f):
method example (line 2357) | def example(self) -> NoReturn:
method __not_a_first_class_strategy (line 2360) | def __not_a_first_class_strategy(self, name: str) -> NoReturn:
function data (line 2369) | def data() -> SearchStrategy[DataObject]:
function register_type_strategy (line 2434) | def register_type_strategy(
function deferred (line 2518) | def deferred(definition: Callable[[], SearchStrategy[Ex]]) -> SearchStra...
function domains (line 2551) | def domains() -> SearchStrategy[str]:
function emails (line 2558) | def emails(
function _functions (line 2579) | def _functions(*, like, returns, pure):
function functions (line 2599) | def functions(
function functions (line 2605) | def functions(
function functions (line 2613) | def functions(
function functions (line 2621) | def functions(
function functions (line 2630) | def functions(*, like=lambda: None, returns=..., pure=False):
function functions (line 2658) | def functions(
function slices (line 2688) | def slices(draw: Any, size: int) -> slice:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/datetime.py
function is_pytz_timezone (line 31) | def is_pytz_timezone(tz):
function replace_tzinfo (line 38) | def replace_tzinfo(value, timezone):
function datetime_does_not_exist (line 57) | def datetime_does_not_exist(value):
function draw_capped_multipart (line 91) | def draw_capped_multipart(
class DatetimeStrategy (line 121) | class DatetimeStrategy(SearchStrategy):
method __init__ (line 122) | def __init__(self, min_value, max_value, timezones_strat, allow_imagin...
method do_draw (line 136) | def do_draw(self, data):
method draw_naive_datetime_and_combine (line 152) | def draw_naive_datetime_and_combine(self, data, tz):
function datetimes (line 164) | def datetimes(
class TimeStrategy (line 221) | class TimeStrategy(SearchStrategy):
method __init__ (line 222) | def __init__(self, min_value, max_value, timezones_strat):
method do_draw (line 228) | def do_draw(self, data):
function times (line 235) | def times(
class DateStrategy (line 260) | class DateStrategy(SearchStrategy):
method __init__ (line 261) | def __init__(self, min_value, max_value):
method do_draw (line 269) | def do_draw(self, data):
method filter (line 274) | def filter(self, condition):
function dates (line 307) | def dates(
class TimedeltaStrategy (line 324) | class TimedeltaStrategy(SearchStrategy):
method __init__ (line 325) | def __init__(self, min_value, max_value):
method do_draw (line 333) | def do_draw(self, data):
function timedeltas (line 348) | def timedeltas(
function _valid_key_cacheable (line 367) | def _valid_key_cacheable(tzpath, key):
function timezone_keys (line 386) | def timezone_keys(
function timezones (line 457) | def timezones(*, no_cache: bool = False) -> SearchStrategy["zoneinfo.Zon...
FILE: hypothesis-python/src/hypothesis/strategies/_internal/deferred.py
class DeferredStrategy (line 26) | class DeferredStrategy(SearchStrategy[Ex]):
method __init__ (line 29) | def __init__(self, definition: Callable[[], SearchStrategy[Ex]]):
method wrapped_strategy (line 36) | def wrapped_strategy(self) -> SearchStrategy[Ex]:
method branches (line 57) | def branches(self) -> Sequence[SearchStrategy[Ex]]:
method calc_label (line 60) | def calc_label(self) -> int:
method calc_is_empty (line 73) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_has_reusable_values (line 76) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method __repr__ (line 79) | def __repr__(self) -> str:
method do_draw (line 92) | def do_draw(self, data: ConjectureData) -> Ex:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/featureflags.py
class FeatureFlags (line 21) | class FeatureFlags:
method __init__ (line 38) | def __init__(
method is_enabled (line 77) | def is_enabled(self, name: Any) -> bool:
method __repr__ (line 115) | def __repr__(self) -> str:
class FeatureStrategy (line 126) | class FeatureStrategy(SearchStrategy[FeatureFlags]):
method __init__ (line 127) | def __init__(self, at_least_one_of: Iterable[Hashable] = ()):
method do_draw (line 131) | def do_draw(self, data: ConjectureData) -> FeatureFlags:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/flatmapped.py
class FlatMapStrategy (line 30) | class FlatMapStrategy(SearchStrategy[MappedTo], Generic[MappedFrom, Mapp...
method __init__ (line 31) | def __init__(
method calc_is_empty (line 40) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_label (line 43) | def calc_label(self) -> int:
method __repr__ (line 50) | def __repr__(self) -> str:
method do_draw (line 57) | def do_draw(self, data: ConjectureData) -> MappedTo:
method branches (line 64) | def branches(self) -> list[SearchStrategy[MappedTo]]:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/functions.py
class FunctionStrategy (line 24) | class FunctionStrategy(SearchStrategy):
method __init__ (line 25) | def __init__(self, like, returns, pure):
method calc_is_empty (line 34) | def calc_is_empty(self, recur: RecurT) -> bool:
method do_draw (line 37) | def do_draw(self, data):
FILE: hypothesis-python/src/hypothesis/strategies/_internal/ipaddress.py
function ip_addresses (line 74) | def ip_addresses(
FILE: hypothesis-python/src/hypothesis/strategies/_internal/lazy.py
function unwrap_strategies (line 31) | def unwrap_strategies(s):
class LazyStrategy (line 66) | class LazyStrategy(SearchStrategy[Ex]):
method __init__ (line 73) | def __init__(
method calc_is_empty (line 90) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_has_reusable_values (line 93) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method calc_is_cacheable (line 96) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method calc_label (line 103) | def calc_label(self) -> int:
method wrapped_strategy (line 107) | def wrapped_strategy(self) -> SearchStrategy[Ex]:
method __with_transform (line 127) | def __with_transform(self, method, fn):
method map (line 139) | def map(self, pack):
method filter (line 142) | def filter(self, condition):
method do_validate (line 145) | def do_validate(self) -> None:
method __repr__ (line 150) | def __repr__(self) -> str:
method do_draw (line 175) | def do_draw(self, data: ConjectureData) -> Ex:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/misc.py
class JustStrategy (line 31) | class JustStrategy(SampledFromStrategy[Ex]):
method value (line 45) | def value(self) -> Ex:
method __repr__ (line 48) | def __repr__(self) -> str:
method calc_is_cacheable (line 57) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method do_filtered_draw (line 60) | def do_filtered_draw(self, data: ConjectureData) -> Ex | UniqueIdentif...
function just (line 68) | def just(value: T) -> SearchStrategy[T]:
function none (line 83) | def none() -> SearchStrategy[None]:
class Nothing (line 92) | class Nothing(SearchStrategy["Never"]):
method calc_is_empty (line 93) | def calc_is_empty(self, recur: RecurT) -> bool:
method do_draw (line 96) | def do_draw(self, data: ConjectureData) -> NoReturn:
method calc_has_reusable_values (line 101) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method __repr__ (line 104) | def __repr__(self) -> str:
method map (line 107) | def map(self, pack: Callable[[Any], Any]) -> SearchStrategy["Never"]:
method filter (line 110) | def filter(self, condition: Callable[[Any], Any]) -> "SearchStrategy[N...
method flatmap (line 113) | def flatmap(
function nothing (line 124) | def nothing() -> SearchStrategy["Never"]:
class BooleansStrategy (line 133) | class BooleansStrategy(SearchStrategy[bool]):
method do_draw (line 134) | def do_draw(self, data: ConjectureData) -> bool:
method __repr__ (line 137) | def __repr__(self) -> str:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/numbers.py
class IntegersStrategy (line 51) | class IntegersStrategy(SearchStrategy[int]):
method __init__ (line 52) | def __init__(self, start: int | None, end: int | None) -> None:
method __repr__ (line 60) | def __repr__(self) -> str:
method do_draw (line 69) | def do_draw(self, data: ConjectureData) -> int:
method filter (line 88) | def filter(self, condition):
function integers (line 112) | def integers(
class FloatStrategy (line 146) | class FloatStrategy(SearchStrategy[float]):
method __init__ (line 149) | def __init__(
method __repr__ (line 178) | def __repr__(self) -> str:
method do_draw (line 184) | def do_draw(self, data: ConjectureData) -> float:
method filter (line 192) | def filter(self, condition):
function floats (line 250) | def floats(
class NanStrategy (line 519) | class NanStrategy(SearchStrategy[float]):
method do_draw (line 522) | def do_draw(self, data: ConjectureData) -> float:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/random.py
class HypothesisRandom (line 27) | class HypothesisRandom(Random, abc.ABC):
method __init__ (line 31) | def __init__(self, *, note_method_calls: bool) -> None:
method __deepcopy__ (line 34) | def __deepcopy__(self, table):
method seed (line 38) | def seed(self, seed):
method getstate (line 42) | def getstate(self):
method setstate (line 46) | def setstate(self, state):
method _hypothesis_do_random (line 50) | def _hypothesis_do_random(self, method, kwargs):
method _hypothesis_log_random (line 53) | def _hypothesis_log_random(self, method, kwargs, result):
function getrandbits (line 95) | def getrandbits(self, n: int) -> int: # type: ignore
function random (line 99) | def random(self) -> float: # type: ignore
function _randbelow (line 103) | def _randbelow(self, n: int) -> int: # type: ignore
function sig_of (line 113) | def sig_of(name):
function define_copy_method (line 125) | def define_copy_method(name):
class RandomState (line 150) | class RandomState:
function state_for_seed (line 155) | def state_for_seed(data, seed):
function normalize_zero (line 169) | def normalize_zero(f: float) -> float:
class ArtificialRandom (line 176) | class ArtificialRandom(HypothesisRandom):
method __init__ (line 179) | def __init__(self, *, note_method_calls: bool, data: ConjectureData) -...
method __repr__ (line 184) | def __repr__(self) -> str:
method __copy__ (line 187) | def __copy__(self) -> "ArtificialRandom":
method __convert_result (line 195) | def __convert_result(self, method, kwargs, result):
method _hypothesis_do_random (line 209) | def _hypothesis_do_random(self, method, kwargs):
method seed (line 334) | def seed(self, seed):
method getstate (line 337) | def getstate(self):
method setstate (line 349) | def setstate(self, state):
function convert_kwargs (line 356) | def convert_kwargs(name, kwargs):
class TrueRandom (line 392) | class TrueRandom(HypothesisRandom):
method __init__ (line 393) | def __init__(self, seed, note_method_calls):
method _hypothesis_do_random (line 398) | def _hypothesis_do_random(self, method, kwargs):
method __copy__ (line 407) | def __copy__(self) -> "TrueRandom":
method __repr__ (line 415) | def __repr__(self) -> str:
method seed (line 418) | def seed(self, seed):
method getstate (line 422) | def getstate(self):
method setstate (line 425) | def setstate(self, state):
class RandomStrategy (line 429) | class RandomStrategy(SearchStrategy[HypothesisRandom]):
method __init__ (line 430) | def __init__(self, *, note_method_calls: bool, use_true_random: bool) ...
method do_draw (line 435) | def do_draw(self, data: ConjectureData) -> HypothesisRandom:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/recursive.py
class LimitReached (line 31) | class LimitReached(BaseException):
class LimitedStrategy (line 35) | class LimitedStrategy(SearchStrategy):
method __init__ (line 36) | def __init__(self, strategy):
method marker (line 42) | def marker(self):
method marker (line 46) | def marker(self, value):
method currently_capped (line 50) | def currently_capped(self):
method currently_capped (line 54) | def currently_capped(self, value):
method __repr__ (line 57) | def __repr__(self) -> str:
method do_validate (line 60) | def do_validate(self) -> None:
method do_draw (line 63) | def do_draw(self, data):
method capped (line 71) | def capped(self, max_templates):
class RecursiveStrategy (line 81) | class RecursiveStrategy(SearchStrategy):
method __init__ (line 82) | def __init__(
method __repr__ (line 104) | def __repr__(self) -> str:
method do_validate (line 113) | def do_validate(self) -> None:
method do_draw (line 160) | def do_draw(self, data):
FILE: hypothesis-python/src/hypothesis/strategies/_internal/regex.py
class IncompatibleWithAlphabet (line 66) | class IncompatibleWithAlphabet(InvalidArgument):
function update_group (line 71) | def update_group(draw, group_name, strategy):
function reuse_group (line 79) | def reuse_group(draw, group_name):
function group_conditional (line 88) | def group_conditional(draw, group_name, if_yes, if_no):
function clear_cache_after_draw (line 97) | def clear_cache_after_draw(draw, base_strategy):
function chars_not_in_alphabet (line 104) | def chars_not_in_alphabet(alphabet, string):
class Context (line 112) | class Context:
method __init__ (line 115) | def __init__(self, flags):
class CharactersBuilder (line 119) | class CharactersBuilder:
method __init__ (line 129) | def __init__(self, *, negate=False, flags=0, alphabet):
method strategy (line 143) | def strategy(self):
method add_category (line 162) | def add_category(self, category):
method add_char (line 183) | def add_char(self, c):
class BytesBuilder (line 194) | class BytesBuilder(CharactersBuilder):
method __init__ (line 195) | def __init__(self, *, negate=False, flags=0):
method strategy (line 204) | def strategy(self):
method add_category (line 211) | def add_category(self, category):
function maybe_pad (line 217) | def maybe_pad(draw, regex, strategy, left_pad_strategy, right_pad_strate...
function base_regex_strategy (line 230) | def base_regex_strategy(regex, parsed=None, alphabet=None):
function regex_strategy (line 246) | def regex_strategy(
function _strategy (line 312) | def _strategy(codes, context, is_unicode, *, alphabet):
FILE: hypothesis-python/src/hypothesis/strategies/_internal/shared.py
class SharedStrategy (line 21) | class SharedStrategy(SearchStrategy[Ex]):
method __init__ (line 22) | def __init__(self, base: SearchStrategy[Ex], key: Hashable | None = No...
method __repr__ (line 27) | def __repr__(self) -> str:
method calc_label (line 33) | def calc_label(self) -> int:
method do_draw (line 38) | def do_draw(self, data: ConjectureData) -> Any:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/strategies.py
function recursive_property (line 82) | def recursive_property(strategy: "SearchStrategy", name: str, default: o...
class SearchStrategy (line 221) | class SearchStrategy(Generic[Ex]):
method __init__ (line 236) | def __init__(self):
method is_currently_empty (line 239) | def is_currently_empty(self, data: ConjectureData) -> bool:
method is_empty (line 255) | def is_empty(self) -> Any:
method has_reusable_values (line 272) | def has_reusable_values(self) -> Any:
method is_cacheable (line 276) | def is_cacheable(self) -> Any:
method calc_is_cacheable (line 283) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method calc_is_empty (line 286) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_has_reusable_values (line 295) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method example (line 298) | def example(self) -> Ex: # FIXME
method map (line 378) | def map(self, pack: Callable[[Ex], T]) -> "SearchStrategy[T]":
method flatmap (line 387) | def flatmap(
method filter (line 417) | def filter(self, condition: Callable[[Ex], Any]) -> "SearchStrategy[Ex]":
method branches (line 438) | def branches(self) -> Sequence["SearchStrategy[Ex]"]:
method __or__ (line 441) | def __or__(self, other: "SearchStrategy[T]") -> "SearchStrategy[Ex | T]":
method __bool__ (line 471) | def __bool__(self) -> bool:
method validate (line 479) | def validate(self) -> None:
method class_label (line 516) | def class_label(self) -> int:
method label (line 527) | def label(self) -> int:
method calc_label (line 539) | def calc_label(self) -> int:
method do_validate (line 542) | def do_validate(self) -> None:
method do_draw (line 545) | def do_draw(self, data: ConjectureData) -> Ex:
function _is_hashable (line 549) | def _is_hashable(value: object) -> tuple[bool, int | None]:
function is_hashable (line 558) | def is_hashable(value: object) -> bool:
class SampledFromStrategy (line 562) | class SampledFromStrategy(SearchStrategy[Ex]):
method __init__ (line 570) | def __init__(
method map (line 590) | def map(self, pack: Callable[[Ex], T]) -> SearchStrategy[T]:
method filter (line 600) | def filter(self, condition: Callable[[Ex], Any]) -> SearchStrategy[Ex]:
method __repr__ (line 608) | def __repr__(self):
method calc_label (line 628) | def calc_label(self) -> int:
method calc_has_reusable_values (line 679) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method calc_is_cacheable (line 686) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method _transform (line 689) | def _transform(
method do_draw (line 709) | def do_draw(self, data: ConjectureData) -> Ex:
method get_element (line 724) | def get_element(self, i: int) -> Ex | UniqueIdentifier:
method do_filtered_draw (line 727) | def do_filtered_draw(self, data: ConjectureData) -> Ex | UniqueIdentif...
class OneOfStrategy (line 785) | class OneOfStrategy(SearchStrategy[Ex]):
method __init__ (line 794) | def __init__(self, strategies: Sequence[SearchStrategy[Ex]]):
method calc_is_empty (line 801) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_has_reusable_values (line 804) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
method calc_is_cacheable (line 807) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method element_strategies (line 811) | def element_strategies(self) -> Sequence[SearchStrategy[Ex]]:
method calc_label (line 840) | def calc_label(self) -> int:
method do_draw (line 845) | def do_draw(self, data: ConjectureData) -> Ex:
method __repr__ (line 853) | def __repr__(self) -> str:
method do_validate (line 856) | def do_validate(self) -> None:
method branches (line 861) | def branches(self) -> Sequence[SearchStrategy[Ex]]:
method filter (line 876) | def filter(self, condition: Callable[[Ex], Any]) -> SearchStrategy[Ex]:
function one_of (line 884) | def one_of(
function one_of (line 891) | def one_of(__a1: SearchStrategy[Ex]) -> SearchStrategy[Ex]: # pragma: n...
function one_of (line 896) | def one_of(
function one_of (line 903) | def one_of(
function one_of (line 910) | def one_of(
function one_of (line 920) | def one_of(
function one_of (line 931) | def one_of(*args: SearchStrategy[Any]) -> SearchStrategy[Any]: # pragma...
function one_of (line 936) | def one_of(
class MappedStrategy (line 985) | class MappedStrategy(SearchStrategy[MappedTo], Generic[MappedFrom, Mappe...
method __init__ (line 992) | def __init__(
method calc_is_empty (line 1001) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_is_cacheable (line 1004) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method __repr__ (line 1007) | def __repr__(self) -> str:
method do_validate (line 1012) | def do_validate(self) -> None:
method do_draw (line 1015) | def do_draw(self, data: ConjectureData) -> MappedTo:
method branches (line 1036) | def branches(self) -> Sequence[SearchStrategy[MappedTo]]:
method filter (line 1042) | def filter(
function _list_strategy_type (line 1066) | def _list_strategy_type() -> Any:
function _collection_ish_functions (line 1072) | def _collection_ish_functions() -> Sequence[Any]:
class FilteredStrategy (line 1105) | class FilteredStrategy(SearchStrategy[Ex]):
method __init__ (line 1106) | def __init__(
method calc_is_empty (line 1125) | def calc_is_empty(self, recur: RecurT) -> bool:
method calc_is_cacheable (line 1128) | def calc_is_cacheable(self, recur: RecurT) -> bool:
method __repr__ (line 1131) | def __repr__(self) -> str:
method do_validate (line 1142) | def do_validate(self) -> None:
method filter (line 1164) | def filter(self, condition: Callable[[Ex], Any]) -> "FilteredStrategy[...
method condition (line 1180) | def condition(self) -> Callable[[Ex], Any]:
method do_draw (line 1200) | def do_draw(self, data: ConjectureData) -> Ex:
method do_filtered_draw (line 1207) | def do_filtered_draw(self, data: ConjectureData) -> Ex | UniqueIdentif...
method branches (line 1222) | def branches(self) -> Sequence[SearchStrategy[Ex]]:
function check_strategy (line 1230) | def check_strategy(arg: object, name: str = "") -> None:
FILE: hypothesis-python/src/hypothesis/strategies/_internal/strings.py
function _check_is_single_character (line 40) | def _check_is_single_character(c: object) -> str:
class OneCharStringStrategy (line 51) | class OneCharStringStrategy(SearchStrategy[str]):
method __init__ (line 54) | def __init__(self, intervals: IntervalSet, force_repr: str | None = No...
method from_characters_args (line 61) | def from_characters_args(
method from_alphabet (line 107) | def from_alphabet(cls, alphabet: str | SearchStrategy) -> "OneCharStri...
method __repr__ (line 131) | def __repr__(self) -> str:
method do_draw (line 134) | def do_draw(self, data: ConjectureData) -> str:
class TextStrategy (line 165) | class TextStrategy(ListStrategy[str]):
method do_draw (line 166) | def do_draw(self, data):
method __repr__ (line 184) | def __repr__(self) -> str:
method filter (line 209) | def filter(self, condition):
function _string_filter_rewrite (line 236) | def _string_filter_rewrite(self, kind, condition):
function _identifier_characters (line 329) | def _identifier_characters() -> tuple[IntervalSet, IntervalSet]:
class BytesStrategy (line 357) | class BytesStrategy(SearchStrategy):
method __init__ (line 358) | def __init__(self, min_size: int, max_size: int | None):
method do_draw (line 365) | def do_draw(self, data: ConjectureData) -> bytes:
method filter (line 377) | def filter(self, condition):
FILE: hypothesis-python/src/hypothesis/strategies/_internal/types.py
function type_sorting_key (line 213) | def type_sorting_key(t):
function _compatible_args (line 222) | def _compatible_args(args, superclass_args):
function try_issubclass (line 236) | def try_issubclass(thing, superclass):
function _evaluate_type_alias_type (line 260) | def _evaluate_type_alias_type(thing, *, typevars): # pragma: no cover #...
function evaluate_type_alias_type (line 312) | def evaluate_type_alias_type(thing): # pragma: no cover # covered on 3.12+
function is_a_type_alias_type (line 321) | def is_a_type_alias_type(thing): # pragma: no cover # covered by 3.12+ ...
function is_a_union (line 332) | def is_a_union(thing: object) -> bool:
function is_a_type (line 337) | def is_a_type(thing: object) -> bool:
function is_typing_literal (line 353) | def is_typing_literal(thing: object) -> bool:
function is_annotated_type (line 360) | def is_annotated_type(thing: object) -> bool:
function get_constraints_filter_map (line 367) | def get_constraints_filter_map():
function _get_constraints (line 382) | def _get_constraints(args: tuple[Any, ...]) -> Iterator["at.BaseMetadata"]:
function _flat_annotated_repr_parts (line 397) | def _flat_annotated_repr_parts(annotated_type):
function find_annotated_strategy (line 415) | def find_annotated_strategy(annotated_type):
function has_type_arguments (line 457) | def has_type_arguments(type_):
function is_generic_type (line 469) | def is_generic_type(type_):
function _try_import_forward_ref (line 485) | def _try_import_forward_ref(thing, typ, *, type_params): # pragma: no c...
function from_typing_type (line 506) | def from_typing_type(thing):
function can_cast (line 685) | def can_cast(type, value):
function _networks (line 694) | def _networks(bits):
function _from_numpy_type (line 910) | def _from_numpy_type(thing: type) -> st.SearchStrategy | None:
function register (line 922) | def register(type_, fallback=None, *, module=typing):
function resolve_Type (line 954) | def resolve_Type(thing):
function resolve_List (line 975) | def resolve_List(thing):
function resolve_Tuple (line 980) | def resolve_Tuple(thing):
function _can_hash (line 992) | def _can_hash(val):
function _from_hashable_type (line 1009) | def _from_hashable_type(type_):
function resolve_Set (line 1018) | def resolve_Set(thing):
function resolve_FrozenSet (line 1023) | def resolve_FrozenSet(thing):
function resolve_Dict (line 1028) | def resolve_Dict(thing):
function resolve_DefaultDict (line 1039) | def resolve_DefaultDict(thing):
function resolve_ItemsView (line 1044) | def resolve_ItemsView(thing):
function resolve_KeysView (line 1049) | def resolve_KeysView(thing):
function resolve_ValuesView (line 1056) | def resolve_ValuesView(thing):
function resolve_Iterator (line 1063) | def resolve_Iterator(thing):
function resolve_Counter (line 1068) | def resolve_Counter(thing):
function resolve_deque (line 1076) | def resolve_deque(thing):
function resolve_ChainMap (line 1081) | def resolve_ChainMap(thing):
function resolve_OrderedDict (line 1086) | def resolve_OrderedDict(thing):
function resolve_Pattern (line 1091) | def resolve_Pattern(thing):
function resolve_Match (line 1103) | def resolve_Match(thing):
class GeneratorStrategy (line 1113) | class GeneratorStrategy(st.SearchStrategy):
method __init__ (line 1114) | def __init__(self, yields, returns):
method __repr__ (line 1121) | def __repr__(self) -> str:
method do_draw (line 1124) | def do_draw(self, data):
function resolve_Generator (line 1132) | def resolve_Generator(thing):
function resolve_Callable (line 1138) | def resolve_Callable(thing):
function resolve_TypeVar (line 1179) | def resolve_TypeVar(thing):
function resolve_memoryview (line 1230) | def resolve_memoryview(thing):
FILE: hypothesis-python/src/hypothesis/strategies/_internal/utils.py
function _value_key (line 36) | def _value_key(value: object) -> ValueKey:
function clear_strategy_cache (line 42) | def clear_strategy_cache() -> None:
function cacheable (line 46) | def cacheable(fn: T) -> T:
function defines_strategy (line 84) | def defines_strategy(
function _to_jsonable (line 159) | def _to_jsonable(obj: object, *, avoid_realization: bool, seen: set[int]...
function to_jsonable (line 217) | def to_jsonable(obj: object, *, avoid_realization: bool) -> object:
FILE: hypothesis-python/src/hypothesis/utils/conventions.py
class UniqueIdentifier (line 12) | class UniqueIdentifier:
method __init__ (line 15) | def __init__(self, identifier: str) -> None:
method __repr__ (line 18) | def __repr__(self) -> str:
FILE: hypothesis-python/src/hypothesis/utils/deprecation.py
function note_deprecation (line 17) | def note_deprecation(
FILE: hypothesis-python/src/hypothesis/utils/dynamicvariables.py
class DynamicVariable (line 19) | class DynamicVariable(Generic[T]):
method __init__ (line 20) | def __init__(self, default: T) -> None:
method value (line 25) | def value(self) -> T:
method value (line 29) | def value(self, value: T) -> None:
method with_value (line 33) | def with_value(self, value: T) -> Generator[None, None, None]:
FILE: hypothesis-python/src/hypothesis/utils/terminal.py
function guess_background_color (line 15) | def guess_background_color() -> Literal["light", "dark", "unknown"]:
FILE: hypothesis-python/src/hypothesis/utils/threading.py
class ThreadLocal (line 16) | class ThreadLocal:
method __init__ (line 25) | def __init__(self, **kwargs: Callable) -> None:
method __getattr__ (line 35) | def __getattr__(self, name: str) -> Any:
method __setattr__ (line 45) | def __setattr__(self, name: str, value: Any) -> None:
FILE: hypothesis-python/src/hypothesis/vendor/pretty.py
function _safe_getattr (line 97) | def _safe_getattr(obj: object, attr: str, default: Any | None = None) ->...
function pretty (line 110) | def pretty(obj: object, *, cycle: bool = False) -> str:
class IDKey (line 117) | class IDKey:
method __init__ (line 118) | def __init__(self, value: object):
method __hash__ (line 121) | def __hash__(self) -> int:
method __eq__ (line 124) | def __eq__(self, __o: object) -> bool:
class RepresentationPrinter (line 128) | class RepresentationPrinter:
method __init__ (line 138) | def __init__(
method pretty (line 196) | def pretty(self, obj: object, *, cycle: bool = False) -> None:
method _break_outer_groups (line 284) | def _break_outer_groups(self) -> None:
method text (line 298) | def text(self, obj: str) -> None:
method breakable (line 313) | def breakable(self, sep: str = " ") -> None:
method break_ (line 333) | def break_(self) -> None:
method indent (line 342) | def indent(self, indent: int) -> Generator[None, None, None]:
method group (line 351) | def group(
method begin_group (line 368) | def begin_group(self, indent: int = 0, open: str = "") -> None:
method end_group (line 381) | def end_group(self, dedent: int = 0, close: str = "") -> None:
method _enumerate (line 390) | def _enumerate(self, seq: Iterable[T]) -> Generator[tuple[int, T], Non...
method flush (line 400) | def flush(self) -> None:
method getvalue (line 407) | def getvalue(self) -> str:
method maybe_repr_known_object_as_call (line 412) | def maybe_repr_known_object_as_call(
method repr_call (line 448) | def repr_call(
class Printable (line 523) | class Printable:
method output (line 524) | def output(self, stream: TextIOBase, output_width: int) -> int: # pra...
class Text (line 528) | class Text(Printable):
method __init__ (line 529) | def __init__(self) -> None:
method output (line 533) | def output(self, stream: TextIOBase, output_width: int) -> int:
method add (line 538) | def add(self, obj: str, width: int) -> None:
class Breakable (line 543) | class Breakable(Printable):
method __init__ (line 544) | def __init__(self, seq: str, width: int, pretty: RepresentationPrinter...
method output (line 552) | def output(self, stream: TextIOBase, output_width: int) -> int:
class Group (line 563) | class Group(Printable):
method __init__ (line 564) | def __init__(self, depth: int) -> None:
class GroupQueue (line 570) | class GroupQueue:
method __init__ (line 571) | def __init__(self, *groups: Group) -> None:
method enq (line 576) | def enq(self, group: Group) -> None:
method deq (line 582) | def deq(self) -> Group | None:
method remove (line 594) | def remove(self, group: Group) -> None:
function _seq_pprinter_factory (line 601) | def _seq_pprinter_factory(start: str, end: str, basetype: type) -> Prett...
function get_class_name (line 635) | def get_class_name(cls: type[object]) -> str:
function _set_pprinter_factory (line 641) | def _set_pprinter_factory(
function _dict_pprinter_factory (line 686) | def _dict_pprinter_factory(
function _super_pprint (line 724) | def _super_pprint(obj: Any, p: RepresentationPrinter, cycle: bool) -> None:
function _re_pattern_pprint (line 733) | def _re_pattern_pprint(obj: re.Pattern, p: RepresentationPrinter, cycle:...
function _type_pprint (line 766) | def _type_pprint(obj: type[object], p: RepresentationPrinter, cycle: boo...
function _repr_pprint (line 791) | def _repr_pprint(obj: object, p: RepresentationPrinter, cycle: bool) -> ...
function pprint_fields (line 801) | def pprint_fields(
function _get_slice_comment (line 817) | def _get_slice_comment(
function _tuple_pprinter (line 829) | def _tuple_pprinter(arg_labels: ArgLabelsT) -> PrettyPrintFunction:
function _fixeddict_pprinter (line 855) | def _fixeddict_pprinter(
function _function_pprint (line 888) | def _function_pprint(
function _exception_pprint (line 899) | def _exception_pprint(
function _repr_integer (line 915) | def _repr_integer(obj: int, p: RepresentationPrinter, cycle: bool) -> None:
function _repr_float_counting_nans (line 927) | def _repr_float_counting_nans(
function for_type_by_name (line 967) | def for_type_by_name(
function _defaultdict_pprint (line 984) | def _defaultdict_pprint(
function _ordereddict_pprint (line 998) | def _ordereddict_pprint(
function _deque_pprint (line 1009) | def _deque_pprint(obj: deque[object], p: RepresentationPrinter, cycle: b...
function _counter_pprint (line 1018) | def _counter_pprint(
function _repr_dataframe (line 1029) | def _repr_dataframe(
function _repr_enum (line 1038) | def _repr_enum(obj: Enum, p: RepresentationPrinter, cycle: bool) -> None:
class _ReprDots (line 1049) | class _ReprDots:
method __repr__ (line 1050) | def __repr__(self) -> str:
function _repr_partial (line 1054) | def _repr_partial(obj: partial[Any], p: RepresentationPrinter, cycle: bo...
FILE: hypothesis-python/tests/array_api/common.py
function installed_array_modules (line 37) | def installed_array_modules() -> dict[str, EntryPoint]:
function flushes_to_zero (line 48) | def flushes_to_zero(xp, width: Literal[32, 64]) -> bool:
FILE: hypothesis-python/tests/array_api/conftest.py
class InvalidArgumentWarning (line 44) | class InvalidArgumentWarning(UserWarning):
function pytest_generate_tests (line 93) | def pytest_generate_tests(metafunc):
function pytest_collection_modifyitems (line 108) | def pytest_collection_modifyitems(config, items):
FILE: hypothesis-python/tests/array_api/test_argument_validation.py
function e (line 20) | def e(name, *, _min_version: NominalVersion | None = None, **kwargs):
function test_raise_invalid_argument (line 222) | def test_raise_invalid_argument(xp, xps, strat_name, kwargs):
function test_make_strategies_namespace_raise_invalid_argument (line 231) | def test_make_strategies_namespace_raise_invalid_argument(xp, api_version):
FILE: hypothesis-python/tests/array_api/test_arrays.py
function skip_on_missing_unique_values (line 34) | def skip_on_missing_unique_values(xp):
function xfail_on_indistinct_nans (line 39) | def xfail_on_indistinct_nans(xp):
function test_draw_arrays_from_dtype (line 53) | def test_draw_arrays_from_dtype(xp, xps, dtype_name):
function test_draw_arrays_from_scalar_names (line 60) | def test_draw_arrays_from_scalar_names(xp, xps, dtype_name):
function test_draw_arrays_from_shapes (line 67) | def test_draw_arrays_from_shapes(xp, xps, data):
function test_draw_arrays_from_int_shapes (line 76) | def test_draw_arrays_from_int_shapes(xp, xps, data):
function test_draw_arrays_from_dtype_strategies (line 97) | def test_draw_arrays_from_dtype_strategies(xp, xps, strat_name):
function test_draw_arrays_from_dtype_name_strategies (line 106) | def test_draw_arrays_from_dtype_name_strategies(xp, xps, data):
function test_generate_arrays_from_shapes_strategy (line 117) | def test_generate_arrays_from_shapes_strategy(xp, xps):
function test_generate_arrays_from_integers_strategy_as_shape (line 122) | def test_generate_arrays_from_integers_strategy_as_shape(xp, xps):
function test_generate_arrays_from_zero_dimensions (line 127) | def test_generate_arrays_from_zero_dimensions(xp, xps):
function test_generate_arrays_from_zero_sided_shapes (line 133) | def test_generate_arrays_from_zero_sided_shapes(xp, xps, data):
function test_generate_arrays_from_unsigned_ints (line 140) | def test_generate_arrays_from_unsigned_ints(xp, xps):
function test_generate_arrays_from_0d_arrays (line 148) | def test_generate_arrays_from_0d_arrays(xp, xps):
function test_minimize_arrays_with_default_dtype_shape_strategies (line 162) | def test_minimize_arrays_with_default_dtype_shape_strategies(xp, xps):
function test_minimize_arrays_with_0d_shape_strategy (line 171) | def test_minimize_arrays_with_0d_shape_strategy(xp, xps):
function test_minimizes_numeric_arrays (line 179) | def test_minimizes_numeric_arrays(xp, xps, dtype):
function test_minimize_large_uint_arrays (line 185) | def test_minimize_large_uint_arrays(xp, xps):
function test_minimize_float_arrays (line 198) | def test_minimize_float_arrays(xp, xps):
function test_minimizes_to_fill (line 214) | def test_minimizes_to_fill(xp, xps):
function test_generate_unique_arrays (line 221) | def test_generate_unique_arrays(xp, xps):
function test_cannot_draw_unique_arrays_with_too_small_elements (line 230) | def test_cannot_draw_unique_arrays_with_too_small_elements(xp, xps):
function test_cannot_fill_arrays_with_non_castable_value (line 239) | def test_cannot_fill_arrays_with_non_castable_value(xp, xps):
function test_generate_unique_arrays_with_high_collision_elements (line 247) | def test_generate_unique_arrays_with_high_collision_elements(xp, xps):
function test_generate_unique_arrays_using_all_elements (line 266) | def test_generate_unique_arrays_using_all_elements(xp, xps):
function test_may_fill_unique_arrays_with_nan (line 276) | def test_may_fill_unique_arrays_with_nan(xp, xps):
function test_may_not_fill_unique_array_with_non_nan (line 290) | def test_may_not_fill_unique_array_with_non_nan(xp, xps):
function test_floating_point_array (line 303) | def test_floating_point_array():
function test_may_not_use_overflowing_integers (line 329) | def test_may_not_use_overflowing_integers(xp, xps, kwargs):
function test_may_not_use_unrepresentable_elements (line 349) | def test_may_not_use_unrepresentable_elements(xp, xps, fill, dtype, strat):
function test_floats_can_be_constrained (line 359) | def test_floats_can_be_constrained(xp, xps):
function test_floats_can_be_constrained_excluding_endpoints (line 370) | def test_floats_can_be_constrained_excluding_endpoints(xp, xps):
function test_is_still_unique_with_nan_fill (line 388) | def test_is_still_unique_with_nan_fill(xp, xps):
function test_unique_array_with_fill_can_use_all_elements (line 404) | def test_unique_array_with_fill_can_use_all_elements(xp, xps):
function test_generate_unique_arrays_without_fill (line 421) | def test_generate_unique_arrays_without_fill(xp, xps):
function test_efficiently_generate_unique_arrays_using_all_elements (line 436) | def test_efficiently_generate_unique_arrays_using_all_elements(xp, xps):
function test_array_element_rewriting (line 450) | def test_array_element_rewriting(xp, xps, data, start, size):
function test_generate_0d_arrays_with_no_fill (line 465) | def test_generate_0d_arrays_with_no_fill(xp, xps):
function test_excluded_min_in_float_arrays (line 476) | def test_excluded_min_in_float_arrays(xp, xps, dtype, low, data):
function distinct_int64_integers (line 493) | def distinct_int64_integers(draw):
function test_does_not_reuse_distinct_integers (line 500) | def test_does_not_reuse_distinct_integers(xp, xps):
function test_may_reuse_distinct_integers_if_asked (line 510) | def test_may_reuse_distinct_integers_if_asked(xp, xps):
function test_subnormal_elements_validation (line 525) | def test_subnormal_elements_validation(xp, xps):
FILE: hypothesis-python/tests/array_api/test_from_dtype.py
function test_strategies_have_reusable_values (line 28) | def test_strategies_have_reusable_values(xp, xps, dtype_name):
function test_produces_castable_instances_from_dtype (line 35) | def test_produces_castable_instances_from_dtype(xp, xps, dtype_name):
function test_produces_castable_instances_from_name (line 44) | def test_produces_castable_instances_from_name(xp, xps, dtype_name):
function test_passing_inferred_strategies_in_arrays (line 53) | def test_passing_inferred_strategies_in_arrays(xp, xps, dtype_name):
function test_from_dtype_with_kwargs (line 77) | def test_from_dtype_with_kwargs(xp, xps, dtype, kwargs, predicate):
function test_can_minimize_floats (line 83) | def test_can_minimize_floats(xp, xps):
function test_subnormal_generation (line 102) | def test_subnormal_generation(xp, xps, kwargs):
FILE: hypothesis-python/tests/array_api/test_indices.py
function test_generate_optional_indices (line 30) | def test_generate_optional_indices(xp, xps, condition):
function test_cannot_generate_newaxis_when_disabled (line 40) | def test_cannot_generate_newaxis_when_disabled(xp, xps):
function test_generate_indices_for_0d_shape (line 47) | def test_generate_indices_for_0d_shape(xp, xps):
function test_generate_tuples_and_non_tuples_for_1d_shape (line 56) | def test_generate_tuples_and_non_tuples_for_1d_shape(xp, xps):
function test_generate_long_ellipsis (line 63) | def test_generate_long_ellipsis(xp, xps):
function test_indices_replaces_whole_axis_slices_with_ellipsis (line 77) | def test_indices_replaces_whole_axis_slices_with_ellipsis(xp, xps):
function test_efficiently_generate_indexers (line 89) | def test_efficiently_generate_indexers(xp, xps):
function test_generate_valid_indices (line 95) | def test_generate_valid_indices(xp, xps, allow_newaxis, allow_ellipsis, ...
FILE: hypothesis-python/tests/array_api/test_partial_adoptors.py
class MockedArray (line 35) | class MockedArray:
method __init__ (line 36) | def __init__(self, wrapped, *, exclude=()):
method __getattr__ (line 40) | def __getattr__(self, name):
function wrap_array (line 47) | def wrap_array(func: callable, exclude: tuple[str, ...] = ()) -> callable:
function make_mock_xp (line 60) | def make_mock_xp(
function test_warning_on_noncompliant_xp (line 99) | def test_warning_on_noncompliant_xp():
function test_error_on_missing_attr (line 111) | def test_error_on_missing_attr(stratname, args, attr):
function test_error_on_missing_dtypes (line 140) | def test_error_on_missing_dtypes(stratname):
function test_warning_on_partial_dtypes (line 162) | def test_warning_on_partial_dtypes(stratname, keep_anys, data):
function test_raises_on_inferring_with_no_dunder_version (line 184) | def test_raises_on_inferring_with_no_dunder_version():
function test_raises_on_invalid_dunder_version (line 192) | def test_raises_on_invalid_dunder_version():
FILE: hypothesis-python/tests/array_api/test_pretty.py
function test_namespaced_methods_meta (line 44) | def test_namespaced_methods_meta(xp, xps, name):
function test_namespaced_strategies_repr (line 78) | def test_namespaced_strategies_repr(xp, xps, name, valid_args):
function test_inferred_version_strategies_namespace_repr (line 88) | def test_inferred_version_strategies_namespace_repr(xp):
function test_specified_version_strategies_namespace_repr (line 100) | def test_specified_version_strategies_namespace_repr(xp, monkeypatch):
FILE: hypothesis-python/tests/array_api/test_scalar_dtypes.py
function test_all_generated_dtypes_are_of_group (line 41) | def test_all_generated_dtypes_are_of_group(xp, xps, strat_name, dtype_na...
function test_all_generated_scalar_dtypes_are_scalar (line 48) | def test_all_generated_scalar_dtypes_are_scalar(xp, xps):
function test_all_generated_numeric_dtypes_are_numeric (line 57) | def test_all_generated_numeric_dtypes_are_numeric(xp, xps):
function skipif_unsupported_complex (line 66) | def skipif_unsupported_complex(strat_name, dtype_name):
function test_strategy_can_generate_every_dtype (line 85) | def test_strategy_can_generate_every_dtype(xp, xps, strat_name, dtype_na...
function test_minimise_scalar_dtypes (line 92) | def test_minimise_scalar_dtypes(xp, xps):
function test_can_specify_sizes_as_an_int (line 108) | def test_can_specify_sizes_as_an_int(xp, xps, strat_name, sizes):
FILE: hypothesis-python/tests/array_api/test_strategies_namespace.py
class HashableArrayModuleFactory (line 34) | class HashableArrayModuleFactory:
method __getattr__ (line 40) | def __getattr__(self, name):
method __hash__ (line 43) | def __hash__(self):
function test_caching (line 48) | def test_caching(api_version, monkeypatch):
function test_inferred_namespace_shares_cache (line 68) | def test_inferred_namespace_shares_cache(api_version1, api_version2, mon...
function test_complex_dtypes_raises_on_2021_12 (line 85) | def test_complex_dtypes_raises_on_2021_12():
FILE: hypothesis-python/tests/attrs/test_attrs.py
function a_converter (line 22) | def a_converter(x) -> int:
class Inferrables (line 27) | class Inferrables:
function test_attrs_inference_builds (line 32) | def test_attrs_inference_builds(c):
function test_attrs_inference_from_type (line 36) | def test_attrs_inference_from_type():
class AttrsClass (line 44) | class AttrsClass:
function test_jsonable_attrs (line 48) | def test_jsonable_attrs():
function test_hypothesis_is_not_the_first_to_import_attrs (line 53) | def test_hypothesis_is_not_the_first_to_import_attrs(testdir):
FILE: hypothesis-python/tests/attrs/test_inference.py
class Inferrables (line 27) | class Inferrables:
class Required (line 72) | class Required:
class UnhelpfulConverter (line 77) | class UnhelpfulConverter:
function test_attrs_inference_builds (line 82) | def test_attrs_inference_builds(c):
function test_attrs_inference_from_type (line 87) | def test_attrs_inference_from_type(c):
function test_cannot_infer (line 92) | def test_cannot_infer(c):
function test_cannot_infer_takes_self (line 97) | def test_cannot_infer_takes_self():
class HasPrivateAttribute (line 105) | class HasPrivateAttribute:
function test_private_attribute (line 110) | def test_private_attribute(s):
function test_private_attribute_underscore_fails (line 114) | def test_private_attribute_underscore_fails():
function test_private_attribute_underscore_infer_fails (line 119) | def test_private_attribute_underscore_infer_fails():
class HasAliasedAttribute (line 129) | class HasAliasedAttribute:
function test_aliased_attribute (line 134) | def test_aliased_attribute(s):
FILE: hypothesis-python/tests/attrs/test_pretty.py
class ReprDetector (line 16) | class ReprDetector:
method _repr_pretty_ (line 17) | def _repr_pretty_(self, p, cycle):
method __repr__ (line 21) | def __repr__(self):
class SomeAttrsClass (line 26) | class SomeAttrsClass:
function test_pretty_prints_attrs_classes (line 30) | def test_pretty_prints_attrs_classes():
class SomeAttrsClassWithCustomPretty (line 35) | class SomeAttrsClassWithCustomPretty:
method _repr_pretty_ (line 36) | def _repr_pretty_(self, p, cycle):
function test_custom_pretty_print_method_overrides_field_printing (line 41) | def test_custom_pretty_print_method_overrides_field_printing():
class SomeAttrsClassWithLotsOfFields (line 46) | class SomeAttrsClassWithLotsOfFields:
function test_will_line_break_between_fields (line 68) | def test_will_line_break_between_fields():
class SomeDataClassWithNoFields (line 79) | class SomeDataClassWithNoFields: ...
function test_prints_empty_dataclass_correctly (line 82) | def test_prints_empty_dataclass_correctly():
class AttrsClassWithNoInitField (line 87) | class AttrsClassWithNoInitField:
function test_does_not_include_no_init_fields_in_attrs_printing (line 92) | def test_does_not_include_no_init_fields_in_attrs_printing():
class Namespace (line 99) | class Namespace:
class A (line 101) | class A:
function test_includes_namespace_classes_in_pretty (line 105) | def test_includes_namespace_classes_in_pretty():
FILE: hypothesis-python/tests/codemods/test_codemod_cli.py
function run (line 35) | def run(command, *, cwd=None, input=None):
function test_codemod_single_file (line 47) | def test_codemod_single_file(tmp_path):
function test_codemod_multiple_files (line 55) | def test_codemod_multiple_files(tmp_path):
function test_codemod_from_stdin (line 66) | def test_codemod_from_stdin():
FILE: hypothesis-python/tests/codemods/test_codemods.py
function test_refactor_function_is_idempotent (line 16) | def test_refactor_function_is_idempotent():
class TestFixComplexMinMagnitude (line 26) | class TestFixComplexMinMagnitude(CodemodTest):
method test_noop (line 29) | def test_noop(self) -> None:
method test_substitution (line 43) | def test_substitution(self) -> None:
class TestFixPositionalKeywonlyArgs (line 55) | class TestFixPositionalKeywonlyArgs(CodemodTest):
method test_substitution (line 58) | def test_substitution(self) -> None:
method test_noop_with_new_floats_kw (line 73) | def test_noop_with_new_floats_kw(self) -> None:
method test_noop_if_unsure (line 81) | def test_noop_if_unsure(self) -> None:
method test_stateful_rule_noop (line 103) | def test_stateful_rule_noop(self):
method test_kwargs_noop (line 116) | def test_kwargs_noop(self):
method test_noop_with_too_many_arguments_passed (line 125) | def test_noop_with_too_many_arguments_passed(self) -> None:
class TestHealthCheckAll (line 136) | class TestHealthCheckAll(CodemodTest):
method test_noop_other_attributes (line 139) | def test_noop_other_attributes(self):
method test_substitution (line 144) | def test_substitution(self) -> None:
class TestFixCharactersArguments (line 152) | class TestFixCharactersArguments(CodemodTest):
method test_substitution (line 155) | def test_substitution(self) -> None:
method test_remove_redundant_exclude_categories (line 163) | def test_remove_redundant_exclude_categories(self) -> None:
FILE: hypothesis-python/tests/common/__init__.py
function abc (line 46) | def abc(x, y, z):
FILE: hypothesis-python/tests/common/arguments.py
function e (line 17) | def e(a, *args, **kwargs):
function e_to_str (line 21) | def e_to_str(elt):
function argument_validation_test (line 28) | def argument_validation_test(bad_args):
FILE: hypothesis-python/tests/common/costbounds.py
function find_integer_cost (line 16) | def find_integer_cost(n):
FILE: hypothesis-python/tests/common/debug.py
class Found (line 29) | class Found(Exception):
function minimal (line 33) | def minimal(
function find_any (line 86) | def find_any(definition, condition=lambda _: True, settings=None):
function assert_no_examples (line 104) | def assert_no_examples(strategy, condition=lambda _: True):
function assert_all_examples (line 111) | def assert_all_examples(strategy, predicate, settings=None):
function assert_simple_property (line 135) | def assert_simple_property(strategy, predicate, settings=None):
function check_can_generate_examples (line 154) | def check_can_generate_examples(strategy, settings=None):
FILE: hypothesis-python/tests/common/setup.py
function run (line 26) | def run():
FILE: hypothesis-python/tests/common/strategies.py
class _Slow (line 16) | class _Slow(SearchStrategy):
method do_draw (line 17) | def do_draw(self, data):
class HardToShrink (line 25) | class HardToShrink(SearchStrategy):
method __init__ (line 26) | def __init__(self):
method do_draw (line 31) | def do_draw(self, data):
FILE: hypothesis-python/tests/common/utils.py
function flaky (line 48) | def flaky(max_runs, min_passes):
function capture_out (line 75) | def capture_out():
class ExcInfo (line 89) | class ExcInfo:
function fails_with (line 93) | def fails_with(e, *, match=None):
class NotDeprecated (line 108) | class NotDeprecated(Exception):
function validate_deprecation (line 113) | def validate_deprecation():
function checks_deprecated_behaviour (line 135) | def checks_deprecated_behaviour(func):
function all_values (line 146) | def all_values(db):
function non_covering_examples (line 150) | def non_covering_examples(database):
function counts_calls (line 156) | def counts_calls(func):
function assert_output_contains_failure (line 171) | def assert_output_contains_failure(output, test, **kwargs):
function assert_falsifying_output (line 177) | def assert_falsifying_output(
function temp_registered (line 200) | def temp_registered(type_, strat_or_factory):
function raises_warning (line 219) | def raises_warning(expected_warning, match=None):
function capture_observations (line 227) | def capture_observations(*, choices=None):
class Why (line 250) | class Why(enum.Enum):
function xfail_on_crosshair (line 259) | def xfail_on_crosshair(why: Why, /, *, strict=True, as_marks=False):
function skipif_threading (line 271) | def skipif_threading(f):
function xfail_if_gil_disabled (line 277) | def xfail_if_gil_disabled(f):
function restore_recursion_limit (line 296) | def restore_recursion_limit():
function run_concurrently (line 305) | def run_concurrently(function, *, n: int) -> None:
function wait_for (line 327) | def wait_for(condition, *, timeout=1, interval=0.01):
FILE: hypothesis-python/tests/conftest.py
function pytest_configure (line 53) | def pytest_configure(config):
function pytest_addoption (line 74) | def pytest_addoption(parser):
function warns_or_raises (line 81) | def warns_or_raises(request):
function _make_unknown_lambdas_fail (line 104) | def _make_unknown_lambdas_fail(monkeypatch):
function allow_unknown_lambdas (line 121) | def allow_unknown_lambdas(monkeypatch):
function _consistently_increment_time (line 137) | def _consistently_increment_time(monkeypatch):
function pytest_runtest_call (line 214) | def pytest_runtest_call(item):
function _worker_path (line 266) | def _worker_path(session: pytest.Session) -> Path:
function _benchmark_shrinks (line 274) | def _benchmark_shrinks(item: pytest.Function) -> None:
function pytest_sessionfinish (line 318) | def pytest_sessionfinish(session, exitstatus):
FILE: hypothesis-python/tests/conjecture/common.py
function interesting_origin (line 39) | def interesting_origin(n: int | None = None) -> InterestingOrigin:
function run_to_data (line 55) | def run_to_data(f):
function run_to_nodes (line 69) | def run_to_nodes(f):
function buffer_size_limit (line 77) | def buffer_size_limit(n):
function shrinking_from (line 87) | def shrinking_from(start):
function fresh_data (line 110) | def fresh_data(*, random=None, observer=None) -> ConjectureData:
function clamped_shrink_towards (line 150) | def clamped_shrink_towards(constraints):
function draw_value (line 159) | def draw_value(choice_type, constraints):
function choices (line 165) | def choices(draw):
function nodes (line 171) | def nodes(draw, *, was_forced=None, choice_types=None):
function nodes_inline (line 187) | def nodes_inline(*values: list[ChoiceT]) -> list[ChoiceNode]:
function float_constr (line 248) | def float_constr(
function integer_constr (line 263) | def integer_constr(min_value=None, max_value=None, *, weights=None, shri...
function string_constr (line 272) | def string_constr(intervals, *, min_size=0, max_size=COLLECTION_DEFAULT_...
FILE: hypothesis-python/tests/conjecture/test_choice.py
function test_compute_max_children_is_positive (line 71) | def test_compute_max_children_is_positive(choice_type_and_constraints):
function test_compute_max_children (line 171) | def test_compute_max_children(choice_type, constraints, count_children):
function test_draw_string_single_interval_with_equal_bounds (line 176) | def test_draw_string_single_interval_with_equal_bounds(s, n):
function test_compute_max_children_and_all_children_agree (line 208) | def test_compute_max_children_and_all_children_agree(choice_type_and_con...
function test_compute_max_children_unbounded_integer_ranges (line 228) | def test_compute_max_children_unbounded_integer_ranges(constraints):
function test_nodes (line 235) | def test_nodes(random):
function test_copy_choice_node (line 288) | def test_copy_choice_node(node):
function test_choice_node_equality (line 300) | def test_choice_node_equality(node):
function test_cannot_modify_forced_nodes (line 307) | def test_cannot_modify_forced_nodes(node):
function test_data_with_empty_choices_is_overrun (line 312) | def test_data_with_empty_choices_is_overrun():
function test_data_with_changed_forced_value (line 321) | def test_data_with_changed_forced_value(node):
function test_data_with_same_forced_value_is_valid (line 377) | def test_data_with_same_forced_value_is_valid(node):
function test_all_children_are_permitted_values (line 392) | def test_all_children_are_permitted_values(choice_type_and_constraints):
function test_choice_permitted (line 461) | def test_choice_permitted(value, constraints, permitted):
function test_forced_nodes_are_trivial (line 466) | def test_forced_nodes_are_trivial(node):
function test_trivial_nodes (line 587) | def test_trivial_nodes(node):
function test_nontrivial_nodes (line 662) | def test_nontrivial_nodes(node):
function test_conservative_nontrivial_nodes (line 709) | def test_conservative_nontrivial_nodes(node):
function test_choice_node_is_hashable (line 723) | def test_choice_node_is_hashable(node):
function test_choices_size_positive (line 728) | def test_choices_size_positive(nodes):
function test_node_template_count (line 733) | def test_node_template_count(n):
function test_node_template_to_overrun (line 738) | def test_node_template_to_overrun():
function test_node_template_single_node_overruns (line 748) | def test_node_template_single_node_overruns():
function test_node_template_simplest_is_actually_trivial (line 759) | def test_node_template_simplest_is_actually_trivial(node):
function test_choice_indices_are_positive (line 771) | def test_choice_indices_are_positive(choice_type_and_constraints):
function test_shrink_towards_has_index_0 (line 778) | def test_shrink_towards_has_index_0(constraints):
function test_choice_to_index_injective (line 787) | def test_choice_to_index_injective(choice_type_and_constraints):
function test_choice_from_value_injective (line 812) | def test_choice_from_value_injective(choice_type_and_constraints):
function test_choice_index_and_value_are_inverses (line 825) | def test_choice_index_and_value_are_inverses(choice_type_and_constraints):
function test_choice_index_and_value_are_inverses_explicit (line 856) | def test_choice_index_and_value_are_inverses_explicit(
function test_integer_choice_index (line 887) | def test_integer_choice_index(constraints, choices):
function test_drawing_directly_matches_for_choices (line 895) | def test_drawing_directly_matches_for_choices(nodes):
function test_draw_directly_explicit (line 902) | def test_draw_directly_explicit():
function test_choices_key_distinguishes_weird_cases (line 944) | def test_choices_key_distinguishes_weird_cases(choices1, choices2):
function test_node_template_overrun (line 948) | def test_node_template_overrun():
FILE: hypothesis-python/tests/conjecture/test_choice_tree.py
function select (line 21) | def select(*args):
function exhaust (line 25) | def exhaust(f):
function test_can_enumerate_a_shallow_set (line 40) | def test_can_enumerate_a_shallow_set(ls):
function test_can_enumerate_a_nested_set (line 46) | def test_can_enumerate_a_nested_set():
function test_can_enumerate_empty (line 56) | def test_can_enumerate_empty():
function test_all_filtered_child (line 64) | def test_all_filtered_child():
function test_skips_over_exhausted_children (line 72) | def test_skips_over_exhausted_children():
function test_extends_prefix_from_right (line 92) | def test_extends_prefix_from_right():
function test_starts_from_the_end (line 101) | def test_starts_from_the_end():
function test_skips_over_exhausted_subtree (line 109) | def test_skips_over_exhausted_subtree():
function test_exhausts_randomly (line 118) | def test_exhausts_randomly():
function test_exhausts_randomly_when_filtering (line 135) | def test_exhausts_randomly_when_filtering():
FILE: hypothesis-python/tests/conjecture/test_data_tree.py
function runner_for (line 47) | def runner_for(*examples):
function test_can_lookup_cached_examples (line 65) | def test_can_lookup_cached_examples():
function test_can_lookup_cached_examples_with_forced (line 72) | def test_can_lookup_cached_examples_with_forced():
function test_can_detect_when_tree_is_exhausted (line 79) | def test_can_detect_when_tree_is_exhausted():
function test_can_detect_when_tree_is_exhausted_variable_size (line 87) | def test_can_detect_when_tree_is_exhausted_variable_size():
function test_one_dead_branch (line 96) | def test_one_dead_branch():
function test_non_dead_root (line 107) | def test_non_dead_root():
function test_can_reexecute_dead_examples (line 114) | def test_can_reexecute_dead_examples():
function test_novel_prefixes_are_novel (line 121) | def test_novel_prefixes_are_novel():
function test_overruns_if_prefix (line 138) | def test_overruns_if_prefix():
function test_stores_the_tree_flat_until_needed (line 148) | def test_stores_the_tree_flat_until_needed():
function test_split_in_the_middle (line 161) | def test_split_in_the_middle():
function test_stores_forced_nodes (line 175) | def test_stores_forced_nodes():
function test_correctly_relocates_forced_nodes (line 187) | def test_correctly_relocates_forced_nodes():
function test_can_go_from_interesting_to_valid (line 199) | def test_can_go_from_interesting_to_valid():
function test_going_from_interesting_to_invalid_is_flaky (line 210) | def test_going_from_interesting_to_invalid_is_flaky():
function test_concluding_at_prefix_is_flaky (line 221) | def test_concluding_at_prefix_is_flaky():
function test_concluding_with_overrun_at_prefix_is_not_flaky (line 233) | def test_concluding_with_overrun_at_prefix_is_not_flaky():
function test_changing_n_bits_is_flaky_in_prefix (line 245) | def test_changing_n_bits_is_flaky_in_prefix():
function test_changing_n_bits_is_flaky_in_branch (line 257) | def test_changing_n_bits_is_flaky_in_branch():
function test_extending_past_conclusion_is_flaky (line 271) | def test_extending_past_conclusion_is_flaky():
function test_changing_to_forced_is_flaky (line 285) | def test_changing_to_forced_is_flaky():
function test_changing_value_of_forced_is_flaky (line 298) | def test_changing_value_of_forced_is_flaky():
function test_does_not_truncate_if_unseen (line 311) | def test_does_not_truncate_if_unseen():
function test_truncates_if_seen (line 317) | def test_truncates_if_seen():
function test_child_becomes_exhausted_after_split (line 330) | def test_child_becomes_exhausted_after_split():
function test_will_generate_novel_prefix_to_avoid_exhausted_branches (line 346) | def test_will_generate_novel_prefix_to_avoid_exhausted_branches():
function test_will_mark_changes_in_discard_as_flaky (line 363) | def test_will_mark_changes_in_discard_as_flaky():
function test_is_not_flaky_on_positive_zero_and_negative_zero (line 380) | def test_is_not_flaky_on_positive_zero_and_negative_zero():
function test_low_probabilities_are_still_explored (line 404) | def test_low_probabilities_are_still_explored():
function _test_observed_draws_are_recorded_in_tree (line 413) | def _test_observed_draws_are_recorded_in_tree(choice_type):
function _test_non_observed_draws_are_not_recorded_in_tree (line 433) | def _test_non_observed_draws_are_not_recorded_in_tree(choice_type):
function test_observed_choice_type_draw (line 453) | def test_observed_choice_type_draw(choice_type):
function test_non_observed_choice_type_draw (line 460) | def test_non_observed_choice_type_draw(choice_type):
function test_can_generate_hard_values (line 464) | def test_can_generate_hard_values():
function test_can_generate_hard_floats (line 484) | def test_can_generate_hard_floats():
function test_datatree_repr (line 524) | def test_datatree_repr(bool_constraints, int_constraints):
function _draw (line 567) | def _draw(data, node, *, forced=None):
function test_simulate_forced_floats (line 572) | def test_simulate_forced_floats(node):
FILE: hypothesis-python/tests/conjecture/test_engine.py
function test_non_cloneable_intervals (line 69) | def test_non_cloneable_intervals():
function test_deletable_draws (line 79) | def test_deletable_draws():
function test_can_load_data_from_a_corpus (line 90) | def test_can_load_data_from_a_corpus():
function slow_shrinker (line 107) | def slow_shrinker():
function test_terminates_shrinks (line 118) | def test_terminates_shrinks(n, monkeypatch):
function test_detects_flakiness (line 144) | def test_detects_flakiness():
function recur (line 162) | def recur(i, data):
function test_recursion_error_is_not_flaky (line 171) | def test_recursion_error_is_not_flaky():
function test_variadic_draw (line 184) | def test_variadic_draw():
function test_draw_to_overrun (line 205) | def test_draw_to_overrun():
function test_can_navigate_to_a_valid_example (line 216) | def test_can_navigate_to_a_valid_example():
function test_stops_after_max_examples_when_reading (line 228) | def test_stops_after_max_examples_when_reading():
function test_stops_after_max_examples_when_generating (line 247) | def test_stops_after_max_examples_when_generating():
function test_stops_after_max_examples_when_generating_more_bugs (line 259) | def test_stops_after_max_examples_when_generating_more_bugs(examples):
function test_interleaving_engines (line 286) | def test_interleaving_engines():
function test_phases_can_disable_shrinking (line 308) | def test_phases_can_disable_shrinking():
function test_reuse_phase_runs_for_max_examples_if_generation_is_disabled (line 322) | def test_reuse_phase_runs_for_max_examples_if_generation_is_disabled():
function test_erratic_draws (line 341) | def test_erratic_draws():
function test_no_read_no_shrink (line 357) | def test_no_read_no_shrink():
function test_one_dead_branch (line 370) | def test_one_dead_branch():
function test_does_not_save_on_interrupt (line 385) | def test_does_not_save_on_interrupt():
function test_saves_on_skip_exceptions_to_reraise (line 398) | def test_saves_on_skip_exceptions_to_reraise():
function test_returns_forced (line 416) | def test_returns_forced():
function fails_health_check (line 427) | def fails_health_check(label, **kwargs):
function test_fails_health_check_for_all_invalid (line 444) | def test_fails_health_check_for_all_invalid():
function test_fails_health_check_for_large_base (line 451) | def test_fails_health_check_for_large_base():
function test_fails_health_check_for_large_non_base (line 457) | def test_fails_health_check_for_large_non_base():
function test_fails_health_check_for_slow_draws (line 465) | def test_fails_health_check_for_slow_draws():
function test_health_check_too_slow_with_invalid_examples (line 471) | def test_health_check_too_slow_with_invalid_examples():
function test_health_check_too_slow_with_overrun_examples (line 492) | def test_health_check_too_slow_with_overrun_examples():
function test_can_shrink_variable_draws (line 517) | def test_can_shrink_variable_draws(n_large):
function test_can_shrink_variable_string_draws (line 530) | def test_can_shrink_variable_string_draws():
function test_variable_size_string_increasing (line 547) | def test_variable_size_string_increasing():
function test_run_nothing (line 563) | def test_run_nothing():
class Foo (line 572) | class Foo:
method __repr__ (line 573) | def __repr__(self):
function test_debug_data (line 577) | def test_debug_data(capsys):
function test_can_write_bytes_towards_the_end (line 605) | def test_can_write_bytes_towards_the_end():
function test_uniqueness_is_preserved_when_writing_at_beginning (line 618) | def test_uniqueness_is_preserved_when_writing_at_beginning():
function test_clears_out_its_database_on_shrinking (line 634) | def test_clears_out_its_database_on_shrinking(
function test_shrinks_both_interesting_examples (line 668) | def test_shrinks_both_interesting_examples(monkeypatch):
function test_discarding (line 686) | def test_discarding(monkeypatch):
function test_can_remove_discarded_data (line 708) | def test_can_remove_discarded_data():
function test_discarding_iterates_to_fixed_point (line 723) | def test_discarding_iterates_to_fixed_point():
function test_discarding_is_not_fooled_by_empty_discards (line 737) | def test_discarding_is_not_fooled_by_empty_discards():
function test_discarding_can_fail (line 750) | def test_discarding_can_fail():
function test_shrinking_from_mostly_zero (line 762) | def test_shrinking_from_mostly_zero(monkeypatch):
function test_handles_nesting_of_discard_correctly (line 778) | def test_handles_nesting_of_discard_correctly(monkeypatch):
function test_database_clears_secondary_key (line 801) | def test_database_clears_secondary_key():
function test_database_uses_values_from_secondary_key (line 834) | def test_database_uses_values_from_secondary_key():
function test_exit_because_max_iterations (line 870) | def test_exit_because_max_iterations():
function test_max_iterations_with_all_invalid (line 888) | def test_max_iterations_with_all_invalid():
function test_max_iterations_with_some_valid (line 908) | def test_max_iterations_with_some_valid(n_valid):
function test_exit_because_shrink_phase_timeout (line 934) | def test_exit_because_shrink_phase_timeout(monkeypatch):
function test_dependent_block_pairs_can_lower_to_zero (line 953) | def test_dependent_block_pairs_can_lower_to_zero():
function test_handle_size_too_large_during_dependent_lowering (line 968) | def test_handle_size_too_large_during_dependent_lowering():
function test_block_may_grow_during_lexical_shrinking (line 980) | def test_block_may_grow_during_lexical_shrinking():
function test_lower_common_node_offset_does_nothing_when_changed_blocks_are_zero (line 995) | def test_lower_common_node_offset_does_nothing_when_changed_blocks_are_z...
function test_lower_common_node_offset_ignores_zeros (line 1010) | def test_lower_common_node_offset_ignores_zeros():
function test_cached_test_function_returns_right_value (line 1025) | def test_cached_test_function_returns_right_value():
function test_cached_test_function_does_not_reinvoke_on_prefix (line 1043) | def test_cached_test_function_does_not_reinvoke_on_prefix():
function test_will_evict_entries_from_the_cache (line 1063) | def test_will_evict_entries_from_the_cache(monkeypatch):
function test_branch_ending_in_write (line 1084) | def test_branch_ending_in_write():
function test_exhaust_space (line 1111) | def test_exhaust_space():
function test_discards_kill_branches (line 1123) | def test_discards_kill_branches():
function test_number_of_examples_in_integer_range_is_bounded (line 1146) | def test_number_of_examples_in_integer_range_is_bounded(n):
function test_prefix_cannot_exceed_buffer_size (line 1155) | def test_prefix_cannot_exceed_buffer_size(monkeypatch):
function test_does_not_shrink_multiple_bugs_when_told_not_to (line 1170) | def test_does_not_shrink_multiple_bugs_when_told_not_to():
function test_does_not_keep_generating_when_multiple_bugs (line 1192) | def test_does_not_keep_generating_when_multiple_bugs():
function test_shrink_after_max_examples (line 1210) | def test_shrink_after_max_examples():
function test_shrink_after_max_iterations (line 1265) | def test_shrink_after_max_iterations():
function test_populates_the_pareto_front (line 1321) | def test_populates_the_pareto_front():
function test_pareto_front_contains_smallest_valid (line 1340) | def test_pareto_front_contains_smallest_valid():
function test_replaces_all_dominated (line 1360) | def test_replaces_all_dominated():
function test_does_not_duplicate_elements (line 1385) | def test_does_not_duplicate_elements():
function test_includes_right_hand_side_targets_in_dominance (line 1404) | def test_includes_right_hand_side_targets_in_dominance():
function test_smaller_interesting_dominates_larger_valid (line 1421) | def test_smaller_interesting_dominates_larger_valid():
function test_runs_full_set_of_examples (line 1437) | def test_runs_full_set_of_examples():
function test_runs_optimisation_even_if_not_generating (line 1451) | def test_runs_optimisation_even_if_not_generating():
function test_runs_optimisation_once_when_generating (line 1466) | def test_runs_optimisation_once_when_generating():
function test_does_not_run_optimisation_when_max_examples_is_small (line 1482) | def test_does_not_run_optimisation_when_max_examples_is_small():
function test_does_not_cache_extended_prefix (line 1498) | def test_does_not_cache_extended_prefix():
function test_does_cache_if_extend_is_not_used (line 1512) | def test_does_cache_if_extend_is_not_used():
function test_does_result_for_reuse (line 1529) | def test_does_result_for_reuse():
function test_does_not_use_cached_overrun_if_extending (line 1546) | def test_does_not_use_cached_overrun_if_extending():
function test_uses_cached_overrun_if_not_extending (line 1564) | def test_uses_cached_overrun_if_not_extending():
function test_can_be_set_to_ignore_limits (line 1580) | def test_can_be_set_to_ignore_limits():
function test_too_slow_report (line 1596) | def test_too_slow_report():
function _draw (line 1623) | def _draw(cd, node):
function test_overruns_with_extend_are_not_cached (line 1628) | def test_overruns_with_extend_are_not_cached(node):
function test_simulate_to_evicted_data (line 1653) | def test_simulate_to_evicted_data(monkeypatch):
function test_mildly_complicated_strategies (line 1688) | def test_mildly_complicated_strategies(strategy, condition):
function test_does_not_shrink_if_replaying_from_database (line 1695) | def test_does_not_shrink_if_replaying_from_database():
function test_does_shrink_if_replaying_inexact_from_database (line 1712) | def test_does_shrink_if_replaying_inexact_from_database():
function test_stops_if_hits_interesting_early_and_only_want_one_bug (line 1727) | def test_stops_if_hits_interesting_early_and_only_want_one_bug():
function test_skips_secondary_if_interesting_is_found (line 1744) | def test_skips_secondary_if_interesting_is_found():
function test_discards_invalid_db_entries (line 1767) | def test_discards_invalid_db_entries(key_name):
function test_discards_invalid_db_entries_pareto (line 1799) | def test_discards_invalid_db_entries_pareto():
FILE: hypothesis-python/tests/conjecture/test_float_encoding.py
function assert_reordered_exponents (line 28) | def assert_reordered_exponents(res):
function test_encode_permutes_elements (line 36) | def test_encode_permutes_elements():
function test_decode_permutes_elements (line 40) | def test_decode_permutes_elements():
function test_decode_encode (line 44) | def test_decode_encode():
function test_encode_decode (line 49) | def test_encode_decode():
function test_double_reverse_bounded (line 55) | def test_double_reverse_bounded(data):
function test_double_reverse (line 63) | def test_double_reverse(i):
function test_floats_round_trip (line 76) | def test_floats_round_trip(f):
function test_floats_order_worse_than_their_integral_part (line 86) | def test_floats_order_worse_than_their_integral_part(n, g):
function test_integral_floats_order_as_integers (line 105) | def test_integral_floats_order_as_integers(x, y):
function test_fractional_floats_are_worse_than_one (line 112) | def test_fractional_floats_are_worse_than_one(f):
function test_reverse_bits_table_reverses_bits (line 117) | def test_reverse_bits_table_reverses_bits():
function test_reverse_bits_table_has_right_elements (line 122) | def test_reverse_bits_table_has_right_elements():
function float_runner (line 126) | def float_runner(start, condition, *, constraints=None):
function minimal_from (line 140) | def minimal_from(start, condition, *, constraints=None):
function test_can_shrink_downwards (line 161) | def test_can_shrink_downwards(start, end):
function test_shrinks_downwards_to_integers (line 169) | def test_shrinks_downwards_to_integers(f, mul):
function test_shrink_to_integer_upper_bound (line 174) | def test_shrink_to_integer_upper_bound():
function test_shrink_up_to_one (line 178) | def test_shrink_up_to_one():
function test_shrink_down_to_half (line 182) | def test_shrink_down_to_half():
function test_shrink_fractional_part (line 186) | def test_shrink_fractional_part():
function test_does_not_shrink_across_one (line 190) | def test_does_not_shrink_across_one():
function test_reject_out_of_bounds_floats_while_shrinking (line 201) | def test_reject_out_of_bounds_floats_while_shrinking():
function test_shrinks_to_canonical_nan (line 209) | def test_shrinks_to_canonical_nan(nan):
FILE: hypothesis-python/tests/conjecture/test_forced.py
function test_forced_many (line 30) | def test_forced_many(data):
function test_forced_values (line 134) | def test_forced_values(choice_type_and_constraints):
function test_forced_floats_with_nan (line 161) | def test_forced_floats_with_nan(random, sign, min_value, max_value):
function test_forced_with_large_magnitude_integers (line 169) | def test_forced_with_large_magnitude_integers(data):
FILE: hypothesis-python/tests/conjecture/test_inquisitor.py
function fails_with_output (line 20) | def fails_with_output(expected):
function test_inquisitor_comments_basic_fail_if_either (line 55) | def test_inquisitor_comments_basic_fail_if_either(a, b, c, d, e):
function test_inquisitor_comments_basic_fail_if_not_all (line 71) | def test_inquisitor_comments_basic_fail_if_not_all(a, b, c):
function test_inquisitor_no_together_comment_if_single_argument (line 86) | def test_inquisitor_no_together_comment_if_single_argument(a, b):
function ints_with_forced_draw (line 91) | def ints_with_forced_draw(draw):
function test_inquisitor_doesnt_break_on_varying_forced_nodes (line 108) | def test_inquisitor_doesnt_break_on_varying_forced_nodes(n1, n2):
function test_issue_3755_regression (line 115) | def test_issue_3755_regression(start_date, data):
class MyClass (line 123) | class MyClass:
method __init__ (line 124) | def __init__(self, x, y):
function test_inquisitor_builds_subargs (line 141) | def test_inquisitor_builds_subargs(obj):
function test_inquisitor_builds_kwargs_subargs (line 157) | def test_inquisitor_builds_kwargs_subargs(obj):
function test_inquisitor_tuple_subargs (line 173) | def test_inquisitor_tuple_subargs(t):
function test_inquisitor_fixeddict_subargs (line 189) | def test_inquisitor_fixeddict_subargs(d):
function test_inquisitor_tuple_multiple_varying (line 206) | def test_inquisitor_tuple_multiple_varying(t):
function test_inquisitor_skip_subset_slices (line 224) | def test_inquisitor_skip_subset_slices(obj):
function test_inquisitor_duplicate_param_names (line 244) | def test_inquisitor_duplicate_param_names(kw, b):
class Outer (line 252) | class Outer:
method __init__ (line 253) | def __init__(self, inner, value):
class Inner (line 258) | class Inner:
method __init__ (line 259) | def __init__(self, x):
function test_inquisitor_multi_level_nesting (line 281) | def test_inquisitor_multi_level_nesting(bare, outer):
FIL
Condensed preview — 666 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,118K chars).
[
{
"path": ".claude/CLAUDE.md",
"chars": 2068,
"preview": "# Hypothesis Development Guide\n\n## Essential Reading\n\n**Always read `CONTRIBUTING.rst` before starting work**, especiall"
},
{
"path": ".claude/commands/hypothesis.md",
"chars": 6597,
"preview": "---\ndescription: Write property-based tests with Hypothesis\n---\n\nYou are an expert developer of property-based tests, sp"
},
{
"path": ".gitattributes",
"chars": 126,
"preview": "* text eol=lf\n\n# Denote all files that are truly binary and should not be modified.\n*.png binary\n*.jpg binary\n*.gif b"
},
{
"path": ".github/CODEOWNERS",
"chars": 363,
"preview": "# Engine changes need to be approved by Zac-HD, as per\n# https://github.com/HypothesisWorks/hypothesis/blob/master/guide"
},
{
"path": ".github/CODE_OF_CONDUCT.rst",
"chars": 2631,
"preview": "---------------\nCode of conduct\n---------------\n\nHypothesis's community is an inclusive space, and everyone in it is exp"
},
{
"path": ".github/actions/install-base/action.yml",
"chars": 1670,
"preview": "name: \"Install\"\ndescription: \"Install python, then cache\"\ninputs:\n python-version:\n description: \"Python version\"\n "
},
{
"path": ".github/workflows/fuzz.yml",
"chars": 3258,
"preview": "name: Fuzzing\n\nenv:\n # Tell pytest and other tools to produce coloured terminal output.\n # Make sure this is also in t"
},
{
"path": ".github/workflows/main.yml",
"chars": 10717,
"preview": "name: Hypothesis CI\n\nenv:\n # Tell pytest and other tools to produce coloured terminal output.\n # Make sure this is als"
},
{
"path": ".github/workflows/update-deps.yml",
"chars": 901,
"preview": "name: Update pinned dependencies\n\non:\n schedule:\n - cron: 0 0 * * 0\n workflow_dispatch:\n\njobs:\n release:\n name:"
},
{
"path": ".github/workflows/website.yml",
"chars": 1167,
"preview": "name: Build website & deploy to GitHub Pages\n\non:\n # Runs on pushes targeting the default branch\n push:\n branches: "
},
{
"path": ".gitignore",
"chars": 1229,
"preview": "# mypyc\n\n*.so\n\n# misc (editors, file systems, etc)\n\n*.swo\n*.swp\n.idea\n.vagrant\n.DS_Store\n.hypothesis\n.vscode/\n.claude/se"
},
{
"path": ".readthedocs.yml",
"chars": 670,
"preview": "# Read the Docs configuration file\n# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details\n\n# Requir"
},
{
"path": "AUTHORS.rst",
"chars": 12321,
"preview": "--------------------\nList of Contributors\n--------------------\n\nThe primary author for most of Hypothesis is David R. Ma"
},
{
"path": "CITATION.cff",
"chars": 2188,
"preview": "cff-version: 1.2.0\nmessage: |\n If you use Hypothesis as part of a published research project,\n please cite our paper i"
},
{
"path": "CONTRIBUTING.rst",
"chars": 10915,
"preview": "=============\nContributing\n=============\n\nFirst off: It's great that you want to contribute to Hypothesis! Thanks!\n\n----"
},
{
"path": "LICENSE.txt",
"chars": 414,
"preview": "Copyright (c) 2013, David R. MacIver\n\nAll code in this repository except where explicitly noted otherwise is released\nun"
},
{
"path": "README.md",
"chars": 1637,
"preview": "<div align=\"center\">\n <img src=\"https://raw.githubusercontent.com/HypothesisWorks/hypothesis/master/brand/dragonfly-rai"
},
{
"path": "brand/README.md",
"chars": 2202,
"preview": "# Logos and other pretty things\n\nHypothesis has a beautiful logo, thanks to the generous work of Libby Berrie in [issue "
},
{
"path": "brand/hypothesis.gpl",
"chars": 1007,
"preview": "GIMP Palette\nName: Hypothesis Palette\nColumns: 1\n# generated by @kathyreid <kathy@kathyreid.id.au>\n# from the Dragonfly "
},
{
"path": "build.sh",
"chars": 1955,
"preview": "#!/usr/bin/env bash\n\n# This script is here to bootstrap the Hypothesis build process into a working\n# version of Python,"
},
{
"path": "guides/README.md",
"chars": 320,
"preview": "# Guides for Hypothesis Development\n\nThis is a general collection of useful documentation for people working on Hypothes"
},
{
"path": "guides/api-style.rst",
"chars": 10251,
"preview": "===============\nHouse API Style\n===============\n\nHere are some guidelines for how to write APIs so that they \"feel\" like"
},
{
"path": "guides/documentation.rst",
"chars": 3949,
"preview": "=====================================\nThe Hypothesis Documentation Handbook\n=====================================\n\nGood "
},
{
"path": "guides/internals.rst",
"chars": 15874,
"preview": "===================================\nHow to Work on Hypothesis Internals\n===================================\n\nThis is a g"
},
{
"path": "guides/review.rst",
"chars": 13435,
"preview": "===================================\nThe Hypothesis Code Review Handbook\n===================================\n\nThis docume"
},
{
"path": "guides/strategies-that-shrink.rst",
"chars": 12924,
"preview": "===================================\nDesigning strategies to shrink well\n===================================\n\nReducing te"
},
{
"path": "guides/testing-hypothesis.rst",
"chars": 2366,
"preview": "==================\nTesting Hypothesis\n==================\n\nNote: This guide is currently entirely specific to the Python "
},
{
"path": "hypothesis-python/LICENSE.txt",
"chars": 17141,
"preview": "Copyright (c) 2013, David R. MacIver\n\nAll code in this repository except where explicitly noted otherwise is released\nun"
},
{
"path": "hypothesis-python/README.md",
"chars": 75,
"preview": "The Hypothesis python readme has moved to [the main readme](../README.md)!\n"
},
{
"path": "hypothesis-python/RELEASE-sample.rst",
"chars": 1939,
"preview": "RELEASE_TYPE: patch\n\nThis patch improves import-detection in :doc:`the Ghostwriter <ghostwriter>`\n(:issue:`3884`), parti"
},
{
"path": "hypothesis-python/benchmark/README.md",
"chars": 921,
"preview": "This directory contains plotting code for our shrinker benchmarking. The code for collecting the data is in `conftest.py"
},
{
"path": "hypothesis-python/benchmark/graph.py",
"chars": 4028,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/benchmark/spec.json",
"chars": 12603,
"preview": "{\n \"$schema\": \"https://vega.github.io/schema/vega/v5.json\",\n \"width\": 1600,\n \"height\": 800,\n \"padding\": 5,\n "
},
{
"path": "hypothesis-python/docs/_ext/hypothesis_linkcheck.py",
"chars": 2071,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/docs/_ext/hypothesis_redirects.py",
"chars": 7519,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/docs/_static/better-signatures.css",
"chars": 470,
"preview": "/* dl gets used both for defining each top-level `.. autofunc` on a page (where we want vertical margsin)\n and is wrap"
},
{
"path": "hypothesis-python/docs/_static/dark-fix.css",
"chars": 375,
"preview": "/*\nSee https://github.com/HypothesisWorks/hypothesis/issues/4588 and\nhttps://github.com/pradyunsg/furo/discussions/909. "
},
{
"path": "hypothesis-python/docs/_static/no-scroll.css",
"chars": 159,
"preview": "/* disable autoscroll-to-target behavior\n https://github.com/pradyunsg/furo/discussions/384#discussioncomment-2249243 "
},
{
"path": "hypothesis-python/docs/_static/wrap-in-tables.css",
"chars": 477,
"preview": "/* override table width restrictions */\n/* thanks to https://github.com/readthedocs/sphinx_rtd_theme/issues/117#issuecom"
},
{
"path": "hypothesis-python/docs/changelog.rst",
"chars": 540320,
"preview": "=========\nChangelog\n=========\n\nThis is a record of all past Hypothesis releases and what went into them,\nin reverse chro"
},
{
"path": "hypothesis-python/docs/community.rst",
"chars": 1739,
"preview": "=========\nCommunity\n=========\n\nThe Hypothesis community is full of excellent people who can answer your questions and he"
},
{
"path": "hypothesis-python/docs/compatibility.rst",
"chars": 7596,
"preview": "Compatibility\n=============\n\nHypothesis generally does its level best to be compatible with everything you could need it"
},
{
"path": "hypothesis-python/docs/conf.py",
"chars": 8600,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/docs/development.rst",
"chars": 2015,
"preview": "======================\nHypothesis development\n======================\n\nHypothesis development is managed by `David R. Mac"
},
{
"path": "hypothesis-python/docs/explanation/domain.rst",
"chars": 5732,
"preview": "Domain and distribution\n=======================\n\n.. note::\n\n This page is primarily for users who may be familiar wit"
},
{
"path": "hypothesis-python/docs/explanation/example-count.rst",
"chars": 4102,
"preview": "How many times will Hypothesis run my test?\n===========================================\n\nThis is a trickier question tha"
},
{
"path": "hypothesis-python/docs/explanation/index.rst",
"chars": 207,
"preview": "Explanations\n============\n\nThese explanation pages are oriented towards deepening your understanding of Hypothesis, incl"
},
{
"path": "hypothesis-python/docs/extensions.rst",
"chars": 12872,
"preview": "Third-party extensions\n======================\n\nThere are a number of open-source community libraries that extend Hypothe"
},
{
"path": "hypothesis-python/docs/extras.rst",
"chars": 1411,
"preview": "======================\nFirst-party extensions\n======================\n\nHypothesis has minimal dependencies, to maximise\nc"
},
{
"path": "hypothesis-python/docs/how-to/custom-database.rst",
"chars": 2501,
"preview": "Write a custom Hypothesis database\n==================================\n\nTo define your own |ExampleDatabase| class, imple"
},
{
"path": "hypothesis-python/docs/how-to/detect-hypothesis-tests.rst",
"chars": 999,
"preview": "Detect Hypothesis tests\n-----------------------\n\nHow to dynamically determine whether a test function has been defined w"
},
{
"path": "hypothesis-python/docs/how-to/external-fuzzers.rst",
"chars": 3087,
"preview": "Use Hypothesis with an external fuzzer\n======================================\n\nSometimes you might want to point a tradi"
},
{
"path": "hypothesis-python/docs/how-to/index.rst",
"chars": 323,
"preview": "How-to guides\n=============\n\nThese how-to pages are practical guides for applying Hypothesis in specific scenarios. Each"
},
{
"path": "hypothesis-python/docs/how-to/suppress-healthchecks.rst",
"chars": 1912,
"preview": "Suppress a health check everywhere\n==================================\n\nHypothesis sometimes raises a |HealthCheck| to in"
},
{
"path": "hypothesis-python/docs/how-to/type-strategies.rst",
"chars": 1871,
"preview": "Write type hints for strategies\n===============================\n\nHypothesis provides type hints for all strategies and f"
},
{
"path": "hypothesis-python/docs/index.rst",
"chars": 3006,
"preview": ".. raw:: html\n\n <!-- adapted from https://docs.django-cms.org/en/release-4.1.x/, with thanks -->\n\n <style>\n "
},
{
"path": "hypothesis-python/docs/packaging.rst",
"chars": 2827,
"preview": "====================\nPackaging guidelines\n====================\n\nDownstream packagers often want to package Hypothesis. H"
},
{
"path": "hypothesis-python/docs/prolog.rst",
"chars": 16097,
"preview": ".. |given| replace:: :func:`~hypothesis.given`\n.. |@given| replace:: :func:`@given <hypothesis.given>`\n.. |@example| rep"
},
{
"path": "hypothesis-python/docs/quickstart.rst",
"chars": 5224,
"preview": "Quickstart\n==========\n\nThis is a lightning introduction to the most important features of Hypothesis; enough to get you "
},
{
"path": "hypothesis-python/docs/redirect.html.template",
"chars": 2288,
"preview": "<!DOCTYPE html>\n<html>\n <head>\n <noscript>\n <meta http-equiv=\"refresh\" content=\"0; url=${to_uri}\" />\n </nosc"
},
{
"path": "hypothesis-python/docs/reference/api.rst",
"chars": 20612,
"preview": "API Reference\n=============\n\nReference for non-strategy objects that are part of the Hypothesis API. For documentation o"
},
{
"path": "hypothesis-python/docs/reference/index.rst",
"chars": 693,
"preview": "API Reference\n=============\n\nThe technical API reference for Hypothesis is split into four pages:\n\n* :doc:`API Reference"
},
{
"path": "hypothesis-python/docs/reference/integrations.rst",
"chars": 13434,
"preview": "Integrations Reference\n======================\n\nReference for Hypothesis features with a defined interface, but no code A"
},
{
"path": "hypothesis-python/docs/reference/internals.rst",
"chars": 2097,
"preview": "Hypothesis internals\n====================\n\n.. warning::\n\n This page documents internal Hypothesis interfaces. Some ar"
},
{
"path": "hypothesis-python/docs/reference/schema_metadata.json",
"chars": 2976,
"preview": "{\n \"type\": \"object\",\n \"properties\": {\n \"traceback\": {\n \"type\": [\"string\", \"null\"],\n \""
},
{
"path": "hypothesis-python/docs/reference/schema_metadata_choices.json",
"chars": 4125,
"preview": "{\n \"type\": \"object\",\n \"properties\": {\n \"choice_nodes\": {\n \"type\": [\"array\", \"null\"],\n "
},
{
"path": "hypothesis-python/docs/reference/schema_observations.json",
"chars": 6318,
"preview": "{\n \"title\": \"PBT Observations\",\n \"description\": \"PBT Observations define a standard way to communicate what happen"
},
{
"path": "hypothesis-python/docs/reference/strategies.rst",
"chars": 9528,
"preview": ".. _strategies:\n\nStrategies Reference\n====================\n\nStrategies are the way Hypothesis describes the values for |"
},
{
"path": "hypothesis-python/docs/stateful.rst",
"chars": 12612,
"preview": "Stateful tests\n==============\n\n.. note::\n\n See also `How not to Die Hard with Hypothesis <https://hypothesis.works/ar"
},
{
"path": "hypothesis-python/docs/tutorial/adapting-strategies.rst",
"chars": 5868,
"preview": "Adapting strategies\n===================\n\nThis page discusses ways to adapt strategies to your needs, either by transform"
},
{
"path": "hypothesis-python/docs/tutorial/adding-notes.rst",
"chars": 1381,
"preview": "Adding notes\n============\n\nWhen a test fails, Hypothesis will normally print output that looks like this:\n\n.. code::\n\n "
},
{
"path": "hypothesis-python/docs/tutorial/builtin-strategies.rst",
"chars": 1958,
"preview": "Built-in strategies\n===================\n\nThis page shows some of the strategies that Hypothesis provides for you.\n\nStrat"
},
{
"path": "hypothesis-python/docs/tutorial/custom-strategies.rst",
"chars": 6238,
"preview": "Custom strategies\n==================\n\nThis page describes how to write a custom strategy, for when the built-in strategi"
},
{
"path": "hypothesis-python/docs/tutorial/flaky.rst",
"chars": 5564,
"preview": "Flaky failures\n==============\n\nHave you ever had a test fail, and then you re-run it, only for the test to magically pas"
},
{
"path": "hypothesis-python/docs/tutorial/index.rst",
"chars": 513,
"preview": "Tutorial\n========\n\nThe Hypothesis tutorial introduces the main features of Hypothesis. We suggest reading through in ord"
},
{
"path": "hypothesis-python/docs/tutorial/introduction.rst",
"chars": 7780,
"preview": "Introduction to Hypothesis\n==========================\n\nThis page introduces two fundamental parts of Hypothesis (|@given"
},
{
"path": "hypothesis-python/docs/tutorial/replaying-failures.rst",
"chars": 5092,
"preview": "Replaying failed tests\n======================\n\nReplaying failures found by your Hypothesis tests is almost as important "
},
{
"path": "hypothesis-python/docs/tutorial/settings.rst",
"chars": 4557,
"preview": "Configuring test settings\n=========================\n\nThis page discusses how to configure the behavior of a single Hypot"
},
{
"path": "hypothesis-python/docs/usage.rst",
"chars": 4214,
"preview": "Projects using Hypothesis\n=========================\n\nHypothesis is downloaded `over 4 million times each week <https://p"
},
{
"path": "hypothesis-python/examples/README.md",
"chars": 378,
"preview": "# Examples of Hypothesis usage\n\nThis is a directory for examples of using Hypothesis that show case its features or demo"
},
{
"path": "hypothesis-python/examples/example_hypothesis_entrypoint/example_hypothesis_entrypoint.py",
"chars": 928,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/examples/example_hypothesis_entrypoint/setup.py",
"chars": 910,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/examples/example_hypothesis_entrypoint/test_entrypoint.py",
"chars": 767,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/examples/test_basic.py",
"chars": 1155,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/examples/test_binary_search.py",
"chars": 4609,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/examples/test_rle.py",
"chars": 3313,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/pyproject.toml",
"chars": 6489,
"preview": "[build-system]\n# require a recent setuptools for `license = ` support\nrequires = [\"setuptools >= 78.1.0\", \"wheel\"]\nbuild"
},
{
"path": "hypothesis-python/pyrightconfig.json",
"chars": 57,
"preview": "{\n \"include\": [\"src\"],\n \"typeCheckingMode\": \"strict\"\n}\n"
},
{
"path": "hypothesis-python/scripts/basic-test.sh",
"chars": 3124,
"preview": "#!/bin/bash\nset -e -o xtrace\n\nHERE=\"$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\"\ncd \"$HERE/..\"\n\npython -c '\nimport"
},
{
"path": "hypothesis-python/scripts/other-tests.sh",
"chars": 3518,
"preview": "#!/bin/bash\nset -e -o xtrace\n\nHERE=\"$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\"\ncd \"$HERE/..\"\n\npip install .\n\n\nPY"
},
{
"path": "hypothesis-python/scripts/validate_branch_check.py",
"chars": 1712,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/_hypothesis_ftz_detector.py",
"chars": 6563,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/_hypothesis_globals.py",
"chars": 1214,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/_hypothesis_pytestplugin.py",
"chars": 21037,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/__init__.py",
"chars": 1624,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/_settings.py",
"chars": 47313,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/configuration.py",
"chars": 4311,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/control.py",
"chars": 14667,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/core.py",
"chars": 102530,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/database.py",
"chars": 48513,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/entry_points.py",
"chars": 964,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/errors.py",
"chars": 11681,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/__init__.py",
"chars": 415,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/_array_helpers.py",
"chars": 28030,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/_patching.py",
"chars": 12535,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/array_api.py",
"chars": 42324,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/cli.py",
"chars": 12885,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/codemods.py",
"chars": 11238,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/dateutil.py",
"chars": 2295,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/django/__init__.py",
"chars": 908,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/django/_fields.py",
"chars": 15225,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/django/_impl.py",
"chars": 8977,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/dpcontracts.py",
"chars": 1721,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/ghostwriter.py",
"chars": 73501,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/lark.py",
"chars": 9882,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/numpy.py",
"chars": 52654,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/pandas/__init__.py",
"chars": 633,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/pandas/impl.py",
"chars": 28513,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/pytestplugin.py",
"chars": 752,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/pytz.py",
"chars": 2440,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/extra/redis.py",
"chars": 5547,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/__init__.py",
"chars": 415,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/cache.py",
"chars": 12668,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/cathetus.py",
"chars": 2258,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/charmap.py",
"chars": 11770,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/compat.py",
"chars": 10590,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/__init__.py",
"chars": 415,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/choice.py",
"chars": 23651,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/data.py",
"chars": 48702,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/datatree.py",
"chars": 48420,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/engine.py",
"chars": 76171,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/floats.py",
"chars": 7217,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/junkdrawer.py",
"chars": 18247,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/optimiser.py",
"chars": 8856,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/pareto.py",
"chars": 15371,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/provider_conformance.py",
"chars": 17159,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/providers.py",
"chars": 43248,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py",
"chars": 74526,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/__init__.py",
"chars": 906,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/bytes.py",
"chars": 880,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/choicetree.py",
"chars": 4989,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/collection.py",
"chars": 3237,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/common.py",
"chars": 5831,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/floats.py",
"chars": 4147,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/integer.py",
"chars": 2218,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/ordering.py",
"chars": 3567,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/shrinking/string.py",
"chars": 946,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/conjecture/utils.py",
"chars": 14344,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/constants_ast.py",
"chars": 9989,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/coverage.py",
"chars": 3407,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/detection.py",
"chars": 1228,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/entropy.py",
"chars": 11005,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/escalation.py",
"chars": 6864,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/filtering.py",
"chars": 14651,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/floats.py",
"chars": 7162,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/healthcheck.py",
"chars": 815,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/intervalsets.py",
"chars": 11940,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/lambda_sources.py",
"chars": 16933,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/observability.py",
"chars": 19486,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/reflection.py",
"chars": 20063,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/scrutineer.py",
"chars": 12104,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/internal/validation.py",
"chars": 4137,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/provisional.py",
"chars": 8015,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/py.typed",
"chars": 0,
"preview": ""
},
{
"path": "hypothesis-python/src/hypothesis/reporting.py",
"chars": 1730,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/stateful.py",
"chars": 46681,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/statistics.py",
"chars": 5438,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/__init__.py",
"chars": 3286,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/__init__.py",
"chars": 620,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/attrs.py",
"chars": 8943,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/collections.py",
"chars": 15233,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/core.py",
"chars": 110669,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/datetime.py",
"chars": 20493,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/deferred.py",
"chars": 3683,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/featureflags.py",
"chars": 5539,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/flatmapped.py",
"chars": 2141,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/functions.py",
"chars": 2435,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/ipaddress.py",
"chars": 4228,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/lazy.py",
"chars": 6232,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/misc.py",
"chars": 4538,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/numbers.py",
"chars": 21002,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/random.py",
"chars": 13419,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/recursive.py",
"chars": 6370,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/regex.py",
"chars": 21668,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/shared.py",
"chars": 2214,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/strategies.py",
"chars": 50203,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/strings.py",
"chars": 14655,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/types.py",
"chars": 47384,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/strategies/_internal/utils.py",
"chars": 8894,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/utils/__init__.py",
"chars": 558,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/utils/conventions.py",
"chars": 701,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/utils/deprecation.py",
"chars": 1015,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/utils/dynamicvariables.py",
"chars": 1144,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/utils/terminal.py",
"chars": 1406,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/utils/threading.py",
"chars": 1952,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/vendor/__init__.py",
"chars": 415,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/vendor/pretty.py",
"chars": 39137,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/src/hypothesis/vendor/tlds-alpha-by-domain.txt",
"chars": 9526,
"preview": "# Version 2026021400, Last Updated Sat Feb 14 07:07:01 2026 UTC\nAAA\nAARP\nABB\nABBOTT\nABBVIE\nABC\nABLE\nABOGADO\nABUDHABI\nAC\n"
},
{
"path": "hypothesis-python/src/hypothesis/version.py",
"chars": 498,
"preview": "# This file is part of Hypothesis, which may be found at\n# https://github.com/HypothesisWorks/hypothesis/\n#\n# Copyright "
},
{
"path": "hypothesis-python/tests/README.md",
"chars": 4235,
"preview": "# Don't Panic\n\nThe Hypothesis test suite is large, but we've written these notes to help you out. It's aimed at contrib"
}
]
// ... and 466 more files (download for full content)
About this extraction
This page contains the full source code of the HypothesisWorks/hypothesis GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 666 files (4.6 MB), approximately 1.3M tokens, and a symbol index with 6126 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.