开源软件构建与测试

Changes of Revision 6

_service:tar_scm:python-hypothesis.spec Changed

@@ -1,11 +1,11 @@
 %{?python_enable_dependency_generator}
 Name:           python-hypothesis
-Version:        6.47.0
+Version:        6.79.0
 Release:        1
 Summary:        based testing for python code
 License:        MPLv2.0
-URL:            https://github.com/HypothesisWorks/hypothesis-python
-Source0:        https://github.com/HypothesisWorks/hypothesis/archive/hypothesis-python-%{version}.tar.gz
+URL:            https://github.com/HypothesisWorks/hypothesis
+Source0:        %{url}/archive/hypothesis-python-%{version}/hypothesis-%{version}.tar.gz
 BuildRequires:  python-sphinx
 BuildArch:      noarch
 
@@ -34,8 +34,7 @@
 Help document for the python-hypothesis
 
 %prep
-%autosetup -n hypothesis-hypothesis-python-%{version}/hypothesis-python -p1
-sed -i -e '/sphinx.ext.intersphinx/d' docs/conf.py
+%autosetup -n hypothesis-%{version} -p1
 
 %build
 %py3_build
@@ -47,14 +46,17 @@
 %doc README.rst
 
 %files -n python3-hypothesis
-%doc ../LICENSE.txt
-%{python3_sitelib}/_hypothesis_pytestplugin.py
-%{python3_sitelib}/__pycache__/_hypothesis_pytestplugin*.pyc
+%license LICENSE.txt
+%{python3_sitelib}/_hypothesis_*.py
+%{python3_sitelib}/__pycache__/_hypothesis_*.pyc
 %{_bindir}/hypothesis
 %{python3_sitelib}/hypothesis-*.egg-info
 %{python3_sitelib}/hypothesis/
 
 %changelog
+* Sun Jun 18 2023 Dongxing Wang <dxwangk@isoftstone.com> - 6.79.0-1
+- Upgrade package to version 6.79.0
+
 * Thu Jul 7 2022 wulei <wulei80@h-partners.com> - 6.47.0-1
 - Upgrade to 6.47.0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/LICENSE.txt -> _service:tar_scm:hypothesis-6.79.0.tar.gz/LICENSE.txt Changed

@@ -6,3 +6,377 @@
 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.

_service:tar_scm:hypothesis-6.79.0.tar.gz/MANIFEST.in Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/PKG-INFO Added

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: hypothesis
+Version: 6.79.0
+Summary: A library for property-based testing
+Home-page: https://hypothesis.works
+Author: David R. MacIver and Zac Hatfield-Dodds
+Author-email: david@drmaciver.com
+License: MPL-2.0
+Project-URL: Source, https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-python
+Project-URL: Changelog, https://hypothesis.readthedocs.io/en/latest/changes.html
+Project-URL: Documentation, https://hypothesis.readthedocs.io
+Project-URL: Issues, https://github.com/HypothesisWorks/hypothesis/issues
+Keywords: python testing fuzzing property-based-testing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Hypothesis
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Education :: Testing
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+Provides-Extra: cli
+Provides-Extra: codemods
+Provides-Extra: ghostwriter
+Provides-Extra: pytz
+Provides-Extra: dateutil
+Provides-Extra: lark
+Provides-Extra: numpy
+Provides-Extra: pandas
+Provides-Extra: pytest
+Provides-Extra: dpcontracts
+Provides-Extra: redis
+Provides-Extra: zoneinfo
+Provides-Extra: django
+Provides-Extra: all
+License-File: LICENSE.txt
+
+==========
+Hypothesis
+==========
+
+Hypothesis is an advanced testing library for Python. It lets you write tests which
+are parametrized by a source of examples, and then generates simple and comprehensible
+examples that make your tests fail. This lets you find more bugs in your code with less
+work.
+
+e.g.
+
+.. code-block:: python
+
+  @given(st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1))
+  def test_mean(xs):
+      assert min(xs) <= mean(xs) <= max(xs)
+
+.. code-block::
+
+  Falsifying example: test_mean(
+    xs=1.7976321109618856e+308, 6.102390043022755e+303
+  )
+
+Hypothesis is extremely practical and advances the state of the art of
+unit testing by some way. It's easy to use, stable, and powerful. If
+you're not using Hypothesis to test your project then you're missing out.
+
+------------------------
+Quick Start/Installation
+------------------------
+
+If you just want to get started:
+
+.. code-block::
+
+  pip install hypothesis
+
+
+-----------------
+Links of interest
+-----------------
+
+The main Hypothesis site is at `hypothesis.works <https://hypothesis.works/>`_, and contains a lot
+of good introductory and explanatory material.
+
+Extensive documentation and examples of usage are `available at readthedocs <https://hypothesis.readthedocs.io/en/latest/>`_.
+
+If you want to talk to people about using Hypothesis, `we have both an IRC channel
+and a mailing list <https://hypothesis.readthedocs.io/en/latest/community.html>`_.
+
+If you want to receive occasional updates about Hypothesis, including useful tips and tricks, there's a
+`TinyLetter mailing list to sign up for them <https://tinyletter.com/DRMacIver/>`_.
+
+If you want to contribute to Hypothesis, `instructions are here <https://github.com/HypothesisWorks/hypothesis-python/blob/master/CONTRIBUTING.rst>`_.
+
+If you want to hear from people who are already using Hypothesis, some of them `have written
+about it <https://hypothesis.readthedocs.io/en/latest/endorsements.html>`_.
+
+If you want to create a downstream package of Hypothesis, please read `these guidelines for packagers <https://hypothesis.readthedocs.io/en/latest/packaging.html>`_.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/README.rst -> _service:tar_scm:hypothesis-6.79.0.tar.gz/README.rst Changed

@@ -2,47 +2,58 @@
 Hypothesis
 ==========
 
-Hypothesis is a family of testing libraries which let you write tests parametrized
-by a source of examples. A Hypothesis implementation then generates simple and
-comprehensible examples that make your tests fail.
-This simplifies writing your tests and makes them more powerful at the same time,
-by letting software automate the boring bits and do them to a higher standard than a human would,
-freeing you to focus on the higher level test logic.
-
-This sort of testing is often called "property-based testing",
-and the most widely known implementation of the concept is the Haskell
-library `QuickCheck <https://hackage.haskell.org/package/QuickCheck>`_,
-but Hypothesis differs significantly from QuickCheck and is designed to fit
-idiomatically and easily into existing styles of testing that you are used to,
-with absolutely no familiarity with Haskell or functional programming needed.
-
-`Hypothesis for Python <hypothesis-python>`_ is the original implementation,
-and the only one that is currently fully production ready and actively maintained.
-
-------------------------------
-Hypothesis for Other Languages
-------------------------------
-
-The core ideas of Hypothesis are language agnostic and in principle it is
-suitable for any language. We are interested in developing and supporting
-implementations for a wide variety of languages, but currently lack the
-resources to do so, so our porting efforts are mostly prototypes.
-
-The two prototype implementations of Hypothesis for other languages are:
-
-* `Hypothesis for Ruby <hypothesis-ruby>`_
-  is a reasonable start on a port of Hypothesis to Ruby.
-* `Hypothesis for Java <https://github.com/HypothesisWorks/hypothesis-java>`_
-  is a prototype written some time ago. It's far from feature complete and is
-  not under active development, but was intended to prove the viability of the
-  concept.
-
-Additionally there is a port of the core engine of Hypothesis, Conjecture, to
-Rust. It is not feature complete but in the long run we are hoping to move
-much of the existing functionality to Rust and rebuild Hypothesis for Python
-on top of it, greatly lowering the porting effort to other languages.
-
-Any or all of these could be turned into full fledged implementations with relatively
-little effort (no more than a few months of full time work), but as well as the
-initial work this would require someone prepared to provide or fund ongoing
-maintenance efforts for them in order to be viable.
+Hypothesis is an advanced testing library for Python. It lets you write tests which
+are parametrized by a source of examples, and then generates simple and comprehensible
+examples that make your tests fail. This lets you find more bugs in your code with less
+work.
+
+e.g.
+
+.. code-block:: python
+
+  @given(st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1))
+  def test_mean(xs):
+      assert min(xs) <= mean(xs) <= max(xs)
+
+.. code-block::
+
+  Falsifying example: test_mean(
+    xs=1.7976321109618856e+308, 6.102390043022755e+303
+  )
+
+Hypothesis is extremely practical and advances the state of the art of
+unit testing by some way. It's easy to use, stable, and powerful. If
+you're not using Hypothesis to test your project then you're missing out.
+
+------------------------
+Quick Start/Installation
+------------------------
+
+If you just want to get started:
+
+.. code-block::
+
+  pip install hypothesis
+
+
+-----------------
+Links of interest
+-----------------
+
+The main Hypothesis site is at `hypothesis.works <https://hypothesis.works/>`_, and contains a lot
+of good introductory and explanatory material.
+
+Extensive documentation and examples of usage are `available at readthedocs <https://hypothesis.readthedocs.io/en/latest/>`_.
+
+If you want to talk to people about using Hypothesis, `we have both an IRC channel
+and a mailing list <https://hypothesis.readthedocs.io/en/latest/community.html>`_.
+
+If you want to receive occasional updates about Hypothesis, including useful tips and tricks, there's a
+`TinyLetter mailing list to sign up for them <https://tinyletter.com/DRMacIver/>`_.
+
+If you want to contribute to Hypothesis, `instructions are here <https://github.com/HypothesisWorks/hypothesis-python/blob/master/CONTRIBUTING.rst>`_.
+
+If you want to hear from people who are already using Hypothesis, some of them `have written
+about it <https://hypothesis.readthedocs.io/en/latest/endorsements.html>`_.
+
+If you want to create a downstream package of Hypothesis, please read `these guidelines for packagers <https://hypothesis.readthedocs.io/en/latest/packaging.html>`_.

_service:tar_scm:hypothesis-6.79.0.tar.gz/setup.cfg Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/setup.py Added

@@ -0,0 +1,140 @@
+# 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 os
+import sys
+import warnings
+
+import setuptools
+
+if sys.version_info:2 < (3, 7):
+    raise Exception(
+        "You are trying to install Hypothesis using Python "
+        f"{sys.version.split()0}, but it requires Python 3.7 or later."
+        "Update `pip` and `setuptools`, try again, and you will automatically "
+        "get the latest compatible version of Hypothesis instead.  "
+        "See also https://python3statement.org/practicalities/"
+    )
+
+
+def local_file(name):
+    return os.path.relpath(os.path.join(os.path.dirname(__file__), name))
+
+
+SOURCE = local_file("src")
+README = local_file("README.rst")
+
+setuptools_version = tuple(map(int, setuptools.__version__.split("."):1))
+
+if setuptools_version < (42,):
+    # Warning only - very bad if uploading bdist but fine if installing sdist.
+    warnings.warn(
+        "This version of setuptools is too old to handle license_files "
+        "metadata key.  For more info, see:  "
+        "https://setuptools.pypa.io/en/latest/userguide/declarative_config.html#metadata"
+    )
+
+
+# Assignment to placate pyflakes. The actual version is from the exec that follows.
+__version__ = None
+
+with open(local_file("src/hypothesis/version.py")) as o:
+    exec(o.read())
+
+assert __version__ is not None
+
+
+extras = {
+    "cli": "click>=7.0", "black>=19.10b0", "rich>=9.0.0",
+    "codemods": "libcst>=0.3.16",
+    "ghostwriter": "black>=19.10b0",
+    "pytz": "pytz>=2014.1",
+    "dateutil": "python-dateutil>=1.4",
+    "lark": "lark>=0.10.1",  # probably still works with old `lark-parser` too
+    "numpy": "numpy>=1.16.0",  # oldest with wheels for non-EOL Python (for now)
+    "pandas": "pandas>=1.1",
+    "pytest": "pytest>=4.6",
+    "dpcontracts": "dpcontracts>=0.4",
+    "redis": "redis>=3.0.0",
+    # zoneinfo is an odd one: every dependency is conditional, because they're
+    # only necessary on old versions of Python or Windows systems.
+    "zoneinfo": 
+        "tzdata>=2023.3 ; sys_platform == 'win32'",
+        "backports.zoneinfo>=0.2.1 ; python_version<'3.9'",
+    ,
+    # We only support Django versions with upstream support - see
+    # https://www.djangoproject.com/download/#supported-versions
+    # We also leave the choice of timezone library to the user, since it
+    # might be zoneinfo or pytz depending on version and configuration.
+    "django": "django>=3.2",
+}
+
+extras"all" = sorted(
+    set(sum(extras.values(), "importlib_metadata>=3.6; python_version<'3.8'"))
+)
+
+
+setuptools.setup(
+    name="hypothesis",
+    version=__version__,
+    author="David R. MacIver and Zac Hatfield-Dodds",
+    author_email="david@drmaciver.com",
+    packages=setuptools.find_packages(SOURCE),
+    package_dir={"": SOURCE},
+    package_data={"hypothesis": "py.typed", "vendor/tlds-alpha-by-domain.txt"},
+    url="https://hypothesis.works",
+    project_urls={
+        "Source": "https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-python",
+        "Changelog": "https://hypothesis.readthedocs.io/en/latest/changes.html",
+        "Documentation": "https://hypothesis.readthedocs.io",
+        "Issues": "https://github.com/HypothesisWorks/hypothesis/issues",
+    },
+    license="MPL-2.0",
+    description="A library for property-based testing",
+    zip_safe=False,
+    extras_require=extras,
+    install_requires=
+        "attrs>=19.2.0",
+        "exceptiongroup>=1.0.0 ; python_version<'3.11'",
+        "sortedcontainers>=2.1.0,<3.0.0",
+    ,
+    python_requires=">=3.7",
+    classifiers=
+        "Development Status :: 5 - Production/Stable",
+        "Framework :: Hypothesis",
+        "Framework :: Pytest",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+        "Operating System :: Unix",
+        "Operating System :: POSIX",
+        "Operating System :: Microsoft :: Windows",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3 :: Only",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+        "Topic :: Education :: Testing",
+        "Topic :: Software Development :: Testing",
+        "Typing :: Typed",
+    ,
+    py_modules="_hypothesis_pytestplugin", "_hypothesis_ftz_detector",
+    entry_points={
+        "pytest11": "hypothesispytest = _hypothesis_pytestplugin",
+        "console_scripts": "hypothesis = hypothesis.extra.cli:main",
+    },
+    long_description=open(README).read(),
+    long_description_content_type="text/x-rst",
+    keywords="python testing fuzzing property-based-testing",
+)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/_hypothesis_ftz_detector.py Added

@@ -0,0 +1,149 @@
+# 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/.
+
+"""
+This is a toolkit for determining which module set the "flush to zero" flag.
+
+For details, see the docstring and comments in `identify_ftz_culprit()`.  This module
+is defined outside the main Hypothesis namespace so that we can avoid triggering
+import of Hypothesis itself from each subprocess which must import the worker function.
+"""
+
+import importlib
+import sys
+
+KNOWN_EVER_CULPRITS = (
+    # https://moyix.blogspot.com/2022/09/someones-been-messing-with-my-subnormals.html
+    # fmt: off
+    "archive-pdf-tools", "bgfx-python", "bicleaner-ai-glove", "BTrees", "cadbiom",
+    "ctranslate2", "dyNET", "dyNET38", "gevent", "glove-python-binary", "higra",
+    "hybridq", "ikomia", "ioh", "jij-cimod", "lavavu", "lavavu-osmesa", "MulticoreTSNE",
+    "neural-compressor", "nwhy", "openjij", "openturns", "perfmetrics", "pHashPy",
+    "pyace-lite", "pyapr", "pycompadre", "pycompadre-serial", "PyKEP", "pykep",
+    "pylimer-tools", "pyqubo", "pyscf", "PyTAT", "python-prtree", "qiskit-aer",
+    "qiskit-aer-gpu", "RelStorage", "sail-ml", "segmentation", "sente", "sinr",
+    "snapml", "superman", "symengine", "systran-align", "texture-tool", "tsne-mp",
+    "xcsf",
+    # fmt: on
+)
+
+
+def flush_to_zero():
+    # If this subnormal number compares equal to zero we have a problem
+    return 2.0**-1073 == 0
+
+
+def run_in_process(fn, *args):
+    import multiprocessing as mp
+
+    mp.set_start_method("spawn", force=True)
+    q = mp.Queue()
+    p = mp.Process(target=target, args=(q, fn, *args))
+    p.start()
+    retval = q.get()
+    p.join()
+    return retval
+
+
+def target(q, fn, *args):
+    q.put(fn(*args))
+
+
+def always_imported_modules():
+    return flush_to_zero(), set(sys.modules)
+
+
+def modules_imported_by(mod):
+    """Return the set of modules imported transitively by mod."""
+    before = set(sys.modules)
+    try:
+        importlib.import_module(mod)
+    except Exception:
+        return None, set()
+    imports = set(sys.modules) - before
+    return flush_to_zero(), imports
+
+
+# We don't want to redo all the expensive process-spawning checks when we've already
+# done them, so we cache known-good packages and a known-FTZ result if we have one.
+KNOWN_FTZ = None
+CHECKED_CACHE = set()
+
+
+def identify_ftz_culprits():
+    """Find the modules in sys.modules which cause "mod" to be imported."""
+    # If we've run this function before, return the same result.
+    global KNOWN_FTZ
+    if KNOWN_FTZ:
+        return KNOWN_FTZ
+    # Start by determining our baseline: the FTZ and sys.modules state in a fresh
+    # process which has only imported this module and nothing else.
+    always_enables_ftz, always_imports = run_in_process(always_imported_modules)
+    if always_enables_ftz:
+        raise RuntimeError("Python is always in FTZ mode, even without imports!")
+    CHECKED_CACHE.update(always_imports)
+
+    # Next, we'll search through sys.modules looking for a package (or packages) such
+    # that importing them in a new process sets the FTZ state.  As a heuristic, we'll
+    # start with packages known to have ever enabled FTZ, then top-level packages as
+    # a way to eliminate large fractions of the search space relatively quickly.
+    def key(name):
+        """Prefer known-FTZ modules, then top-level packages, then alphabetical."""
+        return (name not in KNOWN_EVER_CULPRITS, name.count("."), name)
+
+    # We'll track the set of modules to be checked, and those which do trigger FTZ.
+    candidates = set(sys.modules) - CHECKED_CACHE
+    triggering_modules = {}
+    while candidates:
+        mod = min(candidates, key=key)
+        candidates.discard(mod)
+        enables_ftz, imports = run_in_process(modules_imported_by, mod)
+        imports -= CHECKED_CACHE
+        if enables_ftz:
+            triggering_modulesmod = imports
+            candidates &= imports
+        else:
+            candidates -= imports
+            CHECKED_CACHE.update(imports)
+
+    # We only want to report the 'top level' packages which enable FTZ - for example,
+    # if the enabling code is in `a.b`, and `a` in turn imports `a.b`, we prefer to
+    # report `a`.  On the other hand, if `a` does _not_ import `a.b`, as is the case
+    # for `hypothesis.extra.*` modules, then `a` will not be in `triggering_modules`
+    # and we'll report `a.b` here instead.
+    prefixes = tuple(n + "." for n in triggering_modules)
+    result = {k for k in triggering_modules if not k.startswith(prefixes)}
+
+    # Suppose that `bar` enables FTZ, and `foo` imports `bar`.  At this point we're
+    # tracking both, but only want to report the latter.
+    for a in sorted(result):
+        for b in sorted(result):
+            if a in triggering_modulesb and b not in triggering_modulesa:
+                result.discard(b)
+
+    # There may be a cyclic dependency which that didn't handle, or simply two
+    # separate modules which both enable FTZ.  We already gave up comprehensive
+    # reporting for speed above (`candidates &= imports`), so we'll also buy
+    # simpler reporting by arbitrarily selecting the alphabetically first package.
+    KNOWN_FTZ = min(result)  # Cache the result - it's likely this will trigger again!
+    return KNOWN_FTZ
+
+
+if __name__ == "__main__":
+    # This would be really really annoying to write automated tests for, so I've
+    # done some manual exploratory testing: `pip install grequests gevent==21.12.0`,
+    # and call print() as desired to observe behavior.
+    import grequests  # noqa
+
+    # To test without skipping to a known answer, uncomment the following line and
+    # change the last element of key from `name` to `-len(name)` so that we check
+    # grequests before gevent.
+    # KNOWN_EVER_CULPRITS = c for c in KNOWN_EVER_CULPRITS if c != "gevent"
+    print(identify_ftz_culprits())

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/_hypothesis_pytestplugin.py Added

@@ -0,0 +1,412 @@
+# 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/.
+
+"""
+The pytest plugin for Hypothesis.
+
+We move this from the old location at `hypothesis.extra.pytestplugin` so that it
+can be loaded by Pytest without importing Hypothesis.  In turn, this means that
+Hypothesis will not load our own third-party plugins (with associated side-effects)
+unless and until the user explicitly runs `import hypothesis`.
+
+See https://github.com/HypothesisWorks/hypothesis/issues/3140 for details.
+"""
+
+import base64
+import json
+import sys
+from inspect import signature
+
+import pytest
+
+try:
+    from _pytest.junitxml import xml_key
+except ImportError:
+    xml_key = "_xml"  # type: ignore
+
+LOAD_PROFILE_OPTION = "--hypothesis-profile"
+VERBOSITY_OPTION = "--hypothesis-verbosity"
+PRINT_STATISTICS_OPTION = "--hypothesis-show-statistics"
+SEED_OPTION = "--hypothesis-seed"
+EXPLAIN_OPTION = "--hypothesis-explain"
+
+_VERBOSITY_NAMES = "quiet", "normal", "verbose", "debug"
+_ALL_OPTIONS = 
+    LOAD_PROFILE_OPTION,
+    VERBOSITY_OPTION,
+    PRINT_STATISTICS_OPTION,
+    SEED_OPTION,
+    EXPLAIN_OPTION,
+
+_FIXTURE_MSG = """Function-scoped fixture {0!r} used by {1!r}
+
+Function-scoped fixtures are not reset between examples generated by
+`@given(...)`, which is often surprising and can cause subtle test bugs.
+
+If you were expecting the fixture to run separately for each generated example,
+then unfortunately you will need to find a different way to achieve your goal
+(e.g. using a similar context manager instead of a fixture).
+
+If you are confident that your test will work correctly even though the
+fixture is not reset between generated examples, you can suppress this health
+check to assure Hypothesis that you understand what you are doing.
+"""
+
+STATS_KEY = "_hypothesis_stats"
+FAILING_EXAMPLES_KEY = "_hypothesis_failing_examples"
+
+
+class StoringReporter:
+    def __init__(self, config):
+        assert "hypothesis" in sys.modules
+        from hypothesis.reporting import default
+
+        self.report = default
+        self.config = config
+        self.results = 
+
+    def __call__(self, msg):
+        if self.config.getoption("capture", "fd") == "no":
+            self.report(msg)
+        if not isinstance(msg, str):
+            msg = repr(msg)
+        self.results.append(msg)
+
+
+# Avoiding distutils.version.LooseVersion due to
+# https://github.com/HypothesisWorks/hypothesis/issues/2490
+if tuple(map(int, pytest.__version__.split("."):2)) < (4, 6):  # pragma: no cover
+    import warnings
+
+    PYTEST_TOO_OLD_MESSAGE = """
+        You are using pytest version %s. Hypothesis tests work with any test
+        runner, but our pytest plugin requires pytest 4.6 or newer.
+        Note that the pytest developers no longer support your version either!
+        Disabling the Hypothesis pytest plugin...
+    """
+    warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,))
+
+else:
+
+    def pytest_addoption(parser):
+        group = parser.getgroup("hypothesis", "Hypothesis")
+        group.addoption(
+            LOAD_PROFILE_OPTION,
+            action="store",
+            help="Load in a registered hypothesis.settings profile",
+        )
+        group.addoption(
+            VERBOSITY_OPTION,
+            action="store",
+            choices=_VERBOSITY_NAMES,
+            help="Override profile with verbosity setting specified",
+        )
+        group.addoption(
+            PRINT_STATISTICS_OPTION,
+            action="store_true",
+            help="Configure when statistics are printed",
+            default=False,
+        )
+        group.addoption(
+            SEED_OPTION,
+            action="store",
+            help="Set a seed to use for all Hypothesis tests",
+        )
+        group.addoption(
+            EXPLAIN_OPTION,
+            action="store_true",
+            help="Enable the `explain` phase for failing Hypothesis tests",
+            default=False,
+        )
+
+    def _any_hypothesis_option(config):
+        return bool(any(config.getoption(opt) for opt in _ALL_OPTIONS))
+
+    def pytest_report_header(config):
+        if not (
+            config.option.verbose >= 1
+            or "hypothesis" in sys.modules
+            or _any_hypothesis_option(config)
+        ):
+            return None
+
+        from hypothesis import Verbosity, settings
+
+        if config.option.verbose < 1 and settings.default.verbosity < Verbosity.verbose:
+            return None
+        settings_str = settings.default.show_changed()
+        if settings_str != "":
+            settings_str = f" -> {settings_str}"
+        return f"hypothesis profile {settings._current_profile!r}{settings_str}"
+
+    def pytest_configure(config):
+        config.addinivalue_line("markers", "hypothesis: Tests which use hypothesis.")
+        if not _any_hypothesis_option(config):
+            return
+        from hypothesis import Phase, Verbosity, core, settings
+
+        profile = config.getoption(LOAD_PROFILE_OPTION)
+        if profile:
+            settings.load_profile(profile)
+        verbosity_name = config.getoption(VERBOSITY_OPTION)
+        if verbosity_name and verbosity_name != settings.default.verbosity.name:
+            verbosity_value = Verbosityverbosity_name
+            name = f"{settings._current_profile}-with-{verbosity_name}-verbosity"
+            # register_profile creates a new profile, exactly like the current one,
+            # with the extra values given (in this case 'verbosity')
+            settings.register_profile(name, verbosity=verbosity_value)
+            settings.load_profile(name)
+        if (
+            config.getoption(EXPLAIN_OPTION)
+            and Phase.explain not in settings.default.phases
+        ):
+            name = f"{settings._current_profile}-with-explain-phase"
+            phases = settings.default.phases + (Phase.explain,)
+            settings.register_profile(name, phases=phases)
+            settings.load_profile(name)
+
+        seed = config.getoption(SEED_OPTION)
+        if seed is not None:
+            try:
+                seed = int(seed)
+            except ValueError:
+                pass
+            core.global_force_seed = seed
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(item):
+        __tracebackhide__ = True
+        if not (hasattr(item, "obj") and "hypothesis" in sys.modules):
+            yield
+            return
+
+        from hypothesis import core
+        from hypothesis.internal.detection import is_hypothesis_test
+
+        # See https://github.com/pytest-dev/pytest/issues/9159
+        # TODO: add `pytest_version >= (7, 2) or` once the issue above is fixed.
+        core.pytest_shows_exceptiongroups = (
+            item.config.getoption("tbstyle", "auto") == "native"
+        )
+        core.running_under_pytest = True
+
+        if not is_hypothesis_test(item.obj):
+            # If @given was not applied, check whether other hypothesis
+            # decorators were applied, and raise an error if they were.
+            # We add this frame of indirection to enable __tracebackhide__.
+            def raise_hypothesis_usage_error(msg):
+                raise InvalidArgument(msg)
+
+            if getattr(item.obj, "is_hypothesis_strategy_function", False):
+                from hypothesis.errors import InvalidArgument
+
+                raise_hypothesis_usage_error(
+                    f"{item.nodeid} is a function that returns a Hypothesis strategy, "
+                    "but pytest has collected it as a test function.  This is useless "
+                    "as the function body will never be executed.  To define a test "
+                    "function, use @given instead of @composite."
+                )
+            message = "Using `@%s` on a test without `@given` is completely pointless."
+            for name, attribute in 
+                ("example", "hypothesis_explicit_examples"),
+                ("seed", "_hypothesis_internal_use_seed"),
+                ("settings", "_hypothesis_internal_settings_applied"),
+                ("reproduce_example", "_hypothesis_internal_use_reproduce_failure"),
+            :
+                if hasattr(item.obj, attribute):
+                    from hypothesis.errors import InvalidArgument  # noqa: F811
+
+                    raise_hypothesis_usage_error(message % (name,))
+            yield
+        else:
+            from hypothesis import HealthCheck, settings
+            from hypothesis.internal.escalation import current_pytest_item
+            from hypothesis.internal.healthcheck import fail_health_check
+            from hypothesis.reporting import with_reporter
+            from hypothesis.statistics import collector, describe_statistics
+
+            # Retrieve the settings for this test from the test object, which
+            # is normally a Hypothesis wrapped_test wrapper. If this doesn't
+            # work, the test object is probably something weird
+            # (e.g a stateful test wrapper), so we skip the function-scoped
+            # fixture check.
+            settings = getattr(  # noqa: F811
+                item.obj, "_hypothesis_internal_use_settings", None
+            )
+
+            # Check for suspicious use of function-scoped fixtures, but only
+            # if the corresponding health check is not suppressed.
+            if (
+                settings is not None
+                and HealthCheck.function_scoped_fixture
+                not in settings.suppress_health_check
+            ):
+                # Warn about function-scoped fixtures, excluding autouse fixtures because
+                # the advice is probably not actionable and the status quo seems OK...
+                # See https://github.com/HypothesisWorks/hypothesis/issues/377 for detail.
+                argnames = None
+                for fx_defs in item._request._fixturemanager.getfixtureinfo(
+                    node=item, func=item.function, cls=None
+                ).name2fixturedefs.values():
+                    if argnames is None:
+                        argnames = frozenset(signature(item.function).parameters)
+                    for fx in fx_defs:
+                        if fx.argname in argnames:
+                            active_fx = item._request._get_active_fixturedef(fx.argname)
+                            if active_fx.scope == "function":
+                                fail_health_check(
+                                    settings,
+                                    _FIXTURE_MSG.format(fx.argname, item.nodeid),
+                                    HealthCheck.function_scoped_fixture,
+                                )
+
+            if item.get_closest_marker("parametrize") is not None:
+                # Give every parametrized test invocation a unique database key
+                key = item.nodeid.encode()
+                item.obj.hypothesis.inner_test._hypothesis_internal_add_digest = key
+
+            store = StoringReporter(item.config)
+
+            def note_statistics(stats):
+                stats"nodeid" = item.nodeid
+                item.hypothesis_statistics = describe_statistics(stats)
+
+            with collector.with_value(note_statistics):
+                with with_reporter(store):
+                    with current_pytest_item.with_value(item):
+                        yield
+            if store.results:
+                item.hypothesis_report_information = list(store.results)
+
+    def _stash_get(config, key, default):
+        if hasattr(config, "stash"):
+            # pytest 7
+            return config.stash.get(key, default)
+        elif hasattr(config, "_store"):
+            # pytest 5.4
+            return config._store.get(key, default)
+        else:
+            return getattr(config, key, default)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(item, call):
+        report = (yield).get_result()
+        if hasattr(item, "hypothesis_report_information"):
+            report.sections.append(
+                ("Hypothesis", "\n".join(item.hypothesis_report_information))
+            )
+        if report.when != "teardown":
+            return
+
+        terminalreporter = item.config.pluginmanager.getplugin("terminalreporter")
+
+        if hasattr(item, "hypothesis_statistics"):
+            stats = item.hypothesis_statistics
+            stats_base64 = base64.b64encode(stats.encode()).decode()
+
+            name = "hypothesis-statistics-" + item.nodeid
+
+            # Include hypothesis information to the junit XML report.
+            #
+            # Note that when `pytest-xdist` is enabled, `xml_key` is not present in the
+            # stash, so we don't add anything to the junit XML report in that scenario.
+            # https://github.com/pytest-dev/pytest/issues/7767#issuecomment-1082436256
+            xml = _stash_get(item.config, xml_key, None)
+            if xml:
+                xml.add_global_property(name, stats_base64)
+
+            # If there's a terminal report, include our summary stats for each test
+            if terminalreporter is not None:
+                report.__dict__STATS_KEY = stats
+
+            # If there's an HTML report, include our summary stats for each test
+            pytest_html = item.config.pluginmanager.getplugin("html")
+            if pytest_html is not None:  # pragma: no cover
+                report.extra = getattr(report, "extra", ) + 
+                    pytest_html.extras.text(stats, name="Hypothesis stats")
+                
+
+        # This doesn't intrinsically have anything to do with the terminalreporter;
+        # we're just cargo-culting a way to get strings back to a single function
+        # even if the test were distributed with pytest-xdist.
+        failing_examples = getattr(item, FAILING_EXAMPLES_KEY, None)
+        if failing_examples and terminalreporter is not None:
+            try:
+                from hypothesis.extra._patching import FAIL_MSG, get_patch_for
+            except ImportError:
+                return
+            # We'll save this as a triple of filename, hunk_before, hunk_after.
+            triple = get_patch_for(item.obj, (x, FAIL_MSG) for x in failing_examples)
+            if triple is not None:
+                report.__dict__FAILING_EXAMPLES_KEY = json.dumps(triple)
+
+    def pytest_terminal_summary(terminalreporter):
+        failing_examples = 
+        print_stats = terminalreporter.config.getoption(PRINT_STATISTICS_OPTION)
+        if print_stats:
+            terminalreporter.section("Hypothesis Statistics")
+        for reports in terminalreporter.stats.values():
+            for report in reports:
+                stats = report.__dict__.get(STATS_KEY)
+                if stats and print_stats:
+                    terminalreporter.write_line(stats + "\n\n")
+                fex = report.__dict__.get(FAILING_EXAMPLES_KEY)
+                if fex:
+                    failing_examples.append(json.loads(fex))
+
+        if failing_examples:
+            # This must have been imported already to write the failing examples
+            from hypothesis.extra._patching import gc_patches, make_patch, save_patch
+
+            patch = make_patch(failing_examples)
+            try:
+                gc_patches()
+                fname = save_patch(patch)
+            except Exception:
+                # fail gracefully if we hit any filesystem or permissions problems
+                return
+            terminalreporter.section("Hypothesis")
+            terminalreporter.write_line(
+                f"`git apply {fname}` to add failing examples to your code."
+            )
+
+    def pytest_collection_modifyitems(items):
+        if "hypothesis" not in sys.modules:
+            return
+
+        from hypothesis.internal.detection import is_hypothesis_test
+
+        for item in items:
+            if isinstance(item, pytest.Function) and is_hypothesis_test(item.obj):
+                item.add_marker("hypothesis")
+
+    # Monkeypatch some internals to prevent applying @pytest.fixture() to a
+    # function which has already been decorated with @hypothesis.given().
+    # (the reverse case is already an explicit error in Hypothesis)
+    # We do this here so that it catches people on old Pytest versions too.
+    from _pytest import fixtures
+
+    def _ban_given_call(self, function):
+        if "hypothesis" in sys.modules:
+            from hypothesis.internal.detection import is_hypothesis_test
+
+            if is_hypothesis_test(function):
+                raise RuntimeError(
+                    f"Can't apply @pytest.fixture() to {function.__name__} because "
+                    "it is already decorated with @hypothesis.given()"
+                )
+        return _orig_call(self, function)
+
+    _orig_call = fixtures.FixtureFunctionMarker.__call__
+    fixtures.FixtureFunctionMarker.__call__ = _ban_given_call  # type: ignore
+
+
+def load():
+    """Required for `pluggy` to load a plugin from setuptools entrypoints."""

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/PKG-INFO Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/SOURCES.txt Added

@@ -0,0 +1,116 @@
+LICENSE.txt
+MANIFEST.in
+README.rst
+setup.cfg
+setup.py
+src/_hypothesis_ftz_detector.py
+src/_hypothesis_pytestplugin.py
+src/hypothesis/__init__.py
+src/hypothesis/_error_if_old.py
+src/hypothesis/_settings.py
+src/hypothesis/configuration.py
+src/hypothesis/control.py
+src/hypothesis/core.py
+src/hypothesis/database.py
+src/hypothesis/entry_points.py
+src/hypothesis/errors.py
+src/hypothesis/executors.py
+src/hypothesis/provisional.py
+src/hypothesis/py.typed
+src/hypothesis/reporting.py
+src/hypothesis/stateful.py
+src/hypothesis/statistics.py
+src/hypothesis/version.py
+src/hypothesis.egg-info/PKG-INFO
+src/hypothesis.egg-info/SOURCES.txt
+src/hypothesis.egg-info/dependency_links.txt
+src/hypothesis.egg-info/entry_points.txt
+src/hypothesis.egg-info/not-zip-safe
+src/hypothesis.egg-info/requires.txt
+src/hypothesis.egg-info/top_level.txt
+src/hypothesis/extra/__init__.py
+src/hypothesis/extra/_array_helpers.py
+src/hypothesis/extra/_patching.py
+src/hypothesis/extra/array_api.py
+src/hypothesis/extra/cli.py
+src/hypothesis/extra/codemods.py
+src/hypothesis/extra/dateutil.py
+src/hypothesis/extra/dpcontracts.py
+src/hypothesis/extra/ghostwriter.py
+src/hypothesis/extra/lark.py
+src/hypothesis/extra/numpy.py
+src/hypothesis/extra/pytestplugin.py
+src/hypothesis/extra/pytz.py
+src/hypothesis/extra/redis.py
+src/hypothesis/extra/django/__init__.py
+src/hypothesis/extra/django/_fields.py
+src/hypothesis/extra/django/_impl.py
+src/hypothesis/extra/pandas/__init__.py
+src/hypothesis/extra/pandas/impl.py
+src/hypothesis/internal/__init__.py
+src/hypothesis/internal/cache.py
+src/hypothesis/internal/cathetus.py
+src/hypothesis/internal/charmap.py
+src/hypothesis/internal/compat.py
+src/hypothesis/internal/coverage.py
+src/hypothesis/internal/detection.py
+src/hypothesis/internal/entropy.py
+src/hypothesis/internal/escalation.py
+src/hypothesis/internal/filtering.py
+src/hypothesis/internal/floats.py
+src/hypothesis/internal/healthcheck.py
+src/hypothesis/internal/intervalsets.py
+src/hypothesis/internal/lazyformat.py
+src/hypothesis/internal/reflection.py
+src/hypothesis/internal/scrutineer.py
+src/hypothesis/internal/validation.py
+src/hypothesis/internal/conjecture/__init__.py
+src/hypothesis/internal/conjecture/choicetree.py
+src/hypothesis/internal/conjecture/data.py
+src/hypothesis/internal/conjecture/datatree.py
+src/hypothesis/internal/conjecture/engine.py
+src/hypothesis/internal/conjecture/floats.py
+src/hypothesis/internal/conjecture/junkdrawer.py
+src/hypothesis/internal/conjecture/optimiser.py
+src/hypothesis/internal/conjecture/pareto.py
+src/hypothesis/internal/conjecture/shrinker.py
+src/hypothesis/internal/conjecture/utils.py
+src/hypothesis/internal/conjecture/dfa/__init__.py
+src/hypothesis/internal/conjecture/dfa/lstar.py
+src/hypothesis/internal/conjecture/shrinking/__init__.py
+src/hypothesis/internal/conjecture/shrinking/common.py
+src/hypothesis/internal/conjecture/shrinking/dfas.py
+src/hypothesis/internal/conjecture/shrinking/floats.py
+src/hypothesis/internal/conjecture/shrinking/integer.py
+src/hypothesis/internal/conjecture/shrinking/learned_dfas.py
+src/hypothesis/internal/conjecture/shrinking/lexical.py
+src/hypothesis/internal/conjecture/shrinking/ordering.py
+src/hypothesis/strategies/__init__.py
+src/hypothesis/strategies/_internal/__init__.py
+src/hypothesis/strategies/_internal/attrs.py
+src/hypothesis/strategies/_internal/collections.py
+src/hypothesis/strategies/_internal/core.py
+src/hypothesis/strategies/_internal/datetime.py
+src/hypothesis/strategies/_internal/deferred.py
+src/hypothesis/strategies/_internal/featureflags.py
+src/hypothesis/strategies/_internal/flatmapped.py
+src/hypothesis/strategies/_internal/functions.py
+src/hypothesis/strategies/_internal/ipaddress.py
+src/hypothesis/strategies/_internal/lazy.py
+src/hypothesis/strategies/_internal/misc.py
+src/hypothesis/strategies/_internal/numbers.py
+src/hypothesis/strategies/_internal/random.py
+src/hypothesis/strategies/_internal/recursive.py
+src/hypothesis/strategies/_internal/regex.py
+src/hypothesis/strategies/_internal/shared.py
+src/hypothesis/strategies/_internal/strategies.py
+src/hypothesis/strategies/_internal/strings.py
+src/hypothesis/strategies/_internal/types.py
+src/hypothesis/strategies/_internal/utils.py
+src/hypothesis/utils/__init__.py
+src/hypothesis/utils/conventions.py
+src/hypothesis/utils/dynamicvariables.py
+src/hypothesis/utils/terminal.py
+src/hypothesis/vendor/__init__.py
+src/hypothesis/vendor/pretty.py
+src/hypothesis/vendor/tlds-alpha-by-domain.txt
\ No newline at end of file

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/dependency_links.txt Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/entry_points.txt Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/not-zip-safe Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/requires.txt Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis.egg-info/top_level.txt Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/_error_if_old.py Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/_settings.py Added

@@ -0,0 +1,714 @@
+# 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/.
+
+"""The settings module configures runtime options for Hypothesis.
+
+Either an explicit settings object can be used or the default object on
+this module can be modified.
+"""
+
+import contextlib
+import datetime
+import inspect
+import os
+import warnings
+from enum import Enum, EnumMeta, IntEnum, unique
+from typing import TYPE_CHECKING, Any, Collection, Dict, List, Optional, TypeVar, Union
+
+import attr
+
+from hypothesis.errors import (
+    HypothesisDeprecationWarning,
+    InvalidArgument,
+    InvalidState,
+)
+from hypothesis.internal.reflection import get_pretty_function_description
+from hypothesis.internal.validation import check_type, try_convert
+from hypothesis.utils.conventions import not_set
+from hypothesis.utils.dynamicvariables import DynamicVariable
+
+if TYPE_CHECKING:
+    from hypothesis.database import ExampleDatabase
+
+__all__ = "settings"
+
+all_settings: Dictstr, "Setting" = {}
+
+T = TypeVar("T")
+
+
+class settingsProperty:
+    def __init__(self, name, show_default):
+        self.name = name
+        self.show_default = show_default
+
+    def __get__(self, obj, type=None):
+        if obj is None:
+            return self
+        else:
+            try:
+                result = obj.__dict__self.name
+                # This is a gross hack, but it preserves the old behaviour that
+                # you can change the storage directory and it will be reflected
+                # in the default database.
+                if self.name == "database" and result is not_set:
+                    from hypothesis.database import ExampleDatabase
+
+                    result = ExampleDatabase(not_set)
+                return result
+            except KeyError:
+                raise AttributeError(self.name) from None
+
+    def __set__(self, obj, value):
+        obj.__dict__self.name = value
+
+    def __delete__(self, obj):
+        raise AttributeError(f"Cannot delete attribute {self.name}")
+
+    @property
+    def __doc__(self):
+        description = all_settingsself.name.description
+        default = (
+            repr(getattr(settings.default, self.name))
+            if self.show_default
+            else "(dynamically calculated)"
+        )
+        return f"{description}\n\ndefault value: ``{default}``"
+
+
+default_variable = DynamicVariable(None)
+
+
+class settingsMeta(type):
+    def __init__(cls, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @property
+    def default(cls):
+        v = default_variable.value
+        if v is not None:
+            return v
+        if hasattr(settings, "_current_profile"):
+            settings.load_profile(settings._current_profile)
+            assert default_variable.value is not None
+        return default_variable.value
+
+    def _assign_default_internal(cls, value):
+        default_variable.value = value
+
+    def __setattr__(cls, name, value):
+        if name == "default":
+            raise AttributeError(
+                "Cannot assign to the property settings.default - "
+                "consider using settings.load_profile instead."
+            )
+        elif not (isinstance(value, settingsProperty) or name.startswith("_")):
+            raise AttributeError(
+                f"Cannot assign hypothesis.settings.{name}={value!r} - the settings "
+                "class is immutable.  You can change the global default "
+                "settings with settings.load_profile, or use @settings(...) "
+                "to decorate your test instead."
+            )
+        return super().__setattr__(name, value)
+
+
+class settings(metaclass=settingsMeta):
+    """A settings object configures options including verbosity, runtime controls,
+    persistence, determinism, and more.
+
+    Default values are picked up from the settings.default object and
+    changes made there will be picked up in newly created settings.
+    """
+
+    __definitions_are_locked = False
+    _profiles: Dictstr, "settings" = {}
+    __module__ = "hypothesis"
+
+    def __getattr__(self, name):
+        if name in all_settings:
+            return all_settingsname.default
+        else:
+            raise AttributeError(f"settings has no attribute {name}")
+
+    def __init__(
+        self,
+        parent: Optional"settings" = None,
+        *,
+        # This looks pretty strange, but there's good reason: we want Mypy to detect
+        # bad calls downstream, but not to freak out about the `= not_set` part even
+        # though it's not semantically valid to pass that as an argument value.
+        # The intended use is "like **kwargs, but more tractable for tooling".
+        max_examples: int = not_set,  # type: ignore
+        derandomize: bool = not_set,  # type: ignore
+        database: Optional"ExampleDatabase" = not_set,  # type: ignore
+        verbosity: "Verbosity" = not_set,  # type: ignore
+        phases: Collection"Phase" = not_set,  # type: ignore
+        stateful_step_count: int = not_set,  # type: ignore
+        report_multiple_bugs: bool = not_set,  # type: ignore
+        suppress_health_check: Collection"HealthCheck" = not_set,  # type: ignore
+        deadline: Unionint, float, datetime.timedelta, None = not_set,  # type: ignore
+        print_blob: bool = not_set,  # type: ignore
+    ) -> None:
+        if parent is not None:
+            check_type(settings, parent, "parent")
+        if derandomize not in (not_set, False):
+            if database not in (not_set, None):  # type: ignore
+                raise InvalidArgument(
+                    "derandomize=True implies database=None, so passing "
+                    f"database={database!r} too is invalid."
+                )
+            database = None
+
+        defaults = parent or settings.default
+        if defaults is not None:
+            for setting in all_settings.values():
+                value = locals()setting.name
+                if value is not_set:
+                    object.__setattr__(
+                        self, setting.name, getattr(defaults, setting.name)
+                    )
+                else:
+                    object.__setattr__(self, setting.name, setting.validator(value))
+
+    def __call__(self, test: T) -> T:
+        """Make the settings object (self) an attribute of the test.
+
+        The settings are later discovered by looking them up on the test itself.
+        """
+        # Aliasing as Any avoids mypy errors (attr-defined) when accessing and
+        # setting custom attributes on the decorated function or class.
+        _test: Any = test
+
+        # Using the alias here avoids a mypy error (return-value) later when
+        # ``test`` is returned, because this check results in type refinement.
+        if not callable(_test):
+            raise InvalidArgument(
+                "settings objects can be called as a decorator with @given, "
+                f"but decorated test={test!r} is not callable."
+            )
+        if inspect.isclass(test):
+            from hypothesis.stateful import RuleBasedStateMachine
+
+            if issubclass(_test, RuleBasedStateMachine):
+                attr_name = "_hypothesis_internal_settings_applied"
+                if getattr(test, attr_name, False):
+                    raise InvalidArgument(
+                        "Applying the @settings decorator twice would "
+                        "overwrite the first version; merge their arguments "
+                        "instead."
+                    )
+                setattr(test, attr_name, True)
+                _test.TestCase.settings = self
+                return test  # type: ignore
+            else:
+                raise InvalidArgument(
+                    "@settings(...) can only be used as a decorator on "
+                    "functions, or on subclasses of RuleBasedStateMachine."
+                )
+        if hasattr(_test, "_hypothesis_internal_settings_applied"):
+            # Can't use _hypothesis_internal_use_settings as an indicator that
+            # @settings was applied, because @given also assigns that attribute.
+            descr = get_pretty_function_description(test)
+            raise InvalidArgument(
+                f"{descr} has already been decorated with a settings object.\n"
+                f"    Previous:  {_test._hypothesis_internal_use_settings!r}\n"
+                f"    This:  {self!r}"
+            )
+
+        _test._hypothesis_internal_use_settings = self
+        _test._hypothesis_internal_settings_applied = True
+        return test
+
+    @classmethod
+    def _define_setting(
+        cls,
+        name,
+        description,
+        default,
+        options=None,
+        validator=None,
+        show_default=True,
+    ):
+        """Add a new setting.
+
+        - name is the name of the property that will be used to access the
+          setting. This must be a valid python identifier.
+        - description will appear in the property's docstring
+        - default is the default value. This may be a zero argument
+          function in which case it is evaluated and its result is stored
+          the first time it is accessed on any given settings object.
+        """
+        if settings.__definitions_are_locked:
+            raise InvalidState(
+                "settings have been locked and may no longer be defined."
+            )
+        if options is not None:
+            options = tuple(options)
+            assert default in options
+
+            def validator(value):
+                if value not in options:
+                    msg = f"Invalid {name}, {value!r}. Valid options: {options!r}"
+                    raise InvalidArgument(msg)
+                return value
+
+        else:
+            assert validator is not None
+
+        all_settingsname = Setting(
+            name=name,
+            description=description.strip(),
+            default=default,
+            validator=validator,
+        )
+        setattr(settings, name, settingsProperty(name, show_default))
+
+    @classmethod
+    def lock_further_definitions(cls):
+        settings.__definitions_are_locked = True
+
+    def __setattr__(self, name, value):
+        raise AttributeError("settings objects are immutable")
+
+    def __repr__(self):
+        bits = sorted(f"{name}={getattr(self, name)!r}" for name in all_settings)
+        return "settings({})".format(", ".join(bits))
+
+    def show_changed(self):
+        bits = 
+        for name, setting in all_settings.items():
+            value = getattr(self, name)
+            if value != setting.default:
+                bits.append(f"{name}={value!r}")
+        return ", ".join(sorted(bits, key=len))
+
+    @staticmethod
+    def register_profile(
+        name: str,
+        parent: Optional"settings" = None,
+        **kwargs: Any,
+    ) -> None:
+        """Registers a collection of values to be used as a settings profile.
+
+        Settings profiles can be loaded by name - for example, you might
+        create a 'fast' profile which runs fewer examples, keep the 'default'
+        profile, and create a 'ci' profile that increases the number of
+        examples and uses a different database to store failures.
+
+        The arguments to this method are exactly as for
+        :class:`~hypothesis.settings`: optional ``parent`` settings, and
+        keyword arguments for each setting that will be set differently to
+        parent (or settings.default, if parent is None).
+        """
+        check_type(str, name, "name")
+        settings._profilesname = settings(parent=parent, **kwargs)
+
+    @staticmethod
+    def get_profile(name: str) -> "settings":
+        """Return the profile with the given name."""
+        check_type(str, name, "name")
+        try:
+            return settings._profilesname
+        except KeyError:
+            raise InvalidArgument(f"Profile {name!r} is not registered") from None
+
+    @staticmethod
+    def load_profile(name: str) -> None:
+        """Loads in the settings defined in the profile provided.
+
+        If the profile does not exist, InvalidArgument will be raised.
+        Any setting not defined in the profile will be the library
+        defined default for that setting.
+        """
+        check_type(str, name, "name")
+        settings._current_profile = name
+        settings._assign_default_internal(settings.get_profile(name))
+
+
+@contextlib.contextmanager
+def local_settings(s):
+    default_context_manager = default_variable.with_value(s)
+    with default_context_manager:
+        yield s
+
+
+@attr.s()
+class Setting:
+    name = attr.ib()
+    description = attr.ib()
+    default = attr.ib()
+    validator = attr.ib()
+
+
+def _max_examples_validator(x):
+    check_type(int, x, name="max_examples")
+    if x < 1:
+        raise InvalidArgument(
+            f"max_examples={x!r} should be at least one. You can disable "
+            "example generation with the `phases` setting instead."
+        )
+    return x
+
+
+settings._define_setting(
+    "max_examples",
+    default=100,
+    validator=_max_examples_validator,
+    description="""
+Once this many satisfying examples have been considered without finding any
+counter-example, Hypothesis will stop looking.
+
+Note that we might call your test function fewer times if we find a bug early
+or can tell that we've exhausted the search space; or more if we discard some
+examples due to use of .filter(), assume(), or a few other things that can
+prevent the test case from completing successfully.
+
+The default value is chosen to suit a workflow where the test will be part of
+a suite that is regularly executed locally or on a CI server, balancing total
+running time against the chance of missing a bug.
+
+If you are writing one-off tests, running tens of thousands of examples is
+quite reasonable as Hypothesis may miss uncommon bugs with default settings.
+For very complex code, we have observed Hypothesis finding novel bugs after
+*several million* examples while testing :pypi:`SymPy`.
+If you are running more than 100k examples for a test, consider using our
+:ref:`integration for coverage-guided fuzzing <fuzz_one_input>` - it really
+shines when given minutes or hours to run.
+""",
+)
+
+
+settings._define_setting(
+    "derandomize",
+    default=False,
+    options=(True, False),
+    description="""
+If True, seed Hypothesis' random number generator using a hash of the test
+function, so that every run will test the same set of examples until you
+update Hypothesis, Python, or the test function.
+
+This allows you to `check for regressions and look for bugs
+<https://blog.nelhage.com/post/two-kinds-of-testing/>`__ using
+:ref:`separate settings profiles <settings_profiles>` - for example running
+quick deterministic tests on every commit, and a longer non-deterministic
+nightly testing run.
+""",
+)
+
+
+def _validate_database(db):
+    from hypothesis.database import ExampleDatabase
+
+    if db is None or isinstance(db, ExampleDatabase):
+        return db
+    raise InvalidArgument(
+        "Arguments to the database setting must be None or an instance of "
+        f"ExampleDatabase.  Try passing database=ExampleDatabase({db!r}), or "
+        "construct and use one of the specific subclasses in "
+        "hypothesis.database"
+    )
+
+
+settings._define_setting(
+    "database",
+    default=not_set,
+    show_default=False,
+    description="""
+An instance of :class:`~hypothesis.database.ExampleDatabase` that will be
+used to save examples to and load previous examples from. May be ``None``
+in which case no storage will be used.
+
+See the :doc:`example database documentation <database>` for a list of built-in
+example database implementations, and how to define custom implementations.
+""",
+    validator=_validate_database,
+)
+
+
+@unique
+class Phase(IntEnum):
+    explicit = 0  #: controls whether explicit examples are run.
+    reuse = 1  #: controls whether previous examples will be reused.
+    generate = 2  #: controls whether new examples will be generated.
+    target = 3  #: controls whether examples will be mutated for targeting.
+    shrink = 4  #: controls whether examples will be shrunk.
+    explain = 5  #: controls whether Hypothesis attempts to explain test failures.
+
+    def __repr__(self):
+        return f"Phase.{self.name}"
+
+
+class HealthCheckMeta(EnumMeta):
+    def __iter__(self):
+        deprecated = (HealthCheck.return_value, HealthCheck.not_a_test_method)
+        return iter(x for x in super().__iter__() if x not in deprecated)
+
+
+@unique
+class HealthCheck(Enum, metaclass=HealthCheckMeta):
+    """Arguments for :attr:`~hypothesis.settings.suppress_health_check`.
+
+    Each member of this enum is a type of health check to suppress.
+    """
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}.{self.name}"
+
+    @classmethod
+    def all(cls) -> List"HealthCheck":
+        # Skipping of deprecated attributes is handled in HealthCheckMeta.__iter__
+        note_deprecation(
+            "`Healthcheck.all()` is deprecated; use `list(HealthCheck)` instead.",
+            since="2023-04-16",
+            has_codemod=True,
+        )
+        return list(HealthCheck)
+
+    data_too_large = 1
+    """Checks if too many examples are aborted for being too large.
+
+    This is measured by the number of random choices that Hypothesis makes
+    in order to generate something, not the size of the generated object.
+    For example, choosing a 100MB object from a predefined list would take
+    only a few bits, while generating 10KB of JSON from scratch might trigger
+    this health check.
+    """
+
+    filter_too_much = 2
+    """Check for when the test is filtering out too many examples, either
+    through use of :func:`~hypothesis.assume()` or :ref:`filter() <filtering>`,
+    or occasionally for Hypothesis internal reasons."""
+
+    too_slow = 3
+    """Check for when your data generation is extremely slow and likely to hurt
+    testing."""
+
+    return_value = 5
+    """Deprecated; we always error if a test returns a non-None value."""
+
+    large_base_example = 7
+    """Checks if the natural example to shrink towards is very large."""
+
+    not_a_test_method = 8
+    """Deprecated; we always error if :func:`@given <hypothesis.given>` is applied
+    to a method defined by :class:`python:unittest.TestCase` (i.e. not a test)."""
+
+    function_scoped_fixture = 9
+    """Checks if :func:`@given <hypothesis.given>` has been applied to a test
+    with a pytest function-scoped fixture. Function-scoped fixtures run once
+    for the whole function, not once per example, and this is usually not what
+    you want.
+
+    Because of this limitation, tests that need to set up or reset
+    state for every example need to do so manually within the test itself,
+    typically using an appropriate context manager.
+
+    Suppress this health check only in the rare case that you are using a
+    function-scoped fixture that does not need to be reset between individual
+    examples, but for some reason you cannot use a wider fixture scope
+    (e.g. session scope, module scope, class scope).
+
+    This check requires the :ref:`Hypothesis pytest plugin<pytest-plugin>`,
+    which is enabled by default when running Hypothesis inside pytest."""
+
+
+@unique
+class Verbosity(IntEnum):
+    quiet = 0
+    normal = 1
+    verbose = 2
+    debug = 3
+
+    def __repr__(self):
+        return f"Verbosity.{self.name}"
+
+
+settings._define_setting(
+    "verbosity",
+    options=tuple(Verbosity),
+    default=Verbosity.normal,
+    description="Control the verbosity level of Hypothesis messages",
+)
+
+
+def _validate_phases(phases):
+    phases = tuple(phases)
+    for a in phases:
+        if not isinstance(a, Phase):
+            raise InvalidArgument(f"{a!r} is not a valid phase")
+    return tuple(p for p in list(Phase) if p in phases)
+
+
+settings._define_setting(
+    "phases",
+    # We leave the `explain` phase disabled by default, for speed and brevity
+    # TODO: consider default-enabling this in CI?
+    default=_validate_phases(set(Phase) - {Phase.explain}),
+    description=(
+        "Control which phases should be run. "
+        "See :ref:`the full documentation for more details <phases>`"
+    ),
+    validator=_validate_phases,
+)
+
+
+def _validate_stateful_step_count(x):
+    check_type(int, x, name="stateful_step_count")
+    if x < 1:
+        raise InvalidArgument(f"stateful_step_count={x!r} must be at least one.")
+    return x
+
+
+settings._define_setting(
+    name="stateful_step_count",
+    default=50,
+    validator=_validate_stateful_step_count,
+    description="""
+Number of steps to run a stateful program for before giving up on it breaking.
+""",
+)
+
+settings._define_setting(
+    name="report_multiple_bugs",
+    default=True,
+    options=(True, False),
+    description="""
+Because Hypothesis runs the test many times, it can sometimes find multiple
+bugs in a single run.  Reporting all of them at once is usually very useful,
+but replacing the exceptions can occasionally clash with debuggers.
+If disabled, only the exception with the smallest minimal example is raised.
+""",
+)
+
+
+def validate_health_check_suppressions(suppressions):
+    suppressions = try_convert(list, suppressions, "suppress_health_check")
+    for s in suppressions:
+        if not isinstance(s, HealthCheck):
+            raise InvalidArgument(
+                f"Non-HealthCheck value {s!r} of type {type(s).__name__} "
+                "is invalid in suppress_health_check."
+            )
+        if s in (HealthCheck.return_value, HealthCheck.not_a_test_method):
+            note_deprecation(
+                f"The {s.name} health check is deprecated, because this is always an error.",
+                since="2023-03-15",
+                has_codemod=False,
+            )
+    return suppressions
+
+
+settings._define_setting(
+    "suppress_health_check",
+    default=(),
+    description="""A list of :class:`~hypothesis.HealthCheck` items to disable.""",
+    validator=validate_health_check_suppressions,
+)
+
+
+class duration(datetime.timedelta):
+    """A timedelta specifically measured in milliseconds."""
+
+    def __repr__(self):
+        ms = self.total_seconds() * 1000
+        return f"timedelta(milliseconds={int(ms) if ms == int(ms) else ms!r})"
+
+
+def _validate_deadline(x):
+    if x is None:
+        return x
+    invalid_deadline_error = InvalidArgument(
+        f"deadline={x!r} (type {type(x).__name__}) must be a timedelta object, "
+        "an integer or float number of milliseconds, or None to disable the "
+        "per-test-case deadline."
+    )
+    if isinstance(x, (int, float)):
+        if isinstance(x, bool):
+            raise invalid_deadline_error
+        try:
+            x = duration(milliseconds=x)
+        except OverflowError:
+            raise InvalidArgument(
+                f"deadline={x!r} is invalid, because it is too large to represent "
+                "as a timedelta. Use deadline=None to disable deadlines."
+            ) from None
+    if isinstance(x, datetime.timedelta):
+        if x <= datetime.timedelta(0):
+            raise InvalidArgument(
+                f"deadline={x!r} is invalid, because it is impossible to meet a "
+                "deadline <= 0. Use deadline=None to disable deadlines."
+            )
+        return duration(seconds=x.total_seconds())
+    raise invalid_deadline_error
+
+
+settings._define_setting(
+    "deadline",
+    default=duration(milliseconds=200),
+    validator=_validate_deadline,
+    description="""
+If set, a duration (as timedelta, or integer or float number of milliseconds)
+that each individual example (i.e. each time your test
+function is called, not the whole decorated test) within a test is not
+allowed to exceed. Tests which take longer than that may be converted into
+errors (but will not necessarily be if close to the deadline, to allow some
+variability in test run time).
+
+Set this to ``None`` to disable this behaviour entirely.
+""",
+)
+
+
+def is_in_ci() -> bool:
+    # GitHub Actions, Travis CI and AppVeyor have "CI"
+    # Azure Pipelines has "TF_BUILD"
+    return "CI" in os.environ or "TF_BUILD" in os.environ
+
+
+settings._define_setting(
+    "print_blob",
+    default=is_in_ci(),
+    show_default=False,
+    options=(True, False),
+    description="""
+If set to ``True``, Hypothesis will print code for failing examples that can be used with
+:func:`@reproduce_failure <hypothesis.reproduce_failure>` to reproduce the failing example.
+The default is ``True`` if the ``CI`` or ``TF_BUILD`` env vars are set, ``False`` otherwise.
+""",
+)
+
+settings.lock_further_definitions()
+
+
+def note_deprecation(message: str, *, since: str, has_codemod: bool) -> None:
+    if since != "RELEASEDAY":
+        date = datetime.datetime.strptime(since, "%Y-%m-%d").date()
+        assert datetime.date(2021, 1, 1) <= date
+    if has_codemod:
+        message += (
+            "\n    The `hypothesis codemod` command-line tool can automatically "
+            "refactor your code to fix this warning."
+        )
+    warnings.warn(HypothesisDeprecationWarning(message), stacklevel=2)
+
+
+settings.register_profile("default", settings())
+settings.load_profile("default")
+assert settings.default is not None
+
+
+# Check that the kwonly args to settings.__init__ is the same as the set of
+# defined settings - in case we've added or remove something from one but
+# not the other.
+assert set(all_settings) == {
+    p.name
+    for p in inspect.signature(settings.__init__).parameters.values()
+    if p.kind == inspect.Parameter.KEYWORD_ONLY
+}

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/configuration.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/control.py Added

@@ -0,0 +1,228 @@
+# 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 math
+from collections import defaultdict
+from typing import NoReturn, Union
+
+from hypothesis import Verbosity, settings
+from hypothesis.errors import InvalidArgument, UnsatisfiedAssumption
+from hypothesis.internal.compat import BaseExceptionGroup
+from hypothesis.internal.conjecture.data import ConjectureData
+from hypothesis.internal.reflection import get_pretty_function_description
+from hypothesis.internal.validation import check_type
+from hypothesis.reporting import report, verbose_report
+from hypothesis.utils.dynamicvariables import DynamicVariable
+from hypothesis.vendor.pretty import IDKey
+
+
+def reject() -> NoReturn:
+    raise UnsatisfiedAssumption()
+
+
+def assume(condition: object) -> bool:
+    """Calling ``assume`` is like an :ref:`assert <python:assert>` that marks
+    the example as bad, rather than failing the test.
+
+    This allows you to specify properties that you *assume* will be
+    true, and let Hypothesis try to avoid similar examples in future.
+    """
+    if not condition:
+        raise UnsatisfiedAssumption()
+    return True
+
+
+_current_build_context = DynamicVariable(None)
+
+
+def currently_in_test_context() -> bool:
+    """Return ``True`` if the calling code is currently running inside an
+    :func:`@given <hypothesis.given>` or :doc:`stateful <stateful>` test,
+    ``False`` otherwise.
+
+    This is useful for third-party integrations and assertion helpers which
+    may be called from traditional or property-based tests, but can only use
+    :func:`~hypothesis.assume` or :func:`~hypothesis.target` in the latter case.
+    """
+    return _current_build_context.value is not None
+
+
+def current_build_context() -> "BuildContext":
+    context = _current_build_context.value
+    if context is None:
+        raise InvalidArgument("No build context registered")
+    return context
+
+
+class BuildContext:
+    def __init__(self, data, is_final=False, close_on_capture=True):
+        assert isinstance(data, ConjectureData)
+        self.data = data
+        self.tasks = 
+        self.is_final = is_final
+        self.close_on_capture = close_on_capture
+        self.close_on_del = False
+        # Use defaultdict(list) here to handle the possibility of having multiple
+        # functions registered for the same object (due to caching, small ints, etc).
+        # The printer will discard duplicates which return different representations.
+        self.known_object_printers = defaultdict(list)
+
+    def record_call(self, obj, func, args, kwargs, arg_slices=None):
+        name = get_pretty_function_description(func)
+        self.known_object_printersIDKey(obj).append(
+            lambda obj, p, cycle: (
+                p.text("<...>")
+                if cycle
+                else p.repr_call(name, args, kwargs, arg_slices=arg_slices)
+            )
+        )
+
+    def prep_args_kwargs_from_strategies(self, arg_strategies, kwarg_strategies):
+        arg_labels = {}
+        all_s = (None, s) for s in arg_strategies + list(kwarg_strategies.items())
+        args = 
+        kwargs = {}
+        for i, (k, s) in enumerate(all_s):
+            start_idx = self.data.index
+            obj = self.data.draw(s)
+            end_idx = self.data.index
+            assert k is not None
+            kwargsk = obj
+
+            # This high up the stack, we can't see or really do much with the conjecture
+            # Example objects - not least because they're only materialized after the
+            # test case is completed.  Instead, we'll stash the (start_idx, end_idx)
+            # pair on our data object for the ConjectureRunner engine to deal with, and
+            # pass a dict of such out so that the pretty-printer knows where to place
+            # the which-parts-matter comments later.
+            if start_idx != end_idx:
+                arg_labelsk or i = (start_idx, end_idx)
+                self.data.arg_slices.add((start_idx, end_idx))
+
+        return args, kwargs, arg_labels
+
+    def __enter__(self):
+        self.assign_variable = _current_build_context.with_value(self)
+        self.assign_variable.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):
+        self.assign_variable.__exit__(exc_type, exc_value, tb)
+        errors = 
+        for task in self.tasks:
+            try:
+                task()
+            except BaseException as err:
+                errors.append(err)
+        if errors:
+            if len(errors) == 1:
+                raise errors0 from exc_value
+            raise BaseExceptionGroup("Cleanup failed", errors) from exc_value
+
+
+def cleanup(teardown):
+    """Register a function to be called when the current test has finished
+    executing. Any exceptions thrown in teardown will be printed but not
+    rethrown.
+
+    Inside a test this isn't very interesting, because you can just use
+    a finally block, but note that you can use this inside map, flatmap,
+    etc. in order to e.g. insist that a value is closed at the end.
+    """
+    context = _current_build_context.value
+    if context is None:
+        raise InvalidArgument("Cannot register cleanup outside of build context")
+    context.tasks.append(teardown)
+
+
+def should_note():
+    context = _current_build_context.value
+    if context is None:
+        raise InvalidArgument("Cannot make notes outside of a test")
+    return context.is_final or settings.default.verbosity >= Verbosity.verbose
+
+
+def note(value: str) -> None:
+    """Report this value for the minimal failing example."""
+    if should_note():
+        report(value)
+
+
+def event(value: str) -> None:
+    """Record an event that occurred this test. Statistics on number of test
+    runs with each event will be reported at the end if you run Hypothesis in
+    statistics reporting mode.
+
+    Events should be strings or convertible to them.
+    """
+    context = _current_build_context.value
+    if context is None:
+        raise InvalidArgument("Cannot make record events outside of a test")
+
+    context.data.note_event(value)
+
+
+def target(observation: Unionint, float, *, label: str = "") -> Unionint, float:
+    """Calling this function with an ``int`` or ``float`` observation gives it feedback
+    with which to guide our search for inputs that will cause an error, in
+    addition to all the usual heuristics.  Observations must always be finite.
+
+    Hypothesis will try to maximize the observed value over several examples;
+    almost any metric will work so long as it makes sense to increase it.
+    For example, ``-abs(error)`` is a metric that increases as ``error``
+    approaches zero.
+
+    Example metrics:
+
+    - Number of elements in a collection, or tasks in a queue
+    - Mean or maximum runtime of a task (or both, if you use ``label``)
+    - Compression ratio for data (perhaps per-algorithm or per-level)
+    - Number of steps taken by a state machine
+
+    The optional ``label`` argument can be used to distinguish between
+    and therefore separately optimise distinct observations, such as the
+    mean and standard deviation of a dataset.  It is an error to call
+    ``target()`` with any label more than once per test case.
+
+    .. note::
+        **The more examples you run, the better this technique works.**
+
+        As a rule of thumb, the targeting effect is noticeable above
+        :obj:`max_examples=1000 <hypothesis.settings.max_examples>`,
+        and immediately obvious by around ten thousand examples
+        *per label* used by your test.
+
+    :ref:`statistics` include the best score seen for each label,
+    which can help avoid `the threshold problem
+    <https://hypothesis.works/articles/threshold-problem/>`__ when the minimal
+    example shrinks right down to the threshold of failure (:issue:`2180`).
+    """
+    check_type((int, float), observation, "observation")
+    if not math.isfinite(observation):
+        raise InvalidArgument(f"observation={observation!r} must be a finite float.")
+    check_type(str, label, "label")
+
+    context = _current_build_context.value
+    if context is None:
+        raise InvalidArgument(
+            "Calling target() outside of a test is invalid.  "
+            "Consider guarding this call with `if currently_in_test_context(): ...`"
+        )
+    verbose_report(f"Saw target(observation={observation!r}, label={label!r})")
+
+    if label in context.data.target_observations:
+        raise InvalidArgument(
+            f"Calling target({observation!r}, label={label!r}) would overwrite "
+            f"target({context.data.target_observationslabel!r}, label={label!r})"
+        )
+    else:
+        context.data.target_observationslabel = observation
+
+    return observation

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/core.py Added

@@ -0,0 +1,1525 @@
+# 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/.
+
+"""This module provides the core primitives of Hypothesis, such as given."""
+
+import base64
+import contextlib
+import datetime
+import inspect
+import io
+import sys
+import time
+import types
+import unittest
+import warnings
+import zlib
+from collections import defaultdict
+from functools import partial
+from random import Random
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    BinaryIO,
+    Callable,
+    Coroutine,
+    Hashable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from unittest import TestCase
+
+import attr
+
+from hypothesis import strategies as st
+from hypothesis._settings import (
+    HealthCheck,
+    Phase,
+    Verbosity,
+    local_settings,
+    settings as Settings,
+)
+from hypothesis.control import BuildContext
+from hypothesis.errors import (
+    DeadlineExceeded,
+    DidNotReproduce,
+    FailedHealthCheck,
+    Flaky,
+    Found,
+    HypothesisDeprecationWarning,
+    HypothesisWarning,
+    InvalidArgument,
+    NoSuchExample,
+    StopTest,
+    Unsatisfiable,
+    UnsatisfiedAssumption,
+)
+from hypothesis.executors import default_new_style_executor, new_style_executor
+from hypothesis.internal.compat import (
+    PYPY,
+    BaseExceptionGroup,
+    bad_django_TestCase,
+    get_type_hints,
+    int_from_bytes,
+)
+from hypothesis.internal.conjecture.data import ConjectureData, Status
+from hypothesis.internal.conjecture.engine import BUFFER_SIZE, ConjectureRunner
+from hypothesis.internal.conjecture.shrinker import sort_key
+from hypothesis.internal.entropy import deterministic_PRNG
+from hypothesis.internal.escalation import (
+    current_pytest_item,
+    escalate_hypothesis_internal_error,
+    format_exception,
+    get_interesting_origin,
+    get_trimmed_traceback,
+)
+from hypothesis.internal.healthcheck import fail_health_check
+from hypothesis.internal.reflection import (
+    convert_positional_arguments,
+    define_function_signature,
+    function_digest,
+    get_pretty_function_description,
+    get_signature,
+    impersonate,
+    is_mock,
+    nicerepr,
+    proxies,
+    repr_call,
+)
+from hypothesis.internal.scrutineer import Tracer, explanatory_lines
+from hypothesis.internal.validation import check_type
+from hypothesis.reporting import (
+    current_verbosity,
+    report,
+    verbose_report,
+    with_reporter,
+)
+from hypothesis.statistics import describe_targets, note_statistics
+from hypothesis.strategies._internal.misc import NOTHING
+from hypothesis.strategies._internal.strategies import (
+    Ex,
+    SearchStrategy,
+    check_strategy,
+)
+from hypothesis.vendor.pretty import RepresentationPrinter
+from hypothesis.version import __version__
+
+if sys.version_info >= (3, 10):
+    from types import EllipsisType as EllipsisType
+elif TYPE_CHECKING:
+    from builtins import ellipsis as EllipsisType
+else:  # pragma: no cover
+    EllipsisType = type(Ellipsis)
+
+
+TestFunc = TypeVar("TestFunc", bound=Callable)
+
+
+running_under_pytest = False
+pytest_shows_exceptiongroups = True
+global_force_seed = None
+_hypothesis_global_random = None
+
+
+@attr.s()
+class Example:
+    args = attr.ib()
+    kwargs = attr.ib()
+    # Plus two optional arguments for .xfail()
+    raises = attr.ib(default=None)
+    reason = attr.ib(default=None)
+
+
+class example:
+    """A decorator which ensures a specific example is always tested."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        if args and kwargs:
+            raise InvalidArgument(
+                "Cannot mix positional and keyword arguments for examples"
+            )
+        if not (args or kwargs):
+            raise InvalidArgument("An example must provide at least one argument")
+
+        self.hypothesis_explicit_examples: ListExample = 
+        self._this_example = Example(tuple(args), kwargs)
+
+    def __call__(self, test: TestFunc) -> TestFunc:
+        if not hasattr(test, "hypothesis_explicit_examples"):
+            test.hypothesis_explicit_examples = self.hypothesis_explicit_examples  # type: ignore
+        test.hypothesis_explicit_examples.append(self._this_example)  # type: ignore
+        return test
+
+    def xfail(
+        self,
+        condition: bool = True,
+        *,
+        reason: str = "",
+        raises: Union
+            TypeBaseException, TupleTypeBaseException, ...
+         = BaseException,
+    ) -> "example":
+        """Mark this example as an expected failure, like pytest.mark.xfail().
+
+        Expected-failing examples allow you to check that your test does fail on
+        some examples, and therefore build confidence that *passing* tests are
+        because your code is working, not because the test is missing something.
+
+        .. code-block:: python
+
+            @example(...).xfail()
+            @example(...).xfail(reason="Prices must be non-negative")
+            @example(...).xfail(raises=(KeyError, ValueError))
+            @example(...).xfail(sys.version_info:2 >= (3, 9), reason="needs py39+")
+            @example(...).xfail(condition=sys.platform != "linux", raises=OSError)
+            def test(x):
+                pass
+        """
+        check_type(bool, condition, "condition")
+        check_type(str, reason, "reason")
+        if not (
+            isinstance(raises, type) and issubclass(raises, BaseException)
+        ) and not (
+            isinstance(raises, tuple)
+            and raises  # () -> expected to fail with no error, which is impossible
+            and all(
+                isinstance(r, type) and issubclass(r, BaseException) for r in raises
+            )
+        ):
+            raise InvalidArgument(
+                f"raises={raises!r} must be an exception type or tuple of exception types"
+            )
+        if condition:
+            self._this_example = attr.evolve(
+                self._this_example, raises=raises, reason=reason
+            )
+        return self
+
+    def via(self, *whence: str) -> "example":
+        """Attach a machine-readable label noting whence this example came.
+
+        The idea is that tools will be able to add ``@example()`` cases for you, e.g.
+        to maintain a high-coverage set of explicit examples, but also *remove* them
+        if they become redundant - without ever deleting manually-added examples:
+
+        .. code-block:: python
+
+            # You can choose to annotate examples, or not, as you prefer
+            @example(...)
+            @example(...).via("regression test for issue #42")
+
+            # The `hy-` prefix is reserved for automated tooling
+            @example(...).via("hy-failing")
+            @example(...).via("hy-coverage")
+            @example(...).via("hy-target-$label")
+            def test(x):
+                pass
+
+        Note that this "method chaining" syntax requires Python 3.9 or later, for
+        :pep:`614` relaxing grammar restrictions on decorators.  If you need to
+        support older versions of Python, you can use an identity function:
+
+        .. code-block:: python
+
+            def identity(x):
+                return x
+
+
+            @identity(example(...).via("label"))
+            def test(x):
+                pass
+
+        """
+        if len(whence) != 1 or not isinstance(whence0, str):
+            raise InvalidArgument(".via() must be passed a string")
+        # This is deliberately a no-op at runtime; the tools operate on source code.
+        return self
+
+    if sys.version_info:2 >= (3, 8):
+        # We want a positional-only argument, and on Python 3.8+ we'll get it.
+        __sig = get_signature(via)
+        via = define_function_signature(
+            name=via.__name__,
+            docstring=via.__doc__,
+            signature=__sig.replace(
+                parameters=
+                    p.replace(kind=inspect.Parameter.POSITIONAL_ONLY)
+                    for p in __sig.parameters.values()
+                
+            ),
+        )(via)
+        del __sig
+
+
+def seed(seed: Hashable) -> CallableTestFunc, TestFunc:
+    """seed: Start the test execution from a specific seed.
+
+    May be any hashable object. No exact meaning for seed is provided
+    other than that for a fixed seed value Hypothesis will try the same
+    actions (insofar as it can given external sources of non-
+    determinism. e.g. timing and hash randomization).
+
+    Overrides the derandomize setting, which is designed to enable
+    deterministic builds rather than reproducing observed failures.
+
+    """
+
+    def accept(test):
+        test._hypothesis_internal_use_seed = seed
+        current_settings = getattr(test, "_hypothesis_internal_use_settings", None)
+        test._hypothesis_internal_use_settings = Settings(
+            current_settings, database=None
+        )
+        return test
+
+    return accept
+
+
+def reproduce_failure(version: str, blob: bytes) -> CallableTestFunc, TestFunc:
+    """Run the example that corresponds to this data blob in order to reproduce
+    a failure.
+
+    A test with this decorator *always* runs only one example and always fails.
+    If the provided example does not cause a failure, or is in some way invalid
+    for this test, then this will fail with a DidNotReproduce error.
+
+    This decorator is not intended to be a permanent addition to your test
+    suite. It's simply some code you can add to ease reproduction of a problem
+    in the event that you don't have access to the test database. Because of
+    this, *no* compatibility guarantees are made between different versions of
+    Hypothesis - its API may change arbitrarily from version to version.
+    """
+
+    def accept(test):
+        test._hypothesis_internal_use_reproduce_failure = (version, blob)
+        return test
+
+    return accept
+
+
+def encode_failure(buffer):
+    buffer = bytes(buffer)
+    compressed = zlib.compress(buffer)
+    if len(compressed) < len(buffer):
+        buffer = b"\1" + compressed
+    else:
+        buffer = b"\0" + buffer
+    return base64.b64encode(buffer)
+
+
+def decode_failure(blob):
+    try:
+        buffer = base64.b64decode(blob)
+    except Exception:
+        raise InvalidArgument(f"Invalid base64 encoded string: {blob!r}") from None
+    prefix = buffer:1
+    if prefix == b"\0":
+        return buffer1:
+    elif prefix == b"\1":
+        try:
+            return zlib.decompress(buffer1:)
+        except zlib.error as err:
+            raise InvalidArgument(
+                f"Invalid zlib compression for blob {blob!r}"
+            ) from err
+    else:
+        raise InvalidArgument(
+            f"Could not decode blob {blob!r}: Invalid start byte {prefix!r}"
+        )
+
+
+def _invalid(message, *, exc=InvalidArgument, test, given_kwargs):
+    @impersonate(test)
+    def wrapped_test(*arguments, **kwargs):  # pragma: no cover  # coverage limitation
+        raise exc(message)
+
+    wrapped_test.is_hypothesis_test = True
+    wrapped_test.hypothesis = HypothesisHandle(
+        inner_test=test,
+        get_fuzz_target=wrapped_test,
+        given_kwargs=given_kwargs,
+    )
+    return wrapped_test
+
+
+def is_invalid_test(test, original_sig, given_arguments, given_kwargs):
+    """Check the arguments to ``@given`` for basic usage constraints.
+
+    Most errors are not raised immediately; instead we return a dummy test
+    function that will raise the appropriate error if it is actually called.
+    When the user runs a subset of tests (e.g via ``pytest -k``), errors will
+    only be reported for tests that actually ran.
+    """
+    invalid = partial(_invalid, test=test, given_kwargs=given_kwargs)
+
+    if not (given_arguments or given_kwargs):
+        return invalid("given must be called with at least one argument")
+
+    params = list(original_sig.parameters.values())
+    pos_params = p for p in params if p.kind is p.POSITIONAL_OR_KEYWORD
+    kwonly_params = p for p in params if p.kind is p.KEYWORD_ONLY
+    if given_arguments and params != pos_params:
+        return invalid(
+            "positional arguments to @given are not supported with varargs, "
+            "varkeywords, positional-only, or keyword-only arguments"
+        )
+
+    if len(given_arguments) > len(pos_params):
+        return invalid(
+            f"Too many positional arguments for {test.__name__}() were passed to "
+            f"@given - expected at most {len(pos_params)} "
+            f"arguments, but got {len(given_arguments)} {given_arguments!r}"
+        )
+
+    if ... in given_arguments:
+        return invalid(
+            "... was passed as a positional argument to @given, but may only be "
+            "passed as a keyword argument or as the sole argument of @given"
+        )
+
+    if given_arguments and given_kwargs:
+        return invalid("cannot mix positional and keyword arguments to @given")
+    extra_kwargs = 
+        k for k in given_kwargs if k not in {p.name for p in pos_params + kwonly_params}
+    
+    if extra_kwargs and (params ==  or params-1.kind is not params-1.VAR_KEYWORD):
+        arg = extra_kwargs0
+        return invalid(
+            f"{test.__name__}() got an unexpected keyword argument {arg!r}, "
+            f"from `{arg}={given_kwargsarg!r}` in @given"
+        )
+    if any(p.default is not p.empty for p in params):
+        return invalid("Cannot apply @given to a function with defaults.")
+
+    # This case would raise Unsatisfiable *anyway*, but by detecting it here we can
+    # provide a much more helpful error message for people e.g. using the Ghostwriter.
+    empty = 
+        f"{s!r} (arg {idx})" for idx, s in enumerate(given_arguments) if s is NOTHING
+     + f"{name}={s!r}" for name, s in given_kwargs.items() if s is NOTHING
+    if empty:
+        strats = "strategies" if len(empty) > 1 else "strategy"
+        return invalid(
+            f"Cannot generate examples from empty {strats}: " + ", ".join(empty),
+            exc=Unsatisfiable,
+        )
+
+
+def execute_explicit_examples(state, wrapped_test, arguments, kwargs, original_sig):
+    assert isinstance(state, StateForActualGivenExecution)
+    posargs = 
+        p.name
+        for p in original_sig.parameters.values()
+        if p.kind is p.POSITIONAL_OR_KEYWORD
+    
+
+    for example in reversed(getattr(wrapped_test, "hypothesis_explicit_examples", ())):
+        assert isinstance(example, Example)
+        # All of this validation is to check that @example() got "the same" arguments
+        # as @given, i.e. corresponding to the same parameters, even though they might
+        # be any mixture of positional and keyword arguments.
+        if example.args:
+            assert not example.kwargs
+            if any(
+                p.kind is p.POSITIONAL_ONLY for p in original_sig.parameters.values()
+            ):
+                raise InvalidArgument(
+                    "Cannot pass positional arguments to @example() when decorating "
+                    "a test function which has positional-only parameters."
+                )
+            if len(example.args) > len(posargs):
+                raise InvalidArgument(
+                    "example has too many arguments for test. Expected at most "
+                    f"{len(posargs)} but got {len(example.args)}"
+                )
+            example_kwargs = dict(zip(posargs-len(example.args) :, example.args))
+        else:
+            example_kwargs = dict(example.kwargs)
+        given_kws = ", ".join(
+            repr(k) for k in sorted(wrapped_test.hypothesis._given_kwargs)
+        )
+        example_kws = ", ".join(repr(k) for k in sorted(example_kwargs))
+        if given_kws != example_kws:
+            raise InvalidArgument(
+                f"Inconsistent args: @given() got strategies for {given_kws}, "
+                f"but @example() got arguments for {example_kws}"
+            ) from None
+
+        # This is certainly true because the example_kwargs exactly match the params
+        # reserved by @given(), which are then remove from the function signature.
+        assert set(example_kwargs).isdisjoint(kwargs)
+        example_kwargs.update(kwargs)
+
+        if Phase.explicit not in state.settings.phases:
+            continue
+
+        with local_settings(state.settings):
+            fragments_reported = 
+            try:
+                bits = ", ".join(nicerepr(x) for x in arguments) + ", ".join(
+                    f"{k}={nicerepr(v)}" for k, v in example_kwargs.items()
+                )
+                execute_example = partial(
+                    state.execute_once,
+                    ConjectureData.for_buffer(b""),
+                    is_final=True,
+                    print_example=True,
+                    example_kwargs=example_kwargs,
+                )
+                with with_reporter(fragments_reported.append):
+                    if example.raises is None:
+                        execute_example()
+                    else:
+                        # @example(...).xfail(...)
+                        try:
+                            execute_example()
+                        except failure_exceptions_to_catch() as err:
+                            if not isinstance(err, example.raises):
+                                raise
+                        except example.raises as err:
+                            # We'd usually check this as early as possible, but it's
+                            # possible for failure_exceptions_to_catch() to grow when
+                            # e.g. pytest is imported between import- and test-time.
+                            raise InvalidArgument(
+                                f"@example({bits}) raised an expected {err!r}, "
+                                "but Hypothesis does not treat this as a test failure"
+                            ) from err
+                        else:
+                            # Unexpectedly passing; always raise an error in this case.
+                            reason = f" because {example.reason}" * bool(example.reason)
+                            if example.raises is BaseException:
+                                name = "exception"  # special-case no raises= arg
+                            elif not isinstance(example.raises, tuple):
+                                name = example.raises.__name__
+                            elif len(example.raises) == 1:
+                                name = example.raises0.__name__
+                            else:
+                                name = (
+                                    ", ".join(ex.__name__ for ex in example.raises:-1)
+                                    + f", or {example.raises-1.__name__}"
+                                )
+                            vowel = name.upper()0 in "AEIOU"
+                            raise AssertionError(
+                                f"Expected a{'n' * vowel} {name} from @example({bits})"
+                                f"{reason}, but no exception was raised."
+                            )
+            except UnsatisfiedAssumption:
+                # Odd though it seems, we deliberately support explicit examples that
+                # are then rejected by a call to `assume()`.  As well as iterative
+                # development, this is rather useful to replay Hypothesis' part of
+                # a saved failure when other arguments are supplied by e.g. pytest.
+                # See https://github.com/HypothesisWorks/hypothesis/issues/2125
+                pass
+            except BaseException as err:
+                # In order to support reporting of multiple failing examples, we yield
+                # each of the (report text, error) pairs we find back to the top-level
+                # runner.  This also ensures that user-facing stack traces have as few
+                # frames of Hypothesis internals as possible.
+                err = err.with_traceback(get_trimmed_traceback())
+
+                # One user error - whether misunderstanding or typo - we've seen a few
+                # times is to pass strategies to @example() where values are expected.
+                # Checking is easy, and false-positives not much of a problem, so:
+                if isinstance(err, failure_exceptions_to_catch()) and any(
+                    isinstance(arg, SearchStrategy)
+                    for arg in example.args + tuple(example.kwargs.values())
+                ):
+                    new = HypothesisWarning(
+                        "The @example() decorator expects to be passed values, but "
+                        "you passed strategies instead.  See https://hypothesis."
+                        "readthedocs.io/en/latest/reproducing.html for details."
+                    )
+                    new.__cause__ = err
+                    err = new
+
+                yield (fragments_reported, err)
+                if (
+                    state.settings.report_multiple_bugs
+                    and pytest_shows_exceptiongroups
+                    and isinstance(err, failure_exceptions_to_catch())
+                    and not isinstance(err, skip_exceptions_to_reraise())
+                ):
+                    continue
+                break
+            finally:
+                if fragments_reported:
+                    assert fragments_reported0.startswith("Falsifying example")
+                    fragments_reported0 = fragments_reported0.replace(
+                        "Falsifying example", "Falsifying explicit example", 1
+                    )
+
+            if fragments_reported:
+                verbose_report(fragments_reported0.replace("Falsifying", "Trying", 1))
+                for f in fragments_reported1::
+                    verbose_report(f)
+
+
+def get_random_for_wrapped_test(test, wrapped_test):
+    settings = wrapped_test._hypothesis_internal_use_settings
+    wrapped_test._hypothesis_internal_use_generated_seed = None
+
+    if wrapped_test._hypothesis_internal_use_seed is not None:
+        return Random(wrapped_test._hypothesis_internal_use_seed)
+    elif settings.derandomize:
+        return Random(int_from_bytes(function_digest(test)))
+    elif global_force_seed is not None:
+        return Random(global_force_seed)
+    else:
+        global _hypothesis_global_random
+        if _hypothesis_global_random is None:
+            _hypothesis_global_random = Random()
+        seed = _hypothesis_global_random.getrandbits(128)
+        wrapped_test._hypothesis_internal_use_generated_seed = seed
+        return Random(seed)
+
+
+@attr.s
+class Stuff:
+    selfy = attr.ib(default=None)
+    args = attr.ib(factory=tuple)
+    kwargs = attr.ib(factory=dict)
+    given_kwargs = attr.ib(factory=dict)
+
+
+def process_arguments_to_given(wrapped_test, arguments, kwargs, given_kwargs, params):
+    selfy = None
+    arguments, kwargs = convert_positional_arguments(wrapped_test, arguments, kwargs)
+
+    # If the test function is a method of some kind, the bound object
+    # will be the first named argument if there are any, otherwise the
+    # first vararg (if any).
+    posargs = p.name for p in params.values() if p.kind is p.POSITIONAL_OR_KEYWORD
+    if posargs:
+        selfy = kwargs.get(posargs0)
+    elif arguments:
+        selfy = arguments0
+
+    # Ensure that we don't mistake mocks for self here.
+    # This can cause the mock to be used as the test runner.
+    if is_mock(selfy):
+        selfy = None
+
+    test_runner = new_style_executor(selfy)
+
+    arguments = tuple(arguments)
+
+    for k, s in given_kwargs.items():
+        check_strategy(s, name=k)
+        s.validate()
+
+    stuff = Stuff(selfy=selfy, args=arguments, kwargs=kwargs, given_kwargs=given_kwargs)
+
+    return arguments, kwargs, test_runner, stuff
+
+
+def skip_exceptions_to_reraise():
+    """Return a tuple of exceptions meaning 'skip this test', to re-raise.
+
+    This is intended to cover most common test runners; if you would
+    like another to be added please open an issue or pull request adding
+    it to this function and to tests/cover/test_lazy_import.py
+    """
+    # This is a set because nose may simply re-export unittest.SkipTest
+    exceptions = set()
+    # We use this sys.modules trick to avoid importing libraries -
+    # you can't be an instance of a type from an unimported module!
+    # This is fast enough that we don't need to cache the result,
+    # and more importantly it avoids possible side-effects :-)
+    if "unittest" in sys.modules:
+        exceptions.add(sys.modules"unittest".SkipTest)
+    if "unittest2" in sys.modules:
+        exceptions.add(sys.modules"unittest2".SkipTest)
+    if "nose" in sys.modules:
+        exceptions.add(sys.modules"nose".SkipTest)
+    if "_pytest" in sys.modules:
+        exceptions.add(sys.modules"_pytest".outcomes.Skipped)
+    return tuple(sorted(exceptions, key=str))
+
+
+def failure_exceptions_to_catch():
+    """Return a tuple of exceptions meaning 'this test has failed', to catch.
+
+    This is intended to cover most common test runners; if you would
+    like another to be added please open an issue or pull request.
+    """
+    # While SystemExit and GeneratorExit are instances of BaseException, we also
+    # expect them to be deterministic - unlike KeyboardInterrupt - and so we treat
+    # them as standard exceptions, check for flakiness, etc.
+    # See https://github.com/HypothesisWorks/hypothesis/issues/2223 for details.
+    exceptions = Exception, SystemExit, GeneratorExit
+    if "_pytest" in sys.modules:
+        exceptions.append(sys.modules"_pytest".outcomes.Failed)
+    return tuple(exceptions)
+
+
+def new_given_signature(original_sig, given_kwargs):
+    """Make an updated signature for the wrapped test."""
+    return original_sig.replace(
+        parameters=
+            p
+            for p in original_sig.parameters.values()
+            if not (
+                p.name in given_kwargs
+                and p.kind in (p.POSITIONAL_OR_KEYWORD, p.KEYWORD_ONLY)
+            )
+        ,
+        return_annotation=None,
+    )
+
+
+class StateForActualGivenExecution:
+    def __init__(self, test_runner, stuff, test, settings, random, wrapped_test):
+        self.test_runner = test_runner
+        self.stuff = stuff
+        self.settings = settings
+        self.last_exception = None
+        self.falsifying_examples = ()
+        self.random = random
+        self.__test_runtime = None
+        self.ever_executed = False
+
+        self.is_find = getattr(wrapped_test, "_hypothesis_internal_is_find", False)
+        self.wrapped_test = wrapped_test
+
+        self.test = test
+
+        self.print_given_args = getattr(
+            wrapped_test, "_hypothesis_internal_print_given_args", True
+        )
+
+        self.files_to_propagate = set()
+        self.failed_normally = False
+        self.failed_due_to_deadline = False
+
+        self.explain_traces = defaultdict(set)
+
+    def execute_once(
+        self,
+        data,
+        print_example=False,
+        is_final=False,
+        expected_failure=None,
+        example_kwargs=None,
+    ):
+        """Run the test function once, using ``data`` as input.
+
+        If the test raises an exception, it will propagate through to the
+        caller of this method. Depending on its type, this could represent
+        an ordinary test failure, or a fatal error, or a control exception.
+
+        If this method returns normally, the test might have passed, or
+        it might have placed ``data`` in an unsuccessful state and then
+        swallowed the corresponding control exception.
+        """
+
+        self.ever_executed = True
+        data.is_find = self.is_find
+
+        text_repr = None
+        if self.settings.deadline is None:
+            test = self.test
+        else:
+
+            @proxies(self.test)
+            def test(*args, **kwargs):
+                self.__test_runtime = None
+                initial_draws = len(data.draw_times)
+                start = time.perf_counter()
+                result = self.test(*args, **kwargs)
+                finish = time.perf_counter()
+                internal_draw_time = sum(data.draw_timesinitial_draws:)
+                runtime = datetime.timedelta(
+                    seconds=finish - start - internal_draw_time
+                )
+                self.__test_runtime = runtime
+                current_deadline = self.settings.deadline
+                if not is_final:
+                    current_deadline = (current_deadline // 4) * 5
+                if runtime >= current_deadline:
+                    raise DeadlineExceeded(runtime, self.settings.deadline)
+                return result
+
+        def run(data):
+            # Set up dynamic context needed by a single test run.
+            with local_settings(self.settings):
+                with deterministic_PRNG():
+                    with BuildContext(data, is_final=is_final) as context:
+                        if self.stuff.selfy is not None:
+                            data.hypothesis_runner = self.stuff.selfy
+                        # Generate all arguments to the test function.
+                        args = self.stuff.args
+                        kwargs = dict(self.stuff.kwargs)
+                        if example_kwargs is None:
+                            a, kw, argslices = context.prep_args_kwargs_from_strategies(
+                                (), self.stuff.given_kwargs
+                            )
+                            assert not a, "strategies all moved to kwargs by now"
+                        else:
+                            kw = example_kwargs
+                            argslices = {}
+                        kwargs.update(kw)
+                        if expected_failure is not None:
+                            nonlocal text_repr
+                            text_repr = repr_call(test, args, kwargs)
+
+                        if print_example or current_verbosity() >= Verbosity.verbose:
+                            printer = RepresentationPrinter(context=context)
+                            if print_example:
+                                printer.text("Falsifying example:")
+                            else:
+                                printer.text("Trying example:")
+
+                            if self.print_given_args:
+                                printer.text(" ")
+                                printer.repr_call(
+                                    test.__name__,
+                                    args,
+                                    kwargs,
+                                    force_split=True,
+                                    arg_slices=argslices,
+                                    leading_comment=(
+                                        "# " + context.data.slice_comments(0, 0)
+                                        if (0, 0) in context.data.slice_comments
+                                        else None
+                                    ),
+                                )
+                            report(printer.getvalue())
+                        return test(*args, **kwargs)
+
+        # Run the test function once, via the executor hook.
+        # In most cases this will delegate straight to `run(data)`.
+        result = self.test_runner(data, run)
+
+        # If a failure was expected, it should have been raised already, so
+        # instead raise an appropriate diagnostic error.
+        if expected_failure is not None:
+            exception, traceback = expected_failure
+            if (
+                isinstance(exception, DeadlineExceeded)
+                and self.__test_runtime is not None
+            ):
+                report(
+                    "Unreliable test timings! On an initial run, this "
+                    "test took %.2fms, which exceeded the deadline of "
+                    "%.2fms, but on a subsequent run it took %.2f ms, "
+                    "which did not. If you expect this sort of "
+                    "variability in your test timings, consider turning "
+                    "deadlines off for this test by setting deadline=None."
+                    % (
+                        exception.runtime.total_seconds() * 1000,
+                        self.settings.deadline.total_seconds() * 1000,
+                        self.__test_runtime.total_seconds() * 1000,
+                    )
+                )
+            else:
+                report("Failed to reproduce exception. Expected: \n" + traceback)
+            raise Flaky(
+                f"Hypothesis {text_repr} produces unreliable results: "
+                "Falsified on the first call but did not on a subsequent one"
+            ) from exception
+        return result
+
+    def _execute_once_for_engine(self, data):
+        """Wrapper around ``execute_once`` that intercepts test failure
+        exceptions and single-test control exceptions, and turns them into
+        appropriate method calls to `data` instead.
+
+        This allows the engine to assume that any exception other than
+        ``StopTest`` must be a fatal error, and should stop the entire engine.
+        """
+        try:
+            trace = frozenset()
+            if (
+                self.failed_normally
+                and not self.failed_due_to_deadline
+                and Phase.shrink in self.settings.phases
+                and Phase.explain in self.settings.phases
+                and sys.gettrace() is None
+                and not PYPY
+            ):  # pragma: no cover
+                # This is in fact covered by our *non-coverage* tests, but due to the
+                # settrace() contention *not* by our coverage tests.  Ah well.
+                tracer = Tracer()
+                try:
+                    sys.settrace(tracer.trace)
+                    result = self.execute_once(data)
+                    if data.status == Status.VALID:
+                        self.explain_tracesNone.add(frozenset(tracer.branches))
+                finally:
+                    sys.settrace(None)
+                    trace = frozenset(tracer.branches)
+            else:
+                result = self.execute_once(data)
+            if result is not None:
+                fail_health_check(
+                    self.settings,
+                    "Tests run under @given should return None, but "
+                    f"{self.test.__name__} returned {result!r} instead.",
+                    HealthCheck.return_value,
+                )
+        except UnsatisfiedAssumption:
+            # An "assume" check failed, so instead we inform the engine that
+            # this test run was invalid.
+            data.mark_invalid()
+        except StopTest:
+            # The engine knows how to handle this control exception, so it's
+            # OK to re-raise it.
+            raise
+        except (
+            HypothesisDeprecationWarning,
+            FailedHealthCheck,
+        ) + skip_exceptions_to_reraise():
+            # These are fatal errors or control exceptions that should stop the
+            # engine, so we re-raise them.
+            raise
+        except failure_exceptions_to_catch() as e:
+            # If the error was raised by Hypothesis-internal code, re-raise it
+            # as a fatal error instead of treating it as a test failure.
+            escalate_hypothesis_internal_error()
+
+            if data.frozen:
+                # This can happen if an error occurred in a finally
+                # block somewhere, suppressing our original StopTest.
+                # We raise a new one here to resume normal operation.
+                raise StopTest(data.testcounter) from e
+            else:
+                # The test failed by raising an exception, so we inform the
+                # engine that this test run was interesting. This is the normal
+                # path for test runs that fail.
+
+                tb = get_trimmed_traceback()
+                info = data.extra_information
+                info.__expected_traceback = format_exception(e, tb)
+                info.__expected_exception = e
+                verbose_report(info.__expected_traceback)
+
+                self.failed_normally = True
+
+                interesting_origin = get_interesting_origin(e)
+                if trace:  # pragma: no cover
+                    # Trace collection is explicitly disabled under coverage.
+                    self.explain_tracesinteresting_origin.add(trace)
+                if interesting_origin0 == DeadlineExceeded:
+                    self.failed_due_to_deadline = True
+                    self.explain_traces.clear()
+                data.mark_interesting(interesting_origin)
+
+    def run_engine(self):
+        """Run the test function many times, on database input and generated
+        input, using the Conjecture engine.
+        """
+        # Tell pytest to omit the body of this function from tracebacks
+        __tracebackhide__ = True
+        try:
+            database_key = self.wrapped_test._hypothesis_internal_database_key
+        except AttributeError:
+            if global_force_seed is None:
+                database_key = function_digest(self.test)
+            else:
+                database_key = None
+
+        runner = ConjectureRunner(
+            self._execute_once_for_engine,
+            settings=self.settings,
+            random=self.random,
+            database_key=database_key,
+        )
+        # Use the Conjecture engine to run the test function many times
+        # on different inputs.
+        runner.run()
+        note_statistics(runner.statistics)
+
+        if runner.call_count == 0:
+            return
+        if runner.interesting_examples:
+            self.falsifying_examples = sorted(
+                runner.interesting_examples.values(),
+                key=lambda d: sort_key(d.buffer),
+                reverse=True,
+            )
+        else:
+            if runner.valid_examples == 0:
+                rep = get_pretty_function_description(self.test)
+                raise Unsatisfiable(f"Unable to satisfy assumptions of {rep}")
+
+        if not self.falsifying_examples:
+            return
+        elif not (self.settings.report_multiple_bugs and pytest_shows_exceptiongroups):
+            # Pretend that we only found one failure, by discarding the others.
+            del self.falsifying_examples:-1
+
+        # The engine found one or more failures, so we need to reproduce and
+        # report them.
+
+        errors_to_report = 
+
+        report_lines = describe_targets(runner.best_observed_targets)
+        if report_lines:
+            report_lines.append("")
+
+        explanations = explanatory_lines(self.explain_traces, self.settings)
+        for falsifying_example in self.falsifying_examples:
+            info = falsifying_example.extra_information
+            fragments = 
+
+            ran_example = ConjectureData.for_buffer(falsifying_example.buffer)
+            ran_example.slice_comments = falsifying_example.slice_comments
+            assert info.__expected_exception is not None
+            try:
+                with with_reporter(fragments.append):
+                    self.execute_once(
+                        ran_example,
+                        print_example=not self.is_find,
+                        is_final=True,
+                        expected_failure=(
+                            info.__expected_exception,
+                            info.__expected_traceback,
+                        ),
+                    )
+            except (UnsatisfiedAssumption, StopTest) as e:
+                err = Flaky(
+                    "Unreliable assumption: An example which satisfied "
+                    "assumptions on the first run now fails it.",
+                )
+                err.__cause__ = err.__context__ = e
+                errors_to_report.append((fragments, err))
+            except BaseException as e:
+                # If we have anything for explain-mode, this is the time to report.
+                fragments.extend(explanationsfalsifying_example.interesting_origin)
+                errors_to_report.append(
+                    (fragments, e.with_traceback(get_trimmed_traceback()))
+                )
+            else:
+                # execute_once() will always raise either the expected error, or Flaky.
+                raise NotImplementedError("This should be unreachable")
+            finally:
+                # Whether or not replay actually raised the exception again, we want
+                # to print the reproduce_failure decorator for the failing example.
+                if self.settings.print_blob:
+                    fragments.append(
+                        "\nYou can reproduce this example by temporarily adding "
+                        "@reproduce_failure(%r, %r) as a decorator on your test case"
+                        % (__version__, encode_failure(falsifying_example.buffer))
+                    )
+                # Mostly useful for ``find`` and ensuring that objects that
+                # hold on to a reference to ``data`` know that it's now been
+                # finished and they can't draw more data from it.
+                ran_example.freeze()  # pragma: no branch
+                # No branch is possible here because we never have an active exception.
+        _raise_to_user(errors_to_report, self.settings, report_lines)
+
+
+def add_note(exc, note):
+    try:
+        exc.add_note(note)
+    except AttributeError:
+        if not hasattr(exc, "__notes__"):
+            exc.__notes__ = 
+        exc.__notes__.append(note)
+
+
+def _raise_to_user(errors_to_report, settings, target_lines, trailer=""):
+    """Helper function for attaching notes and grouping multiple errors."""
+    failing_prefix = "Falsifying example: "
+    ls = 
+    for fragments, err in errors_to_report:
+        for note in fragments:
+            add_note(err, note)
+            if note.startswith(failing_prefix):
+                ls.append(notelen(failing_prefix) :)
+    if current_pytest_item.value:
+        current_pytest_item.value._hypothesis_failing_examples = ls
+
+    if len(errors_to_report) == 1:
+        _, the_error_hypothesis_found = errors_to_report0
+    else:
+        assert errors_to_report
+        the_error_hypothesis_found = BaseExceptionGroup(
+            f"Hypothesis found {len(errors_to_report)} distinct failures{trailer}.",
+            e for _, e in errors_to_report,
+        )
+
+    if settings.verbosity >= Verbosity.normal:
+        for line in target_lines:
+            add_note(the_error_hypothesis_found, line)
+    raise the_error_hypothesis_found
+
+
+@contextlib.contextmanager
+def fake_subTest(self, msg=None, **__):
+    """Monkeypatch for `unittest.TestCase.subTest` during `@given`.
+
+    If we don't patch this out, each failing example is reported as a
+    separate failing test by the unittest test runner, which is
+    obviously incorrect. We therefore replace it for the duration with
+    this version.
+    """
+    warnings.warn(
+        "subTest per-example reporting interacts badly with Hypothesis "
+        "trying hundreds of examples, so we disable it for the duration of "
+        "any test that uses `@given`.",
+        HypothesisWarning,
+        stacklevel=2,
+    )
+    yield
+
+
+@attr.s()
+class HypothesisHandle:
+    """This object is provided as the .hypothesis attribute on @given tests.
+
+    Downstream users can reassign its attributes to insert custom logic into
+    the execution of each case, for example by converting an async into a
+    sync function.
+
+    This must be an attribute of an attribute, because reassignment of a
+    first-level attribute would not be visible to Hypothesis if the function
+    had been decorated before the assignment.
+
+    See https://github.com/HypothesisWorks/hypothesis/issues/1257 for more
+    information.
+    """
+
+    inner_test = attr.ib()
+    _get_fuzz_target = attr.ib()
+    _given_kwargs = attr.ib()
+
+    @property
+    def fuzz_one_input(
+        self,
+    ) -> CallableUnionbytes, bytearray, memoryview, BinaryIO, Optionalbytes:
+        """Run the test as a fuzz target, driven with the `buffer` of bytes.
+
+        Returns None if buffer invalid for the strategy, canonical pruned
+        bytes if the buffer was valid, and leaves raised exceptions alone.
+        """
+        # Note: most users, if they care about fuzzer performance, will access the
+        # property and assign it to a local variable to move the attribute lookup
+        # outside their fuzzing loop / before the fork point.  We cache it anyway,
+        # so that naive or unusual use-cases get the best possible performance too.
+        try:
+            return self.__cached_target  # type: ignore
+        except AttributeError:
+            self.__cached_target = self._get_fuzz_target()
+            return self.__cached_target
+
+
+@overload
+def given(
+    *_given_arguments: UnionSearchStrategyAny, EllipsisType,
+) -> Callable
+    Callable..., OptionalCoroutineAny, Any, None, Callable..., None
+:  # pragma: no cover
+    ...
+
+
+@overload
+def given(
+    **_given_kwargs: UnionSearchStrategyAny, EllipsisType,
+) -> Callable
+    Callable..., OptionalCoroutineAny, Any, None, Callable..., None
+:  # pragma: no cover
+    ...
+
+
+def given(
+    *_given_arguments: UnionSearchStrategyAny, EllipsisType,
+    **_given_kwargs: UnionSearchStrategyAny, EllipsisType,
+) -> Callable
+    Callable..., OptionalCoroutineAny, Any, None, Callable..., None
+:
+    """A decorator for turning a test function that accepts arguments into a
+    randomized test.
+
+    This is the main entry point to Hypothesis.
+    """
+
+    def run_test_as_given(test):
+        if inspect.isclass(test):
+            # Provide a meaningful error to users, instead of exceptions from
+            # internals that assume we're dealing with a function.
+            raise InvalidArgument("@given cannot be applied to a class.")
+        given_arguments = tuple(_given_arguments)
+        given_kwargs = dict(_given_kwargs)
+
+        original_sig = get_signature(test)
+        if given_arguments == (Ellipsis,) and not given_kwargs:
+            # user indicated that they want to infer all arguments
+            given_kwargs = {
+                p.name: Ellipsis
+                for p in original_sig.parameters.values()
+                if p.kind in (p.POSITIONAL_OR_KEYWORD, p.KEYWORD_ONLY)
+            }
+            given_arguments = ()
+
+        check_invalid = is_invalid_test(
+            test, original_sig, given_arguments, given_kwargs
+        )
+
+        # If the argument check found problems, return a dummy test function
+        # that will raise an error if it is actually called.
+        if check_invalid is not None:
+            return check_invalid
+
+        # Because the argument check succeeded, we can convert @given's
+        # positional arguments into keyword arguments for simplicity.
+        if given_arguments:
+            assert not given_kwargs
+            posargs = 
+                p.name
+                for p in original_sig.parameters.values()
+                if p.kind is p.POSITIONAL_OR_KEYWORD
+            
+            given_kwargs = dict(list(zip(posargs::-1, given_arguments::-1))::-1)
+        # These have been converted, so delete them to prevent accidental use.
+        del given_arguments
+
+        new_signature = new_given_signature(original_sig, given_kwargs)
+
+        # Use type information to convert "infer" arguments into appropriate strategies.
+        if ... in given_kwargs.values():
+            hints = get_type_hints(test)
+        for name in name for name, value in given_kwargs.items() if value is ...:
+            if name not in hints:
+                return _invalid(
+                    f"passed {name}=... for {test.__name__}, but {name} has "
+                    "no type annotation",
+                    test=test,
+                    given_kwargs=given_kwargs,
+                )
+            given_kwargsname = st.from_type(hintsname)
+
+        @impersonate(test)
+        @define_function_signature(test.__name__, test.__doc__, new_signature)
+        def wrapped_test(*arguments, **kwargs):
+            # Tell pytest to omit the body of this function from tracebacks
+            __tracebackhide__ = True
+
+            test = wrapped_test.hypothesis.inner_test
+
+            if getattr(test, "is_hypothesis_test", False):
+                raise InvalidArgument(
+                    f"You have applied @given to the test {test.__name__} more than "
+                    "once, which wraps the test several times and is extremely slow. "
+                    "A similar effect can be gained by combining the arguments "
+                    "of the two calls to given. For example, instead of "
+                    "@given(booleans()) @given(integers()), you could write "
+                    "@given(booleans(), integers())"
+                )
+
+            settings = wrapped_test._hypothesis_internal_use_settings
+
+            random = get_random_for_wrapped_test(test, wrapped_test)
+
+            processed_args = process_arguments_to_given(
+                wrapped_test, arguments, kwargs, given_kwargs, new_signature.parameters
+            )
+            arguments, kwargs, test_runner, stuff = processed_args
+
+            if (
+                inspect.iscoroutinefunction(test)
+                and test_runner is default_new_style_executor
+            ):
+                # See https://github.com/HypothesisWorks/hypothesis/issues/3054
+                # If our custom executor doesn't handle coroutines, or we return an
+                # awaitable from a non-async-def function, we just rely on the
+                # return_value health check.  This catches most user errors though.
+                raise InvalidArgument(
+                    "Hypothesis doesn't know how to run async test functions like "
+                    f"{test.__name__}.  You'll need to write a custom executor, "
+                    "or use a library like pytest-asyncio or pytest-trio which can "
+                    "handle the translation for you.\n    See https://hypothesis."
+                    "readthedocs.io/en/latest/details.html#custom-function-execution"
+                )
+
+            runner = stuff.selfy
+            if isinstance(stuff.selfy, TestCase) and test.__name__ in dir(TestCase):
+                msg = (
+                    f"You have applied @given to the method {test.__name__}, which is "
+                    "used by the unittest runner but is not itself a test."
+                    "  This is not useful in any way."
+                )
+                fail_health_check(settings, msg, HealthCheck.not_a_test_method)
+            if bad_django_TestCase(runner):  # pragma: no cover
+                # Covered by the Django tests, but not the pytest coverage task
+                raise InvalidArgument(
+                    "You have applied @given to a method on "
+                    f"{type(runner).__qualname__}, but this "
+                    "class does not inherit from the supported versions in "
+                    "`hypothesis.extra.django`.  Use the Hypothesis variants "
+                    "to ensure that each example is run in a separate "
+                    "database transaction."
+                )
+
+            state = StateForActualGivenExecution(
+                test_runner, stuff, test, settings, random, wrapped_test
+            )
+
+            reproduce_failure = wrapped_test._hypothesis_internal_use_reproduce_failure
+
+            # If there was a @reproduce_failure decorator, use it to reproduce
+            # the error (or complain that we couldn't). Either way, this will
+            # always raise some kind of error.
+            if reproduce_failure is not None:
+                expected_version, failure = reproduce_failure
+                if expected_version != __version__:
+                    raise InvalidArgument(
+                        "Attempting to reproduce a failure from a different "
+                        "version of Hypothesis. This failure is from %s, but "
+                        "you are currently running %r. Please change your "
+                        "Hypothesis version to a matching one."
+                        % (expected_version, __version__)
+                    )
+                try:
+                    state.execute_once(
+                        ConjectureData.for_buffer(decode_failure(failure)),
+                        print_example=True,
+                        is_final=True,
+                    )
+                    raise DidNotReproduce(
+                        "Expected the test to raise an error, but it "
+                        "completed successfully."
+                    )
+                except StopTest:
+                    raise DidNotReproduce(
+                        "The shape of the test data has changed in some way "
+                        "from where this blob was defined. Are you sure "
+                        "you're running the same test?"
+                    ) from None
+                except UnsatisfiedAssumption:
+                    raise DidNotReproduce(
+                        "The test data failed to satisfy an assumption in the "
+                        "test. Have you added it since this blob was "
+                        "generated?"
+                    ) from None
+
+            # There was no @reproduce_failure, so start by running any explicit
+            # examples from @example decorators.
+            errors = list(
+                execute_explicit_examples(
+                    state, wrapped_test, arguments, kwargs, original_sig
+                )
+            )
+            if errors:
+                # If we're not going to report multiple bugs, we would have
+                # stopped running explicit examples at the first failure.
+                assert len(errors) == 1 or state.settings.report_multiple_bugs
+
+                # If an explicit example raised a 'skip' exception, ensure it's never
+                # wrapped up in an exception group.  Because we break out of the loop
+                # immediately on finding a skip, if present it's always the last error.
+                if isinstance(errors-11, skip_exceptions_to_reraise()):
+                    # Covered by `test_issue_3453_regression`, just in a subprocess.
+                    del errors:-1  # pragma: no cover
+
+                _raise_to_user(errors, state.settings, , " in explicit examples")
+
+            # If there were any explicit examples, they all ran successfully.
+            # The next step is to use the Conjecture engine to run the test on
+            # many different inputs.
+
+            ran_explicit_examples = Phase.explicit in state.settings.phases and getattr(
+                wrapped_test, "hypothesis_explicit_examples", ()
+            )
+            SKIP_BECAUSE_NO_EXAMPLES = unittest.SkipTest(
+                "Hypothesis has been told to run no examples for this test."
+            )
+            if not (
+                Phase.reuse in settings.phases or Phase.generate in settings.phases
+            ):
+                if not ran_explicit_examples:
+                    raise SKIP_BECAUSE_NO_EXAMPLES
+                return
+
+            try:
+                if isinstance(runner, TestCase) and hasattr(runner, "subTest"):
+                    subTest = runner.subTest
+                    try:
+                        runner.subTest = types.MethodType(fake_subTest, runner)
+                        state.run_engine()
+                    finally:
+                        runner.subTest = subTest
+                else:
+                    state.run_engine()
+            except BaseException as e:
+                # The exception caught here should either be an actual test
+                # failure (or BaseExceptionGroup), or some kind of fatal error
+                # that caused the engine to stop.
+
+                generated_seed = wrapped_test._hypothesis_internal_use_generated_seed
+                with local_settings(settings):
+                    if not (state.failed_normally or generated_seed is None):
+                        if running_under_pytest:
+                            report(
+                                f"You can add @seed({generated_seed}) to this test or "
+                                f"run pytest with --hypothesis-seed={generated_seed} "
+                                "to reproduce this failure."
+                            )
+                        else:
+                            report(
+                                f"You can add @seed({generated_seed}) to this test to "
+                                "reproduce this failure."
+                            )
+                    # The dance here is to avoid showing users long tracebacks
+                    # full of Hypothesis internals they don't care about.
+                    # We have to do this inline, to avoid adding another
+                    # internal stack frame just when we've removed the rest.
+                    #
+                    # Using a variable for our trimmed error ensures that the line
+                    # which will actually appear in tracebacks is as clear as
+                    # possible - "raise the_error_hypothesis_found".
+                    the_error_hypothesis_found = e.with_traceback(
+                        None
+                        if isinstance(e, BaseExceptionGroup)
+                        else get_trimmed_traceback()
+                    )
+                    raise the_error_hypothesis_found
+
+            if not (ran_explicit_examples or state.ever_executed):
+                raise SKIP_BECAUSE_NO_EXAMPLES
+
+        def _get_fuzz_target() -> (
+            CallableUnionbytes, bytearray, memoryview, BinaryIO, Optionalbytes
+        ):
+            # Because fuzzing interfaces are very performance-sensitive, we use a
+            # somewhat more complicated structure here.  `_get_fuzz_target()` is
+            # called by the `HypothesisHandle.fuzz_one_input` property, allowing
+            # us to defer our collection of the settings, random instance, and
+            # reassignable `inner_test` (etc) until `fuzz_one_input` is accessed.
+            #
+            # We then share the performance cost of setting up `state` between
+            # many invocations of the target.  We explicitly force `deadline=None`
+            # for performance reasons, saving ~40% the runtime of an empty test.
+            test = wrapped_test.hypothesis.inner_test
+            settings = Settings(
+                parent=wrapped_test._hypothesis_internal_use_settings, deadline=None
+            )
+            random = get_random_for_wrapped_test(test, wrapped_test)
+            _args, _kwargs, test_runner, stuff = process_arguments_to_given(
+                wrapped_test, (), {}, given_kwargs, new_signature.parameters
+            )
+            assert not _args
+            assert not _kwargs
+            state = StateForActualGivenExecution(
+                test_runner, stuff, test, settings, random, wrapped_test
+            )
+            digest = function_digest(test)
+            # We track the minimal-so-far example for each distinct origin, so
+            # that we track log-n instead of n examples for long runs.  In particular
+            # it means that we saturate for common errors in long runs instead of
+            # storing huge volumes of low-value data.
+            minimal_failures: dict = {}
+
+            def fuzz_one_input(
+                buffer: Unionbytes, bytearray, memoryview, BinaryIO
+            ) -> Optionalbytes:
+                # This inner part is all that the fuzzer will actually run,
+                # so we keep it as small and as fast as possible.
+                if isinstance(buffer, io.IOBase):
+                    buffer = buffer.read(BUFFER_SIZE)
+                assert isinstance(buffer, (bytes, bytearray, memoryview))
+                data = ConjectureData.for_buffer(buffer)
+                try:
+                    state.execute_once(data)
+                except (StopTest, UnsatisfiedAssumption):
+                    return None
+                except BaseException:
+                    buffer = bytes(data.buffer)
+                    known = minimal_failures.get(data.interesting_origin)
+                    if settings.database is not None and (
+                        known is None or sort_key(buffer) <= sort_key(known)
+                    ):
+                        settings.database.save(digest, buffer)
+                        minimal_failuresdata.interesting_origin = buffer
+                    raise
+                return bytes(data.buffer)
+
+            fuzz_one_input.__doc__ = HypothesisHandle.fuzz_one_input.__doc__
+            return fuzz_one_input
+
+        # After having created the decorated test function, we need to copy
+        # over some attributes to make the switch as seamless as possible.
+
+        for attrib in dir(test):
+            if not (attrib.startswith("_") or hasattr(wrapped_test, attrib)):
+                setattr(wrapped_test, attrib, getattr(test, attrib))
+        wrapped_test.is_hypothesis_test = True
+        if hasattr(test, "_hypothesis_internal_settings_applied"):
+            # Used to check if @settings is applied twice.
+            wrapped_test._hypothesis_internal_settings_applied = True
+        wrapped_test._hypothesis_internal_use_seed = getattr(
+            test, "_hypothesis_internal_use_seed", None
+        )
+        wrapped_test._hypothesis_internal_use_settings = (
+            getattr(test, "_hypothesis_internal_use_settings", None) or Settings.default
+        )
+        wrapped_test._hypothesis_internal_use_reproduce_failure = getattr(
+            test, "_hypothesis_internal_use_reproduce_failure", None
+        )
+        wrapped_test.hypothesis = HypothesisHandle(test, _get_fuzz_target, given_kwargs)
+        return wrapped_test
+
+    return run_test_as_given
+
+
+def find(
+    specifier: SearchStrategyEx,
+    condition: CallableAny, bool,
+    *,
+    settings: OptionalSettings = None,
+    random: OptionalRandom = None,
+    database_key: Optionalbytes = None,
+) -> Ex:
+    """Returns the minimal example from the given strategy ``specifier`` that
+    matches the predicate function ``condition``."""
+    if settings is None:
+        settings = Settings(max_examples=2000)
+    settings = Settings(
+        settings, suppress_health_check=list(HealthCheck), report_multiple_bugs=False
+    )
+
+    if database_key is None and settings.database is not None:
+        database_key = function_digest(condition)
+
+    if not isinstance(specifier, SearchStrategy):
+        raise InvalidArgument(
+            f"Expected SearchStrategy but got {specifier!r} of "
+            f"type {type(specifier).__name__}"
+        )
+    specifier.validate()
+
+    last: ListEx = 
+
+    @settings
+    @given(specifier)
+    def test(v):
+        if condition(v):
+            last: = v
+            raise Found()
+
+    if random is not None:
+        test = seed(random.getrandbits(64))(test)
+
+    # Aliasing as Any avoids mypy errors (attr-defined) when accessing and
+    # setting custom attributes on the decorated function or class.
+    _test: Any = test
+    _test._hypothesis_internal_is_find = True
+    _test._hypothesis_internal_database_key = database_key
+
+    try:
+        test()
+    except Found:
+        return last0
+
+    raise NoSuchExample(get_pretty_function_description(condition))

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/database.py Added

@@ -0,0 +1,672 @@
+# 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 abc
+import binascii
+import json
+import os
+import sys
+import warnings
+from datetime import datetime, timedelta, timezone
+from hashlib import sha384
+from os import getenv
+from pathlib import Path, PurePath
+from typing import Dict, Iterable, Optional, Set
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+from zipfile import BadZipFile, ZipFile
+
+from hypothesis.configuration import mkdir_p, storage_directory
+from hypothesis.errors import HypothesisException, HypothesisWarning
+from hypothesis.utils.conventions import not_set
+
+__all__ = 
+    "DirectoryBasedExampleDatabase",
+    "ExampleDatabase",
+    "InMemoryExampleDatabase",
+    "MultiplexedDatabase",
+    "ReadOnlyDatabase",
+    "GitHubArtifactDatabase",
+
+
+
+def _usable_dir(path):
+    """
+    Returns True iff the desired path can be used as database path because
+    either the directory exists and can be used, or its root directory can
+    be used and we can make the directory as needed.
+    """
+    while not os.path.exists(path):
+        # Loop terminates because the root dir ('/' on unix) always exists.
+        path = os.path.dirname(path)
+    return os.path.isdir(path) and os.access(path, os.R_OK | os.W_OK | os.X_OK)
+
+
+def _db_for_path(path=None):
+    if path is not_set:
+        if os.getenv("HYPOTHESIS_DATABASE_FILE") is not None:  # pragma: no cover
+            raise HypothesisException(
+                "The $HYPOTHESIS_DATABASE_FILE environment variable no longer has any "
+                "effect.  Configure your database location via a settings profile instead.\n"
+                "https://hypothesis.readthedocs.io/en/latest/settings.html#settings-profiles"
+            )
+
+        path = storage_directory("examples")
+        if not _usable_dir(path):  # pragma: no cover
+            warnings.warn(
+                HypothesisWarning(
+                    "The database setting is not configured, and the default "
+                    "location is unusable - falling back to an in-memory "
+                    f"database for this session.  path={path!r}"
+                )
+            )
+            return InMemoryExampleDatabase()
+    if path in (None, ":memory:"):
+        return InMemoryExampleDatabase()
+    return DirectoryBasedExampleDatabase(str(path))
+
+
+class _EDMeta(abc.ABCMeta):
+    def __call__(self, *args, **kwargs):
+        if self is ExampleDatabase:
+            return _db_for_path(*args, **kwargs)
+        return super().__call__(*args, **kwargs)
+
+
+# This __call__ method is picked up by Sphinx as the signature of all ExampleDatabase
+# subclasses, which is accurate, reasonable, and unhelpful.  Fortunately Sphinx
+# maintains a list of metaclass-call-methods to ignore, and while they would prefer
+# not to maintain it upstream (https://github.com/sphinx-doc/sphinx/pull/8262) we
+# can insert ourselves here.
+#
+# This code only runs if Sphinx has already been imported; and it would live in our
+# docs/conf.py except that we would also like it to work for anyone documenting
+# downstream ExampleDatabase subclasses too.
+if "sphinx" in sys.modules:
+    try:
+        from sphinx.ext.autodoc import _METACLASS_CALL_BLACKLIST
+
+        _METACLASS_CALL_BLACKLIST.append("hypothesis.database._EDMeta.__call__")
+    except Exception:
+        pass
+
+
+class ExampleDatabase(metaclass=_EDMeta):
+    """An abstract base class for storing examples in Hypothesis' internal format.
+
+    An ExampleDatabase maps each ``bytes`` key to many distinct ``bytes``
+    values, like a ``Mappingbytes, AbstractSetbytes``.
+    """
+
+    @abc.abstractmethod
+    def save(self, key: bytes, value: bytes) -> None:
+        """Save ``value`` under ``key``.
+
+        If this value is already present for this key, silently do nothing.
+        """
+        raise NotImplementedError(f"{type(self).__name__}.save")
+
+    @abc.abstractmethod
+    def fetch(self, key: bytes) -> Iterablebytes:
+        """Return an iterable over all values matching this key."""
+        raise NotImplementedError(f"{type(self).__name__}.fetch")
+
+    @abc.abstractmethod
+    def delete(self, key: bytes, value: bytes) -> None:
+        """Remove this value from this key.
+
+        If this value is not present, silently do nothing.
+        """
+        raise NotImplementedError(f"{type(self).__name__}.delete")
+
+    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
+        """Move ``value`` from key ``src`` to key ``dest``. Equivalent to
+        ``delete(src, value)`` followed by ``save(src, value)``, but may
+        have a more efficient implementation.
+
+        Note that ``value`` will be inserted at ``dest`` regardless of whether
+        it is currently present at ``src``.
+        """
+        if src == dest:
+            self.save(src, value)
+            return
+        self.delete(src, value)
+        self.save(dest, value)
+
+
+class InMemoryExampleDatabase(ExampleDatabase):
+    """A non-persistent example database, implemented in terms of a dict of sets.
+
+    This can be useful if you call a test function several times in a single
+    session, or for testing other database implementations, but because it
+    does not persist between runs we do not recommend it for general use.
+    """
+
+    def __init__(self):
+        self.data = {}
+
+    def __repr__(self) -> str:
+        return f"InMemoryExampleDatabase({self.data!r})"
+
+    def fetch(self, key: bytes) -> Iterablebytes:
+        yield from self.data.get(key, ())
+
+    def save(self, key: bytes, value: bytes) -> None:
+        self.data.setdefault(key, set()).add(bytes(value))
+
+    def delete(self, key: bytes, value: bytes) -> None:
+        self.data.get(key, set()).discard(bytes(value))
+
+
+def _hash(key):
+    return sha384(key).hexdigest():16
+
+
+class DirectoryBasedExampleDatabase(ExampleDatabase):
+    """Use a directory to store Hypothesis examples as files.
+
+    Each test corresponds to a directory, and each example to a file within that
+    directory.  While the contents are fairly opaque, a
+    ``DirectoryBasedExampleDatabase`` can be shared by checking the directory
+    into version control, for example with the following ``.gitignore``::
+
+        # Ignore files cached by Hypothesis...
+        .hypothesis/*
+        # except for the examples directory
+        !.hypothesis/examples/
+
+    Note however that this only makes sense if you also pin to an exact version of
+    Hypothesis, and we would usually recommend implementing a shared database with
+    a network datastore - see :class:`~hypothesis.database.ExampleDatabase`, and
+    the :class:`~hypothesis.database.MultiplexedDatabase` helper.
+    """
+
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self.keypaths: Dictbytes, str = {}
+
+    def __repr__(self) -> str:
+        return f"DirectoryBasedExampleDatabase({self.path!r})"
+
+    def _key_path(self, key: bytes) -> str:
+        try:
+            return self.keypathskey
+        except KeyError:
+            pass
+        directory = os.path.join(self.path, _hash(key))
+        self.keypathskey = directory
+        return directory
+
+    def _value_path(self, key, value):
+        return os.path.join(self._key_path(key), _hash(value))
+
+    def fetch(self, key: bytes) -> Iterablebytes:
+        kp = self._key_path(key)
+        if not os.path.exists(kp):
+            return
+        for path in os.listdir(kp):
+            try:
+                with open(os.path.join(kp, path), "rb") as i:
+                    yield i.read()
+            except OSError:
+                pass
+
+    def save(self, key: bytes, value: bytes) -> None:
+        # Note: we attempt to create the dir in question now. We
+        # already checked for permissions, but there can still be other issues,
+        # e.g. the disk is full
+        mkdir_p(self._key_path(key))
+        path = self._value_path(key, value)
+        if not os.path.exists(path):
+            suffix = binascii.hexlify(os.urandom(16)).decode("ascii")
+            tmpname = path + "." + suffix
+            with open(tmpname, "wb") as o:
+                o.write(value)
+            try:
+                os.rename(tmpname, path)
+            except OSError:  # pragma: no cover
+                os.unlink(tmpname)
+            assert not os.path.exists(tmpname)
+
+    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
+        if src == dest:
+            self.save(src, value)
+            return
+        try:
+            os.renames(
+                self._value_path(src, value),
+                self._value_path(dest, value),
+            )
+        except OSError:
+            self.delete(src, value)
+            self.save(dest, value)
+
+    def delete(self, key: bytes, value: bytes) -> None:
+        try:
+            os.unlink(self._value_path(key, value))
+        except OSError:
+            pass
+
+
+class ReadOnlyDatabase(ExampleDatabase):
+    """A wrapper to make the given database read-only.
+
+    The implementation passes through ``fetch``, and turns ``save``, ``delete``, and
+    ``move`` into silent no-ops.
+
+    Note that this disables Hypothesis' automatic discarding of stale examples.
+    It is designed to allow local machines to access a shared database (e.g. from CI
+    servers), without propagating changes back from a local or in-development branch.
+    """
+
+    def __init__(self, db: ExampleDatabase) -> None:
+        assert isinstance(db, ExampleDatabase)
+        self._wrapped = db
+
+    def __repr__(self) -> str:
+        return f"ReadOnlyDatabase({self._wrapped!r})"
+
+    def fetch(self, key: bytes) -> Iterablebytes:
+        yield from self._wrapped.fetch(key)
+
+    def save(self, key: bytes, value: bytes) -> None:
+        pass
+
+    def delete(self, key: bytes, value: bytes) -> None:
+        pass
+
+
+class MultiplexedDatabase(ExampleDatabase):
+    """A wrapper around multiple databases.
+
+    Each ``save``, ``fetch``, ``move``, or ``delete`` operation will be run against
+    all of the wrapped databases.  ``fetch`` does not yield duplicate values, even
+    if the same value is present in two or more of the wrapped databases.
+
+    This combines well with a :class:`ReadOnlyDatabase`, as follows:
+
+    .. code-block:: python
+
+        local = DirectoryBasedExampleDatabase("/tmp/hypothesis/examples/")
+        shared = CustomNetworkDatabase()
+
+        settings.register_profile("ci", database=shared)
+        settings.register_profile(
+            "dev", database=MultiplexedDatabase(local, ReadOnlyDatabase(shared))
+        )
+        settings.load_profile("ci" if os.environ.get("CI") else "dev")
+
+    So your CI system or fuzzing runs can populate a central shared database;
+    while local runs on development machines can reproduce any failures from CI
+    but will only cache their own failures locally and cannot remove examples
+    from the shared database.
+    """
+
+    def __init__(self, *dbs: ExampleDatabase) -> None:
+        assert all(isinstance(db, ExampleDatabase) for db in dbs)
+        self._wrapped = dbs
+
+    def __repr__(self) -> str:
+        return "MultiplexedDatabase({})".format(", ".join(map(repr, self._wrapped)))
+
+    def fetch(self, key: bytes) -> Iterablebytes:
+        seen = set()
+        for db in self._wrapped:
+            for value in db.fetch(key):
+                if value not in seen:
+                    yield value
+                    seen.add(value)
+
+    def save(self, key: bytes, value: bytes) -> None:
+        for db in self._wrapped:
+            db.save(key, value)
+
+    def delete(self, key: bytes, value: bytes) -> None:
+        for db in self._wrapped:
+            db.delete(key, value)
+
+    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
+        for db in self._wrapped:
+            db.move(src, dest, value)
+
+
+class GitHubArtifactDatabase(ExampleDatabase):
+    """
+    A file-based database loaded from a `GitHub Actions <https://docs.github.com/en/actions>`_ artifact.
+
+    You can use this for sharing example databases between CI runs and developers, allowing
+    the latter to get read-only access to the former. This is particularly useful for
+    continuous fuzzing (i.e. with `HypoFuzz <https://hypofuzz.com/>`_),
+    where the CI system can help find new failing examples through fuzzing,
+    and developers can reproduce them locally without any manual effort.
+
+    .. note::
+        You must provide ``GITHUB_TOKEN`` as an environment variable. In CI, Github Actions provides
+        this automatically, but it needs to be set manually for local usage. In a developer machine,
+        this would usually be a `Personal Access Token <https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token>`_.
+        If the repository is private, it's necessary for the token to have `repo` scope
+        in the case of a classic token, or `actions:read` in the case of a fine-grained token.
+
+
+    In most cases, this will be used
+    through the :class:`~hypothesis.database.MultiplexedDatabase`,
+    by combining a local directory-based database with this one. For example:
+
+    .. code-block:: python
+
+        local = DirectoryBasedExampleDatabase(".hypothesis/examples")
+        shared = ReadOnlyDatabase(GitHubArtifactDatabase("user", "repo"))
+
+        settings.register_profile("ci", database=local)
+        settings.register_profile("dev", database=MultiplexedDatabase(local, shared))
+        # We don't want to use the shared database in CI, only to populate its local one.
+        # which the workflow should then upload as an artifact.
+        settings.load_profile("ci" if os.environ.get("CI") else "dev")
+
+    .. note::
+        Because this database is read-only, you always need to wrap it with the
+        :class:`ReadOnlyDatabase`.
+
+    A setup like this can be paired with a GitHub Actions workflow including
+    something like the following:
+
+    .. code-block:: yaml
+
+        - name: Download example database
+          uses: dawidd6/action-download-artifact@v2.24.3
+          with:
+            name: hypothesis-example-db
+            path: .hypothesis/examples
+            if_no_artifact_found: warn
+            workflow_conclusion: completed
+
+        - name: Run tests
+          run: pytest
+
+        - name: Upload example database
+          uses: actions/upload-artifact@v3
+          if: always()
+          with:
+            name: hypothesis-example-db
+            path: .hypothesis/examples
+
+    In this workflow, we use `dawidd6/action-download-artifact <https://github.com/dawidd6/action-download-artifact>`_
+    to download the latest artifact given that the official `actions/download-artifact <https://github.com/actions/download-artifact>`_
+    does not support downloading artifacts from previous workflow runs.
+
+    The database automatically implements a simple file-based cache with a default expiration period
+    of 1 day. You can adjust this through the `cache_timeout` property.
+
+    For mono-repo support, you can provide a unique `artifact_name` (e.g. `hypofuzz-example-db-frontend`).
+    """
+
+    def __init__(
+        self,
+        owner: str,
+        repo: str,
+        artifact_name: str = "hypothesis-example-db",
+        cache_timeout: timedelta = timedelta(days=1),
+        path: OptionalPath = None,
+    ):
+        self.owner = owner
+        self.repo = repo
+        self.artifact_name = artifact_name
+        self.cache_timeout = cache_timeout
+
+        self.keypaths: Dictbytes, PurePath = {}
+
+        # Get the GitHub token from the environment
+        # It's unnecessary to use a token if the repo is public
+        self.token: Optionalstr = getenv("GITHUB_TOKEN")
+
+        if path is None:
+            self.path: Path = Path(
+                storage_directory(f"github-artifacts/{self.artifact_name}/")
+            )
+        else:
+            self.path = path
+
+        # We don't want to initialize the cache until we need to
+        self._initialized: bool = False
+        self._disabled: bool = False
+
+        # This is the path to the artifact in usage
+        # .hypothesis/github-artifacts/<artifact-name>/<modified_isoformat>.zip
+        self._artifact: OptionalPath = None
+        # This caches the artifact structure
+        self._access_cache: OptionalDictPurePath, SetPurePath = None
+
+        # Message to display if user doesn't wrap around ReadOnlyDatabase
+        self._read_only_message = (
+            "This database is read-only. "
+            "Please wrap this class with ReadOnlyDatabase"
+            "i.e. ReadOnlyDatabase(GitHubArtifactDatabase(...))."
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"GitHubArtifactDatabase(owner={self.owner!r}, "
+            f"repo={self.repo!r}, artifact_name={self.artifact_name!r})"
+        )
+
+    def _prepare_for_io(self) -> None:
+        assert self._artifact is not None, "Artifact not loaded."
+
+        if self._initialized:  # pragma: no cover
+            return
+
+        # Test that the artifact is valid
+        try:
+            with ZipFile(self._artifact) as f:
+                if f.testzip():  # pragma: no cover
+                    raise BadZipFile
+
+            # Turns out that testzip() doesn't work quite well
+            # doing the cache initialization here instead
+            # will give us more coverage of the artifact.
+
+            # Cache the files inside each keypath
+            self._access_cache = {}
+            with ZipFile(self._artifact) as zf:
+                namelist = zf.namelist()
+                # Iterate over files in the artifact
+                for filename in namelist:
+                    fileinfo = zf.getinfo(filename)
+                    if fileinfo.is_dir():
+                        self._access_cachePurePath(filename) = set()
+                    else:
+                        # Get the keypath from the filename
+                        keypath = PurePath(filename).parent
+                        # Add the file to the keypath
+                        self._access_cachekeypath.add(PurePath(filename))
+        except BadZipFile:
+            warnings.warn(
+                HypothesisWarning(
+                    "The downloaded artifact from GitHub is invalid. "
+                    "This could be because the artifact was corrupted, "
+                    "or because the artifact was not created by Hypothesis. "
+                )
+            )
+            self._disabled = True
+
+        self._initialized = True
+
+    def _initialize_db(self) -> None:
+        # Create the cache directory if it doesn't exist
+        mkdir_p(str(self.path))
+
+        # Get all artifacts
+        cached_artifacts = sorted(
+            self.path.glob("*.zip"),
+            key=lambda a: datetime.fromisoformat(a.stem.replace("_", ":")),
+        )
+
+        # Remove all but the latest artifact
+        for artifact in cached_artifacts:-1:
+            artifact.unlink()
+
+        try:
+            found_artifact = cached_artifacts-1
+        except IndexError:
+            found_artifact = None
+
+        # Check if the latest artifact is a cache hit
+        if found_artifact is not None and (
+            datetime.now(timezone.utc)
+            - datetime.fromisoformat(found_artifact.stem.replace("_", ":"))
+            < self.cache_timeout
+        ):
+            self._artifact = found_artifact
+        else:
+            # Download the latest artifact from GitHub
+            new_artifact = self._fetch_artifact()
+
+            if new_artifact:
+                if found_artifact is not None:
+                    found_artifact.unlink()
+                self._artifact = new_artifact
+            elif found_artifact is not None:
+                warnings.warn(
+                    HypothesisWarning(
+                        "Using an expired artifact as a fallback for the database: "
+                        f"{found_artifact}"
+                    )
+                )
+                self._artifact = found_artifact
+            else:
+                warnings.warn(
+                    HypothesisWarning(
+                        "Couldn't acquire a new or existing artifact. "
+                        "Disabling database."
+                    )
+                )
+                self._disabled = True
+                return
+
+        self._prepare_for_io()
+
+    def _get_bytes(self, url: str) -> Optionalbytes:  # pragma: no cover
+        request = Request(
+            url,
+            headers={
+                "Accept": "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28 ",
+                "Authorization": f"Bearer {self.token}",
+            },
+        )
+        response_bytes: Optionalbytes = None
+        try:
+            response = urlopen(request)
+            response_bytes = response.read()
+            warning_message = None
+        except HTTPError as e:
+            if e.code == 401:
+                warning_message = (
+                    "Authorization failed when trying to download artifact from GitHub. "
+                    "Check that you have a valid GITHUB_TOKEN set in your environment."
+                )
+            else:
+                warning_message = (
+                    "Could not get the latest artifact from GitHub. "
+                    "This could be because because the repository "
+                    "or artifact does not exist. "
+                )
+        except URLError:
+            warning_message = "Could not connect to GitHub to get the latest artifact. "
+        except TimeoutError:
+            warning_message = (
+                "Could not connect to GitHub to get the latest artifact "
+                "(connection timed out)."
+            )
+
+        if warning_message is not None:
+            warnings.warn(HypothesisWarning(warning_message))
+            return None
+
+        return response_bytes
+
+    def _fetch_artifact(self) -> OptionalPath:  # pragma: no cover
+        # Get the list of artifacts from GitHub
+        url = f"https://api.github.com/repos/{self.owner}/{self.repo}/actions/artifacts"
+        response_bytes = self._get_bytes(url)
+        if response_bytes is None:
+            return None
+
+        artifacts = json.loads(response_bytes)"artifacts"
+        artifacts = a for a in artifacts if a"name" == self.artifact_name
+
+        if not artifacts:
+            return None
+
+        # Get the latest artifact from the list
+        artifact = max(artifacts, key=lambda a: a"created_at")
+        url = artifact"archive_download_url"
+
+        # Download the artifact
+        artifact_bytes = self._get_bytes(url)
+        if artifact_bytes is None:
+            return None
+
+        # Save the artifact to the cache
+        # We replace ":" with "_" to ensure the filenames are compatible
+        # with Windows filesystems
+        timestamp = datetime.now(timezone.utc).isoformat().replace(":", "_")
+        artifact_path = self.path / f"{timestamp}.zip"
+        try:
+            with open(artifact_path, "wb") as f:
+                f.write(artifact_bytes)
+        except OSError:
+            warnings.warn(
+                HypothesisWarning("Could not save the latest artifact from GitHub. ")
+            )
+            return None
+
+        return artifact_path
+
+    def _key_path(self, key: bytes) -> PurePath:
+        try:
+            return self.keypathskey
+        except KeyError:
+            pass
+
+        directory = PurePath(_hash(key) + "/")
+        self.keypathskey = directory
+        return directory
+
+    def fetch(self, key: bytes) -> Iterablebytes:
+        if self._disabled:
+            return
+
+        if not self._initialized:
+            self._initialize_db()
+            if self._disabled:
+                return
+
+        assert self._artifact is not None
+        assert self._access_cache is not None
+
+        kp = self._key_path(key)
+
+        with ZipFile(self._artifact) as zf:
+            # Get the all files in the the kp from the cache
+            filenames = self._access_cache.get(kp, ())
+            for filename in filenames:
+                with zf.open(filename.as_posix()) as f:
+                    yield f.read()
+
+    # Read-only interface
+    def save(self, key: bytes, value: bytes) -> None:
+        raise RuntimeError(self._read_only_message)
+
+    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
+        raise RuntimeError(self._read_only_message)
+
+    def delete(self, key: bytes, value: bytes) -> None:
+        raise RuntimeError(self._read_only_message)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/entry_points.py Added

@@ -0,0 +1,65 @@
+# 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/.
+
+"""Run all functions registered for the "hypothesis" entry point.
+
+This can be used with `st.register_type_strategy` to register strategies for your
+custom types, running the relevant code when *hypothesis* is imported instead of
+your package.
+"""
+
+try:
+    # We prefer to use importlib.metadata, or the backport on Python <= 3.7,
+    # because it's much faster than pkg_resources (200ms import time speedup).
+    try:
+        from importlib import metadata as importlib_metadata
+    except ImportError:
+        import importlib_metadata  # type: ignore  # mypy thinks this is a redefinition
+
+    def get_entry_points():
+        try:
+            eps = importlib_metadata.entry_points(group="hypothesis")
+        except TypeError:  # pragma: no cover
+            # Load-time selection requires Python >= 3.10 or importlib_metadata >= 3.6,
+            # so we'll retain this fallback logic for some time to come.  See also
+            # https://importlib-metadata.readthedocs.io/en/latest/using.html
+            eps = importlib_metadata.entry_points().get("hypothesis", )
+        yield from eps
+
+except ImportError:
+    # But if we're not on Python >= 3.8 and the importlib_metadata backport
+    # is not installed, we fall back to pkg_resources anyway.
+    try:
+        import pkg_resources
+    except ImportError:
+        import warnings
+
+        from hypothesis.errors import HypothesisWarning
+
+        warnings.warn(
+            "Under Python <= 3.7, Hypothesis requires either the importlib_metadata "
+            "or setuptools package in order to load plugins via entrypoints.",
+            HypothesisWarning,
+        )
+
+        def get_entry_points():
+            yield from ()
+
+    else:
+
+        def get_entry_points():
+            yield from pkg_resources.iter_entry_points("hypothesis")
+
+
+def run():
+    for entry in get_entry_points():  # pragma: no cover
+        hook = entry.load()
+        if callable(hook):
+            hook()

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/errors.py Added

@@ -0,0 +1,182 @@
+# 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/.
+
+
+class HypothesisException(Exception):
+    """Generic parent class for exceptions thrown by Hypothesis."""
+
+
+class _Trimmable(HypothesisException):
+    """Hypothesis can trim these tracebacks even if they're raised internally."""
+
+
+class UnsatisfiedAssumption(HypothesisException):
+    """An internal error raised by assume.
+
+    If you're seeing this error something has gone wrong.
+    """
+
+
+class NoSuchExample(HypothesisException):
+    """The condition we have been asked to satisfy appears to be always false.
+
+    This does not guarantee that no example exists, only that we were
+    unable to find one.
+    """
+
+    def __init__(self, condition_string, extra=""):
+        super().__init__(f"No examples found of condition {condition_string}{extra}")
+
+
+class Unsatisfiable(_Trimmable):
+    """We ran out of time or examples before we could find enough examples
+    which satisfy the assumptions of this hypothesis.
+
+    This could be because the function is too slow. If so, try upping
+    the timeout. It could also be because the function is using assume
+    in a way that is too hard to satisfy. If so, try writing a custom
+    strategy or using a better starting point (e.g if you are requiring
+    a list has unique values you could instead filter out all duplicate
+    values from the list)
+    """
+
+
+class Flaky(_Trimmable):
+    """This function appears to fail non-deterministically: We have seen it
+    fail when passed this example at least once, but a subsequent invocation
+    did not fail.
+
+    Common causes for this problem are:
+        1. The function depends on external state. e.g. it uses an external
+           random number generator. Try to make a version that passes all the
+           relevant state in from Hypothesis.
+        2. The function is suffering from too much recursion and its failure
+           depends sensitively on where it's been called from.
+        3. The function is timing sensitive and can fail or pass depending on
+           how long it takes. Try breaking it up into smaller functions which
+           don't do that and testing those instead.
+    """
+
+
+class InvalidArgument(_Trimmable, TypeError):
+    """Used to indicate that the arguments to a Hypothesis function were in
+    some manner incorrect."""
+
+
+class ResolutionFailed(InvalidArgument):
+    """Hypothesis had to resolve a type to a strategy, but this failed.
+
+    Type inference is best-effort, so this only happens when an
+    annotation exists but could not be resolved for a required argument
+    to the target of ``builds()``, or where the user passed ``...``.
+    """
+
+
+class InvalidState(HypothesisException):
+    """The system is not in a state where you were allowed to do that."""
+
+
+class InvalidDefinition(_Trimmable, TypeError):
+    """Used to indicate that a class definition was not well put together and
+    has something wrong with it."""
+
+
+class HypothesisWarning(HypothesisException, Warning):
+    """A generic warning issued by Hypothesis."""
+
+
+class FailedHealthCheck(_Trimmable):
+    """Raised when a test fails a healthcheck."""
+
+
+class NonInteractiveExampleWarning(HypothesisWarning):
+    """SearchStrategy.example() is designed for interactive use,
+    but should never be used in the body of a test.
+    """
+
+
+class HypothesisDeprecationWarning(HypothesisWarning, FutureWarning):
+    """A deprecation warning issued by Hypothesis.
+
+    Actually inherits from FutureWarning, because DeprecationWarning is
+    hidden by the default warnings filter.
+
+    You can configure the Python :mod:`python:warnings` to handle these
+    warnings differently to others, either turning them into errors or
+    suppressing them entirely.  Obviously we would prefer the former!
+    """
+
+
+class Frozen(HypothesisException):
+    """Raised when a mutation method has been called on a ConjectureData object
+    after freeze() has been called."""
+
+
+def __getattr__(name):
+    if name == "MultipleFailures":
+        from hypothesis._settings import note_deprecation
+        from hypothesis.internal.compat import BaseExceptionGroup
+
+        note_deprecation(
+            "MultipleFailures is deprecated; use the builtin `BaseExceptionGroup` type "
+            "instead, or `exceptiongroup.BaseExceptionGroup` before Python 3.11",
+            since="2022-08-02",
+            has_codemod=False,  # This would be a great PR though!
+        )
+        return BaseExceptionGroup
+
+    raise AttributeError(f"Module 'hypothesis.errors' has no attribute {name}")
+
+
+class DeadlineExceeded(_Trimmable):
+    """Raised when an individual test body has taken too long to run."""
+
+    def __init__(self, runtime, deadline):
+        super().__init__(
+            "Test took %.2fms, which exceeds the deadline of %.2fms"
+            % (runtime.total_seconds() * 1000, deadline.total_seconds() * 1000)
+        )
+        self.runtime = runtime
+        self.deadline = deadline
+
+    def __reduce__(self):
+        return (type(self), (self.runtime, self.deadline))
+
+
+class StopTest(BaseException):
+    """Raised when a test should stop running and return control to
+    the Hypothesis engine, which should then continue normally.
+    """
+
+    def __init__(self, testcounter):
+        super().__init__(repr(testcounter))
+        self.testcounter = testcounter
+
+
+class DidNotReproduce(HypothesisException):
+    pass
+
+
+class Found(Exception):
+    """Signal that the example matches condition. Internal use only."""
+
+    hypothesis_internal_never_escalate = True
+
+
+class RewindRecursive(Exception):
+    """Signal that the type inference should be rewound due to recursive types. Internal use only."""
+
+    def __init__(self, target):
+        self.target = target
+
+
+class SmallSearchSpaceWarning(HypothesisWarning):
+    """Indicates that an inferred strategy does not span the search space
+    in a meaningful way, for example by only creating default instances."""

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/executors.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/_array_helpers.py Added

@@ -0,0 +1,689 @@
+# 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 re
+from typing import NamedTuple, Optional, Tuple, Union
+
+from hypothesis import assume, strategies as st
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.coverage import check_function
+from hypothesis.internal.validation import check_type, check_valid_interval
+from hypothesis.strategies._internal.utils import defines_strategy
+from hypothesis.utils.conventions import UniqueIdentifier, not_set
+
+__all__ = 
+    "NDIM_MAX",
+    "Shape",
+    "BroadcastableShapes",
+    "BasicIndex",
+    "check_argument",
+    "order_check",
+    "check_valid_dims",
+    "array_shapes",
+    "valid_tuple_axes",
+    "broadcastable_shapes",
+    "mutually_broadcastable_shapes",
+    "MutuallyBroadcastableShapesStrategy",
+    "BasicIndexStrategy",
+
+
+
+Shape = Tupleint, ...
+# We silence flake8 here because it disagrees with mypy about `ellipsis` (`type(...)`)
+BasicIndex = TupleUnionint, slice, None, "ellipsis", ...  # noqa: F821
+
+
+class BroadcastableShapes(NamedTuple):
+    input_shapes: TupleShape, ...
+    result_shape: Shape
+
+
+@check_function
+def check_argument(condition, fail_message, *f_args, **f_kwargs):
+    if not condition:
+        raise InvalidArgument(fail_message.format(*f_args, **f_kwargs))
+
+
+@check_function
+def order_check(name, floor, min_, max_):
+    if floor > min_:
+        raise InvalidArgument(f"min_{name} must be at least {floor} but was {min_}")
+    if min_ > max_:
+        raise InvalidArgument(f"min_{name}={min_} is larger than max_{name}={max_}")
+
+
+# 32 is a dimension limit specific to NumPy, and does not necessarily apply to
+# other array/tensor libraries. Historically these strategies were built for the
+# NumPy extra, so it's nice to keep these limits, and it's seemingly unlikely
+# someone would want to generate >32 dim arrays anyway.
+# See https://github.com/HypothesisWorks/hypothesis/pull/3067.
+NDIM_MAX = 32
+
+
+@check_function
+def check_valid_dims(dims, name):
+    if dims > NDIM_MAX:
+        raise InvalidArgument(
+            f"{name}={dims}, but Hypothesis does not support arrays with "
+            f"more than {NDIM_MAX} dimensions"
+        )
+
+
+@defines_strategy()
+def array_shapes(
+    *,
+    min_dims: int = 1,
+    max_dims: Optionalint = None,
+    min_side: int = 1,
+    max_side: Optionalint = None,
+) -> st.SearchStrategyShape:
+    """Return a strategy for array shapes (tuples of int >= 1).
+
+    * ``min_dims`` is the smallest length that the generated shape can possess.
+    * ``max_dims`` is the largest length that the generated shape can possess,
+      defaulting to ``min_dims + 2``.
+    * ``min_side`` is the smallest size that a dimension can possess.
+    * ``max_side`` is the largest size that a dimension can possess,
+      defaulting to ``min_side + 5``.
+    """
+    check_type(int, min_dims, "min_dims")
+    check_type(int, min_side, "min_side")
+    check_valid_dims(min_dims, "min_dims")
+
+    if max_dims is None:
+        max_dims = min(min_dims + 2, NDIM_MAX)
+    check_type(int, max_dims, "max_dims")
+    check_valid_dims(max_dims, "max_dims")
+
+    if max_side is None:
+        max_side = min_side + 5
+    check_type(int, max_side, "max_side")
+
+    order_check("dims", 0, min_dims, max_dims)
+    order_check("side", 0, min_side, max_side)
+
+    return st.lists(
+        st.integers(min_side, max_side), min_size=min_dims, max_size=max_dims
+    ).map(tuple)
+
+
+@defines_strategy()
+def valid_tuple_axes(
+    ndim: int,
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+) -> st.SearchStrategyTupleint, ...:
+    """All tuples will have a length >= ``min_size`` and <= ``max_size``. The default
+    value for ``max_size`` is ``ndim``.
+
+    Examples from this strategy shrink towards an empty tuple, which render most
+    sequential functions as no-ops.
+
+    The following are some examples drawn from this strategy.
+
+    .. code-block:: pycon
+
+      >>> valid_tuple_axes(3).example() for i in range(4)
+      (-3, 1), (0, 1, -1), (0, 2), (0, -2, 2)
+
+    ``valid_tuple_axes`` can be joined with other strategies to generate
+    any type of valid axis object, i.e. integers, tuples, and ``None``:
+
+    .. code-block:: python
+
+      any_axis_strategy = none() | integers(-ndim, ndim - 1) | valid_tuple_axes(ndim)
+
+    """
+    check_type(int, ndim, "ndim")
+    check_type(int, min_size, "min_size")
+    if max_size is None:
+        max_size = ndim
+    check_type(int, max_size, "max_size")
+    order_check("size", 0, min_size, max_size)
+    check_valid_interval(max_size, ndim, "max_size", "ndim")
+
+    axes = st.integers(0, max(0, 2 * ndim - 1)).map(
+        lambda x: x if x < ndim else x - 2 * ndim
+    )
+
+    return st.lists(
+        axes, min_size=min_size, max_size=max_size, unique_by=lambda x: x % ndim
+    ).map(tuple)
+
+
+@defines_strategy()
+def broadcastable_shapes(
+    shape: Shape,
+    *,
+    min_dims: int = 0,
+    max_dims: Optionalint = None,
+    min_side: int = 1,
+    max_side: Optionalint = None,
+) -> st.SearchStrategyShape:
+    """Return a strategy for shapes that are broadcast-compatible with the
+    provided shape.
+
+    Examples from this strategy shrink towards a shape with length ``min_dims``.
+    The size of an aligned dimension shrinks towards size ``1``. The size of an
+    unaligned dimension shrink towards ``min_side``.
+
+    * ``shape`` is a tuple of integers.
+    * ``min_dims`` is the smallest length that the generated shape can possess.
+    * ``max_dims`` is the largest length that the generated shape can possess,
+      defaulting to ``max(len(shape), min_dims) + 2``.
+    * ``min_side`` is the smallest size that an unaligned dimension can possess.
+    * ``max_side`` is the largest size that an unaligned dimension can possess,
+      defaulting to 2 plus the size of the largest aligned dimension.
+
+    The following are some examples drawn from this strategy.
+
+    .. code-block:: pycon
+
+        >>> broadcastable_shapes(shape=(2, 3)).example() for i in range(5)
+        (1, 3), (), (2, 3), (2, 1), (4, 1, 3), (3, )
+
+    """
+    check_type(tuple, shape, "shape")
+    check_type(int, min_side, "min_side")
+    check_type(int, min_dims, "min_dims")
+    check_valid_dims(min_dims, "min_dims")
+
+    strict_check = max_side is None or max_dims is None
+
+    if max_dims is None:
+        max_dims = min(max(len(shape), min_dims) + 2, NDIM_MAX)
+    check_type(int, max_dims, "max_dims")
+    check_valid_dims(max_dims, "max_dims")
+
+    if max_side is None:
+        max_side = max(shape-max_dims: + (min_side,)) + 2
+    check_type(int, max_side, "max_side")
+
+    order_check("dims", 0, min_dims, max_dims)
+    order_check("side", 0, min_side, max_side)
+
+    if strict_check:
+        dims = max_dims
+        bound_name = "max_dims"
+    else:
+        dims = min_dims
+        bound_name = "min_dims"
+
+    # check for unsatisfiable min_side
+    if not all(min_side <= s for s in shape::-1:dims if s != 1):
+        raise InvalidArgument(
+            f"Given shape={shape}, there are no broadcast-compatible "
+            f"shapes that satisfy: {bound_name}={dims} and min_side={min_side}"
+        )
+
+    # check for unsatisfiable min_side, max_side
+    if not (
+        min_side <= 1 <= max_side or all(s <= max_side for s in shape::-1:dims)
+    ):
+        raise InvalidArgument(
+            f"Given base_shape={shape}, there are no broadcast-compatible "
+            f"shapes that satisfy all of {bound_name}={dims}, "
+            f"min_side={min_side}, and max_side={max_side}"
+        )
+
+    if not strict_check:
+        # reduce max_dims to exclude unsatisfiable dimensions
+        for n, s in zip(range(max_dims), shape::-1):
+            if s < min_side and s != 1:
+                max_dims = n
+                break
+            elif not (min_side <= 1 <= max_side or s <= max_side):
+                max_dims = n
+                break
+
+    return MutuallyBroadcastableShapesStrategy(
+        num_shapes=1,
+        base_shape=shape,
+        min_dims=min_dims,
+        max_dims=max_dims,
+        min_side=min_side,
+        max_side=max_side,
+    ).map(lambda x: x.input_shapes0)
+
+
+# See https://numpy.org/doc/stable/reference/c-api/generalized-ufuncs.html
+# Implementation based on numpy.lib.function_base._parse_gufunc_signature
+# with minor upgrades to handle numeric and optional dimensions.  Examples:
+#
+#     add       (),()->()                   binary ufunc
+#     sum1d     (i)->()                     reduction
+#     inner1d   (i),(i)->()                 vector-vector multiplication
+#     matmat    (m,n),(n,p)->(m,p)          matrix multiplication
+#     vecmat    (n),(n,p)->(p)              vector-matrix multiplication
+#     matvec    (m,n),(n)->(m)              matrix-vector multiplication
+#     matmul    (m?,n),(n,p?)->(m?,p?)      combination of the four above
+#     cross1d   (3),(3)->(3)                cross product with frozen dimensions
+#
+# Note that while no examples of such usage are given, Numpy does allow
+# generalised ufuncs that have *multiple output arrays*.  This is not
+# currently supported by Hypothesis - please contact us if you would use it!
+#
+# We are unsure if gufuncs allow frozen dimensions to be optional, but it's
+# easy enough to support here - and so we will unless we learn otherwise.
+_DIMENSION = r"\w+\??"  # Note that \w permits digits too!
+_SHAPE = r"$(?:{0}(?:,{0})".format(_DIMENSION) + r"{0,31})?$"
+_ARGUMENT_LIST = "{0}(?:,{0})*".format(_SHAPE)
+_SIGNATURE = rf"^{_ARGUMENT_LIST}->{_SHAPE}$"
+_SIGNATURE_MULTIPLE_OUTPUT = r"^{0}->{0}$".format(_ARGUMENT_LIST)
+
+
+class _GUfuncSig(NamedTuple):
+    input_shapes: TupleShape, ...
+    result_shape: Shape
+
+
+def _hypothesis_parse_gufunc_signature(signature, all_checks=True):
+    # Disable all_checks to better match the Numpy version, for testing
+    if not re.match(_SIGNATURE, signature):
+        if re.match(_SIGNATURE_MULTIPLE_OUTPUT, signature):
+            raise InvalidArgument(
+                "Hypothesis does not yet support generalised ufunc signatures "
+                "with multiple output arrays - mostly because we don't know of "
+                "anyone who uses them!  Please get in touch with us to fix that."
+                f"\n (signature={signature!r})"
+            )
+        if re.match(
+            (
+                # Taken from np.lib.function_base._SIGNATURE
+                r"^$(?:\w+(?:,\w+)*)?$(?:,$(?:\w+(?:,\w+)*)?$)*->"
+                r"$(?:\w+(?:,\w+)*)?$(?:,$(?:\w+(?:,\w+)*)?$)*$"
+            ),
+            signature,
+        ):
+            raise InvalidArgument(
+                f"signature={signature!r} matches Numpy's regex for gufunc signatures, "
+                f"but contains shapes with more than {NDIM_MAX} dimensions and is thus invalid."
+            )
+        raise InvalidArgument(f"{signature!r} is not a valid gufunc signature")
+    input_shapes, output_shapes = (
+        tuple(tuple(re.findall(_DIMENSION, a)) for a in re.findall(_SHAPE, arg_list))
+        for arg_list in signature.split("->")
+    )
+    assert len(output_shapes) == 1
+    result_shape = output_shapes0
+    if all_checks:
+        # Check that there are no names in output shape that do not appear in inputs.
+        # (kept out of parser function for easier generation of test values)
+        # We also disallow frozen optional dimensions - this is ambiguous as there is
+        # no way to share an un-named dimension between shapes.  Maybe just padding?
+        # Anyway, we disallow it pending clarification from upstream.
+        frozen_optional_err = (
+            "Got dimension %r, but handling of frozen optional dimensions "
+            "is ambiguous.  If you known how this should work, please "
+            "contact us to get this fixed and documented (signature=%r)."
+        )
+        only_out_err = (
+            "The %r dimension only appears in the output shape, and is "
+            "not frozen, so the size is not determined (signature=%r)."
+        )
+        names_in = {n.strip("?") for shp in input_shapes for n in shp}
+        names_out = {n.strip("?") for n in result_shape}
+        for shape in input_shapes + (result_shape,):
+            for name in shape:
+                try:
+                    int(name.strip("?"))
+                    if "?" in name:
+                        raise InvalidArgument(frozen_optional_err % (name, signature))
+                except ValueError:
+                    if name.strip("?") in (names_out - names_in):
+                        raise InvalidArgument(
+                            only_out_err % (name, signature)
+                        ) from None
+    return _GUfuncSig(input_shapes=input_shapes, result_shape=result_shape)
+
+
+@defines_strategy()
+def mutually_broadcastable_shapes(
+    *,
+    num_shapes: UnionUniqueIdentifier, int = not_set,
+    signature: UnionUniqueIdentifier, str = not_set,
+    base_shape: Shape = (),
+    min_dims: int = 0,
+    max_dims: Optionalint = None,
+    min_side: int = 1,
+    max_side: Optionalint = None,
+) -> st.SearchStrategyBroadcastableShapes:
+    """Return a strategy for a specified number of shapes N that are
+    mutually-broadcastable with one another and with the provided base shape.
+
+    * ``num_shapes`` is the number of mutually broadcast-compatible shapes to generate.
+    * ``base_shape`` is the shape against which all generated shapes can broadcast.
+      The default shape is empty, which corresponds to a scalar and thus does
+      not constrain broadcasting at all.
+    * ``min_dims`` is the smallest length that the generated shape can possess.
+    * ``max_dims`` is the largest length that the generated shape can possess,
+      defaulting to ``max(len(shape), min_dims) + 2``.
+    * ``min_side`` is the smallest size that an unaligned dimension can possess.
+    * ``max_side`` is the largest size that an unaligned dimension can possess,
+      defaulting to 2 plus the size of the largest aligned dimension.
+
+    The strategy will generate a :obj:`python:typing.NamedTuple` containing:
+
+    * ``input_shapes`` as a tuple of the N generated shapes.
+    * ``result_shape`` as the resulting shape produced by broadcasting the N shapes
+      with the base shape.
+
+    The following are some examples drawn from this strategy.
+
+    .. code-block:: pycon
+
+        >>> # Draw three shapes where each shape is broadcast-compatible with (2, 3)
+        ... strat = mutually_broadcastable_shapes(num_shapes=3, base_shape=(2, 3))
+        >>> for _ in range(5):
+        ...     print(strat.example())
+        BroadcastableShapes(input_shapes=((4, 1, 3), (4, 2, 3), ()), result_shape=(4, 2, 3))
+        BroadcastableShapes(input_shapes=((3,), (1, 3), (2, 3)), result_shape=(2, 3))
+        BroadcastableShapes(input_shapes=((), (), ()), result_shape=())
+        BroadcastableShapes(input_shapes=((3,), (), (3,)), result_shape=(3,))
+        BroadcastableShapes(input_shapes=((1, 2, 3), (3,), ()), result_shape=(1, 2, 3))
+
+    """
+    arg_msg = "Pass either the `num_shapes` or the `signature` argument, but not both."
+    if num_shapes is not not_set:
+        check_argument(signature is not_set, arg_msg)
+        check_type(int, num_shapes, "num_shapes")
+        assert isinstance(num_shapes, int)  # for mypy
+        parsed_signature = None
+        sig_dims = 0
+    else:
+        check_argument(signature is not not_set, arg_msg)
+        if signature is None:
+            raise InvalidArgument(
+                "Expected a string, but got invalid signature=None.  "
+                "(maybe .signature attribute of an element-wise ufunc?)"
+            )
+        check_type(str, signature, "signature")
+        parsed_signature = _hypothesis_parse_gufunc_signature(signature)
+        all_shapes = parsed_signature.input_shapes + (parsed_signature.result_shape,)
+        sig_dims = min(len(s) for s in all_shapes)
+        num_shapes = len(parsed_signature.input_shapes)
+
+    if num_shapes < 1:
+        raise InvalidArgument(f"num_shapes={num_shapes} must be at least 1")
+
+    check_type(tuple, base_shape, "base_shape")
+    check_type(int, min_side, "min_side")
+    check_type(int, min_dims, "min_dims")
+    check_valid_dims(min_dims, "min_dims")
+
+    strict_check = max_dims is not None
+
+    if max_dims is None:
+        max_dims = min(max(len(base_shape), min_dims) + 2, NDIM_MAX - sig_dims)
+    check_type(int, max_dims, "max_dims")
+    check_valid_dims(max_dims, "max_dims")
+
+    if max_side is None:
+        max_side = max(base_shape-max_dims: + (min_side,)) + 2
+    check_type(int, max_side, "max_side")
+
+    order_check("dims", 0, min_dims, max_dims)
+    order_check("side", 0, min_side, max_side)
+
+    if signature is not None and max_dims > NDIM_MAX - sig_dims:
+        raise InvalidArgument(
+            f"max_dims={signature!r} would exceed the {NDIM_MAX}-dimension"
+            "limit Hypothesis imposes on array shapes, "
+            f"given signature={parsed_signature!r}"
+        )
+
+    if strict_check:
+        dims = max_dims
+        bound_name = "max_dims"
+    else:
+        dims = min_dims
+        bound_name = "min_dims"
+
+    # check for unsatisfiable min_side
+    if not all(min_side <= s for s in base_shape::-1:dims if s != 1):
+        raise InvalidArgument(
+            f"Given base_shape={base_shape}, there are no broadcast-compatible "
+            f"shapes that satisfy: {bound_name}={dims} and min_side={min_side}"
+        )
+
+    # check for unsatisfiable min_side, max_side
+    if not (
+        min_side <= 1 <= max_side or all(s <= max_side for s in base_shape::-1:dims)
+    ):
+        raise InvalidArgument(
+            f"Given base_shape={base_shape}, there are no broadcast-compatible "
+            f"shapes that satisfy all of {bound_name}={dims}, "
+            f"min_side={min_side}, and max_side={max_side}"
+        )
+
+    if not strict_check:
+        # reduce max_dims to exclude unsatisfiable dimensions
+        for n, s in zip(range(max_dims), base_shape::-1):
+            if s < min_side and s != 1:
+                max_dims = n
+                break
+            elif not (min_side <= 1 <= max_side or s <= max_side):
+                max_dims = n
+                break
+
+    return MutuallyBroadcastableShapesStrategy(
+        num_shapes=num_shapes,
+        signature=parsed_signature,
+        base_shape=base_shape,
+        min_dims=min_dims,
+        max_dims=max_dims,
+        min_side=min_side,
+        max_side=max_side,
+    )
+
+
+class MutuallyBroadcastableShapesStrategy(st.SearchStrategy):
+    def __init__(
+        self,
+        num_shapes,
+        signature=None,
+        base_shape=(),
+        min_dims=0,
+        max_dims=None,
+        min_side=1,
+        max_side=None,
+    ):
+        super().__init__()
+        self.base_shape = base_shape
+        self.side_strat = st.integers(min_side, max_side)
+        self.num_shapes = num_shapes
+        self.signature = signature
+        self.min_dims = min_dims
+        self.max_dims = max_dims
+        self.min_side = min_side
+        self.max_side = max_side
+
+        self.size_one_allowed = self.min_side <= 1 <= self.max_side
+
+    def do_draw(self, data):
+        # We don't usually have a gufunc signature; do the common case first & fast.
+        if self.signature is None:
+            return self._draw_loop_dimensions(data)
+
+        # When we *do*, draw the core dims, then draw loop dims, and finally combine.
+        core_in, core_res = self._draw_core_dimensions(data)
+
+        # If some core shape has omitted optional dimensions, it's an error to add
+        # loop dimensions to it.  We never omit core dims if min_dims >= 1.
+        # This ensures that we respect Numpy's gufunc broadcasting semantics and user
+        # constraints without needing to check whether the loop dims will be
+        # interpreted as an invalid substitute for the omitted core dims.
+        # We may implement this check later!
+        use = None not in shp for shp in core_in
+        loop_in, loop_res = self._draw_loop_dimensions(data, use=use)
+
+        def add_shape(loop, core):
+            return tuple(x for x in (loop + core)-NDIM_MAX: if x is not None)
+
+        return BroadcastableShapes(
+            input_shapes=tuple(add_shape(l_in, c) for l_in, c in zip(loop_in, core_in)),
+            result_shape=add_shape(loop_res, core_res),
+        )
+
+    def _draw_core_dimensions(self, data):
+        # Draw gufunc core dimensions, with None standing for optional dimensions
+        # that will not be present in the final shape.  We track omitted dims so
+        # that we can do an accurate per-shape length cap.
+        dims = {}
+        shapes = 
+        for shape in self.signature.input_shapes + (self.signature.result_shape,):
+            shapes.append()
+            for name in shape:
+                if name.isdigit():
+                    shapes-1.append(int(name))
+                    continue
+                if name not in dims:
+                    dim = name.strip("?")
+                    dimsdim = data.draw(self.side_strat)
+                    if self.min_dims == 0 and not data.draw_bits(3):
+                        dimsdim + "?" = None
+                    else:
+                        dimsdim + "?" = dimsdim
+                shapes-1.append(dimsname)
+        return tuple(tuple(s) for s in shapes:-1), tuple(shapes-1)
+
+    def _draw_loop_dimensions(self, data, use=None):
+        # All shapes are handled in column-major order; i.e. they are reversed
+        base_shape = self.base_shape::-1
+        result_shape = list(base_shape)
+        shapes =  for _ in range(self.num_shapes)
+        if use is None:
+            use = True for _ in range(self.num_shapes)
+        else:
+            assert len(use) == self.num_shapes
+            assert all(isinstance(x, bool) for x in use)
+
+        for dim_count in range(1, self.max_dims + 1):
+            dim = dim_count - 1
+
+            # We begin by drawing a valid dimension-size for the given
+            # dimension. This restricts the variability across the shapes
+            # at this dimension such that they can only choose between
+            # this size and a singleton dimension.
+            if len(base_shape) < dim_count or base_shapedim == 1:
+                # dim is unrestricted by the base-shape: shrink to min_side
+                dim_side = data.draw(self.side_strat)
+            elif base_shapedim <= self.max_side:
+                # dim is aligned with non-singleton base-dim
+                dim_side = base_shapedim
+            else:
+                # only a singleton is valid in alignment with the base-dim
+                dim_side = 1
+
+            allowed_sides = sorted(1, dim_side)  # shrink to 0 when available
+            for shape_id, shape in enumerate(shapes):
+                # Populating this dimension-size for each shape, either
+                # the drawn size is used or, if permitted, a singleton
+                # dimension.
+                if dim <= len(result_shape) and self.size_one_allowed:
+                    # aligned: shrink towards size 1
+                    side = data.draw(st.sampled_from(allowed_sides))
+                else:
+                    side = dim_side
+
+                # Use a trick where where a biased coin is queried to see
+                # if the given shape-tuple will continue to be grown. All
+                # of the relevant draws will still be made for the given
+                # shape-tuple even if it is no longer being added to.
+                # This helps to ensure more stable shrinking behavior.
+                if self.min_dims < dim_count:
+                    useshape_id &= cu.biased_coin(
+                        data, 1 - 1 / (1 + self.max_dims - dim)
+                    )
+
+                if useshape_id:
+                    shape.append(side)
+                    if len(result_shape) < len(shape):
+                        result_shape.append(shape-1)
+                    elif shape-1 != 1 and result_shapedim == 1:
+                        result_shapedim = shape-1
+            if not any(use):
+                break
+
+        result_shape = result_shape: max(map(len, self.base_shape + shapes))
+
+        assert len(shapes) == self.num_shapes
+        assert all(self.min_dims <= len(s) <= self.max_dims for s in shapes)
+        assert all(self.min_side <= s <= self.max_side for side in shapes for s in side)
+
+        return BroadcastableShapes(
+            input_shapes=tuple(tuple(reversed(shape)) for shape in shapes),
+            result_shape=tuple(reversed(result_shape)),
+        )
+
+
+class BasicIndexStrategy(st.SearchStrategy):
+    def __init__(
+        self,
+        shape,
+        min_dims,
+        max_dims,
+        allow_ellipsis,
+        allow_newaxis,
+        allow_fewer_indices_than_dims,
+    ):
+        self.shape = shape
+        self.min_dims = min_dims
+        self.max_dims = max_dims
+        self.allow_ellipsis = allow_ellipsis
+        self.allow_newaxis = allow_newaxis
+        # allow_fewer_indices_than_dims=False will disable generating indices
+        # that don't cover all axes, i.e. indices that will flat index arrays.
+        # This is necessary for the Array API as such indices are not supported.
+        self.allow_fewer_indices_than_dims = allow_fewer_indices_than_dims
+
+    def do_draw(self, data):
+        # General plan: determine the actual selection up front with a straightforward
+        # approach that shrinks well, then complicate it by inserting other things.
+        result = 
+        for dim_size in self.shape:
+            if dim_size == 0:
+                result.append(slice(None))
+                continue
+            strategy = st.integers(-dim_size, dim_size - 1) | st.slices(dim_size)
+            result.append(data.draw(strategy))
+        # Insert some number of new size-one dimensions if allowed
+        result_dims = sum(isinstance(idx, slice) for idx in result)
+        while (
+            self.allow_newaxis
+            and result_dims < self.max_dims
+            and (result_dims < self.min_dims or data.draw(st.booleans()))
+        ):
+            i = data.draw(st.integers(0, len(result)))
+            result.insert(i, None)  # Note that `np.newaxis is None`
+            result_dims += 1
+        # Check that we'll have the right number of dimensions; reject if not.
+        # It's easy to do this by construction if you don't care about shrinking,
+        # which is really important for array shapes.  So we filter instead.
+        assume(self.min_dims <= result_dims <= self.max_dims)
+        # This is a quick-and-dirty way to insert ..., xor shorten the indexer,
+        # but it means we don't have to do any structural analysis.
+        if self.allow_ellipsis and data.draw(st.booleans()):
+            # Choose an index; then replace all adjacent whole-dimension slices.
+            i = j = data.draw(st.integers(0, len(result)))
+            while i > 0 and resulti - 1 == slice(None):
+                i -= 1
+            while j < len(result) and resultj == slice(None):
+                j += 1
+            resulti:j = Ellipsis
+        elif self.allow_fewer_indices_than_dims:  # pragma: no cover
+            while result-1: == slice(None, None) and data.draw(st.integers(0, 7)):
+                result.pop()
+        if len(result) == 1 and data.draw(st.booleans()):
+            # Sometimes generate bare element equivalent to a length-one tuple
+            return result0
+        return tuple(result)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/_patching.py Added

@@ -0,0 +1,228 @@
+# 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/.
+
+"""
+Write patches which add @example() decorators for discovered test cases.
+
+Requires `hypothesiscodemods,ghostwriter` installed, i.e. black and libcst.
+
+This module is used by Hypothesis' builtin pytest plugin for failing examples
+discovered during testing, and by HypoFuzz for _covering_ examples discovered
+during fuzzing.
+"""
+
+import difflib
+import hashlib
+import inspect
+import re
+import sys
+from ast import literal_eval
+from contextlib import suppress
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+
+import libcst as cst
+from libcst import matchers as m
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+
+from hypothesis.configuration import storage_directory
+from hypothesis.extra.codemods import _native_parser
+from hypothesis.version import __version__
+
+try:
+    import black
+except ImportError:
+    black = None  # type: ignore
+
+HEADER = f"""\
+From HEAD Mon Sep 17 00:00:00 2001
+From: Hypothesis {__version__} <no-reply@hypothesis.works>
+Date: {{when:%a, %d %b %Y %H:%M:%S}}
+Subject: PATCH {{msg}}
+
+---
+"""
+FAIL_MSG = "discovered failure"
+_space_only_re = re.compile("^ +$", re.MULTILINE)
+_leading_space_re = re.compile("(^ *)(?:^ \n)", re.MULTILINE)
+
+
+def dedent(text):
+    # Simplified textwrap.dedent, for valid Python source code only
+    text = _space_only_re.sub("", text)
+    prefix = min(_leading_space_re.findall(text), key=len)
+    return re.sub(r"(?m)^" + prefix, "", text), prefix
+
+
+def indent(text: str, prefix: str) -> str:
+    return "".join(prefix + line for line in text.splitlines(keepends=True))
+
+
+class AddExamplesCodemod(VisitorBasedCodemodCommand):
+    DESCRIPTION = "Add explicit examples to failing tests."
+
+    @classmethod
+    def refactor(cls, code, fn_examples, *, strip_via=(), dec="example"):
+        """Add @example() decorator(s) for failing test(s).
+
+        `code` is the source code of the module where the test functions are defined.
+        `fn_examples` is a dict of function name to list-of-failing-examples.
+        """
+        assert not isinstance(strip_via, str), "expected a collection of strings"
+        dedented, prefix = dedent(code)
+        with _native_parser():
+            mod = cst.parse_module(dedented)
+        modded = (
+            cls(CodemodContext(), fn_examples, prefix, strip_via, dec)
+            .transform_module(mod)
+            .code
+        )
+        return indent(modded, prefix=prefix)
+
+    def __init__(self, context, fn_examples, prefix="", strip_via=(), dec="example"):
+        assert fn_examples, "This codemod does nothing without fn_examples."
+        super().__init__(context)
+
+        self.decorator_func = cst.parse_expression(dec)
+        self.line_length = 88 - len(prefix)  # to match Black's default formatting
+        value_in_strip_via = m.MatchIfTrue(lambda x: literal_eval(x.value) in strip_via)
+        self.strip_matching = m.Call(
+            m.Attribute(m.Call(), m.Name("via")),
+            m.Arg(m.SimpleString() & value_in_strip_via),
+        )
+
+        # Codemod the failing examples to Call nodes usable as decorators
+        self.fn_examples = {
+            k: tuple(self.__call_node_to_example_dec(ex, via) for ex, via in nodes)
+            for k, nodes in fn_examples.items()
+        }
+
+    def __call_node_to_example_dec(self, node, via):
+        # If we have black installed, remove trailing comma, _unless_ there's a comment
+        node = node.with_changes(
+            func=self.decorator_func,
+            args=
+                a.with_changes(
+                    comma=a.comma
+                    if m.findall(a.comma, m.Comment())
+                    else cst.MaybeSentinel.DEFAULT
+                )
+                for a in node.args
+            
+            if black
+            else node.args,
+        )
+        # Note: calling a method on a decorator requires PEP-614, i.e. Python 3.9+,
+        # but plumbing two cases through doesn't seem worth the trouble :-/
+        via = cst.Call(
+            func=cst.Attribute(node, cst.Name("via")),
+            args=cst.Arg(cst.SimpleString(repr(via))),
+        )
+        if black:  # pragma: no branch
+            pretty = black.format_str(
+                cst.Module().code_for_node(via),
+                mode=black.FileMode(line_length=self.line_length),
+            )
+            via = cst.parse_expression(pretty.strip())
+        return cst.Decorator(via)
+
+    def leave_FunctionDef(self, _, updated_node):
+        return updated_node.with_changes(
+            # TODO: improve logic for where in the list to insert this decorator
+            decorators=tuple(
+                d
+                for d in updated_node.decorators
+                # `findall()` to see through the identity function workaround on py38
+                if not m.findall(d, self.strip_matching)
+            )
+            + self.fn_examples.get(updated_node.name.value, ())
+        )
+
+
+def get_patch_for(func, failing_examples, *, strip_via=()):
+    # Skip this if we're unable to find the location or source of this function.
+    try:
+        module = sys.modulesfunc.__module__
+        fname = Path(module.__file__).relative_to(Path.cwd())
+        before = inspect.getsource(func)
+    except Exception:
+        return None
+
+    # The printed examples might include object reprs which are invalid syntax,
+    # so we parse here and skip over those.  If _none_ are valid, there's no patch.
+    call_nodes = 
+    for ex, via in failing_examples:
+        with suppress(Exception):
+            node = cst.parse_expression(ex)
+            assert isinstance(node, cst.Call), node
+            call_nodes.append((node, via))
+    if not call_nodes:
+        return None
+
+    if (
+        module.__dict__.get("hypothesis") is sys.modules"hypothesis"
+        and "given" not in module.__dict__  # more reliably present than `example`
+    ):
+        decorator_func = "hypothesis.example"
+    else:
+        decorator_func = "example"
+
+    # Do the codemod and return a triple containing location and replacement info.
+    after = AddExamplesCodemod.refactor(
+        before,
+        fn_examples={func.__name__: call_nodes},
+        strip_via=strip_via,
+        dec=decorator_func,
+    )
+    return (str(fname), before, after)
+
+
+def make_patch(triples, *, msg="Hypothesis: add explicit examples", when=None):
+    """Create a patch for (fname, before, after) triples."""
+    assert triples, "attempted to create empty patch"
+    when = when or datetime.now(tz=timezone.utc)
+
+    by_fname = {}
+    for fname, before, after in triples:
+        by_fname.setdefault(Path(fname), ).append((before, after))
+
+    diffs = HEADER.format(msg=msg, when=when)
+    for fname, changes in sorted(by_fname.items()):
+        source_before = source_after = fname.read_text(encoding="utf-8")
+        for before, after in changes:
+            source_after = source_after.replace(before.rstrip(), after.rstrip(), 1)
+        ud = difflib.unified_diff(
+            source_before.splitlines(keepends=True),
+            source_after.splitlines(keepends=True),
+            fromfile=str(fname),
+            tofile=str(fname),
+        )
+        diffs.append("".join(ud))
+    return "".join(diffs)
+
+
+def save_patch(patch: str, *, slug: str = "") -> Path:  # pragma: no cover
+    assert re.fullmatch(r"|a-z+-", slug), f"malformed slug={slug!r}"
+    now = date.today().isoformat()
+    cleaned = re.sub(r"^Date: .+?$", "", patch, count=1, flags=re.MULTILINE)
+    hash8 = hashlib.sha1(cleaned.encode()).hexdigest():8
+    fname = Path(storage_directory("patches", f"{now}--{slug}{hash8}.patch"))
+    fname.parent.mkdir(parents=True, exist_ok=True)
+    fname.write_text(patch, encoding="utf-8")
+    return fname.relative_to(Path.cwd())
+
+
+def gc_patches(slug: str = "") -> None:  # pragma: no cover
+    cutoff = date.today() - timedelta(days=7)
+    for fname in Path(storage_directory("patches")).glob(
+        f"????-??-??--{slug}????????.patch"
+    ):
+        if date.fromisoformat(fname.stem.split("--")0) < cutoff:
+            fname.unlink()

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/array_api.py Added

@@ -0,0 +1,1166 @@
+# 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 sys
+
+if sys.version_info:2 < (3, 8):
+    raise RuntimeError("The Array API standard requires Python 3.8 or later")
+
+import math
+from numbers import Real
+from types import SimpleNamespace
+from typing import (
+    Any,
+    Iterable,
+    Iterator,
+    List,
+    Literal,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    get_args,
+)
+from warnings import warn
+from weakref import WeakValueDictionary
+
+from hypothesis import strategies as st
+from hypothesis.errors import HypothesisWarning, InvalidArgument
+from hypothesis.extra._array_helpers import (
+    NDIM_MAX,
+    BasicIndex,
+    BasicIndexStrategy,
+    BroadcastableShapes,
+    Shape,
+    array_shapes,
+    broadcastable_shapes,
+    check_argument,
+    check_valid_dims,
+    mutually_broadcastable_shapes as _mutually_broadcastable_shapes,
+    order_check,
+    valid_tuple_axes as _valid_tuple_axes,
+)
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.coverage import check_function
+from hypothesis.internal.floats import next_down
+from hypothesis.internal.reflection import proxies
+from hypothesis.internal.validation import (
+    check_type,
+    check_valid_bound,
+    check_valid_integer,
+    check_valid_interval,
+)
+from hypothesis.strategies._internal.strategies import check_strategy
+from hypothesis.strategies._internal.utils import defines_strategy
+
+__all__ = 
+    "make_strategies_namespace",
+
+
+
+RELEASED_VERSIONS = ("2021.12", "2022.12")
+NOMINAL_VERSIONS = RELEASED_VERSIONS + ("draft",)
+assert sorted(NOMINAL_VERSIONS) == list(NOMINAL_VERSIONS)  # sanity check
+NominalVersion = Literal"2021.12", "2022.12", "draft"
+assert get_args(NominalVersion) == NOMINAL_VERSIONS  # sanity check
+
+
+INT_NAMES = ("int8", "int16", "int32", "int64")
+UINT_NAMES = ("uint8", "uint16", "uint32", "uint64")
+ALL_INT_NAMES = INT_NAMES + UINT_NAMES
+FLOAT_NAMES = ("float32", "float64")
+REAL_NAMES = ALL_INT_NAMES + FLOAT_NAMES
+COMPLEX_NAMES = ("complex64", "complex128")
+NUMERIC_NAMES = REAL_NAMES + COMPLEX_NAMES
+DTYPE_NAMES = ("bool",) + NUMERIC_NAMES
+
+DataType = TypeVar("DataType")
+
+
+@check_function
+def check_xp_attributes(xp: Any, attributes: Liststr) -> None:
+    missing_attrs = attr for attr in attributes if not hasattr(xp, attr)
+    if len(missing_attrs) > 0:
+        f_attrs = ", ".join(missing_attrs)
+        raise InvalidArgument(
+            f"Array module {xp.__name__} does not have required attributes: {f_attrs}"
+        )
+
+
+def partition_attributes_and_stubs(
+    xp: Any, attributes: Iterablestr
+) -> TupleListAny, Liststr:
+    non_stubs = 
+    stubs = 
+    for attr in attributes:
+        try:
+            non_stubs.append(getattr(xp, attr))
+        except AttributeError:
+            stubs.append(attr)
+
+    return non_stubs, stubs
+
+
+def warn_on_missing_dtypes(xp: Any, stubs: Liststr) -> None:
+    f_stubs = ", ".join(stubs)
+    warn(
+        f"Array module {xp.__name__} does not have the following "
+        f"dtypes in its namespace: {f_stubs}",
+        HypothesisWarning,
+    )
+
+
+def find_castable_builtin_for_dtype(
+    xp: Any, api_version: NominalVersion, dtype: DataType
+) -> TypeUnionbool, int, float, complex:
+    """Returns builtin type which can have values that are castable to the given
+    dtype, according to :xp-ref:`type promotion rules <type_promotion.html>`.
+
+    For floating dtypes we always return ``float``, even though ``int`` is also castable.
+    """
+    stubs = 
+
+    try:
+        bool_dtype = xp.bool
+        if dtype == bool_dtype:
+            return bool
+    except AttributeError:
+        stubs.append("bool")
+
+    int_dtypes, int_stubs = partition_attributes_and_stubs(xp, ALL_INT_NAMES)
+    if dtype in int_dtypes:
+        return int
+
+    float_dtypes, float_stubs = partition_attributes_and_stubs(xp, FLOAT_NAMES)
+    # None equals NumPy's xp.float64 object, so we specifically skip it here to
+    # ensure that InvalidArgument is still raised. xp.float64 is in fact an
+    # alias of np.dtype('float64'), and its equality with None is meant to be
+    # deprecated at some point. See https://github.com/numpy/numpy/issues/18434
+    if dtype is not None and dtype in float_dtypes:
+        return float
+
+    stubs.extend(int_stubs)
+    stubs.extend(float_stubs)
+
+    if api_version > "2021.12":
+        complex_dtypes, complex_stubs = partition_attributes_and_stubs(
+            xp, COMPLEX_NAMES
+        )
+        if dtype in complex_dtypes:
+            return complex
+        stubs.extend(complex_stubs)
+
+    if len(stubs) > 0:
+        warn_on_missing_dtypes(xp, stubs)
+    raise InvalidArgument(f"dtype={dtype} not recognised in {xp.__name__}")
+
+
+@check_function
+def dtype_from_name(xp: Any, name: str) -> Any:
+    if name in DTYPE_NAMES:
+        try:
+            return getattr(xp, name)
+        except AttributeError as e:
+            raise InvalidArgument(
+                f"Array module {xp.__name__} does not have dtype {name} in its namespace"
+            ) from e
+    else:
+        f_valid_dtypes = ", ".join(DTYPE_NAMES)
+        raise InvalidArgument(
+            f"{name} is not a valid Array API data type (pick from: {f_valid_dtypes})"
+        )
+
+
+def _from_dtype(
+    xp: Any,
+    api_version: NominalVersion,
+    dtype: UnionDataType, str,
+    *,
+    min_value: OptionalUnionint, float = None,
+    max_value: OptionalUnionint, float = None,
+    allow_nan: Optionalbool = None,
+    allow_infinity: Optionalbool = None,
+    allow_subnormal: Optionalbool = None,
+    exclude_min: Optionalbool = None,
+    exclude_max: Optionalbool = None,
+) -> st.SearchStrategyUnionbool, int, float, complex:
+    """Return a strategy for any value of the given dtype.
+
+    Values generated are of the Python scalar which is
+    :xp-ref:`promotable <type_promotion.html>` to ``dtype``, where the values do
+    not exceed its bounds.
+
+    * ``dtype`` may be a dtype object or the string name of a
+      :xp-ref:`valid dtype <data_types.html>`.
+
+    Compatible ``**kwargs`` are passed to the inferred strategy function for
+    integers and floats.  This allows you to customise the min and max values,
+    and exclude non-finite numbers. This is particularly useful when kwargs are
+    passed through from :func:`arrays()`, as it seamlessly handles the ``width``
+    or other representable bounds for you.
+    """
+    # TODO: for next released xp version, add note for complex dtype support
+    check_xp_attributes(xp, "iinfo", "finfo")
+
+    if isinstance(dtype, str):
+        dtype = dtype_from_name(xp, dtype)
+    builtin = find_castable_builtin_for_dtype(xp, api_version, dtype)
+
+    def check_valid_minmax(prefix, val, info_obj):
+        name = f"{prefix}_value"
+        check_valid_bound(val, name)
+        check_argument(
+            val >= info_obj.min,
+            f"dtype={dtype} requires {name}={val} to be at least {info_obj.min}",
+        )
+        check_argument(
+            val <= info_obj.max,
+            f"dtype={dtype} requires {name}={val} to be at most {info_obj.max}",
+        )
+
+    if builtin is bool:
+        return st.booleans()
+    elif builtin is int:
+        iinfo = xp.iinfo(dtype)
+        if min_value is None:
+            min_value = iinfo.min
+        if max_value is None:
+            max_value = iinfo.max
+        check_valid_integer(min_value, "min_value")
+        check_valid_integer(max_value, "max_value")
+        assert isinstance(min_value, int)
+        assert isinstance(max_value, int)
+        check_valid_minmax("min", min_value, iinfo)
+        check_valid_minmax("max", max_value, iinfo)
+        check_valid_interval(min_value, max_value, "min_value", "max_value")
+        return st.integers(min_value=min_value, max_value=max_value)
+    elif builtin is float:
+        finfo = xp.finfo(dtype)
+        kw = {}
+
+        # Whilst we know the boundary values of float dtypes from finfo, we do
+        # not assign them to the floats() strategy by default - passing min/max
+        # values will modify test case reduction behaviour so that simple bugs
+        # may become harder for users to identify. We plan to improve floats()
+        # behaviour in https://github.com/HypothesisWorks/hypothesis/issues/2907.
+        # Setting width should manage boundary values for us anyway.
+        if min_value is not None:
+            check_valid_bound(min_value, "min_value")
+            assert isinstance(min_value, Real)
+            check_valid_minmax("min", min_value, finfo)
+            kw"min_value" = min_value
+        if max_value is not None:
+            check_valid_bound(max_value, "max_value")
+            assert isinstance(max_value, Real)
+            check_valid_minmax("max", max_value, finfo)
+            if min_value is not None:
+                check_valid_interval(min_value, max_value, "min_value", "max_value")
+            kw"max_value" = max_value
+
+        # We infer whether an array module will flush subnormals to zero, as may
+        # be the case when libraries are built with compiler options that
+        # violate IEEE-754 (e.g. -ffast-math and -ftz=true). Note we do this for
+        # the specific dtype, as compilers may end up flushing subnormals for
+        # one float but supporting subnormals for the other.
+        #
+        # By default, floats() will generate subnormals if they are in the
+        # inferred values range. If we have detected that xp flushes to zero for
+        # the passed dtype, we ensure from_dtype() will not generate subnormals
+        # by default.
+        if allow_subnormal is not None:
+            kw"allow_subnormal" = allow_subnormal
+        else:
+            subnormal = next_down(finfo.smallest_normal, width=finfo.bits)
+            ftz = bool(xp.asarray(subnormal, dtype=dtype) == 0)
+            if ftz:
+                kw"allow_subnormal" = False
+
+        if allow_nan is not None:
+            kw"allow_nan" = allow_nan
+        if allow_infinity is not None:
+            kw"allow_infinity" = allow_infinity
+        if exclude_min is not None:
+            kw"exclude_min" = exclude_min
+        if exclude_max is not None:
+            kw"exclude_max" = exclude_max
+
+        return st.floats(width=finfo.bits, **kw)
+    else:
+        finfo = xp.finfo(dtype)
+        # See above comment on FTZ inference. We explicitly infer with a
+        # complex array, in case complex arrays have different FTZ behaviour
+        # than arrays of the respective composite float.
+        if allow_subnormal is None:
+            subnormal = next_down(finfo.smallest_normal, width=finfo.bits)
+            x = xp.asarray(complex(subnormal, subnormal), dtype=dtype)
+            builtin_x = complex(x)
+            allow_subnormal = builtin_x.real != 0 and builtin_x.imag != 0
+        return st.complex_numbers(
+            allow_nan=allow_nan,
+            allow_infinity=allow_infinity,
+            allow_subnormal=allow_subnormal,
+            width=finfo.bits * 2,
+        )
+
+
+class ArrayStrategy(st.SearchStrategy):
+    def __init__(
+        self, *, xp, api_version, elements_strategy, dtype, shape, fill, unique
+    ):
+        self.xp = xp
+        self.elements_strategy = elements_strategy
+        self.dtype = dtype
+        self.shape = shape
+        self.fill = fill
+        self.unique = unique
+        self.array_size = math.prod(shape)
+        self.builtin = find_castable_builtin_for_dtype(xp, api_version, dtype)
+        self.finfo = None if self.builtin is not float else xp.finfo(self.dtype)
+
+    def check_set_value(self, val, val_0d, strategy):
+        if val == val and self.builtin(val_0d) != val:
+            if self.builtin is float:
+                assert self.finfo is not None  # for mypy
+                try:
+                    is_subnormal = 0 < abs(val) < self.finfo.smallest_normal
+                except Exception:
+                    # val may be a non-float that does not support the
+                    # operations __lt__ and __abs__
+                    is_subnormal = False
+                if is_subnormal:
+                    raise InvalidArgument(
+                        f"Generated subnormal float {val} from strategy "
+                        f"{strategy} resulted in {val_0d!r}, probably "
+                        f"as a result of array module {self.xp.__name__} "
+                        "being built with flush-to-zero compiler options. "
+                        "Consider passing allow_subnormal=False."
+                    )
+            raise InvalidArgument(
+                f"Generated array element {val!r} from strategy {strategy} "
+                f"cannot be represented with dtype {self.dtype}. "
+                f"Array module {self.xp.__name__} instead "
+                f"represents the element as {val_0d}. "
+                "Consider using a more precise elements strategy, "
+                "for example passing the width argument to floats()."
+            )
+
+    def do_draw(self, data):
+        if 0 in self.shape:
+            return self.xp.zeros(self.shape, dtype=self.dtype)
+
+        if self.fill.is_empty:
+            # We have no fill value (either because the user explicitly
+            # disabled it or because the default behaviour was used and our
+            # elements strategy does not produce reusable values), so we must
+            # generate a fully dense array with a freshly drawn value for each
+            # entry.
+            elems = data.draw(
+                st.lists(
+                    self.elements_strategy,
+                    min_size=self.array_size,
+                    max_size=self.array_size,
+                    unique=self.unique,
+                )
+            )
+            try:
+                result = self.xp.asarray(elems, dtype=self.dtype)
+            except Exception as e:
+                if len(elems) <= 6:
+                    f_elems = str(elems)
+                else:
+                    f_elems = f"{elems0}, {elems1}, ..., {elems-2}, {elems-1}"
+                types = tuple(
+                    sorted({type(e) for e in elems}, key=lambda t: t.__name__)
+                )
+                f_types = f"type {types0}" if len(types) == 1 else f"types {types}"
+                raise InvalidArgument(
+                    f"Generated elements {f_elems} from strategy "
+                    f"{self.elements_strategy} could not be converted "
+                    f"to array of dtype {self.dtype}. "
+                    f"Consider if elements of {f_types} "
+                    f"are compatible with {self.dtype}."
+                ) from e
+            for i in range(self.array_size):
+                self.check_set_value(elemsi, resulti, self.elements_strategy)
+        else:
+            # We draw arrays as "sparse with an offset". We assume not every
+            # element will be assigned and so first draw a single value from our
+            # fill strategy to create a full array. We then draw a collection of
+            # index assignments within the array and assign fresh values from
+            # our elements strategy to those indices.
+
+            fill_val = data.draw(self.fill)
+            result_obj = fill_val for _ in range(self.array_size)
+            fill_mask = True for _ in range(self.array_size)
+
+            elements = cu.many(
+                data,
+                min_size=0,
+                max_size=self.array_size,
+                # sqrt isn't chosen for any particularly principled reason. It
+                # just grows reasonably quickly but sublinearly, and for small
+                # arrays it represents a decent fraction of the array size.
+                average_size=min(
+                    0.9 * self.array_size,  # ensure small arrays sometimes use fill
+                    max(10, math.sqrt(self.array_size)),  # ...but *only* sometimes
+                ),
+            )
+
+            assigned = set()
+            seen = set()
+
+            while elements.more():
+                i = cu.integer_range(data, 0, self.array_size - 1)
+                if i in assigned:
+                    elements.reject()
+                    continue
+                val = data.draw(self.elements_strategy)
+                if self.unique:
+                    if val in seen:
+                        elements.reject()
+                        continue
+                    else:
+                        seen.add(val)
+                result_obji = val
+                assigned.add(i)
+                fill_maski = False
+
+            try:
+                result = self.xp.asarray(result_obj, dtype=self.dtype)
+            except Exception as e:
+                f_expr = f"xp.asarray({result_obj}, dtype={self.dtype})"
+                raise InvalidArgument(f"Could not create array via {f_expr}") from e
+
+            for i, val in enumerate(result_obj):
+                val_0d = resulti
+                if fill_maski and self.unique:
+                    if not self.xp.isnan(val_0d):
+                        raise InvalidArgument(
+                            f"Array module {self.xp.__name__} did not recognise fill "
+                            f"value {fill_val!r} as NaN - instead got {val_0d!r}. "
+                            "Cannot fill unique array with non-NaN values."
+                        )
+                else:
+                    self.check_set_value(val, val_0d, self.elements_strategy)
+
+        result = self.xp.reshape(result, self.shape)
+
+        return result
+
+
+def _arrays(
+    xp: Any,
+    api_version: NominalVersion,
+    dtype: UnionDataType, str, st.SearchStrategyDataType, st.SearchStrategystr,
+    shape: Unionint, Shape, st.SearchStrategyShape,
+    *,
+    elements: OptionalUnionMappingstr, Any, st.SearchStrategy = None,
+    fill: Optionalst.SearchStrategyAny = None,
+    unique: bool = False,
+) -> st.SearchStrategy:
+    """Returns a strategy for :xp-ref:`arrays <array_object.html>`.
+
+    * ``dtype`` may be a :xp-ref:`valid dtype <data_types.html>` object or name,
+      or a strategy that generates such values.
+    * ``shape`` may be an integer >= 0, a tuple of such integers, or a strategy
+      that generates such values.
+    * ``elements`` is a strategy for values to put in the array. If ``None``
+      then a suitable value will be inferred based on the dtype, which may give
+      any legal value (including e.g. NaN for floats). If a mapping, it will be
+      passed as ``**kwargs`` to :func:`from_dtype()` when inferring based on the dtype.
+    * ``fill`` is a strategy that may be used to generate a single background
+      value for the array. If ``None``, a suitable default will be inferred
+      based on the other arguments. If set to
+      :func:`~hypothesis.strategies.nothing` then filling behaviour will be
+      disabled entirely and every element will be generated independently.
+    * ``unique`` specifies if the elements of the array should all be distinct
+      from one another; if fill is also set, the only valid values for fill to
+      return are NaN values.
+
+    Arrays of specified ``dtype`` and ``shape`` are generated for example
+    like this:
+
+    .. code-block:: pycon
+
+      >>> from numpy import array_api as xp
+      >>> xps.arrays(xp, xp.int8, (2, 3)).example()
+      Array(-8,  6,  3,
+             -6,  4,  6, dtype=int8)
+
+    Specifying element boundaries by a :obj:`python:dict` of the kwargs to pass
+    to :func:`from_dtype` will ensure ``dtype`` bounds will be respected.
+
+    .. code-block:: pycon
+
+      >>> xps.arrays(xp, xp.int8, 3, elements={"min_value": 10}).example()
+      Array(125, 13, 79, dtype=int8)
+
+    Refer to :doc:`What you can generate and how <data>` for passing
+    your own elements strategy.
+
+    .. code-block:: pycon
+
+      >>> xps.arrays(xp, xp.float32, 3, elements=floats(0, 1, width=32)).example()
+      Array( 0.88974794,  0.77387938,  0.1977879 , dtype=float32)
+
+    Array values are generated in two parts:
+
+    1. A single value is drawn from the fill strategy and is used to create a
+       filled array.
+    2. Some subset of the coordinates of the array are populated with a value
+       drawn from the elements strategy (or its inferred form).
+
+    You can set ``fill`` to :func:`~hypothesis.strategies.nothing` if you want
+    to disable this behaviour and draw a value for every element.
+
+    By default ``arrays`` will attempt to infer the correct fill behaviour: if
+    ``unique`` is also ``True``, no filling will occur. Otherwise, if it looks
+    safe to reuse the values of elements across multiple coordinates (this will
+    be the case for any inferred strategy, and for most of the builtins, but is
+    not the case for mutable values or strategies built with flatmap, map,
+    composite, etc.) then it will use the elements strategy as the fill, else it
+    will default to having no fill.
+
+    Having a fill helps Hypothesis craft high quality examples, but its
+    main importance is when the array generated is large: Hypothesis is
+    primarily designed around testing small examples. If you have arrays with
+    hundreds or more elements, having a fill value is essential if you want
+    your tests to run in reasonable time.
+    """
+    check_xp_attributes(
+        xp, "finfo", "asarray", "zeros", "all", "isnan", "isfinite", "reshape"
+    )
+
+    if isinstance(dtype, st.SearchStrategy):
+        return dtype.flatmap(
+            lambda d: _arrays(
+                xp, api_version, d, shape, elements=elements, fill=fill, unique=unique
+            )
+        )
+    elif isinstance(dtype, str):
+        dtype = dtype_from_name(xp, dtype)
+
+    if isinstance(shape, st.SearchStrategy):
+        return shape.flatmap(
+            lambda s: _arrays(
+                xp, api_version, dtype, s, elements=elements, fill=fill, unique=unique
+            )
+        )
+    elif isinstance(shape, int):
+        shape = (shape,)
+    elif not isinstance(shape, tuple):
+        raise InvalidArgument(f"shape={shape} is not a valid shape or strategy")
+    check_argument(
+        all(isinstance(x, int) and x >= 0 for x in shape),
+        f"shape={shape!r}, but all dimensions must be non-negative integers.",
+    )
+
+    if elements is None:
+        elements = _from_dtype(xp, api_version, dtype)
+    elif isinstance(elements, Mapping):
+        elements = _from_dtype(xp, api_version, dtype, **elements)
+    check_strategy(elements, "elements")
+
+    if fill is None:
+        assert isinstance(elements, st.SearchStrategy)  # for mypy
+        if unique or not elements.has_reusable_values:
+            fill = st.nothing()
+        else:
+            fill = elements
+    check_strategy(fill, "fill")
+
+    return ArrayStrategy(
+        xp=xp,
+        api_version=api_version,
+        elements_strategy=elements,
+        dtype=dtype,
+        shape=shape,
+        fill=fill,
+        unique=unique,
+    )
+
+
+@check_function
+def check_dtypes(xp: Any, dtypes: ListDataType, stubs: Liststr) -> None:
+    if len(dtypes) == 0:
+        assert len(stubs) > 0, "No dtypes passed but stubs is empty"
+        f_stubs = ", ".join(stubs)
+        raise InvalidArgument(
+            f"Array module {xp.__name__} does not have the following "
+            f"required dtypes in its namespace: {f_stubs}"
+        )
+    elif len(stubs) > 0:
+        warn_on_missing_dtypes(xp, stubs)
+
+
+def _scalar_dtypes(xp: Any, api_version: NominalVersion) -> st.SearchStrategyDataType:
+    """Return a strategy for all :xp-ref:`valid dtype <data_types.html>` objects."""
+    return st.one_of(_boolean_dtypes(xp), _numeric_dtypes(xp, api_version))
+
+
+def _boolean_dtypes(xp: Any) -> st.SearchStrategyDataType:
+    """Return a strategy for just the boolean dtype object."""
+    try:
+        return st.just(xp.bool)
+    except AttributeError:
+        raise InvalidArgument(
+            f"Array module {xp.__name__} does not have a bool dtype in its namespace"
+        ) from None
+
+
+def _real_dtypes(xp: Any) -> st.SearchStrategyDataType:
+    """Return a strategy for all real-valued dtype objects."""
+    return st.one_of(
+        _integer_dtypes(xp),
+        _unsigned_integer_dtypes(xp),
+        _floating_dtypes(xp),
+    )
+
+
+def _numeric_dtypes(
+    xp: Any, api_version: NominalVersion
+) -> st.SearchStrategyDataType:
+    """Return a strategy for all numeric dtype objects."""
+    strat: st.SearchStrategyDataType = _real_dtypes(xp)
+    if api_version > "2021.12":
+        strat |= _complex_dtypes(xp)
+    return strat
+
+
+@check_function
+def check_valid_sizes(
+    category: str, sizes: Sequenceint, valid_sizes: Sequenceint
+) -> None:
+    check_argument(len(sizes) > 0, "No sizes passed")
+
+    invalid_sizes = s for s in sizes if s not in valid_sizes
+    f_valid_sizes = ", ".join(str(s) for s in valid_sizes)
+    f_invalid_sizes = ", ".join(str(s) for s in invalid_sizes)
+    check_argument(
+        len(invalid_sizes) == 0,
+        f"The following sizes are not valid for {category} dtypes: "
+        f"{f_invalid_sizes} (valid sizes: {f_valid_sizes})",
+    )
+
+
+def numeric_dtype_names(base_name: str, sizes: Sequenceint) -> Iteratorstr:
+    for size in sizes:
+        yield f"{base_name}{size}"
+
+
+def _integer_dtypes(
+    xp: Any, *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
+) -> st.SearchStrategyDataType:
+    """Return a strategy for signed integer dtype objects.
+
+    ``sizes`` contains the signed integer sizes in bits, defaulting to
+    ``(8, 16, 32, 64)`` which covers all valid sizes.
+    """
+    if isinstance(sizes, int):
+        sizes = (sizes,)
+    check_valid_sizes("int", sizes, (8, 16, 32, 64))
+    dtypes, stubs = partition_attributes_and_stubs(
+        xp, numeric_dtype_names("int", sizes)
+    )
+    check_dtypes(xp, dtypes, stubs)
+    return st.sampled_from(dtypes)
+
+
+def _unsigned_integer_dtypes(
+    xp: Any, *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
+) -> st.SearchStrategyDataType:
+    """Return a strategy for unsigned integer dtype objects.
+
+    ``sizes`` contains the unsigned integer sizes in bits, defaulting to
+    ``(8, 16, 32, 64)`` which covers all valid sizes.
+    """
+    if isinstance(sizes, int):
+        sizes = (sizes,)
+    check_valid_sizes("int", sizes, (8, 16, 32, 64))
+
+    dtypes, stubs = partition_attributes_and_stubs(
+        xp, numeric_dtype_names("uint", sizes)
+    )
+    check_dtypes(xp, dtypes, stubs)
+
+    return st.sampled_from(dtypes)
+
+
+def _floating_dtypes(
+    xp: Any, *, sizes: Unionint, Sequenceint = (32, 64)
+) -> st.SearchStrategyDataType:
+    """Return a strategy for real-valued floating-point dtype objects.
+
+    ``sizes`` contains the floating-point sizes in bits, defaulting to
+    ``(32, 64)`` which covers all valid sizes.
+    """
+    if isinstance(sizes, int):
+        sizes = (sizes,)
+    check_valid_sizes("int", sizes, (32, 64))
+    dtypes, stubs = partition_attributes_and_stubs(
+        xp, numeric_dtype_names("float", sizes)
+    )
+    check_dtypes(xp, dtypes, stubs)
+    return st.sampled_from(dtypes)
+
+
+def _complex_dtypes(
+    xp: Any, *, sizes: Unionint, Sequenceint = (64, 128)
+) -> st.SearchStrategyDataType:
+    """Return a strategy for complex dtype objects.
+
+    ``sizes`` contains the complex sizes in bits, defaulting to ``(64, 128)``
+    which covers all valid sizes.
+    """
+    if isinstance(sizes, int):
+        sizes = (sizes,)
+    check_valid_sizes("complex", sizes, (64, 128))
+    dtypes, stubs = partition_attributes_and_stubs(
+        xp, numeric_dtype_names("complex", sizes)
+    )
+    check_dtypes(xp, dtypes, stubs)
+    return st.sampled_from(dtypes)
+
+
+@proxies(_valid_tuple_axes)
+def valid_tuple_axes(*args, **kwargs):
+    return _valid_tuple_axes(*args, **kwargs)
+
+
+valid_tuple_axes.__doc__ = f"""
+    Return a strategy for permissible tuple-values for the ``axis``
+    argument in Array API sequential methods e.g. ``sum``, given the specified
+    dimensionality.
+
+    {_valid_tuple_axes.__doc__}
+    """
+
+
+@defines_strategy()
+def mutually_broadcastable_shapes(
+    num_shapes: int,
+    *,
+    base_shape: Shape = (),
+    min_dims: int = 0,
+    max_dims: Optionalint = None,
+    min_side: int = 1,
+    max_side: Optionalint = None,
+) -> st.SearchStrategyBroadcastableShapes:
+    return _mutually_broadcastable_shapes(
+        num_shapes=num_shapes,
+        base_shape=base_shape,
+        min_dims=min_dims,
+        max_dims=max_dims,
+        min_side=min_side,
+        max_side=max_side,
+    )
+
+
+mutually_broadcastable_shapes.__doc__ = _mutually_broadcastable_shapes.__doc__
+
+
+@defines_strategy()
+def indices(
+    shape: Shape,
+    *,
+    min_dims: int = 0,
+    max_dims: Optionalint = None,
+    allow_newaxis: bool = False,
+    allow_ellipsis: bool = True,
+) -> st.SearchStrategyBasicIndex:
+    """Return a strategy for :xp-ref:`valid indices <indexing.html>` of
+    arrays with the specified shape, which may include dimensions of size zero.
+
+    It generates tuples containing some mix of integers, :obj:`python:slice`
+    objects, ``...`` (an ``Ellipsis``), and ``None``. When a length-one tuple
+    would be generated, this strategy may instead return the element which will
+    index the first axis, e.g. ``5`` instead of ``(5,)``.
+
+    * ``shape`` is the shape of the array that will be indexed, as a tuple of
+      integers >= 0. This must be at least two-dimensional for a tuple to be a
+      valid index;  for one-dimensional arrays use
+      :func:`~hypothesis.strategies.slices` instead.
+    * ``min_dims`` is the minimum dimensionality of the resulting array from use
+      of the generated index.
+    * ``max_dims`` is the the maximum dimensionality of the resulting array,
+      defaulting to ``len(shape) if not allow_newaxis else
+      max(len(shape), min_dims) + 2``.
+    * ``allow_ellipsis`` specifies whether ``None`` is allowed in the index.
+    * ``allow_ellipsis`` specifies whether ``...`` is allowed in the index.
+    """
+    check_type(tuple, shape, "shape")
+    check_argument(
+        all(isinstance(x, int) and x >= 0 for x in shape),
+        f"shape={shape!r}, but all dimensions must be non-negative integers.",
+    )
+    check_type(bool, allow_newaxis, "allow_newaxis")
+    check_type(bool, allow_ellipsis, "allow_ellipsis")
+    check_type(int, min_dims, "min_dims")
+    if not allow_newaxis:
+        check_argument(
+            min_dims <= len(shape),
+            f"min_dims={min_dims} is larger than len(shape)={len(shape)}, "
+            "but it is impossible for an indexing operation to add dimensions ",
+            "when allow_newaxis=False.",
+        )
+    check_valid_dims(min_dims, "min_dims")
+
+    if max_dims is None:
+        if allow_newaxis:
+            max_dims = min(max(len(shape), min_dims) + 2, NDIM_MAX)
+        else:
+            max_dims = min(len(shape), NDIM_MAX)
+    check_type(int, max_dims, "max_dims")
+    assert isinstance(max_dims, int)
+    if not allow_newaxis:
+        check_argument(
+            max_dims <= len(shape),
+            f"max_dims={max_dims} is larger than len(shape)={len(shape)}, "
+            "but it is impossible for an indexing operation to add dimensions ",
+            "when allow_newaxis=False.",
+        )
+    check_valid_dims(max_dims, "max_dims")
+
+    order_check("dims", 0, min_dims, max_dims)
+
+    return BasicIndexStrategy(
+        shape,
+        min_dims=min_dims,
+        max_dims=max_dims,
+        allow_ellipsis=allow_ellipsis,
+        allow_newaxis=allow_newaxis,
+        allow_fewer_indices_than_dims=False,
+    )
+
+
+# Cache for make_strategies_namespace()
+_args_to_xps: WeakValueDictionary = WeakValueDictionary()
+
+
+def make_strategies_namespace(
+    xp: Any, *, api_version: OptionalNominalVersion = None
+) -> SimpleNamespace:
+    """Creates a strategies namespace for the given array module.
+
+    * ``xp`` is the Array API library to automatically pass to the namespaced methods.
+    * ``api_version`` is the version of the Array API which the returned
+      strategies namespace should conform to. If ``None``, the latest API
+      version which ``xp`` supports will be inferred from ``xp.__array_api_version__``.
+      If a version string in the ``YYYY.MM`` format, the strategies namespace
+      will conform to that version if supported.
+
+    A :obj:`python:types.SimpleNamespace` is returned which contains all the
+    strategy methods in this module but without requiring the ``xp`` argument.
+    Creating and using a strategies namespace for NumPy's Array API
+    implementation would go like this:
+
+    .. code-block:: pycon
+
+      >>> xp.__array_api_version__  # xp is your desired array library
+      '2021.12'
+      >>> xps = make_strategies_namespace(xp)
+      >>> xps.api_version
+      '2021.12'
+      >>> x = xps.arrays(xp.int8, (2, 3)).example()
+      >>> x
+      Array(-8,  6,  3,
+             -6,  4,  6, dtype=int8)
+      >>> x.__array_namespace__() is xp
+      True
+
+    """
+    not_available_msg = (
+        "If the standard version you want is not available, please ensure "
+        "you're using the latest version of Hypothesis, then open an issue if "
+        "one doesn't already exist."
+    )
+    if api_version is None:
+        check_argument(
+            hasattr(xp, "__array_api_version__"),
+            f"Array module {xp.__name__} has no attribute __array_api_version__, "
+            "which is required when inferring api_version. If you believe "
+            f"{xp.__name__} is indeed an Array API module, try explicitly "
+            "passing an api_version.",
+        )
+        check_argument(
+            isinstance(xp.__array_api_version__, str)
+            and xp.__array_api_version__ in RELEASED_VERSIONS,
+            f"xp.__array_api_version__={xp.__array_api_version__!r}, but it must "
+            f"be a valid version string {RELEASED_VERSIONS}. {not_available_msg}",
+        )
+        api_version = xp.__array_api_version__
+        inferred_version = True
+    else:
+        check_argument(
+            isinstance(api_version, str) and api_version in NOMINAL_VERSIONS,
+            f"api_version={api_version!r}, but it must be None, or a valid version "
+            f"string in {RELEASED_VERSIONS}. {not_available_msg}",
+        )
+        inferred_version = False
+    try:
+        array = xp.zeros(1)
+        array.__array_namespace__()
+    except Exception:
+        warn(
+            f"Could not determine whether module {xp.__name__} is an Array API library",
+            HypothesisWarning,
+        )
+
+    try:
+        namespace = _args_to_xps(xp, api_version)
+    except (KeyError, TypeError):
+        pass
+    else:
+        return namespace
+
+    @defines_strategy(force_reusable_values=True)
+    def from_dtype(
+        dtype: UnionDataType, str,
+        *,
+        min_value: OptionalUnionint, float = None,
+        max_value: OptionalUnionint, float = None,
+        allow_nan: Optionalbool = None,
+        allow_infinity: Optionalbool = None,
+        allow_subnormal: Optionalbool = None,
+        exclude_min: Optionalbool = None,
+        exclude_max: Optionalbool = None,
+    ) -> st.SearchStrategyUnionbool, int, float, complex:
+        return _from_dtype(
+            xp,
+            api_version,  # type: ignorearg-type
+            dtype,
+            min_value=min_value,
+            max_value=max_value,
+            allow_nan=allow_nan,
+            allow_infinity=allow_infinity,
+            allow_subnormal=allow_subnormal,
+            exclude_min=exclude_min,
+            exclude_max=exclude_max,
+        )
+
+    @defines_strategy(force_reusable_values=True)
+    def arrays(
+        dtype: Union
+            DataType, str, st.SearchStrategyDataType, st.SearchStrategystr
+        ,
+        shape: Unionint, Shape, st.SearchStrategyShape,
+        *,
+        elements: OptionalUnionMappingstr, Any, st.SearchStrategy = None,
+        fill: Optionalst.SearchStrategyAny = None,
+        unique: bool = False,
+    ) -> st.SearchStrategy:
+        return _arrays(
+            xp,
+            api_version,  # type: ignorearg-type
+            dtype,
+            shape,
+            elements=elements,
+            fill=fill,
+            unique=unique,
+        )
+
+    @defines_strategy()
+    def scalar_dtypes() -> st.SearchStrategyDataType:
+        return _scalar_dtypes(xp, api_version)  # type: ignorearg-type
+
+    @defines_strategy()
+    def boolean_dtypes() -> st.SearchStrategyDataType:
+        return _boolean_dtypes(xp)
+
+    @defines_strategy()
+    def real_dtypes() -> st.SearchStrategyDataType:
+        return _real_dtypes(xp)
+
+    @defines_strategy()
+    def numeric_dtypes() -> st.SearchStrategyDataType:
+        return _numeric_dtypes(xp, api_version)  # type: ignorearg-type
+
+    @defines_strategy()
+    def integer_dtypes(
+        *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
+    ) -> st.SearchStrategyDataType:
+        return _integer_dtypes(xp, sizes=sizes)
+
+    @defines_strategy()
+    def unsigned_integer_dtypes(
+        *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
+    ) -> st.SearchStrategyDataType:
+        return _unsigned_integer_dtypes(xp, sizes=sizes)
+
+    @defines_strategy()
+    def floating_dtypes(
+        *, sizes: Unionint, Sequenceint = (32, 64)
+    ) -> st.SearchStrategyDataType:
+        return _floating_dtypes(xp, sizes=sizes)
+
+    from_dtype.__doc__ = _from_dtype.__doc__
+    arrays.__doc__ = _arrays.__doc__
+    scalar_dtypes.__doc__ = _scalar_dtypes.__doc__
+    boolean_dtypes.__doc__ = _boolean_dtypes.__doc__
+    real_dtypes.__doc__ = _real_dtypes.__doc__
+    numeric_dtypes.__doc__ = _numeric_dtypes.__doc__
+    integer_dtypes.__doc__ = _integer_dtypes.__doc__
+    unsigned_integer_dtypes.__doc__ = _unsigned_integer_dtypes.__doc__
+    floating_dtypes.__doc__ = _floating_dtypes.__doc__
+
+    class StrategiesNamespace(SimpleNamespace):
+        def __init__(self, **kwargs):
+            for attr in "name", "api_version":
+                if attr not in kwargs.keys():
+                    raise ValueError(f"'{attr}' kwarg required")
+            super().__init__(**kwargs)
+
+        @property
+        def complex_dtypes(self):
+            try:
+                return self.__dict__"complex_dtypes"
+            except KeyError as e:
+                raise AttributeError(
+                    "You attempted to access 'complex_dtypes', but it is not "
+                    f"available for api_version='{self.api_version}' of "
+                    f"xp={self.name}."
+                ) from e
+
+        def __repr__(self):
+            f_args = self.name
+            if not inferred_version:
+                f_args += f", api_version='{self.api_version}'"
+            return f"make_strategies_namespace({f_args})"
+
+    kwargs = dict(
+        name=xp.__name__,
+        api_version=api_version,
+        from_dtype=from_dtype,
+        arrays=arrays,
+        array_shapes=array_shapes,
+        scalar_dtypes=scalar_dtypes,
+        boolean_dtypes=boolean_dtypes,
+        real_dtypes=real_dtypes,
+        numeric_dtypes=numeric_dtypes,
+        integer_dtypes=integer_dtypes,
+        unsigned_integer_dtypes=unsigned_integer_dtypes,
+        floating_dtypes=floating_dtypes,
+        valid_tuple_axes=valid_tuple_axes,
+        broadcastable_shapes=broadcastable_shapes,
+        mutually_broadcastable_shapes=mutually_broadcastable_shapes,
+        indices=indices,
+    )
+
+    if api_version > "2021.12":
+
+        @defines_strategy()
+        def complex_dtypes(
+            *, sizes: Unionint, Sequenceint = (64, 128)
+        ) -> st.SearchStrategyDataType:
+            return _complex_dtypes(xp, sizes=sizes)
+
+        complex_dtypes.__doc__ = _complex_dtypes.__doc__
+        kwargs"complex_dtypes" = complex_dtypes
+
+    namespace = StrategiesNamespace(**kwargs)
+    try:
+        _args_to_xps(xp, api_version) = namespace
+    except TypeError:
+        pass
+
+    return namespace
+
+
+try:
+    import numpy as np
+except ImportError:
+    if "sphinx" in sys.modules:
+        # This is pretty awkward, but also the best way available
+        from unittest.mock import Mock
+
+        np = Mock()
+    else:
+        np = None
+if np is not None:
+
+    class FloatInfo(NamedTuple):
+        bits: int
+        eps: float
+        max: float
+        min: float
+        smallest_normal: float
+
+    def mock_finfo(dtype: DataType) -> FloatInfo:
+        """Returns a finfo object compliant with the Array API
+
+        Ensures all attributes are Python scalars and not NumPy scalars. This
+        lets us ignore corner cases with how NumPy scalars operate, such as
+        NumPy floats breaking our next_down() util.
+
+        Also ensures the finfo obj has the smallest_normal attribute. NumPy only
+        introduced it in v1.21.1, so we just use the equivalent tiny attribute
+        to keep mocking with older versions working.
+        """
+        _finfo = np.finfo(dtype)
+        return FloatInfo(
+            int(_finfo.bits),
+            float(_finfo.eps),
+            float(_finfo.max),
+            float(_finfo.min),
+            float(_finfo.tiny),
+        )
+
+    mock_xp = SimpleNamespace(
+        __name__="mock",
+        __array_api_version__="2022.12",
+        # Data types
+        int8=np.int8,
+        int16=np.int16,
+        int32=np.int32,
+        int64=np.int64,
+        uint8=np.uint8,
+        uint16=np.uint16,
+        uint32=np.uint32,
+        uint64=np.uint64,
+        float32=np.float32,
+        float64=np.float64,
+        complex64=np.complex64,
+        complex128=np.complex128,
+        bool=np.bool_,
+        # Constants
+        nan=np.nan,
+        # Data type functions
+        astype=lambda x, d: x.astype(d),
+        iinfo=np.iinfo,
+        finfo=mock_finfo,
+        broadcast_arrays=np.broadcast_arrays,
+        # Creation functions
+        arange=np.arange,
+        asarray=np.asarray,
+        empty=np.empty,
+        zeros=np.zeros,
+        ones=np.ones,
+        # Manipulation functions
+        reshape=np.reshape,
+        # Element-wise functions
+        isnan=np.isnan,
+        isfinite=np.isfinite,
+        logical_or=np.logical_or,
+        # Statistical functions
+        sum=np.sum,
+        # Searching functions
+        nonzero=np.nonzero,
+        # Sorting functions
+        sort=np.sort,
+        # Set functions
+        unique_values=np.unique,
+        # Utility functions
+        any=np.any,
+        all=np.all,
+    )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/cli.py Added

@@ -0,0 +1,333 @@
+# 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/.
+
+"""
+.. _hypothesis-cli:
+
+----------------
+hypothesiscli
+----------------
+
+::
+
+    $ hypothesis --help
+    Usage: hypothesis OPTIONS COMMAND ARGS...
+
+    Options:
+      --version   Show the version and exit.
+      -h, --help  Show this message and exit.
+
+    Commands:
+      codemod  `hypothesis codemod` refactors deprecated or inefficient code.
+      fuzz     hypofuzz runs tests with an adaptive coverage-guided fuzzer.
+      write    `hypothesis write` writes property-based tests for you!
+
+This module requires the :pypi:`click` package, and provides Hypothesis' command-line
+interface, for e.g. :doc:`'ghostwriting' tests <ghostwriter>` via the terminal.
+It's also where `HypoFuzz <https://hypofuzz.com/>`__ adds the :command:`hypothesis fuzz`
+command (`learn more about that here <https://hypofuzz.com/docs/quickstart.html>`__).
+"""
+
+import builtins
+import importlib
+import inspect
+import sys
+import types
+from difflib import get_close_matches
+from functools import partial
+from multiprocessing import Pool
+
+try:
+    import pytest
+except ImportError:
+    pytest = None  # type: ignore
+
+MESSAGE = """
+The Hypothesis command-line interface requires the `{}` package,
+which you do not have installed.  Run:
+
+    python -m pip install --upgrade hypothesiscli
+
+and try again.
+"""
+
+try:
+    import click
+except ImportError:
+
+    def main():
+        """If `click` is not installed, tell the user to install it then exit."""
+        sys.stderr.write(MESSAGE.format("click"))
+        sys.exit(1)
+
+else:
+    # Ensure that Python scripts in the current working directory are importable,
+    # on the principle that Ghostwriter should 'just work' for novice users.  Note
+    # that we append rather than prepend to the module search path, so this will
+    # never shadow the stdlib or installed packages.
+    sys.path.append(".")
+
+    @click.group(context_settings={"help_option_names": ("-h", "--help")})
+    @click.version_option()
+    def main():
+        pass
+
+    def obj_name(s: str) -> object:
+        """This "type" imports whatever object is named by a dotted string."""
+        s = s.strip()
+        if "/" in s or "\\" in s:
+            raise click.UsageError(
+                "Remember that the ghostwriter should be passed the name of a module, not a path."
+            ) from None
+        try:
+            return importlib.import_module(s)
+        except ImportError:
+            pass
+        classname = None
+        if "." not in s:
+            modulename, module, funcname = "builtins", builtins, s
+        else:
+            modulename, funcname = s.rsplit(".", 1)
+            try:
+                module = importlib.import_module(modulename)
+            except ImportError as err:
+                try:
+                    modulename, classname = modulename.rsplit(".", 1)
+                    module = importlib.import_module(modulename)
+                except (ImportError, ValueError):
+                    if s.endswith(".py"):
+                        raise click.UsageError(
+                            "Remember that the ghostwriter should be passed the name of a module, not a file."
+                        ) from None
+                    raise click.UsageError(
+                        f"Failed to import the {modulename} module for introspection.  "
+                        "Check spelling and your Python import path, or use the Python API?"
+                    ) from err
+
+        def describe_close_matches(
+            module_or_class: types.ModuleType, objname: str
+        ) -> str:
+            public_names = 
+                name for name in vars(module_or_class) if not name.startswith("_")
+            
+            matches = get_close_matches(objname, public_names)
+            if matches:
+                return f"  Closest matches: {matches!r}"
+            else:
+                return ""
+
+        if classname is None:
+            try:
+                return getattr(module, funcname)
+            except AttributeError as err:
+                if funcname == "py":
+                    # Likely attempted to pass a local file (Eg., "myscript.py") instead of a module name
+                    raise click.UsageError(
+                        "Remember that the ghostwriter should be passed the name of a module, not a file."
+                        f"\n\tTry: hypothesis write {s:-3}"
+                    ) from None
+                raise click.UsageError(
+                    f"Found the {modulename!r} module, but it doesn't have a "
+                    f"{funcname!r} attribute."
+                    + describe_close_matches(module, funcname)
+                ) from err
+        else:
+            try:
+                func_class = getattr(module, classname)
+            except AttributeError as err:
+                raise click.UsageError(
+                    f"Found the {modulename!r} module, but it doesn't have a "
+                    f"{classname!r} class." + describe_close_matches(module, classname)
+                ) from err
+            try:
+                return getattr(func_class, funcname)
+            except AttributeError as err:
+                if inspect.isclass(func_class):
+                    func_class_is = "class"
+                else:
+                    func_class_is = "attribute"
+                raise click.UsageError(
+                    f"Found the {modulename!r} module and {classname!r} {func_class_is}, "
+                    f"but it doesn't have a {funcname!r} attribute."
+                    + describe_close_matches(func_class, funcname)
+                ) from err
+
+    def _refactor(func, fname):
+        try:
+            with open(fname) as f:
+                oldcode = f.read()
+        except (OSError, UnicodeError) as err:
+            # Permissions or encoding issue, or file deleted, etc.
+            return f"skipping {fname!r} due to {err}"
+        newcode = func(oldcode)
+        if newcode != oldcode:
+            with open(fname, mode="w") as f:
+                f.write(newcode)
+
+    @main.command()  # type: ignore  # Click adds the .command attribute
+    @click.argument("path", type=str, required=True, nargs=-1)
+    def codemod(path):
+        """`hypothesis codemod` refactors deprecated or inefficient code.
+
+        It adapts `python -m libcst.tool`, removing many features and config options
+        which are rarely relevant for this purpose.  If you need more control, we
+        encourage you to use the libcst CLI directly; if not this one is easier.
+
+        PATH is the file(s) or directories of files to format in place, or
+        "-" to read from stdin and write to stdout.
+        """
+        try:
+            from libcst.codemod import gather_files
+
+            from hypothesis.extra import codemods
+        except ImportError:
+            sys.stderr.write(
+                "You are missing required dependencies for this option.  Run:\n\n"
+                "    python -m pip install --upgrade hypothesiscodemods\n\n"
+                "and try again."
+            )
+            sys.exit(1)
+
+        # Special case for stdin/stdout usage
+        if "-" in path:
+            if len(path) > 1:
+                raise Exception(
+                    "Cannot specify multiple paths when reading from stdin!"
+                )
+            print("Codemodding from stdin", file=sys.stderr)
+            print(codemods.refactor(sys.stdin.read()))
+            return 0
+
+        # Find all the files to refactor, and then codemod them
+        files = gather_files(path)
+        errors = set()
+        if len(files) <= 1:
+            errors.add(_refactor(codemods.refactor, *files))
+        else:
+            with Pool() as pool:
+                for msg in pool.imap_unordered(
+                    partial(_refactor, codemods.refactor), files
+                ):
+                    errors.add(msg)
+        errors.discard(None)
+        for msg in errors:
+            print(msg, file=sys.stderr)
+        return 1 if errors else 0
+
+    @main.command()  # type: ignore  # Click adds the .command attribute
+    @click.argument("func", type=obj_name, required=True, nargs=-1)
+    @click.option(
+        "--roundtrip",
+        "writer",
+        flag_value="roundtrip",
+        help="start by testing write/read or encode/decode!",
+    )
+    @click.option(
+        "--equivalent",
+        "writer",
+        flag_value="equivalent",
+        help="very useful when optimising or refactoring code",
+    )
+    @click.option(
+        "--errors-equivalent",
+        "writer",
+        flag_value="errors-equivalent",
+        help="--equivalent, but also allows consistent errors",
+    )
+    @click.option(
+        "--idempotent",
+        "writer",
+        flag_value="idempotent",
+        help="check that f(x) == f(f(x))",
+    )
+    @click.option(
+        "--binary-op",
+        "writer",
+        flag_value="binary_operation",
+        help="associativity, commutativity, identity element",
+    )
+    # Note: we deliberately omit a --ufunc flag, because the magic()
+    # detection of ufuncs is both precise and complete.
+    @click.option(
+        "--style",
+        type=click.Choice("pytest", "unittest"),
+        default="pytest" if pytest else "unittest",
+        help="pytest-style function, or unittest-style method?",
+    )
+    @click.option(
+        "-e",
+        "--except",
+        "except_",
+        type=obj_name,
+        multiple=True,
+        help="dotted name of exception(s) to ignore",
+    )
+    @click.option(
+        "--annotate/--no-annotate",
+        default=None,
+        help="force ghostwritten tests to be type-annotated (or not).  "
+        "By default, match the code to test.",
+    )
+    def write(
+        func, writer, except_, style, annotate
+    ):  # noqa: D301  # \b disables autowrap
+        """`hypothesis write` writes property-based tests for you!
+
+        Type annotations are helpful but not required for our advanced introspection
+        and templating logic.  Try running the examples below to see how it works:
+
+        \b
+            hypothesis write gzip
+            hypothesis write numpy.matmul
+            hypothesis write pandas.from_dummies
+            hypothesis write re.compile --except re.error
+            hypothesis write --equivalent ast.literal_eval eval
+            hypothesis write --roundtrip json.dumps json.loads
+            hypothesis write --style=unittest --idempotent sorted
+            hypothesis write --binary-op operator.add
+        """
+        # NOTE: if you want to call this function from Python, look instead at the
+        # ``hypothesis.extra.ghostwriter`` module.  Click-decorated functions have
+        # a different calling convention, and raise SystemExit instead of returning.
+        kwargs = {"except_": except_ or (), "style": style, "annotate": annotate}
+        if writer is None:
+            writer = "magic"
+        elif writer == "idempotent" and len(func) > 1:
+            raise click.UsageError("Test functions for idempotence one at a time.")
+        elif writer == "roundtrip" and len(func) == 1:
+            writer = "idempotent"
+        elif "equivalent" in writer and len(func) == 1:
+            writer = "fuzz"
+        if writer == "errors-equivalent":
+            writer = "equivalent"
+            kwargs"allow_same_errors" = True
+
+        try:
+            from hypothesis.extra import ghostwriter
+        except ImportError:
+            sys.stderr.write(MESSAGE.format("black"))
+            sys.exit(1)
+
+        code = getattr(ghostwriter, writer)(*func, **kwargs)
+        try:
+            from rich.console import Console
+            from rich.syntax import Syntax
+
+            from hypothesis.utils.terminal import guess_background_color
+        except ImportError:
+            print(code)
+        else:
+            try:
+                theme = "default" if guess_background_color() == "light" else "monokai"
+                code = Syntax(code, "python", background_color="default", theme=theme)
+                Console().print(code, soft_wrap=True)
+            except Exception:
+                print("# Error while syntax-highlighting code", file=sys.stderr)
+                print(code)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/codemods.py Added

@@ -0,0 +1,254 @@
+# 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/.
+
+"""
+.. _codemods:
+
+--------------------
+hypothesiscodemods
+--------------------
+
+This module provides codemods based on the :pypi:`LibCST` library, which can
+both detect *and automatically fix* issues with code that uses Hypothesis,
+including upgrading from deprecated features to our recommended style.
+
+You can run the codemods via our CLI::
+
+    $ hypothesis codemod --help
+    Usage: hypothesis codemod OPTIONS PATH...
+
+      `hypothesis codemod` refactors deprecated or inefficient code.
+
+      It adapts `python -m libcst.tool`, removing many features and config
+      options which are rarely relevant for this purpose.  If you need more
+      control, we encourage you to use the libcst CLI directly; if not this one
+      is easier.
+
+      PATH is the file(s) or directories of files to format in place, or "-" to
+      read from stdin and write to stdout.
+
+    Options:
+      -h, --help  Show this message and exit.
+
+Alternatively you can use ``python -m libcst.tool``, which offers more control
+at the cost of additional configuration (adding ``'hypothesis.extra'`` to the
+``modules`` list in ``.libcst.codemod.yaml``) and `some issues on Windows
+<https://github.com/Instagram/LibCST/issues/435>`__.
+
+.. autofunction:: refactor
+"""
+
+import functools
+import importlib
+import os
+from contextlib import contextmanager
+from inspect import Parameter, signature
+from typing import List
+
+import libcst as cst
+import libcst.matchers as m
+from libcst.codemod import VisitorBasedCodemodCommand
+
+
+@contextmanager
+def _native_parser():
+    # Only the native parser supports Python 3.9 and later, but for now it's
+    # only active if you set an environment variable.  Very well then:
+    var = os.environ.get("LIBCST_PARSER_TYPE")
+    try:
+        os.environ"LIBCST_PARSER_TYPE" = "native"
+        yield
+    finally:
+        os.environ.pop("LIBCST_PARSER_TYPE")
+        if var is not None:  # pragma: no cover
+            os.environ"LIBCST_PARSER_TYPE" = var
+
+
+def refactor(code: str) -> str:
+    """Update a source code string from deprecated to modern Hypothesis APIs.
+
+    This may not fix *all* the deprecation warnings in your code, but we're
+    confident that it will be easier than doing it all by hand.
+
+    We recommend using the CLI, but if you want a Python function here it is.
+    """
+    context = cst.codemod.CodemodContext()
+    with _native_parser():
+        mod = cst.parse_module(code)
+    transforms: ListVisitorBasedCodemodCommand = 
+        HypothesisFixPositionalKeywonlyArgs(context),
+        HypothesisFixComplexMinMagnitude(context),
+    
+    for transform in transforms:
+        mod = transform.transform_module(mod)
+    return mod.code
+
+
+def match_qualname(name):
+    # We use the metadata to get qualname instead of matching directly on function
+    # name, because this handles some scope and "from x import y as z" issues.
+    return m.MatchMetadataIfTrue(
+        cst.metadata.QualifiedNameProvider,
+        # If there are multiple possible qualnames, e.g. due to conditional imports,
+        # be conservative.  Better to leave the user to fix a few things by hand than
+        # to break their code while attempting to refactor it!
+        lambda qualnames: all(n.name == name for n in qualnames),
+    )
+
+
+class HypothesisFixComplexMinMagnitude(VisitorBasedCodemodCommand):
+    """Fix a deprecated min_magnitude=None argument for complex numbers::
+
+        st.complex_numbers(min_magnitude=None) -> st.complex_numbers(min_magnitude=0)
+
+    Note that this should be run *after* ``HypothesisFixPositionalKeywonlyArgs``,
+    in order to handle ``st.complex_numbers(None)``.
+    """
+
+    DESCRIPTION = "Fix a deprecated min_magnitude=None argument for complex numbers."
+    METADATA_DEPENDENCIES = (cst.metadata.QualifiedNameProvider,)
+
+    @m.call_if_inside(
+        m.Call(metadata=match_qualname("hypothesis.strategies.complex_numbers"))
+    )
+    def leave_Arg(self, original_node, updated_node):
+        if m.matches(
+            updated_node, m.Arg(keyword=m.Name("min_magnitude"), value=m.Name("None"))
+        ):
+            return updated_node.with_changes(value=cst.Integer("0"))
+        return updated_node
+
+
+@functools.lru_cache()
+def get_fn(import_path):
+    mod, fn = import_path.rsplit(".", 1)
+    return getattr(importlib.import_module(mod), fn)
+
+
+class HypothesisFixPositionalKeywonlyArgs(VisitorBasedCodemodCommand):
+    """Fix positional arguments for newly keyword-only parameters, e.g.::
+
+        st.fractions(0, 1, 9) -> st.fractions(0, 1, max_denominator=9)
+
+    Applies to a majority of our public API, since keyword-only parameters are
+    great but we couldn't use them until after we dropped support for Python 2.
+    """
+
+    DESCRIPTION = "Fix positional arguments for newly keyword-only parameters."
+    METADATA_DEPENDENCIES = (cst.metadata.QualifiedNameProvider,)
+
+    kwonly_functions = (
+        "hypothesis.target",
+        "hypothesis.find",
+        "hypothesis.extra.lark.from_lark",
+        "hypothesis.extra.numpy.arrays",
+        "hypothesis.extra.numpy.array_shapes",
+        "hypothesis.extra.numpy.unsigned_integer_dtypes",
+        "hypothesis.extra.numpy.integer_dtypes",
+        "hypothesis.extra.numpy.floating_dtypes",
+        "hypothesis.extra.numpy.complex_number_dtypes",
+        "hypothesis.extra.numpy.datetime64_dtypes",
+        "hypothesis.extra.numpy.timedelta64_dtypes",
+        "hypothesis.extra.numpy.byte_string_dtypes",
+        "hypothesis.extra.numpy.unicode_string_dtypes",
+        "hypothesis.extra.numpy.array_dtypes",
+        "hypothesis.extra.numpy.nested_dtypes",
+        "hypothesis.extra.numpy.valid_tuple_axes",
+        "hypothesis.extra.numpy.broadcastable_shapes",
+        "hypothesis.extra.pandas.indexes",
+        "hypothesis.extra.pandas.series",
+        "hypothesis.extra.pandas.columns",
+        "hypothesis.extra.pandas.data_frames",
+        "hypothesis.provisional.domains",
+        "hypothesis.stateful.run_state_machine_as_test",
+        "hypothesis.stateful.rule",
+        "hypothesis.stateful.initialize",
+        "hypothesis.strategies.floats",
+        "hypothesis.strategies.lists",
+        "hypothesis.strategies.sets",
+        "hypothesis.strategies.frozensets",
+        "hypothesis.strategies.iterables",
+        "hypothesis.strategies.dictionaries",
+        "hypothesis.strategies.characters",
+        "hypothesis.strategies.text",
+        "hypothesis.strategies.from_regex",
+        "hypothesis.strategies.binary",
+        "hypothesis.strategies.fractions",
+        "hypothesis.strategies.decimals",
+        "hypothesis.strategies.recursive",
+        "hypothesis.strategies.complex_numbers",
+        "hypothesis.strategies.shared",
+        "hypothesis.strategies.uuids",
+        "hypothesis.strategies.runner",
+        "hypothesis.strategies.functions",
+        "hypothesis.strategies.datetimes",
+        "hypothesis.strategies.times",
+    )
+
+    def leave_Call(self, original_node, updated_node):
+        """Convert positional to keyword arguments."""
+        metadata = self.get_metadata(cst.metadata.QualifiedNameProvider, original_node)
+        qualnames = {qn.name for qn in metadata}
+
+        # If this isn't one of our known functions, or it has no posargs, stop there.
+        if (
+            len(qualnames) != 1
+            or not qualnames.intersection(self.kwonly_functions)
+            or not m.matches(
+                updated_node,
+                m.Call(
+                    func=m.DoesNotMatch(m.Call()),
+                    args=m.Arg(keyword=None), m.ZeroOrMore(),
+                ),
+            )
+        ):
+            return updated_node
+
+        # Get the actual function object so that we can inspect the signature.
+        # This does e.g. incur a dependency on Numpy to fix Numpy-dependent code,
+        # but having a single source of truth about the signatures is worth it.
+        try:
+            params = signature(get_fn(*qualnames)).parameters.values()
+        except ModuleNotFoundError:
+            return updated_node
+
+        # st.floats() has a new allow_subnormal kwonly argument not at the end,
+        # so we do a bit more of a dance here.
+        if qualnames == {"hypothesis.strategies.floats"}:
+            params = p for p in params if p.name != "allow_subnormal"
+
+        if len(updated_node.args) > len(params):
+            return updated_node
+
+        # Create new arg nodes with the newly required keywords
+        assign_nospace = cst.AssignEqual(
+            whitespace_before=cst.SimpleWhitespace(""),
+            whitespace_after=cst.SimpleWhitespace(""),
+        )
+        newargs = 
+            arg
+            if arg.keyword or arg.star or p.kind is not Parameter.KEYWORD_ONLY
+            else arg.with_changes(keyword=cst.Name(p.name), equal=assign_nospace)
+            for p, arg in zip(params, updated_node.args)
+        
+        return updated_node.with_changes(args=newargs)
+
+
+class HypothesisFixHealthcheckAll(VisitorBasedCodemodCommand):
+    """Replace Healthcheck.all() with list(Healthcheck)"""
+
+    DESCRIPTION = "Replace Healthcheck.all() with list(Healthcheck)"
+
+    @m.leave(m.Call(func=m.Attribute(m.Name("Healthcheck"), m.Name("all")), args=))
+    def replace_healthcheck(self, original_node, updated_node):
+        return updated_node.with_changes(
+            func=cst.Name("list"),
+            args=cst.Arg(value=cst.Name("Healthcheck")),
+        )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/dateutil.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/django Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/django/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/django/_fields.py Added

@@ -0,0 +1,345 @@
+# 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 re
+import string
+from datetime import timedelta
+from decimal import Decimal
+from functools import lru_cache
+from typing import Any, Callable, Dict, Type, TypeVar, Union
+
+import django
+from django import forms as df
+from django.contrib.auth.forms import UsernameField
+from django.core.validators import (
+    validate_ipv4_address,
+    validate_ipv6_address,
+    validate_ipv46_address,
+)
+from django.db import models as dm
+
+from hypothesis import strategies as st
+from hypothesis.errors import InvalidArgument, ResolutionFailed
+from hypothesis.internal.validation import check_type
+from hypothesis.provisional import urls
+from hypothesis.strategies import emails
+
+AnyField = Uniondm.Field, df.Field
+F = TypeVar("F", bound=AnyField)
+
+
+def numeric_bounds_from_validators(
+    field, min_value=float("-inf"), max_value=float("inf")
+):
+    for v in field.validators:
+        if isinstance(v, django.core.validators.MinValueValidator):
+            min_value = max(min_value, v.limit_value)
+        elif isinstance(v, django.core.validators.MaxValueValidator):
+            max_value = min(max_value, v.limit_value)
+    return min_value, max_value
+
+
+def integers_for_field(min_value, max_value):
+    def inner(field):
+        return st.integers(*numeric_bounds_from_validators(field, min_value, max_value))
+
+    return inner
+
+
+@lru_cache()
+def timezones():
+    # From Django 4.0, the default is to use zoneinfo instead of pytz.
+    assert getattr(django.conf.settings, "USE_TZ", False)
+    if getattr(django.conf.settings, "USE_DEPRECATED_PYTZ", True):
+        from hypothesis.extra.pytz import timezones
+    else:
+        from hypothesis.strategies import timezones
+
+    return timezones()
+
+
+# Mapping of field types, to strategy objects or functions of (type) -> strategy
+_FieldLookUpType = Dict
+    TypeAnyField,
+    Unionst.SearchStrategy, CallableAny, st.SearchStrategy,
+
+_global_field_lookup: _FieldLookUpType = {
+    dm.SmallIntegerField: integers_for_field(-32768, 32767),
+    dm.IntegerField: integers_for_field(-2147483648, 2147483647),
+    dm.BigIntegerField: integers_for_field(-9223372036854775808, 9223372036854775807),
+    dm.PositiveIntegerField: integers_for_field(0, 2147483647),
+    dm.PositiveSmallIntegerField: integers_for_field(0, 32767),
+    dm.BooleanField: st.booleans(),
+    dm.DateField: st.dates(),
+    dm.EmailField: emails(),
+    dm.FloatField: st.floats(),
+    dm.NullBooleanField: st.one_of(st.none(), st.booleans()),
+    dm.URLField: urls(),
+    dm.UUIDField: st.uuids(),
+    df.DateField: st.dates(),
+    df.DurationField: st.timedeltas(),
+    df.EmailField: emails(),
+    df.FloatField: lambda field: st.floats(
+        *numeric_bounds_from_validators(field), allow_nan=False, allow_infinity=False
+    ),
+    df.IntegerField: integers_for_field(-2147483648, 2147483647),
+    df.NullBooleanField: st.one_of(st.none(), st.booleans()),
+    df.URLField: urls(),
+    df.UUIDField: st.uuids(),
+}
+
+_ipv6_strings = st.one_of(
+    st.ip_addresses(v=6).map(str),
+    st.ip_addresses(v=6).map(lambda addr: addr.exploded),
+)
+
+
+def register_for(field_type):
+    def inner(func):
+        _global_field_lookupfield_type = func
+        return func
+
+    return inner
+
+
+@register_for(dm.DateTimeField)
+@register_for(df.DateTimeField)
+def _for_datetime(field):
+    if getattr(django.conf.settings, "USE_TZ", False):
+        return st.datetimes(timezones=timezones())
+    return st.datetimes()
+
+
+def using_sqlite():
+    try:
+        return (
+            getattr(django.conf.settings, "DATABASES", {})
+            .get("default", {})
+            .get("ENGINE", "")
+            .endswith(".sqlite3")
+        )
+    except django.core.exceptions.ImproperlyConfigured:
+        return None
+
+
+@register_for(dm.TimeField)
+def _for_model_time(field):
+    # SQLITE supports TZ-aware datetimes, but not TZ-aware times.
+    if getattr(django.conf.settings, "USE_TZ", False) and not using_sqlite():
+        return st.times(timezones=timezones())
+    return st.times()
+
+
+@register_for(df.TimeField)
+def _for_form_time(field):
+    if getattr(django.conf.settings, "USE_TZ", False):
+        return st.times(timezones=timezones())
+    return st.times()
+
+
+@register_for(dm.DurationField)
+def _for_duration(field):
+    # SQLite stores timedeltas as six bytes of microseconds
+    if using_sqlite():
+        delta = timedelta(microseconds=2**47 - 1)
+        return st.timedeltas(-delta, delta)
+    return st.timedeltas()
+
+
+@register_for(dm.SlugField)
+@register_for(df.SlugField)
+def _for_slug(field):
+    min_size = 1
+    if getattr(field, "blank", False) or not getattr(field, "required", True):
+        min_size = 0
+    return st.text(
+        alphabet=string.ascii_letters + string.digits,
+        min_size=min_size,
+        max_size=field.max_length,
+    )
+
+
+@register_for(dm.GenericIPAddressField)
+def _for_model_ip(field):
+    return {
+        "ipv4": st.ip_addresses(v=4).map(str),
+        "ipv6": _ipv6_strings,
+        "both": st.ip_addresses(v=4).map(str) | _ipv6_strings,
+    }field.protocol.lower()
+
+
+@register_for(df.GenericIPAddressField)
+def _for_form_ip(field):
+    # the IP address form fields have no direct indication of which type
+    #  of address they want, so direct comparison with the validator
+    #  function has to be used instead. Sorry for the potato logic here
+    if validate_ipv46_address in field.default_validators:
+        return st.ip_addresses(v=4).map(str) | _ipv6_strings
+    if validate_ipv4_address in field.default_validators:
+        return st.ip_addresses(v=4).map(str)
+    if validate_ipv6_address in field.default_validators:
+        return _ipv6_strings
+    raise ResolutionFailed(f"No IP version validator on field={field!r}")
+
+
+@register_for(dm.DecimalField)
+@register_for(df.DecimalField)
+def _for_decimal(field):
+    min_value, max_value = numeric_bounds_from_validators(field)
+    bound = Decimal(10**field.max_digits - 1) / (10**field.decimal_places)
+    return st.decimals(
+        min_value=max(min_value, -bound),
+        max_value=min(max_value, bound),
+        places=field.decimal_places,
+    )
+
+
+def length_bounds_from_validators(field):
+    min_size = 1
+    max_size = field.max_length
+    for v in field.validators:
+        if isinstance(v, django.core.validators.MinLengthValidator):
+            min_size = max(min_size, v.limit_value)
+        elif isinstance(v, django.core.validators.MaxLengthValidator):
+            max_size = min(max_size or v.limit_value, v.limit_value)
+    return min_size, max_size
+
+
+@register_for(dm.BinaryField)
+def _for_binary(field):
+    min_size, max_size = length_bounds_from_validators(field)
+    if getattr(field, "blank", False) or not getattr(field, "required", True):
+        return st.just(b"") | st.binary(min_size=min_size, max_size=max_size)
+    return st.binary(min_size=min_size, max_size=max_size)
+
+
+@register_for(dm.CharField)
+@register_for(dm.TextField)
+@register_for(df.CharField)
+@register_for(df.RegexField)
+@register_for(UsernameField)
+def _for_text(field):
+    # We can infer a vastly more precise strategy by considering the
+    # validators as well as the field type.  This is a minimal proof of
+    # concept, but we intend to leverage the idea much more heavily soon.
+    # See https://github.com/HypothesisWorks/hypothesis-python/issues/1116
+    regexes = 
+        re.compile(v.regex, v.flags) if isinstance(v.regex, str) else v.regex
+        for v in field.validators
+        if isinstance(v, django.core.validators.RegexValidator) and not v.inverse_match
+    
+    if regexes:
+        # This strategy generates according to one of the regexes, and
+        # filters using the others.  It can therefore learn to generate
+        # from the most restrictive and filter with permissive patterns.
+        # Not maximally efficient, but it makes pathological cases rarer.
+        # If you want a challenge: extend https://qntm.org/greenery to
+        # compute intersections of the full Python regex language.
+        return st.one_of(*(st.from_regex(r) for r in regexes))
+    # If there are no (usable) regexes, we use a standard text strategy.
+    min_size, max_size = length_bounds_from_validators(field)
+    strategy = st.text(
+        alphabet=st.characters(
+            blacklist_characters="\x00", blacklist_categories=("Cs",)
+        ),
+        min_size=min_size,
+        max_size=max_size,
+    ).filter(lambda s: min_size <= len(s.strip()))
+    if getattr(field, "blank", False) or not getattr(field, "required", True):
+        return st.just("") | strategy
+    return strategy
+
+
+@register_for(df.BooleanField)
+def _for_form_boolean(field):
+    if field.required:
+        return st.just(True)
+    return st.booleans()
+
+
+def register_field_strategy(
+    field_type: TypeAnyField, strategy: st.SearchStrategy
+) -> None:
+    """Add an entry to the global field-to-strategy lookup used by
+    :func:`~hypothesis.extra.django.from_field`.
+
+    ``field_type`` must be a subtype of :class:`django.db.models.Field` or
+    :class:`django.forms.Field`, which must not already be registered.
+    ``strategy`` must be a :class:`~hypothesis.strategies.SearchStrategy`.
+    """
+    if not issubclass(field_type, (dm.Field, df.Field)):
+        raise InvalidArgument(f"field_type={field_type!r} must be a subtype of Field")
+    check_type(st.SearchStrategy, strategy, "strategy")
+    if field_type in _global_field_lookup:
+        raise InvalidArgument(
+            f"field_type={field_type!r} already has a registered "
+            f"strategy ({_global_field_lookupfield_type!r})"
+        )
+    if issubclass(field_type, dm.AutoField):
+        raise InvalidArgument("Cannot register a strategy for an AutoField")
+    _global_field_lookupfield_type = strategy
+
+
+def from_field(field: F) -> st.SearchStrategyUnionF, None:
+    """Return a strategy for values that fit the given field.
+
+    This function is used by :func:`~hypothesis.extra.django.from_form` and
+    :func:`~hypothesis.extra.django.from_model` for any fields that require
+    a value, or for which you passed ``...`` (:obj:`python:Ellipsis`) to infer
+    a strategy from an annotation.
+
+    It's pretty similar to the core :func:`~hypothesis.strategies.from_type`
+    function, with a subtle but important difference: ``from_field`` takes a
+    Field *instance*, rather than a Field *subtype*, so that it has access to
+    instance attributes such as string length and validators.
+    """
+    check_type((dm.Field, df.Field), field, "field")
+    if getattr(field, "choices", False):
+        choices: list = 
+        for value, name_or_optgroup in field.choices:
+            if isinstance(name_or_optgroup, (list, tuple)):
+                choices.extend(key for key, _ in name_or_optgroup)
+            else:
+                choices.append(value)
+        # form fields automatically include an empty choice, strip it out
+        if "" in choices:
+            choices.remove("")
+        min_size = 1
+        if isinstance(field, (dm.CharField, dm.TextField)) and field.blank:
+            choices.insert(0, "")
+        elif isinstance(field, (df.Field)) and not field.required:
+            choices.insert(0, "")
+            min_size = 0
+        strategy = st.sampled_from(choices)
+        if isinstance(field, (df.MultipleChoiceField, df.TypedMultipleChoiceField)):
+            strategy = st.lists(st.sampled_from(choices), min_size=min_size)
+    else:
+        if type(field) not in _global_field_lookup:
+            if getattr(field, "null", False):
+                return st.none()
+            raise ResolutionFailed(f"Could not infer a strategy for {field!r}")
+        strategy = _global_field_lookuptype(field)  # type: ignore
+        if not isinstance(strategy, st.SearchStrategy):
+            strategy = strategy(field)
+    assert isinstance(strategy, st.SearchStrategy)
+    if field.validators:
+
+        def validate(value):
+            try:
+                field.run_validators(value)
+                return True
+            except django.core.exceptions.ValidationError:
+                return False
+
+        strategy = strategy.filter(validate)
+
+    if getattr(field, "null", False):
+        return st.none() | strategy
+    return strategy

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/django/_impl.py Added

@@ -0,0 +1,237 @@
+# 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 sys
+import unittest
+from functools import partial
+from inspect import Parameter, signature
+from typing import TYPE_CHECKING, Optional, Type, Union
+
+from django import forms as df, test as dt
+from django.contrib.staticfiles import testing as dst
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError, models as dm
+
+from hypothesis import reject, strategies as st
+from hypothesis.errors import InvalidArgument
+from hypothesis.extra.django._fields import from_field
+from hypothesis.internal.reflection import define_function_signature
+from hypothesis.strategies._internal.utils import defines_strategy
+
+if sys.version_info >= (3, 10):
+    from types import EllipsisType as EllipsisType
+elif TYPE_CHECKING:
+    from builtins import ellipsis as EllipsisType
+else:
+    EllipsisType = type(Ellipsis)
+
+
+class HypothesisTestCase:
+    def setup_example(self):
+        self._pre_setup()
+
+    def teardown_example(self, example):
+        self._post_teardown()
+
+    def __call__(self, result=None):
+        testMethod = getattr(self, self._testMethodName)
+        if getattr(testMethod, "is_hypothesis_test", False):
+            return unittest.TestCase.__call__(self, result)
+        else:
+            return dt.SimpleTestCase.__call__(self, result)
+
+
+class TestCase(HypothesisTestCase, dt.TestCase):
+    pass
+
+
+class TransactionTestCase(HypothesisTestCase, dt.TransactionTestCase):
+    pass
+
+
+class LiveServerTestCase(HypothesisTestCase, dt.LiveServerTestCase):
+    pass
+
+
+class StaticLiveServerTestCase(HypothesisTestCase, dst.StaticLiveServerTestCase):
+    pass
+
+
+@defines_strategy()
+def from_model(
+    *model: Typedm.Model, **field_strategies: Unionst.SearchStrategy, EllipsisType
+) -> st.SearchStrategy:
+    """Return a strategy for examples of ``model``.
+
+    .. warning::
+        Hypothesis creates saved models. This will run inside your testing
+        transaction when using the test runner, but if you use the dev console
+        this will leave debris in your database.
+
+    ``model`` must be an subclass of :class:`~django:django.db.models.Model`.
+    Strategies for fields may be passed as keyword arguments, for example
+    ``is_staff=st.just(False)``.  In order to support models with fields named
+    "model", this is a positional-only parameter.
+
+    Hypothesis can often infer a strategy based the field type and validators,
+    and will attempt to do so for any required fields.  No strategy will be
+    inferred for an :class:`~django:django.db.models.AutoField`, nullable field,
+    foreign key, or field for which a keyword
+    argument is passed to ``from_model()``.  For example,
+    a Shop type with a foreign key to Company could be generated with::
+
+        shop_strategy = from_model(Shop, company=from_model(Company))
+
+    Like for :func:`~hypothesis.strategies.builds`, you can pass
+    ``...`` (:obj:`python:Ellipsis`) as a keyword argument to infer a strategy for
+    a field which has a default value instead of using the default.
+    """
+    if len(model) == 1:
+        m_type = model0
+    elif len(model) > 1:
+        raise TypeError("Too many positional arguments")
+    else:
+        raise TypeError("Missing required positional argument `model`")
+
+    if not issubclass(m_type, dm.Model):
+        raise InvalidArgument(f"model={model!r} must be a subtype of Model")
+
+    fields_by_name = {f.name: f for f in m_type._meta.concrete_fields}
+    for name, value in sorted(field_strategies.items()):
+        if value is ...:
+            field_strategiesname = from_field(fields_by_namename)
+    for name, field in sorted(fields_by_name.items()):
+        if (
+            name not in field_strategies
+            and not field.auto_created
+            and field.default is dm.fields.NOT_PROVIDED
+        ):
+            field_strategiesname = from_field(field)
+
+    for field in field_strategies:
+        if m_type._meta.get_field(field).primary_key:
+            # The primary key is generated as part of the strategy. We
+            # want to find any existing row with this primary key and
+            # overwrite its contents.
+            kwargs = {field: field_strategies.pop(field)}
+            kwargs"defaults" = st.fixed_dictionaries(field_strategies)  # type: ignore
+            return _models_impl(st.builds(m_type.objects.update_or_create, **kwargs))
+
+    # The primary key is not generated as part of the strategy, so we
+    # just match against any row that has the same value for all
+    # fields.
+    return _models_impl(st.builds(m_type.objects.get_or_create, **field_strategies))
+
+
+if sys.version_info:2 >= (3, 8):
+    # See notes above definition of st.builds() - this signature is compatible
+    # and better matches the semantics of the function.  Great for documentation!
+    sig = signature(from_model)
+    params = list(sig.parameters.values())
+    params0 = params0.replace(kind=Parameter.POSITIONAL_ONLY)
+    from_model = define_function_signature(
+        name=from_model.__name__,
+        docstring=from_model.__doc__,
+        signature=sig.replace(parameters=params),
+    )(from_model)
+
+
+@st.composite
+def _models_impl(draw, strat):
+    """Handle the nasty part of drawing a value for models()"""
+    try:
+        return draw(strat)0
+    except IntegrityError:
+        reject()
+
+
+@defines_strategy()
+def from_form(
+    form: Typedf.Form,
+    form_kwargs: Optionaldict = None,
+    **field_strategies: Unionst.SearchStrategy, EllipsisType,
+) -> st.SearchStrategydf.Form:
+    """Return a strategy for examples of ``form``.
+
+    ``form`` must be an subclass of :class:`~django:django.forms.Form`.
+    Strategies for fields may be passed as keyword arguments, for example
+    ``is_staff=st.just(False)``.
+
+    Hypothesis can often infer a strategy based the field type and validators,
+    and will attempt to do so for any required fields.  No strategy will be
+    inferred for a disabled field or field for which a keyword argument
+    is passed to ``from_form()``.
+
+    This function uses the fields of an unbound ``form`` instance to determine
+    field strategies, any keyword arguments needed to instantiate the unbound
+    ``form`` instance can be passed into ``from_form()`` as a dict with the
+    keyword ``form_kwargs``. E.g.::
+
+        shop_strategy = from_form(Shop, form_kwargs={"company_id": 5})
+
+    Like for :func:`~hypothesis.strategies.builds`, you can pass
+    ``...`` (:obj:`python:Ellipsis`) as a keyword argument to infer a strategy for
+    a field which has a default value instead of using the default.
+    """
+    # currently unsupported:
+    # ComboField
+    # FilePathField
+    # FileField
+    # ImageField
+    form_kwargs = form_kwargs or {}
+    if not issubclass(form, df.BaseForm):
+        raise InvalidArgument(f"form={form!r} must be a subtype of Form")
+
+    # Forms are a little bit different from models. Model classes have
+    # all their fields defined, whereas forms may have different fields
+    # per-instance. So, we ought to instantiate the form and get the
+    # fields from the instance, thus we need to accept the kwargs for
+    # instantiation as well as the explicitly defined strategies
+
+    unbound_form = form(**form_kwargs)
+    fields_by_name = {}
+    for name, field in unbound_form.fields.items():
+        if isinstance(field, df.MultiValueField):
+            # PS: So this is a little strange, but MultiValueFields must
+            # have their form data encoded in a particular way for the
+            # values to actually be picked up by the widget instances'
+            # ``value_from_datadict``.
+            # E.g. if a MultiValueField named 'mv_field' has 3
+            # sub-fields then the ``value_from_datadict`` will look for
+            # 'mv_field_0', 'mv_field_1', and 'mv_field_2'. Here I'm
+            # decomposing the individual sub-fields into the names that
+            # the form validation process expects
+            for i, _field in enumerate(field.fields):
+                fields_by_namef"{name}_{i}" = _field
+        else:
+            fields_by_namename = field
+    for name, value in sorted(field_strategies.items()):
+        if value is ...:
+            field_strategiesname = from_field(fields_by_namename)
+
+    for name, field in sorted(fields_by_name.items()):
+        if name not in field_strategies and not field.disabled:
+            field_strategiesname = from_field(field)
+
+    return _forms_impl(
+        st.builds(
+            partial(form, **form_kwargs),
+            data=st.fixed_dictionaries(field_strategies),  # type: ignore
+        )
+    )
+
+
+@st.composite
+def _forms_impl(draw, strat):
+    """Handle the nasty part of drawing a value for from_form()"""
+    try:
+        return draw(strat)
+    except ValidationError:
+        reject()

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/dpcontracts.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/ghostwriter.py Added

@@ -0,0 +1,1871 @@
+# 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/.
+
+"""
+Writing tests with Hypothesis frees you from the tedium of deciding on and
+writing out specific inputs to test.  Now, the ``hypothesis.extra.ghostwriter``
+module can write your test functions for you too!
+
+The idea is to provide **an easy way to start** property-based testing,
+**and a seamless transition** to more complex test code - because ghostwritten
+tests are source code that you could have written for yourself.
+
+So just pick a function you'd like tested, and feed it to one of the functions
+below.  They follow imports, use but do not require type annotations, and
+generally do their best to write you a useful test.  You can also use
+:ref:`our command-line interface <hypothesis-cli>`::
+
+    $ hypothesis write --help
+    Usage: hypothesis write OPTIONS FUNC...
+
+      `hypothesis write` writes property-based tests for you!
+
+      Type annotations are helpful but not required for our advanced
+      introspection and templating logic.  Try running the examples below to see
+      how it works:
+
+          hypothesis write gzip
+          hypothesis write numpy.matmul
+          hypothesis write pandas.from_dummies
+          hypothesis write re.compile --except re.error
+          hypothesis write --equivalent ast.literal_eval eval
+          hypothesis write --roundtrip json.dumps json.loads
+          hypothesis write --style=unittest --idempotent sorted
+          hypothesis write --binary-op operator.add
+
+    Options:
+      --roundtrip                 start by testing write/read or encode/decode!
+      --equivalent                very useful when optimising or refactoring code
+      --errors-equivalent         --equivalent, but also allows consistent errors
+      --idempotent                check that f(x) == f(f(x))
+      --binary-op                 associativity, commutativity, identity element
+      --style pytest|unittest   pytest-style function, or unittest-style method?
+      -e, --except OBJ_NAME       dotted name of exception(s) to ignore
+      --annotate / --no-annotate  force ghostwritten tests to be type-annotated
+                                  (or not).  By default, match the code to test.
+      -h, --help                  Show this message and exit.
+
+.. tip::
+
+    Using a light theme?  Hypothesis respects `NO_COLOR <https://no-color.org/>`__
+    and ``DJANGO_COLORS=light``.
+
+.. note::
+
+    The ghostwriter requires :pypi:`black`, but the generated code only
+    requires Hypothesis itself.
+
+.. note::
+
+    Legal questions?  While the ghostwriter fragments and logic is under the
+    MPL-2.0 license like the rest of Hypothesis, the *output* from the ghostwriter
+    is made available under the `Creative Commons Zero (CC0)
+    <https://creativecommons.org/share-your-work/public-domain/cc0/>`__
+    public domain dedication, so you can use it without any restrictions.
+"""
+
+import ast
+import builtins
+import contextlib
+import enum
+import inspect
+import os
+import re
+import sys
+import types
+import warnings
+from collections import OrderedDict, defaultdict
+from itertools import permutations, zip_longest
+from keyword import iskeyword
+from string import ascii_lowercase
+from textwrap import dedent, indent
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    DefaultDict,
+    Dict,
+    ForwardRef,
+    Iterable,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import black
+
+from hypothesis import Verbosity, find, settings, strategies as st
+from hypothesis.errors import InvalidArgument, SmallSearchSpaceWarning
+from hypothesis.internal.compat import get_args, get_origin, get_type_hints
+from hypothesis.internal.reflection import get_signature, is_mock
+from hypothesis.internal.validation import check_type
+from hypothesis.provisional import domains
+from hypothesis.strategies._internal.collections import ListStrategy
+from hypothesis.strategies._internal.core import BuildsStrategy
+from hypothesis.strategies._internal.flatmapped import FlatMapStrategy
+from hypothesis.strategies._internal.lazy import LazyStrategy, unwrap_strategies
+from hypothesis.strategies._internal.strategies import (
+    FilteredStrategy,
+    MappedSearchStrategy,
+    OneOfStrategy,
+    SampledFromStrategy,
+)
+from hypothesis.strategies._internal.types import _global_type_lookup, is_generic_type
+
+if sys.version_info >= (3, 10):
+    from types import EllipsisType as EllipsisType
+elif TYPE_CHECKING:
+    from builtins import ellipsis as EllipsisType
+else:
+    EllipsisType = type(Ellipsis)
+
+
+IMPORT_SECTION = """
+# This test code was written by the `hypothesis.extra.ghostwriter` module
+# and is provided under the Creative Commons Zero public domain dedication.
+
+{imports}
+"""
+
+TEMPLATE = """
+@given({given_args})
+def test_{test_kind}_{func_name}({arg_names}){return_annotation}:
+{test_body}
+"""
+
+SUPPRESS_BLOCK = """
+try:
+{test_body}
+except {exceptions}:
+    reject()
+""".strip()
+
+Except = UnionTypeException, TupleTypeException, ...
+ImportSet = SetUnionstr, Tuplestr, str
+RE_TYPES = (type(re.compile(".")), type(re.match(".", "abc")))
+_quietly_settings = settings(
+    database=None,
+    deadline=None,
+    derandomize=True,
+    verbosity=Verbosity.quiet,
+)
+
+
+def _dedupe_exceptions(exc: TupleTypeException, ...) -> TupleTypeException, ...:
+    # This is reminiscent of de-duplication logic I wrote for flake8-bugbear,
+    # but with access to the actual objects we can just check for subclasses.
+    # This lets us print e.g. `Exception` instead of `(Exception, OSError)`.
+    uniques = list(exc)
+    for a, b in permutations(exc, 2):
+        if a in uniques and issubclass(a, b):
+            uniques.remove(a)
+    return tuple(sorted(uniques, key=lambda e: e.__name__))
+
+
+def _check_except(except_: Except) -> TupleTypeException, ...:
+    if isinstance(except_, tuple):
+        for i, e in enumerate(except_):
+            if not isinstance(e, type) or not issubclass(e, Exception):
+                raise InvalidArgument(
+                    f"Expected an Exception but got except_{i}={e!r}"
+                    f" (type={_get_qualname(type(e))})"
+                )
+        return except_
+    if not isinstance(except_, type) or not issubclass(except_, Exception):
+        raise InvalidArgument(
+            "Expected an Exception or tuple of exceptions, but got except_="
+            f"{except_!r} (type={_get_qualname(type(except_))})"
+        )
+    return (except_,)
+
+
+def _exception_string(except_: TupleTypeException, ...) -> TupleImportSet, str:
+    if not except_:
+        return set(), ""
+    exceptions = 
+    imports: ImportSet = set()
+    for ex in _dedupe_exceptions(except_):
+        if ex.__qualname__ in dir(builtins):
+            exceptions.append(ex.__qualname__)
+        else:
+            imports.add(ex.__module__)
+            exceptions.append(_get_qualname(ex, include_module=True))
+    return imports, (
+        "(" + ", ".join(exceptions) + ")" if len(exceptions) > 1 else exceptions0
+    )
+
+
+def _check_style(style: str) -> None:
+    if style not in ("pytest", "unittest"):
+        raise InvalidArgument(f"Valid styles are 'pytest' or 'unittest', got {style!r}")
+
+
+def _exceptions_from_docstring(doc: str) -> TupleTypeException, ...:
+    """Return a tuple of exceptions that the docstring says may be raised.
+
+    Note that we ignore non-builtin exception types for simplicity, as this is
+    used directly in _write_call() and passing import sets around would be really
+    really annoying.
+    """
+    # TODO: it would be great to handle Google- and Numpy-style docstrings
+    #       (e.g. by using the Napoleon Sphinx extension)
+    assert isinstance(doc, str), doc
+    raises = 
+    for excname in re.compile(r"\:raises\s+(\w+)\:", re.MULTILINE).findall(doc):
+        exc_type = getattr(builtins, excname, None)
+        if isinstance(exc_type, type) and issubclass(exc_type, Exception):
+            raises.append(exc_type)
+    return tuple(_dedupe_exceptions(tuple(raises)))
+
+
+def _type_from_doc_fragment(token: str) -> Optionaltype:
+    # Special cases for "integer" and for numpy array-like and dtype
+    if token == "integer":
+        return int
+    if "numpy" in sys.modules:
+        if re.fullmatch(r"Aarray-_ ?like", token):
+            return sys.modules"numpy".ndarray
+        elif token == "dtype":
+            return sys.modules"numpy".dtype
+    # Natural-language syntax, e.g. "sequence of integers"
+    coll_match = re.fullmatch(r"(\w+) of (\w+)", token)
+    if coll_match is not None:
+        coll_token, elem_token = coll_match.groups()
+        elems = _type_from_doc_fragment(elem_token)
+        if elems is None and elem_token.endswith("s"):
+            elems = _type_from_doc_fragment(elem_token:-1)
+        if elems is not None and coll_token in ("list", "sequence", "collection"):
+            return Listelems  # type: ignore
+        # This might be e.g. "array-like of float"; arrays is better than nothing
+        # even if we can't conveniently pass a generic type around.
+        return _type_from_doc_fragment(coll_token)
+    # Check either builtins, or the module for a dotted name
+    if "." not in token:
+        return getattr(builtins, token, None)
+    mod, name = token.rsplit(".", maxsplit=1)
+    return getattr(sys.modules.get(mod, None), name, None)
+
+
+def _strip_typevars(type_):
+    with contextlib.suppress(Exception):
+        if {type(a) for a in get_args(type_)} == {TypeVar}:
+            return get_origin(type_)
+    return type_
+
+
+def _strategy_for(param: inspect.Parameter, docstring: str) -> st.SearchStrategy:
+    # Example types in docstrings:
+    # - `:type a: sequence of integers`
+    # - `b (list, tuple, or None): ...`
+    # - `c : {"foo", "bar", or None}`
+    for pattern in (
+        rf"^\s*\:type\s+{param.name}\:\s+(.+)",  # RST-style
+        rf"^\s*{param.name} $(.+)$:",  # Google-style
+        rf"^\s*{param.name} \: (.+)",  # Numpy-style
+    ):
+        match = re.search(pattern, docstring, flags=re.MULTILINE)
+        if match is None:
+            continue
+        doc_type = match.group(1)
+        if doc_type.endswith(", optional"):
+            # Convention to describe "argument may be omitted"
+            doc_type = doc_type: -len(", optional")
+        doc_type = doc_type.strip("}{")
+        elements = 
+        types = 
+        for token in re.split(r",? +or +| *, *", doc_type):
+            for prefix in ("default ", "python "):
+                # `str or None, default "auto"`; `python int or numpy.int64`
+                if token.startswith(prefix):
+                    token = tokenlen(prefix) :
+            if not token:
+                continue
+            try:
+                # Elements of `{"inner", "outer"}` etc.
+                elements.append(ast.literal_eval(token))
+                continue
+            except (ValueError, SyntaxError):
+                t = _type_from_doc_fragment(token)
+                if isinstance(t, type) or is_generic_type(t):
+                    assert t is not None
+                    types.append(_strip_typevars(t))
+        if (
+            param.default is not inspect.Parameter.empty
+            and param.default not in elements
+            and not isinstance(
+                param.default, tuple(t for t in types if isinstance(t, type))
+            )
+        ):
+            with contextlib.suppress(SyntaxError):
+                compile(repr(st.just(param.default)), "<string>", "eval")
+                elements.insert(0, param.default)
+        if elements or types:
+            return (st.sampled_from(elements) if elements else st.nothing()) | (
+                st.one_of(*map(st.from_type, types)) if types else st.nothing()
+            )
+
+    # If our default value is an Enum or a boolean, we assume that any value
+    # of that type is acceptable.  Otherwise, we only generate the default.
+    if isinstance(param.default, bool):
+        return st.booleans()
+    if isinstance(param.default, enum.Enum):
+        return st.sampled_from(type(param.default))
+    if param.default is not inspect.Parameter.empty:
+        # Using `st.from_type(type(param.default))` would  introduce spurious
+        # failures in cases like the `flags` argument to regex functions.
+        # Better in to keep it simple, and let the user elaborate if desired.
+        return st.just(param.default)
+    return _guess_strategy_by_argname(name=param.name.lower())
+
+
+# fmt: off
+BOOL_NAMES = (
+    "keepdims", "verbose", "debug", "force", "train", "training", "trainable", "bias",
+    "shuffle", "show", "load", "pretrained", "save", "overwrite", "normalize",
+    "reverse", "success", "enabled", "strict", "copy", "quiet", "required", "inplace",
+    "recursive", "enable", "active", "create", "validate", "refresh", "use_bias",
+)
+POSITIVE_INTEGER_NAMES = (
+    "width", "size", "length", "limit", "idx", "stride", "epoch", "epochs", "depth",
+    "pid", "steps", "iteration", "iterations", "vocab_size", "ttl", "count",
+)
+FLOAT_NAMES = (
+    "real", "imag", "alpha", "theta", "beta", "sigma", "gamma", "angle", "reward",
+    "tau", "temperature",
+)
+STRING_NAMES = (
+    "text", "txt", "password", "label", "prefix", "suffix", "desc", "description",
+    "str", "pattern", "subject", "reason", "comment", "prompt", "sentence", "sep",
+)
+# fmt: on
+
+
+def _guess_strategy_by_argname(name: str) -> st.SearchStrategy:
+    """
+    If all else fails, we try guessing a strategy based on common argument names.
+
+    We wouldn't do this in builds() where strict correctness is required, but for
+    the ghostwriter we accept "good guesses" since the user would otherwise have
+    to change the strategy anyway - from `nothing()` - if we refused to guess.
+
+    A "good guess" is _usually correct_, and _a reasonable mistake_ if not.
+    The logic below is therefore based on a manual reading of the builtins and
+    some standard-library docs, plus the analysis of about three hundred million
+    arguments in https://github.com/HypothesisWorks/hypothesis/issues/3311
+    """
+    # Special-cased names
+    if name in ("function", "func", "f"):
+        return st.functions()
+    if name in ("pred", "predicate"):
+        return st.functions(returns=st.booleans(), pure=True)
+    if name in ("iterable",):
+        return st.iterables(st.integers()) | st.iterables(st.text())
+    if name in ("list", "lst", "ls"):
+        return st.lists(st.nothing())
+    if name in ("object",):
+        return st.builds(object)
+    if "uuid" in name:
+        return st.uuids().map(str)
+
+    # Names which imply the value is a boolean
+    if name.startswith("is_") or name in BOOL_NAMES:
+        return st.booleans()
+
+    # Names which imply that the value is a number, perhaps in a particular range
+    if name in ("amount", "threshold", "number", "num"):
+        return st.integers() | st.floats()
+
+    if name in ("port",):
+        return st.integers(0, 2**16 - 1)
+    if (
+        name.endswith("_size")
+        or (name.endswith("size") and "_" not in name)
+        or re.fullmatch(r"n(um)?_a-z_*s", name)
+        or name in POSITIVE_INTEGER_NAMES
+    ):
+        return st.integers(min_value=0)
+    if name in ("offset", "seed", "dim", "total", "priority"):
+        return st.integers()
+
+    if name in ("learning_rate", "dropout", "dropout_rate", "epsilon", "eps", "prob"):
+        return st.floats(0, 1)
+    if name in ("lat", "latitude"):
+        return st.floats(-90, 90)
+    if name in ("lon", "longitude"):
+        return st.floats(-180, 180)
+    if name in ("radius", "tol", "tolerance", "rate"):
+        return st.floats(min_value=0)
+    if name in FLOAT_NAMES:
+        return st.floats()
+
+    # Names which imply that the value is a string
+    if name in ("host", "hostname"):
+        return domains()
+    if name in ("email",):
+        return st.emails()
+    if name in ("word", "slug", "api_key"):
+        return st.from_regex(r"\w+", fullmatch=True)
+    if name in ("char", "character"):
+        return st.characters()
+
+    if (
+        "file" in name
+        or "path" in name
+        or name.endswith("_dir")
+        or name in ("fname", "dir", "dirname", "directory", "folder")
+    ):
+        # Common names for filesystem paths: these are usually strings, but we
+        # don't want to make strings more convenient than pathlib.Path.
+        return st.nothing()
+
+    if (
+        name.endswith("_name")
+        or (name.endswith("name") and "_" not in name)
+        or ("string" in name and "as" not in name)
+        or name.endswith("label")
+        or name in STRING_NAMES
+    ):
+        return st.text()
+
+    # Last clever idea: maybe we're looking a plural, and know the singular:
+    if re.fullmatch(r"\w*^ss", name):
+        elems = _guess_strategy_by_argname(name:-1)
+        if not elems.is_empty:
+            return st.lists(elems)
+
+    # And if all that failed, we'll return nothing() - the user will have to
+    # fill this in by hand, and we'll leave a comment to that effect later.
+    return st.nothing()
+
+
+def _get_params(func: Callable) -> Dictstr, inspect.Parameter:
+    """Get non-vararg parameters of `func` as an ordered dict."""
+    try:
+        params = list(get_signature(func).parameters.values())
+    except Exception:
+        if (
+            isinstance(func, (types.BuiltinFunctionType, types.BuiltinMethodType))
+            and hasattr(func, "__doc__")
+            and isinstance(func.__doc__, str)
+        ):
+            # inspect.signature doesn't work on all builtin functions or methods.
+            # In such cases, we can try to reconstruct simple signatures from the docstring.
+            match = re.match(rf"^{func.__name__}$(.+?)$", func.__doc__)
+            if match is None:
+                raise
+            args = match.group(1).replace("", "").replace("", "")
+            params = 
+            # Even if the signature doesn't contain a /, we assume that arguments
+            # are positional-only until shown otherwise - the / is often omitted.
+            kind: inspect._ParameterKind = inspect.Parameter.POSITIONAL_ONLY
+            for arg in args.split(", "):
+                arg, *_ = arg.partition("=")
+                arg = arg.strip()
+                if arg == "/":
+                    kind = inspect.Parameter.POSITIONAL_OR_KEYWORD
+                    continue
+                if arg.startswith("*") or arg == "...":
+                    kind = inspect.Parameter.KEYWORD_ONLY
+                    continue  # we omit *varargs, if there are any
+                if iskeyword(arg.lstrip("*")) or not arg.lstrip("*").isidentifier():
+                    print(repr(args))
+                    break  # skip all subsequent params if this name is invalid
+                params.append(inspect.Parameter(name=arg, kind=kind))
+
+        elif _is_probably_ufunc(func):
+            # `inspect.signature` doesn't work on ufunc objects, but we can work out
+            # what the required parameters would look like if it did.
+            # Note that we use args named a, b, c... to match the `operator` module,
+            # rather than x1, x2, x3... like the Numpy docs.  Because they're pos-only
+            # this doesn't make a runtime difference, and it's much nicer for use-cases
+            # like `equivalent(numpy.add, operator.add)`.
+            params = 
+                inspect.Parameter(name=name, kind=inspect.Parameter.POSITIONAL_ONLY)
+                for name in ascii_lowercase: func.nin  # type: ignore
+            
+        else:
+            # If we haven't managed to recover a signature through the tricks above,
+            # we're out of ideas and should just re-raise the exception.
+            raise
+    return _params_to_dict(params)
+
+
+def _params_to_dict(
+    params: Iterableinspect.Parameter,
+) -> Dictstr, inspect.Parameter:
+    var_param_kinds = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+    return OrderedDict((p.name, p) for p in params if p.kind not in var_param_kinds)
+
+
+@contextlib.contextmanager
+def _with_any_registered():
+    # If the user has registered their own strategy for Any, leave it alone
+    if Any in _global_type_lookup:
+        yield
+    # We usually want to force from_type(Any) to raise an error because we don't
+    # have enough information to accurately resolve user intent, but in this case
+    # we can treat it as a synonym for object - this is probably wrong, but you'll
+    # get at least _some_ output to edit later.  We then reset everything in order
+    # to avoid polluting the resolution logic in case you run tests later.
+    else:
+        try:
+            _global_type_lookupAny = st.builds(object)
+            yield
+        finally:
+            del _global_type_lookupAny
+            st.from_type.__clear_cache()
+
+
+def _get_strategies(
+    *funcs: Callable, pass_result_to_next_func: bool = False
+) -> Dictstr, st.SearchStrategy:
+    """Return a dict of strategies for the union of arguments to `funcs`.
+
+    If `pass_result_to_next_func` is True, assume that the result of each function
+    is passed to the next, and therefore skip the first argument of all but the
+    first function.
+
+    This dict is used to construct our call to the `@given(...)` decorator.
+    """
+    assert funcs, "Must pass at least one function"
+    given_strategies: Dictstr, st.SearchStrategy = {}
+    for i, f in enumerate(funcs):
+        params = _get_params(f)
+        if pass_result_to_next_func and i >= 1:
+            del paramsnext(iter(params))
+        hints = get_type_hints(f)
+        docstring = getattr(f, "__doc__", None) or ""
+        builder_args = {
+            k: ... if k in hints else _strategy_for(v, docstring)
+            for k, v in params.items()
+        }
+        with _with_any_registered():
+            strat = st.builds(f, **builder_args).wrapped_strategy  # type: ignore
+
+        if strat.args:
+            raise NotImplementedError("Expected to pass everything as kwargs")
+
+        for k, v in strat.kwargs.items():
+            if _valid_syntax_repr(v)1 == "nothing()" and k in hints:
+                # e.g. from_type(Hashable) is OK but the unwrapped repr is not
+                v = LazyStrategy(st.from_type, (hintsk,), {})
+            if k in given_strategies:
+                given_strategiesk |= v
+            else:
+                given_strategiesk = v
+
+    # If there is only one function, we pass arguments to @given in the order of
+    # that function's signature.  Otherwise, we use alphabetical order.
+    if len(funcs) == 1:
+        return {name: given_strategiesname for name in _get_params(f)}
+    return dict(sorted(given_strategies.items()))
+
+
+def _assert_eq(style: str, a: str, b: str) -> str:
+    if style == "unittest":
+        return f"self.assertEqual({a}, {b})"
+    assert style == "pytest"
+    if a.isidentifier() and b.isidentifier():
+        return f"assert {a} == {b}, ({a}, {b})"
+    return f"assert {a} == {b}"
+
+
+def _imports_for_object(obj):
+    """Return the imports for `obj`, which may be empty for e.g. lambdas"""
+    if isinstance(obj, RE_TYPES):
+        return {"re"}
+    try:
+        if is_generic_type(obj):
+            if isinstance(obj, TypeVar):
+                return {(obj.__module__, obj.__name__)}
+            with contextlib.suppress(Exception):
+                return set().union(*map(_imports_for_object, obj.__args__))
+        if (not callable(obj)) or obj.__name__ == "<lambda>":
+            return set()
+        name = _get_qualname(obj).split(".")0
+        return {(_get_module(obj), name)}
+    except Exception:
+        return set()
+
+
+def _imports_for_strategy(strategy):
+    # If we have a lazy from_type strategy, because unwrapping it gives us an
+    # error or invalid syntax, import that type and we're done.
+    if isinstance(strategy, LazyStrategy):
+        if strategy.function.__name__ in (
+            st.from_type.__name__,
+            st.from_regex.__name__,
+        ):
+            return {
+                imp
+                for arg in set(strategy._LazyStrategy__args)
+                | set(strategy._LazyStrategy__kwargs.values())
+                for imp in _imports_for_object(arg)
+            }
+        elif _get_module(strategy.function).startswith("hypothesis.extra."):
+            module = _get_module(strategy.function).replace("._array_helpers", ".numpy")
+            return {(module, strategy.function.__name__)}
+
+    imports = set()
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", SmallSearchSpaceWarning)
+        strategy = unwrap_strategies(strategy)
+
+    # Get imports for s.map(f), s.filter(f), s.flatmap(f), including both s and f
+    if isinstance(strategy, MappedSearchStrategy):
+        imports |= _imports_for_strategy(strategy.mapped_strategy)
+        imports |= _imports_for_object(strategy.pack)
+    if isinstance(strategy, FilteredStrategy):
+        imports |= _imports_for_strategy(strategy.filtered_strategy)
+        for f in strategy.flat_conditions:
+            imports |= _imports_for_object(f)
+    if isinstance(strategy, FlatMapStrategy):
+        imports |= _imports_for_strategy(strategy.flatmapped_strategy)
+        imports |= _imports_for_object(strategy.expand)
+
+    # recurse through one_of to handle e.g. from_type(OptionalFoo)
+    if isinstance(strategy, OneOfStrategy):
+        for s in strategy.element_strategies:
+            imports |= _imports_for_strategy(s)
+
+    # get imports for the target of builds(), and recurse into the argument strategies
+    if isinstance(strategy, BuildsStrategy):
+        imports |= _imports_for_object(strategy.target)
+        for s in strategy.args:
+            imports |= _imports_for_strategy(s)
+        for s in strategy.kwargs.values():
+            imports |= _imports_for_strategy(s)
+
+    if isinstance(strategy, SampledFromStrategy):
+        for obj in strategy.elements:
+            imports |= _imports_for_object(obj)
+
+    if isinstance(strategy, ListStrategy):
+        imports |= _imports_for_strategy(strategy.element_strategy)
+
+    return imports
+
+
+def _valid_syntax_repr(strategy):
+    # For binary_op, we pass a variable name - so pass it right back again.
+    if isinstance(strategy, str):
+        return set(), strategy
+    # Flatten and de-duplicate any one_of strategies, whether that's from resolving
+    # a Union type or combining inputs to multiple functions.
+    try:
+        if isinstance(strategy, OneOfStrategy):
+            seen = set()
+            elems = 
+            for s in strategy.element_strategies:
+                if isinstance(s, SampledFromStrategy) and s.elements == (os.environ,):
+                    continue
+                if repr(s) not in seen:
+                    elems.append(s)
+                    seen.add(repr(s))
+            strategy = st.one_of(elems or st.nothing())
+        # Trivial special case because the wrapped repr for text() is terrible.
+        if strategy == st.text().wrapped_strategy:
+            return set(), "text()"
+        # Remove any typevars; we don't exploit them so they're just clutter here
+        if (
+            isinstance(strategy, LazyStrategy)
+            and strategy.function.__name__ == st.from_type.__name__
+            and strategy._LazyStrategy__representation is None
+        ):
+            strategy._LazyStrategy__args = tuple(
+                _strip_typevars(a) for a in strategy._LazyStrategy__args
+            )
+        # Return a syntactically-valid strategy repr, including fixing some
+        # strategy reprs and replacing invalid syntax reprs with `"nothing()"`.
+        # String-replace to hide the special case in from_type() for Decimal('snan')
+        r = repr(strategy).replace(".filter(_can_hash)", "")
+        # Replace <unknown> with ... in confusing lambdas
+        r = re.sub(r"(lambda.*?: )(<unknown>)(,))", r"\1...\3", r)
+        compile(r, "<string>", "eval")
+        # Finally, try to work out the imports we need for builds(), .map(),
+        # .filter(), and .flatmap() to work without NameError
+        imports = {i for i in _imports_for_strategy(strategy) if i1 in r}
+        return imports, r
+    except (SyntaxError, RecursionError, InvalidArgument):
+        return set(), "nothing()"
+
+
+# When we ghostwrite for a module, we want to treat that as the __module__ for
+# each function, rather than whichever internal file it was actually defined in.
+KNOWN_FUNCTION_LOCATIONS: Dictobject, str = {}
+
+
+def _get_module_helper(obj):
+    # Get the __module__ attribute of the object, and return the first ancestor module
+    # which contains the object; falling back to the literal __module__ if none do.
+    # The goal is to show location from which obj should usually be accessed, rather
+    # than what we assume is an internal submodule which defined it.
+    module_name = obj.__module__
+
+    # if "collections.abc" is used don't use the deprecated aliases in "collections"
+    if module_name == "collections.abc":
+        return module_name
+
+    dots = i for i, c in enumerate(module_name) if c == "." + None
+    for idx in dots:
+        if getattr(sys.modules.get(module_name:idx), obj.__name__, None) is obj:
+            KNOWN_FUNCTION_LOCATIONSobj = module_name:idx
+            return module_name:idx
+    return module_name
+
+
+def _get_module(obj):
+    if obj in KNOWN_FUNCTION_LOCATIONS:
+        return KNOWN_FUNCTION_LOCATIONSobj
+    try:
+        return _get_module_helper(obj)
+    except AttributeError:
+        if not _is_probably_ufunc(obj):
+            raise
+    for module_name in sorted(sys.modules, key=lambda n: tuple(n.split("."))):
+        if obj is getattr(sys.modulesmodule_name, obj.__name__, None):
+            KNOWN_FUNCTION_LOCATIONSobj = module_name
+            return module_name
+    raise RuntimeError(f"Could not find module for ufunc {obj.__name__} ({obj!r}")
+
+
+def _get_qualname(obj, include_module=False):
+    # Replacing angle-brackets for objects defined in `.<locals>.`
+    qname = getattr(obj, "__qualname__", obj.__name__)
+    qname = qname.replace("<", "_").replace(">", "_").replace(" ", "")
+    if include_module:
+        return _get_module(obj) + "." + qname
+    return qname
+
+
+def _write_call(
+    func: Callable, *pass_variables: str, except_: Except, assign: str = ""
+) -> str:
+    """Write a call to `func` with explicit and implicit arguments.
+
+    >>> _write_call(sorted, "my_seq", "func")
+    "builtins.sorted(my_seq, key=func, reverse=reverse)"
+
+    >>> write_call(f, assign="var1")
+    "var1 = f()"
+
+    The fancy part is that we'll check the docstring for any known exceptions
+    which `func` might raise, and catch-and-reject on them... *unless* they're
+    subtypes of `except_`, which will be handled in an outer try-except block.
+    """
+    args = ", ".join(
+        (v or p.name)
+        if p.kind is inspect.Parameter.POSITIONAL_ONLY
+        else f"{p.name}={v or p.name}"
+        for v, p in zip_longest(pass_variables, _get_params(func).values())
+    )
+    call = f"{_get_qualname(func, include_module=True)}({args})"
+    if assign:
+        call = f"{assign} = {call}"
+    raises = _exceptions_from_docstring(getattr(func, "__doc__", "") or "")
+    exnames = ex.__name__ for ex in raises if not issubclass(ex, except_)
+    if not exnames:
+        return call
+    return SUPPRESS_BLOCK.format(
+        test_body=indent(call, prefix="    "),
+        exceptions="(" + ", ".join(exnames) + ")" if len(exnames) > 1 else exnames0,
+    )
+
+
+def _st_strategy_names(s: str) -> str:
+    """Replace strategy name() with st.name().
+
+    Uses a tricky re.sub() to avoid problems with frozensets() matching
+    sets() too.
+    """
+    names = "|".join(sorted(st.__all__, key=len, reverse=True))
+    return re.sub(pattern=rf"\b(?:{names})\b^= ", repl=r"st.\g<0>", string=s)
+
+
+def _make_test_body(
+    *funcs: Callable,
+    ghost: str,
+    test_body: str,
+    except_: TupleTypeException, ...,
+    assertions: str = "",
+    style: str,
+    given_strategies: OptionalMappingstr, Unionstr, st.SearchStrategy = None,
+    imports: OptionalImportSet = None,
+    annotate: bool,
+) -> TupleImportSet, str:
+    # A set of modules to import - we might add to this later.  The import code
+    # is written later, so we can have one import section for multiple magic()
+    # test functions.
+    imports = (imports or set()) | {_get_module(f) for f in funcs}
+
+    # Get strategies for all the arguments to each function we're testing.
+    with _with_any_registered():
+        given_strategies = given_strategies or _get_strategies(
+            *funcs, pass_result_to_next_func=ghost in ("idempotent", "roundtrip")
+        )
+        reprs = ((k,) + _valid_syntax_repr(v)) for k, v in given_strategies.items()
+        imports = imports.union(*(imp for _, imp, _ in reprs))
+        given_args = ", ".join(f"{k}={v}" for k, _, v in reprs)
+    given_args = _st_strategy_names(given_args)
+
+    if except_:
+        # Convert to strings, either builtin names or qualified names.
+        imp, exc_string = _exception_string(except_)
+        imports.update(imp)
+        # And finally indent the existing test body into a try-except block
+        # which catches these exceptions and calls `hypothesis.reject()`.
+        test_body = SUPPRESS_BLOCK.format(
+            test_body=indent(test_body, prefix="    "),
+            exceptions=exc_string,
+        )
+
+    if assertions:
+        test_body = f"{test_body}\n{assertions}"
+
+    # Indent our test code to form the body of a function or method.
+    argnames = "self" if style == "unittest" else 
+    if annotate:
+        argnames.extend(_annotate_args(given_strategies, funcs, imports))
+    else:
+        argnames.extend(given_strategies)
+
+    body = TEMPLATE.format(
+        given_args=given_args,
+        test_kind=ghost,
+        func_name="_".join(_get_qualname(f).replace(".", "_") for f in funcs),
+        arg_names=", ".join(argnames),
+        return_annotation=" -> None" if annotate else "",
+        test_body=indent(test_body, prefix="    "),
+    )
+
+    # For unittest-style, indent method further into a class body
+    if style == "unittest":
+        imports.add("unittest")
+        body = "class Test{}{}(unittest.TestCase):\n{}".format(
+            ghost.title(),
+            "".join(_get_qualname(f).replace(".", "").title() for f in funcs),
+            indent(body, "    "),
+        )
+
+    return imports, body
+
+
+def _annotate_args(
+    argnames: Iterablestr, funcs: IterableCallable, imports: ImportSet
+) -> Iterablestr:
+    arg_parameters: DefaultDictstr, SetAny = defaultdict(set)
+    for func in funcs:
+        try:
+            params = tuple(get_signature(func, eval_str=True).parameters.values())
+        except Exception:
+            # don't add parameters if the annotations could not be evaluated
+            pass
+        else:
+            for key, param in _params_to_dict(params).items():
+                if param.annotation != inspect.Parameter.empty:
+                    arg_parameterskey.add(param.annotation)
+
+    for argname in argnames:
+        parameters = arg_parameters.get(argname)
+        annotation = _parameters_to_annotation_name(parameters, imports)
+        if annotation is None:
+            yield argname
+        else:
+            yield f"{argname}: {annotation}"
+
+
+class _AnnotationData(NamedTuple):
+    type_name: str
+    imports: Setstr
+
+
+def _parameters_to_annotation_name(
+    parameters: OptionalIterableAny, imports: ImportSet
+) -> Optionalstr:
+    if parameters is None:
+        return None
+    annotations = tuple(
+        annotation
+        for annotation in map(_parameter_to_annotation, parameters)
+        if annotation is not None
+    )
+    if not annotations:
+        return None
+    if len(annotations) == 1:
+        type_name, new_imports = annotations0
+        imports.update(new_imports)
+        return type_name
+    joined = _join_generics(("typing.Union", {"typing"}), annotations)
+    if joined is None:
+        return None
+    imports.update(joined.imports)
+    return joined.type_name
+
+
+def _join_generics(
+    origin_type_data: OptionalTuplestr, Setstr,
+    annotations: IterableOptional_AnnotationData,
+) -> Optional_AnnotationData:
+    if origin_type_data is None:
+        return None
+
+    # because typing.Optional is converted to a Union, it also contains None
+    # since typing.Optional only accepts one type variable, we need to remove it
+    if origin_type_data is not None and origin_type_data0 == "typing.Optional":
+        annotations = (
+            annotation
+            for annotation in annotations
+            if annotation is None or annotation.type_name != "None"
+        )
+
+    origin_type, imports = origin_type_data
+    joined = _join_argument_annotations(annotations)
+    if joined is None or not joined0:
+        return None
+
+    arg_types, new_imports = joined
+    imports.update(new_imports)
+    return _AnnotationData("{}{}".format(origin_type, ", ".join(arg_types)), imports)
+
+
+def _join_argument_annotations(
+    annotations: IterableOptional_AnnotationData,
+) -> OptionalTupleListstr, Setstr:
+    imports: Setstr = set()
+    arg_types: Liststr = 
+
+    for annotation in annotations:
+        if annotation is None:
+            return None
+        arg_types.append(annotation.type_name)
+        imports.update(annotation.imports)
+
+    return arg_types, imports
+
+
+def _parameter_to_annotation(parameter: Any) -> Optional_AnnotationData:
+    # if a ForwardRef could not be resolved
+    if isinstance(parameter, str):
+        return None
+
+    if isinstance(parameter, ForwardRef):
+        forwarded_value = parameter.__forward_value__
+        if forwarded_value is None:
+            return None
+        return _parameter_to_annotation(forwarded_value)
+
+    # the arguments of Callable are in a list
+    if isinstance(parameter, list):
+        joined = _join_argument_annotations(
+            _parameter_to_annotation(param) for param in parameter
+        )
+        if joined is None:
+            return None
+        arg_type_names, new_imports = joined
+        return _AnnotationData("{}".format(", ".join(arg_type_names)), new_imports)
+
+    if isinstance(parameter, type):
+        if parameter.__module__ == "builtins":
+            return _AnnotationData(
+                "None" if parameter.__name__ == "NoneType" else parameter.__name__,
+                set(),
+            )
+
+        type_name = _get_qualname(parameter, include_module=True)
+
+        # the types.UnionType does not support type arguments and needs to be translated
+        if type_name == "types.UnionType":
+            return _AnnotationData("typing.Union", {"typing"})
+    else:
+        if hasattr(parameter, "__module__") and hasattr(parameter, "__name__"):
+            type_name = _get_qualname(parameter, include_module=True)
+        else:
+            type_name = str(parameter)
+
+    origin_type = get_origin(parameter)
+
+    # if not generic or no generic arguments
+    if origin_type is None or origin_type == parameter:
+        return _AnnotationData(type_name, set(type_name.rsplit(".", maxsplit=1):-1))
+
+    arg_types = get_args(parameter)
+    if {type(a) for a in arg_types} == {TypeVar}:
+        arg_types = ()
+
+    # typing types get translated to classes that don't support generics
+    origin_annotation: Optional_AnnotationData
+    if type_name.startswith("typing."):
+        try:
+            new_type_name = type_name: type_name.index("")
+        except ValueError:
+            new_type_name = type_name
+        origin_annotation = _AnnotationData(new_type_name, {"typing"})
+    else:
+        origin_annotation = _parameter_to_annotation(origin_type)
+
+    if arg_types:
+        return _join_generics(
+            origin_annotation,
+            (_parameter_to_annotation(arg_type) for arg_type in arg_types),
+        )
+    return origin_annotation
+
+
+def _are_annotations_used(*functions: Callable) -> bool:
+    for function in functions:
+        try:
+            params = get_signature(function).parameters.values()
+        except Exception:
+            pass
+        else:
+            if any(param.annotation != inspect.Parameter.empty for param in params):
+                return True
+    return False
+
+
+def _make_test(imports: ImportSet, body: str) -> str:
+    # Discarding "builtins." and "__main__" probably isn't particularly useful
+    # for user code, but important for making a good impression in demos.
+    body = body.replace("builtins.", "").replace("__main__.", "")
+    body = body.replace("hypothesis.strategies.", "st.")
+    if "st.from_type(typing." in body:
+        imports.add("typing")
+    imports |= {("hypothesis", "given"), ("hypothesis", "strategies as st")}
+    if "        reject()\n" in body:
+        imports.add(("hypothesis", "reject"))
+
+    do_not_import = {"builtins", "__main__", "hypothesis.strategies"}
+    direct = {f"import {i}" for i in imports - do_not_import if isinstance(i, str)}
+    from_imports = defaultdict(set)
+    for module, name in {i for i in imports if isinstance(i, tuple)}:
+        if not (module.startswith("hypothesis.strategies") and name in st.__all__):
+            from_importsmodule.add(name)
+    from_ = {
+        "from {} import {}".format(module, ", ".join(sorted(names)))
+        for module, names in from_imports.items()
+        if isinstance(module, str) and module not in do_not_import
+    }
+    header = IMPORT_SECTION.format(imports="\n".join(sorted(direct) + sorted(from_)))
+    nothings = body.count("st.nothing()")
+    if nothings == 1:
+        header += "# TODO: replace st.nothing() with an appropriate strategy\n\n"
+    elif nothings >= 1:
+        header += "# TODO: replace st.nothing() with appropriate strategies\n\n"
+    return black.format_str(header + body, mode=black.FileMode())
+
+
+def _is_probably_ufunc(obj):
+    # See https://numpy.org/doc/stable/reference/ufuncs.html - there doesn't seem
+    # to be an upstream function to detect this, so we just guess.
+    has_attributes = "nin nout nargs ntypes types identity signature".split()
+    return callable(obj) and all(hasattr(obj, name) for name in has_attributes)
+
+
+# If we have a pair of functions where one name matches the regex and the second
+# is the result of formatting the template with matched groups, our magic()
+# ghostwriter will write a roundtrip test for them.  Additional patterns welcome.
+ROUNDTRIP_PAIRS = (
+    # Defined prefix, shared postfix.  The easy cases.
+    (r"write(.+)", "read{}"),
+    (r"save(.+)", "load{}"),
+    (r"dump(.+)", "load{}"),
+    (r"to(.+)", "from{}"),
+    # Known stem, maybe matching prefixes, maybe matching postfixes.
+    (r"(.*)en(.+)", "{}de{}"),
+    # Shared postfix, prefix only on "inverse" function
+    (r"(.+)", "de{}"),
+    (r"(?!safe)(.+)", "un{}"),  # safe_load / unsafe_load isn't a roundtrip
+    # a2b_postfix and b2a_postfix.  Not a fan of this pattern, but it's pretty
+    # common in code imitating an C API - see e.g. the stdlib binascii module.
+    (r"(.+)2(.+?)(_.+)?", "{1}2{0}{2}"),
+    # Common in e.g. the colorsys module
+    (r"(.+)_to_(.+)", "{1}_to_{0}"),
+    # Sockets patterns
+    (r"(inet|if)_(.+)to(.+)", "{0}_{2}to{1}"),
+    (r"(\w)to(\w)(.+)", "{1}to{0}{2}"),
+    (r"send(.+)", "recv{}"),
+    (r"send(.+)", "receive{}"),
+)
+
+
+def magic(
+    *modules_or_functions: UnionCallable, types.ModuleType,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Guess which ghostwriters to use, for a module or collection of functions.
+
+    As for all ghostwriters, the ``except_`` argument should be an
+    :class:`python:Exception` or tuple of exceptions, and ``style`` may be either
+    ``"pytest"`` to write test functions or ``"unittest"`` to write test methods
+    and :class:`~python:unittest.TestCase`.
+
+    After finding the public functions attached to any modules, the ``magic``
+    ghostwriter looks for pairs of functions to pass to :func:`~roundtrip`,
+    then checks for :func:`~binary_operation` and :func:`~ufunc` functions,
+    and any others are passed to :func:`~fuzz`.
+
+    For example, try :command:`hypothesis write gzip` on the command line!
+    """
+    except_ = _check_except(except_)
+    _check_style(style)
+    if not modules_or_functions:
+        raise InvalidArgument("Must pass at least one function or module to test.")
+    functions = set()
+    for thing in modules_or_functions:
+        if callable(thing):
+            functions.add(thing)
+            # class need to be added for exploration
+            if inspect.isclass(thing):
+                funcs: ListOptionalAny = thing
+            else:
+                funcs = 
+        elif isinstance(thing, types.ModuleType):
+            if hasattr(thing, "__all__"):
+                funcs = getattr(thing, name, None) for name in thing.__all__
+            elif hasattr(thing, "__package__"):
+                pkg = thing.__package__
+                funcs = 
+                    v
+                    for k, v in vars(thing).items()
+                    if callable(v)
+                    and not is_mock(v)
+                    and ((not pkg) or getattr(v, "__module__", pkg).startswith(pkg))
+                    and not k.startswith("_")
+                
+                if pkg and any(getattr(f, "__module__", pkg) == pkg for f in funcs):
+                    funcs = f for f in funcs if getattr(f, "__module__", pkg) == pkg
+        else:
+            raise InvalidArgument(f"Can't test non-module non-callable {thing!r}")
+
+        for f in list(funcs):
+            if inspect.isclass(f):
+                funcs += 
+                    v.__get__(f)
+                    for k, v in vars(f).items()
+                    if hasattr(v, "__func__")
+                    and not is_mock(v)
+                    and not k.startswith("_")
+                
+        for f in funcs:
+            try:
+                if (
+                    (not is_mock(f))
+                    and callable(f)
+                    and _get_params(f)
+                    and not isinstance(f, enum.EnumMeta)
+                ):
+                    functions.add(f)
+                    if getattr(thing, "__name__", None):
+                        if inspect.isclass(thing):
+                            KNOWN_FUNCTION_LOCATIONSf = _get_module_helper(thing)
+                        else:
+                            KNOWN_FUNCTION_LOCATIONSf = thing.__name__
+            except (TypeError, ValueError):
+                pass
+
+    if annotate is None:
+        annotate = _are_annotations_used(*functions)
+
+    imports = set()
+    parts = 
+
+    def make_(how, *args, **kwargs):
+        imp, body = how(*args, **kwargs, except_=except_, style=style)
+        imports.update(imp)
+        parts.append(body)
+
+    by_name = {}
+    for f in functions:
+        try:
+            _get_params(f)
+            by_name_get_qualname(f, include_module=True) = f
+        except Exception:
+            # usually inspect.signature on C code such as socket.inet_aton, sometimes
+            # e.g. Pandas 'CallableDynamicDoc' object has no attribute '__name__'
+            pass
+    if not by_name:
+        return (
+            f"# Found no testable functions in\n"
+            f"# {functions!r} from {modules_or_functions}\n"
+        )
+
+    # Look for pairs of functions that roundtrip, based on known naming patterns.
+    for writename, readname in ROUNDTRIP_PAIRS:
+        for name in sorted(by_name):
+            match = re.fullmatch(writename, name.split(".")-1)
+            if match:
+                inverse_name = readname.format(*match.groups())
+                for other in sorted(
+                    n for n in by_name if n.split(".")-1 == inverse_name
+                ):
+                    make_(
+                        _make_roundtrip_body,
+                        (by_name.pop(name), by_name.pop(other)),
+                        annotate=annotate,
+                    )
+                    break
+                else:
+                    try:
+                        other_func = getattr(
+                            sys.modules_get_module(by_namename),
+                            inverse_name,
+                        )
+                        _get_params(other_func)  # we want to skip if this fails
+                    except Exception:
+                        pass
+                    else:
+                        make_(
+                            _make_roundtrip_body,
+                            (by_name.pop(name), other_func),
+                            annotate=annotate,
+                        )
+
+    # Look for equivalent functions: same name, all required arguments of any can
+    # be found in all signatures, and if all have return-type annotations they match.
+    names = defaultdict(list)
+    for _, f in sorted(by_name.items()):
+        names_get_qualname(f).append(f)
+    for group in names.values():
+        if len(group) >= 2 and len({frozenset(_get_params(f)) for f in group}) == 1:
+            sentinel = object()
+            returns = {get_type_hints(f).get("return", sentinel) for f in group}
+            if len(returns - {sentinel}) <= 1:
+                make_(_make_equiv_body, group, annotate=annotate)
+                for f in group:
+                    by_name.pop(_get_qualname(f, include_module=True))
+
+    # Look for binary operators - functions with two identically-typed arguments,
+    # and the same return type.  The latter restriction might be lifted later.
+    for name, func in sorted(by_name.items()):
+        hints = get_type_hints(func)
+        hints.pop("return", None)
+        params = _get_params(func)
+        if len(hints) == len(params) == 2:
+            a, b = hints.values()
+            arg1, arg2 = params
+            if a == b and len(arg1) == len(arg2) <= 3:
+                make_(_make_binop_body, func, annotate=annotate)
+                del by_namename
+
+    # Look for Numpy ufuncs or gufuncs, and write array-oriented tests for them.
+    if "numpy" in sys.modules:
+        for name, func in sorted(by_name.items()):
+            if _is_probably_ufunc(func):
+                make_(_make_ufunc_body, func, annotate=annotate)
+                del by_namename
+
+    # For all remaining callables, just write a fuzz-test.  In principle we could
+    # guess at equivalence or idempotence; but it doesn't seem accurate enough to
+    # be worth the trouble when it's so easy for the user to specify themselves.
+    for _, f in sorted(by_name.items()):
+        make_(
+            _make_test_body,
+            f,
+            test_body=_write_call(f, except_=except_),
+            ghost="fuzz",
+            annotate=annotate,
+        )
+    return _make_test(imports, "\n".join(parts))
+
+
+def fuzz(
+    func: Callable,
+    *,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Write source code for a property-based test of ``func``.
+
+    The resulting test checks that valid input only leads to expected exceptions.
+    For example:
+
+    .. code-block:: python
+
+        from re import compile, error
+
+        from hypothesis.extra import ghostwriter
+
+        ghostwriter.fuzz(compile, except_=error)
+
+    Gives:
+
+    .. code-block:: python
+
+        # This test code was written by the `hypothesis.extra.ghostwriter` module
+        # and is provided under the Creative Commons Zero public domain dedication.
+        import re
+
+        from hypothesis import given, reject, strategies as st
+
+        # TODO: replace st.nothing() with an appropriate strategy
+
+
+        @given(pattern=st.nothing(), flags=st.just(0))
+        def test_fuzz_compile(pattern, flags):
+            try:
+                re.compile(pattern=pattern, flags=flags)
+            except re.error:
+                reject()
+
+    Note that it includes all the required imports.
+    Because the ``pattern`` parameter doesn't have annotations or a default argument,
+    you'll need to specify a strategy - for example :func:`~hypothesis.strategies.text`
+    or :func:`~hypothesis.strategies.binary`.  After that, you have a test!
+    """
+    if not callable(func):
+        raise InvalidArgument(f"Got non-callable func={func!r}")
+    except_ = _check_except(except_)
+    _check_style(style)
+
+    if annotate is None:
+        annotate = _are_annotations_used(func)
+
+    imports, body = _make_test_body(
+        func,
+        test_body=_write_call(func, except_=except_),
+        except_=except_,
+        ghost="fuzz",
+        style=style,
+        annotate=annotate,
+    )
+    return _make_test(imports, body)
+
+
+def idempotent(
+    func: Callable,
+    *,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Write source code for a property-based test of ``func``.
+
+    The resulting test checks that if you call ``func`` on it's own output,
+    the result does not change.  For example:
+
+    .. code-block:: python
+
+        from typing import Sequence
+
+        from hypothesis.extra import ghostwriter
+
+
+        def timsort(seq: Sequenceint) -> Sequenceint:
+            return sorted(seq)
+
+
+        ghostwriter.idempotent(timsort)
+
+    Gives:
+
+    .. code-block:: python
+
+        # This test code was written by the `hypothesis.extra.ghostwriter` module
+        # and is provided under the Creative Commons Zero public domain dedication.
+
+        from hypothesis import given, strategies as st
+
+
+        @given(seq=st.one_of(st.binary(), st.binary().map(bytearray), st.lists(st.integers())))
+        def test_idempotent_timsort(seq):
+            result = timsort(seq=seq)
+            repeat = timsort(seq=result)
+            assert result == repeat, (result, repeat)
+    """
+    if not callable(func):
+        raise InvalidArgument(f"Got non-callable func={func!r}")
+    except_ = _check_except(except_)
+    _check_style(style)
+
+    if annotate is None:
+        annotate = _are_annotations_used(func)
+
+    imports, body = _make_test_body(
+        func,
+        test_body="result = {}\nrepeat = {}".format(
+            _write_call(func, except_=except_),
+            _write_call(func, "result", except_=except_),
+        ),
+        except_=except_,
+        assertions=_assert_eq(style, "result", "repeat"),
+        ghost="idempotent",
+        style=style,
+        annotate=annotate,
+    )
+    return _make_test(imports, body)
+
+
+def _make_roundtrip_body(funcs, except_, style, annotate):
+    first_param = next(iter(_get_params(funcs0)))
+    test_lines = 
+        _write_call(funcs0, assign="value0", except_=except_),
+        *(
+            _write_call(f, f"value{i}", assign=f"value{i + 1}", except_=except_)
+            for i, f in enumerate(funcs1:)
+        ),
+    
+    return _make_test_body(
+        *funcs,
+        test_body="\n".join(test_lines),
+        except_=except_,
+        assertions=_assert_eq(style, first_param, f"value{len(funcs) - 1}"),
+        ghost="roundtrip",
+        style=style,
+        annotate=annotate,
+    )
+
+
+def roundtrip(
+    *funcs: Callable,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Write source code for a property-based test of ``funcs``.
+
+    The resulting test checks that if you call the first function, pass the result
+    to the second (and so on), the final result is equal to the first input argument.
+
+    This is a *very* powerful property to test, especially when the config options
+    are varied along with the object to round-trip.  For example, try ghostwriting
+    a test for :func:`python:json.dumps` - would you have thought of all that?
+
+    .. code-block:: shell
+
+        hypothesis write --roundtrip json.dumps json.loads
+    """
+    if not funcs:
+        raise InvalidArgument("Round-trip of zero functions is meaningless.")
+    for i, f in enumerate(funcs):
+        if not callable(f):
+            raise InvalidArgument(f"Got non-callable funcs{i}={f!r}")
+    except_ = _check_except(except_)
+    _check_style(style)
+
+    if annotate is None:
+        annotate = _are_annotations_used(*funcs)
+
+    return _make_test(*_make_roundtrip_body(funcs, except_, style, annotate))
+
+
+def _make_equiv_body(funcs, except_, style, annotate):
+    var_names = f"result_{f.__name__}" for f in funcs
+    if len(set(var_names)) < len(var_names):
+        var_names = f"result_{i}_{ f.__name__}" for i, f in enumerate(funcs)
+    test_lines = 
+        _write_call(f, assign=vname, except_=except_)
+        for vname, f in zip(var_names, funcs)
+    
+    assertions = "\n".join(
+        _assert_eq(style, var_names0, vname) for vname in var_names1:
+    )
+
+    return _make_test_body(
+        *funcs,
+        test_body="\n".join(test_lines),
+        except_=except_,
+        assertions=assertions,
+        ghost="equivalent",
+        style=style,
+        annotate=annotate,
+    )
+
+
+EQUIV_FIRST_BLOCK = """
+try:
+{}
+    exc_type = None
+    target(1, label="input was valid")
+{}except Exception as exc:
+    exc_type = type(exc)
+""".strip()
+
+EQUIV_CHECK_BLOCK = """
+if exc_type:
+    with {ctx}(exc_type):
+{check_raises}
+else:
+{call}
+{compare}
+""".rstrip()
+
+
+def _make_equiv_errors_body(funcs, except_, style, annotate):
+    var_names = f"result_{f.__name__}" for f in funcs
+    if len(set(var_names)) < len(var_names):
+        var_names = f"result_{i}_{ f.__name__}" for i, f in enumerate(funcs)
+
+    first, *rest = funcs
+    first_call = _write_call(first, assign=var_names0, except_=except_)
+    extra_imports, suppress = _exception_string(except_)
+    extra_imports.add(("hypothesis", "target"))
+    catch = f"except {suppress}:\n    reject()\n" if suppress else ""
+    test_lines = EQUIV_FIRST_BLOCK.format(indent(first_call, prefix="    "), catch)
+
+    for vname, f in zip(var_names1:, rest):
+        if style == "pytest":
+            ctx = "pytest.raises"
+            extra_imports.add("pytest")
+        else:
+            assert style == "unittest"
+            ctx = "self.assertRaises"
+        block = EQUIV_CHECK_BLOCK.format(
+            ctx=ctx,
+            check_raises=indent(_write_call(f, except_=()), "        "),
+            call=indent(_write_call(f, assign=vname, except_=()), "    "),
+            compare=indent(_assert_eq(style, var_names0, vname), "    "),
+        )
+        test_lines.append(block)
+
+    imports, source_code = _make_test_body(
+        *funcs,
+        test_body="\n".join(test_lines),
+        except_=(),
+        ghost="equivalent",
+        style=style,
+        annotate=annotate,
+    )
+    return imports | extra_imports, source_code
+
+
+def equivalent(
+    *funcs: Callable,
+    allow_same_errors: bool = False,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Write source code for a property-based test of ``funcs``.
+
+    The resulting test checks that calling each of the functions returns
+    an equal value.  This can be used as a classic 'oracle', such as testing
+    a fast sorting algorithm against the :func:`python:sorted` builtin, or
+    for differential testing where none of the compared functions are fully
+    trusted but any difference indicates a bug (e.g. running a function on
+    different numbers of threads, or simply multiple times).
+
+    The functions should have reasonably similar signatures, as only the
+    common parameters will be passed the same arguments - any other parameters
+    will be allowed to vary.
+
+    If allow_same_errors is True, then the test will pass if calling each of
+    the functions returns an equal value, *or* if the first function raises an
+    exception and each of the others raises an exception of the same type.
+    This relaxed mode can be useful for code synthesis projects.
+    """
+    if len(funcs) < 2:
+        raise InvalidArgument("Need at least two functions to compare.")
+    for i, f in enumerate(funcs):
+        if not callable(f):
+            raise InvalidArgument(f"Got non-callable funcs{i}={f!r}")
+    check_type(bool, allow_same_errors, "allow_same_errors")
+    except_ = _check_except(except_)
+    _check_style(style)
+
+    if annotate is None:
+        annotate = _are_annotations_used(*funcs)
+
+    if allow_same_errors and not any(issubclass(Exception, ex) for ex in except_):
+        imports, source_code = _make_equiv_errors_body(funcs, except_, style, annotate)
+    else:
+        imports, source_code = _make_equiv_body(funcs, except_, style, annotate)
+    return _make_test(imports, source_code)
+
+
+X = TypeVar("X")
+Y = TypeVar("Y")
+
+
+def binary_operation(
+    func: CallableX, X, Y,
+    *,
+    associative: bool = True,
+    commutative: bool = True,
+    identity: UnionX, EllipsisType, None = ...,
+    distributes_over: OptionalCallableX, X, X = None,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Write property tests for the binary operation ``func``.
+
+    While :wikipedia:`binary operations <Binary_operation>` are not particularly
+    common, they have such nice properties to test that it seems a shame not to
+    demonstrate them with a ghostwriter.  For an operator `f`, test that:
+
+    - if :wikipedia:`associative <Associative_property>`,
+      ``f(a, f(b, c)) == f(f(a, b), c)``
+    - if :wikipedia:`commutative <Commutative_property>`, ``f(a, b) == f(b, a)``
+    - if :wikipedia:`identity <Identity_element>` is not None, ``f(a, identity) == a``
+    - if :wikipedia:`distributes_over <Distributive_property>` is ``+``,
+      ``f(a, b) + f(a, c) == f(a, b+c)``
+
+    For example:
+
+    .. code-block:: python
+
+        ghostwriter.binary_operation(
+            operator.mul,
+            identity=1,
+            distributes_over=operator.add,
+            style="unittest",
+        )
+    """
+    if not callable(func):
+        raise InvalidArgument(f"Got non-callable func={func!r}")
+    except_ = _check_except(except_)
+    _check_style(style)
+    check_type(bool, associative, "associative")
+    check_type(bool, commutative, "commutative")
+    if distributes_over is not None and not callable(distributes_over):
+        raise InvalidArgument(
+            f"distributes_over={distributes_over!r} must be an operation which "
+            f"distributes over {func.__name__}"
+        )
+    if not any(associative, commutative, identity, distributes_over):
+        raise InvalidArgument(
+            "You must select at least one property of the binary operation to test."
+        )
+
+    if annotate is None:
+        annotate = _are_annotations_used(func)
+
+    imports, body = _make_binop_body(
+        func,
+        associative=associative,
+        commutative=commutative,
+        identity=identity,
+        distributes_over=distributes_over,
+        except_=except_,
+        style=style,
+        annotate=annotate,
+    )
+    return _make_test(imports, body)
+
+
+def _make_binop_body(
+    func: CallableX, X, Y,
+    *,
+    associative: bool = True,
+    commutative: bool = True,
+    identity: UnionX, EllipsisType, None = ...,
+    distributes_over: OptionalCallableX, X, X = None,
+    except_: TupleTypeException, ...,
+    style: str,
+    annotate: bool,
+) -> TupleImportSet, str:
+    strategies = _get_strategies(func)
+    operands, b = (strategies.pop(p) for p in list(_get_params(func)):2)
+    if repr(operands) != repr(b):
+        operands |= b
+    operands_name = func.__name__ + "_operands"
+
+    all_imports = set()
+    parts = 
+
+    def maker(
+        sub_property: str,
+        args: str,
+        body: str,
+        right: Optionalstr = None,
+    ) -> None:
+        if right is None:
+            assertions = ""
+        else:
+            body = f"{body}\n{right}"
+            assertions = _assert_eq(style, "left", "right")
+        imports, body = _make_test_body(
+            func,
+            test_body=body,
+            ghost=sub_property + "_binary_operation",
+            except_=except_,
+            assertions=assertions,
+            style=style,
+            given_strategies={**strategies, **{n: operands_name for n in args}},
+            annotate=annotate,
+        )
+        all_imports.update(imports)
+        if style == "unittest":
+            endline = "(unittest.TestCase):\n"
+            body = bodybody.index(endline) + len(endline) + 1 :
+        parts.append(body)
+
+    if associative:
+        maker(
+            "associative",
+            "abc",
+            _write_call(
+                func,
+                "a",
+                _write_call(func, "b", "c", except_=Exception),
+                except_=Exception,
+                assign="left",
+            ),
+            _write_call(
+                func,
+                _write_call(func, "a", "b", except_=Exception),
+                "c",
+                except_=Exception,
+                assign="right",
+            ),
+        )
+    if commutative:
+        maker(
+            "commutative",
+            "ab",
+            _write_call(func, "a", "b", except_=Exception, assign="left"),
+            _write_call(func, "b", "a", except_=Exception, assign="right"),
+        )
+    if identity is not None:
+        # Guess that the identity element is the minimal example from our operands
+        # strategy.  This is correct often enough to be worthwhile, and close enough
+        # that it's a good starting point to edit much of the rest.
+        if identity is ...:
+            try:
+                identity = find(operands, lambda x: True, settings=_quietly_settings)
+            except Exception:
+                identity = "identity element here"  # type: ignore
+        # If the repr of this element is invalid Python, stringify it - this
+        # can't be executed as-is, but at least makes it clear what should
+        # happen.  E.g. type(None) -> <class 'NoneType'> -> quoted.
+        try:
+            # We don't actually execute this code object; we're just compiling
+            # to check that the repr is syntactically valid.  HOWEVER, we're
+            # going to output that code string into test code which will be
+            # executed; so you still shouldn't ghostwrite for hostile code.
+            compile(repr(identity), "<string>", "exec")
+        except SyntaxError:
+            identity = repr(identity)  # type: ignore
+        maker(
+            "identity",
+            "a",
+            _assert_eq(
+                style,
+                "a",
+                _write_call(func, "a", repr(identity), except_=Exception),
+            ),
+        )
+    if distributes_over:
+        maker(
+            distributes_over.__name__ + "_distributes_over",
+            "abc",
+            _write_call(
+                distributes_over,
+                _write_call(func, "a", "b", except_=Exception),
+                _write_call(func, "a", "c", except_=Exception),
+                except_=Exception,
+                assign="left",
+            ),
+            _write_call(
+                func,
+                "a",
+                _write_call(distributes_over, "b", "c", except_=Exception),
+                except_=Exception,
+                assign="right",
+            ),
+        )
+
+    _, operands_repr = _valid_syntax_repr(operands)
+    operands_repr = _st_strategy_names(operands_repr)
+    classdef = ""
+    if style == "unittest":
+        classdef = f"class TestBinaryOperation{func.__name__}(unittest.TestCase):\n    "
+    return (
+        all_imports,
+        classdef + f"{operands_name} = {operands_repr}\n" + "\n".join(parts),
+    )
+
+
+def ufunc(
+    func: Callable,
+    *,
+    except_: Except = (),
+    style: str = "pytest",
+    annotate: Optionalbool = None,
+) -> str:
+    """Write a property-based test for the :doc:`array ufunc <numpy:reference/ufuncs>` ``func``.
+
+    The resulting test checks that your ufunc or :doc:`gufunc
+    <numpy:reference/c-api/generalized-ufuncs>` has the expected broadcasting and dtype casting
+    behaviour.  You will probably want to add extra assertions, but as with the other
+    ghostwriters this gives you a great place to start.
+
+    .. code-block:: shell
+
+        hypothesis write numpy.matmul
+    """
+    if not _is_probably_ufunc(func):
+        raise InvalidArgument(f"func={func!r} does not seem to be a ufunc")
+    except_ = _check_except(except_)
+    _check_style(style)
+
+    if annotate is None:
+        annotate = _are_annotations_used(func)
+
+    return _make_test(
+        *_make_ufunc_body(func, except_=except_, style=style, annotate=annotate)
+    )
+
+
+def _make_ufunc_body(func, *, except_, style, annotate):
+    import hypothesis.extra.numpy as npst
+
+    if func.signature is None:
+        shapes = npst.mutually_broadcastable_shapes(num_shapes=func.nin)
+    else:
+        shapes = npst.mutually_broadcastable_shapes(signature=func.signature)
+    shapes.function.__module__ = npst.__name__
+
+    body = """
+    input_shapes, expected_shape = shapes
+    input_dtypes, expected_dtype = types.split("->")
+    array_strats = 
+        arrays(dtype=dtp, shape=shp, elements={{"allow_nan": True}})
+        for dtp, shp in zip(input_dtypes, input_shapes)
+    
+
+    {array_names} = data.draw(st.tuples(*array_strats))
+    result = {call}
+    """.format(
+        array_names=", ".join(ascii_lowercase: func.nin),
+        call=_write_call(func, *ascii_lowercase: func.nin, except_=except_),
+    )
+    assertions = "\n{shape_assert}\n{type_assert}".format(
+        shape_assert=_assert_eq(style, "result.shape", "expected_shape"),
+        type_assert=_assert_eq(style, "result.dtype.char", "expected_dtype"),
+    )
+
+    qname = _get_qualname(func, include_module=True)
+    obj_sigs = "O" in sig for sig in func.types
+    if all(obj_sigs) or not any(obj_sigs):
+        types = f"sampled_from({qname}.types)"
+    else:
+        types = f"sampled_from(sig for sig in {qname}.types if 'O' not in sig)"
+
+    return _make_test_body(
+        func,
+        test_body=dedent(body).strip(),
+        except_=except_,
+        assertions=assertions,
+        ghost="ufunc" if func.signature is None else "gufunc",
+        style=style,
+        given_strategies={"data": st.data(), "shapes": shapes, "types": types},
+        imports={("hypothesis.extra.numpy", "arrays")},
+        annotate=annotate,
+    )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/lark.py Added

@@ -0,0 +1,232 @@
+# 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/.
+
+"""
+----------------
+hypothesislark
+----------------
+
+This extra can be used to generate strings matching any context-free grammar,
+using the `Lark parser library <https://github.com/lark-parser/lark>`_.
+
+It currently only supports Lark's native EBNF syntax, but we plan to extend
+this to support other common syntaxes such as ANTLR and :rfc:`5234` ABNF.
+Lark already `supports loading grammars
+<https://lark-parser.readthedocs.io/en/latest/nearley.html>`_
+from `nearley.js <https://nearley.js.org/>`_, so you may not have to write
+your own at all.
+"""
+
+from inspect import signature
+from typing import Dict, Optional
+
+import attr
+import lark
+from lark.grammar import NonTerminal, Terminal
+
+from hypothesis import strategies as st
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture.utils import calc_label_from_name
+from hypothesis.internal.validation import check_type
+from hypothesis.strategies._internal.utils import cacheable, defines_strategy
+
+__all__ = "from_lark"
+
+
+@attr.s()
+class DrawState:
+    """Tracks state of a single draw from a lark grammar.
+
+    Currently just wraps a list of tokens that will be emitted at the
+    end, but as we support more sophisticated parsers this will need
+    to track more state for e.g. indentation level.
+    """
+
+    # The text output so far as a list of string tokens resulting from
+    # each draw to a non-terminal.
+    result = attr.ib(default=attr.Factory(list))
+
+
+def get_terminal_names(terminals, rules, ignore_names):
+    """Get names of all terminals in the grammar.
+
+    The arguments are the results of calling ``Lark.grammar.compile()``,
+    so you would think that the ``terminals`` and ``ignore_names`` would
+    have it all... but they omit terminals created with ``@declare``,
+    which appear only in the expansion(s) of nonterminals.
+    """
+    names = {t.name for t in terminals} | set(ignore_names)
+    for rule in rules:
+        names |= {t.name for t in rule.expansion if isinstance(t, Terminal)}
+    return names
+
+
+class LarkStrategy(st.SearchStrategy):
+    """Low-level strategy implementation wrapping a Lark grammar.
+
+    See ``from_lark`` for details.
+    """
+
+    def __init__(self, grammar, start, explicit):
+        assert isinstance(grammar, lark.lark.Lark)
+        if start is None:
+            start = grammar.options.start
+        if not isinstance(start, list):
+            start = start
+        self.grammar = grammar
+
+        # This is a total hack, but working around the changes is a nicer user
+        # experience than breaking for anyone who doesn't instantly update their
+        # installation of Lark alongside Hypothesis.
+        compile_args = signature(grammar.grammar.compile).parameters
+        if "terminals_to_keep" in compile_args:
+            terminals, rules, ignore_names = grammar.grammar.compile(start, ())
+        elif "start" in compile_args:  # pragma: no cover
+            # Support lark <= 0.10.0, without the terminals_to_keep argument.
+            terminals, rules, ignore_names = grammar.grammar.compile(start)
+        else:  # pragma: no cover
+            # This branch is to support lark <= 0.7.1, without the start argument.
+            terminals, rules, ignore_names = grammar.grammar.compile()
+
+        self.names_to_symbols = {}
+
+        for r in rules:
+            t = r.origin
+            self.names_to_symbolst.name = t
+
+        for t in terminals:
+            self.names_to_symbolst.name = Terminal(t.name)
+
+        self.start = st.sampled_from(self.names_to_symbolss for s in start)
+
+        self.ignored_symbols = tuple(self.names_to_symbolsn for n in ignore_names)
+
+        self.terminal_strategies = {
+            t.name: st.from_regex(t.pattern.to_regexp(), fullmatch=True)
+            for t in terminals
+        }
+        unknown_explicit = set(explicit) - get_terminal_names(
+            terminals, rules, ignore_names
+        )
+        if unknown_explicit:
+            raise InvalidArgument(
+                "The following arguments were passed as explicit_strategies, "
+                "but there is no such terminal production in this grammar: "
+                + repr(sorted(unknown_explicit))
+            )
+        self.terminal_strategies.update(explicit)
+
+        nonterminals = {}
+
+        for rule in rules:
+            nonterminals.setdefault(rule.origin.name, ).append(tuple(rule.expansion))
+
+        for v in nonterminals.values():
+            v.sort(key=len)
+
+        self.nonterminal_strategies = {
+            k: st.sampled_from(v) for k, v in nonterminals.items()
+        }
+
+        self.__rule_labels = {}
+
+    def do_draw(self, data):
+        state = DrawState()
+        start = data.draw(self.start)
+        self.draw_symbol(data, start, state)
+        return "".join(state.result)
+
+    def rule_label(self, name):
+        try:
+            return self.__rule_labelsname
+        except KeyError:
+            return self.__rule_labels.setdefault(
+                name, calc_label_from_name(f"LARK:{name}")
+            )
+
+    def draw_symbol(self, data, symbol, draw_state):
+        if isinstance(symbol, Terminal):
+            try:
+                strategy = self.terminal_strategiessymbol.name
+            except KeyError:
+                raise InvalidArgument(
+                    "Undefined terminal %r. Generation does not currently support "
+                    "use of %%declare unless you pass `explicit`, a dict of "
+                    'names-to-strategies, such as `{%r: st.just("")}`'
+                    % (symbol.name, symbol.name)
+                ) from None
+            draw_state.result.append(data.draw(strategy))
+        else:
+            assert isinstance(symbol, NonTerminal)
+            data.start_example(self.rule_label(symbol.name))
+            expansion = data.draw(self.nonterminal_strategiessymbol.name)
+            for e in expansion:
+                self.draw_symbol(data, e, draw_state)
+                self.gen_ignore(data, draw_state)
+            data.stop_example()
+
+    def gen_ignore(self, data, draw_state):
+        if self.ignored_symbols and data.draw_bits(2) == 3:
+            emit = data.draw(st.sampled_from(self.ignored_symbols))
+            self.draw_symbol(data, emit, draw_state)
+
+    def calc_has_reusable_values(self, recur):
+        return True
+
+
+def check_explicit(name):
+    def inner(value):
+        check_type(str, value, "value drawn from " + name)
+        return value
+
+    return inner
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def from_lark(
+    grammar: lark.lark.Lark,
+    *,
+    start: Optionalstr = None,
+    explicit: OptionalDictstr, st.SearchStrategystr = None,
+) -> st.SearchStrategystr:
+    """A strategy for strings accepted by the given context-free grammar.
+
+    ``grammar`` must be a ``Lark`` object, which wraps an EBNF specification.
+    The Lark EBNF grammar reference can be found
+    `here <https://lark-parser.readthedocs.io/en/latest/grammar.html>`_.
+
+    ``from_lark`` will automatically generate strings matching the
+    nonterminal ``start`` symbol in the grammar, which was supplied as an
+    argument to the Lark class.  To generate strings matching a different
+    symbol, including terminals, you can override this by passing the
+    ``start`` argument to ``from_lark``.  Note that Lark may remove unreachable
+    productions when the grammar is compiled, so you should probably pass the
+    same value for ``start`` to both.
+
+    Currently ``from_lark`` does not support grammars that need custom lexing.
+    Any lexers will be ignored, and any undefined terminals from the use of
+    ``%declare`` will result in generation errors.  To define strategies for
+    such terminals, pass a dictionary mapping their name to a corresponding
+    strategy as the ``explicit`` argument.
+
+    The :pypi:`hypothesmith` project includes a strategy for Python source,
+    based on a grammar and careful post-processing.
+    """
+    check_type(lark.lark.Lark, grammar, "grammar")
+    if explicit is None:
+        explicit = {}
+    else:
+        check_type(dict, explicit, "explicit")
+        explicit = {
+            k: v.map(check_explicit(f"explicit{k!r}={v!r}"))
+            for k, v in explicit.items()
+        }
+    return LarkStrategy(grammar, start, explicit)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/numpy.py Added

@@ -0,0 +1,1133 @@
+# 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 importlib
+import math
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import numpy as np
+
+from hypothesis import strategies as st
+from hypothesis._settings import note_deprecation
+from hypothesis.errors import HypothesisException, InvalidArgument
+from hypothesis.extra._array_helpers import (
+    NDIM_MAX,
+    BasicIndex,
+    BasicIndexStrategy,
+    BroadcastableShapes,
+    Shape,
+    array_shapes,
+    broadcastable_shapes,
+    check_argument,
+    check_valid_dims,
+    mutually_broadcastable_shapes as _mutually_broadcastable_shapes,
+    order_check,
+    valid_tuple_axes as _valid_tuple_axes,
+)
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.coverage import check_function
+from hypothesis.internal.reflection import proxies
+from hypothesis.internal.validation import check_type
+from hypothesis.strategies._internal.numbers import Real
+from hypothesis.strategies._internal.strategies import Ex, T, check_strategy
+from hypothesis.strategies._internal.utils import defines_strategy
+
+
+def _try_import(mod_name: str, attr_name: str) -> Any:
+    assert "." not in attr_name
+    try:
+        mod = importlib.import_module(mod_name)
+        return getattr(mod, attr_name, None)
+    except ImportError:
+        return None
+
+
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike, NDArray
+else:
+    NDArray = _try_import("numpy.typing", "NDArray")
+
+ArrayLike = _try_import("numpy.typing", "ArrayLike")
+_NestedSequence = _try_import("numpy._typing._nested_sequence", "_NestedSequence")
+_SupportsArray = _try_import("numpy._typing._array_like", "_SupportsArray")
+
+__all__ = 
+    "BroadcastableShapes",
+    "from_dtype",
+    "arrays",
+    "array_shapes",
+    "scalar_dtypes",
+    "boolean_dtypes",
+    "unsigned_integer_dtypes",
+    "integer_dtypes",
+    "floating_dtypes",
+    "complex_number_dtypes",
+    "datetime64_dtypes",
+    "timedelta64_dtypes",
+    "byte_string_dtypes",
+    "unicode_string_dtypes",
+    "array_dtypes",
+    "nested_dtypes",
+    "valid_tuple_axes",
+    "broadcastable_shapes",
+    "mutually_broadcastable_shapes",
+    "basic_indices",
+    "integer_array_indices",
+
+
+TIME_RESOLUTIONS = tuple("Y  M  D  h  m  s  ms  us  ns  ps  fs  as".split())
+
+# See https://github.com/HypothesisWorks/hypothesis/pull/3394 and linked discussion.
+NP_FIXED_UNICODE = tuple(int(x) for x in np.__version__.split("."):2) >= (1, 19)
+
+
+@defines_strategy(force_reusable_values=True)
+def from_dtype(
+    dtype: np.dtype,
+    *,
+    alphabet: Optionalst.SearchStrategystr = None,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+    min_value: Unionint, float, None = None,
+    max_value: Unionint, float, None = None,
+    allow_nan: Optionalbool = None,
+    allow_infinity: Optionalbool = None,
+    allow_subnormal: Optionalbool = None,
+    exclude_min: Optionalbool = None,
+    exclude_max: Optionalbool = None,
+    min_magnitude: Real = 0,
+    max_magnitude: OptionalReal = None,
+) -> st.SearchStrategyAny:
+    """Creates a strategy which can generate any value of the given dtype.
+
+    Compatible parameters are passed to the inferred strategy function while
+    inapplicable ones are ignored.
+    This allows you, for example, to customise the min and max values,
+    control the length or contents of strings, or exclude non-finite
+    numbers. This is particularly useful when kwargs are passed through from
+    :func:`arrays` which allow a variety of numeric dtypes, as it seamlessly
+    handles the ``width`` or representable bounds for you.
+    """
+    check_type(np.dtype, dtype, "dtype")
+    kwargs = {k: v for k, v in locals().items() if k != "dtype" and v is not None}
+
+    # Compound datatypes, eg 'f4,f4,f4'
+    if dtype.names is not None:
+        # mapping np.void.type over a strategy is nonsense, so return now.
+        subs = from_dtype(dtype.fieldsname0, **kwargs) for name in dtype.names
+        return st.tuples(*subs)
+
+    # Subarray datatypes, eg '(2, 3)i4'
+    if dtype.subdtype is not None:
+        subtype, shape = dtype.subdtype
+        return arrays(subtype, shape, elements=kwargs)
+
+    def compat_kw(*args, **kw):
+        """Update default args to the strategy with user-supplied keyword args."""
+        assert {"min_value", "max_value", "max_size"}.issuperset(kw)
+        for key in set(kwargs).intersection(kw):
+            msg = f"dtype {dtype!r} requires {key}={kwargskey!r} to be %s {kwkey!r}"
+            if kwkey is not None:
+                if key.startswith("min_") and kwkey > kwargskey:
+                    raise InvalidArgument(msg % ("at least",))
+                elif key.startswith("max_") and kwkey < kwargskey:
+                    raise InvalidArgument(msg % ("at most",))
+        kw.update({k: v for k, v in kwargs.items() if k in args or k in kw})
+        return kw
+
+    # Scalar datatypes
+    if dtype.kind == "b":
+        result: st.SearchStrategyAny = st.booleans()
+    elif dtype.kind == "f":
+        result = st.floats(
+            width=min(8 * dtype.itemsize, 64),
+            **compat_kw(
+                "min_value",
+                "max_value",
+                "allow_nan",
+                "allow_infinity",
+                "allow_subnormal",
+                "exclude_min",
+                "exclude_max",
+            ),
+        )
+    elif dtype.kind == "c":
+        result = st.complex_numbers(
+            width=min(8 * dtype.itemsize, 128),  # convert from bytes to bits
+            **compat_kw(
+                "min_magnitude",
+                "max_magnitude",
+                "allow_nan",
+                "allow_infinity",
+                "allow_subnormal",
+            ),
+        )
+    elif dtype.kind in ("S", "a"):
+        # Numpy strings are null-terminated; only allow round-trippable values.
+        # `itemsize == 0` means 'fixed length determined at array creation'
+        max_size = dtype.itemsize or None
+        result = st.binary(**compat_kw("min_size", max_size=max_size)).filter(
+            lambda b: b-1: != b"\0"
+        )
+    elif dtype.kind == "u":
+        kw = compat_kw(min_value=0, max_value=2 ** (8 * dtype.itemsize) - 1)
+        result = st.integers(**kw)
+    elif dtype.kind == "i":
+        overflow = 2 ** (8 * dtype.itemsize - 1)
+        result = st.integers(**compat_kw(min_value=-overflow, max_value=overflow - 1))
+    elif dtype.kind == "U":
+        # Encoded in UTF-32 (four bytes/codepoint) and null-terminated
+        max_size = (dtype.itemsize or 0) // 4 or None
+        if NP_FIXED_UNICODE and "alphabet" not in kwargs:
+            kwargs"alphabet" = st.characters()
+        result = st.text(**compat_kw("alphabet", "min_size", max_size=max_size)).filter(
+            lambda b: b-1: != "\0"
+        )
+    elif dtype.kind in ("m", "M"):
+        if "" in dtype.str:
+            res = st.just(dtype.str.split("")-1:-1)
+        else:
+            # Note that this case isn't valid to pass to arrays(), but we support
+            # it here because we'd have to guard against equivalents in arrays()
+            # regardless and drawing scalars is a valid use-case.
+            res = st.sampled_from(TIME_RESOLUTIONS)
+        result = st.builds(dtype.type, st.integers(-(2**63), 2**63 - 1), res)
+    else:
+        raise InvalidArgument(f"No strategy inference for {dtype}")
+    return result.map(dtype.type)
+
+
+class ArrayStrategy(st.SearchStrategy):
+    def __init__(self, element_strategy, shape, dtype, fill, unique):
+        self.shape = tuple(shape)
+        self.fill = fill
+        self.array_size = int(np.prod(shape))
+        self.dtype = dtype
+        self.element_strategy = element_strategy
+        self.unique = unique
+        self._check_elements = dtype.kind not in ("O", "V")
+
+    def set_element(self, val, result, idx, *, fill=False):
+        try:
+            resultidx = val
+        except TypeError as err:
+            raise InvalidArgument(
+                f"Could not add element={val!r} of {val.dtype!r} to array of "
+                f"{result.dtype!r} - possible mismatch of time units in dtypes?"
+            ) from err
+        try:
+            elem_changed = self._check_elements and val != resultidx and val == val
+        except Exception as err:  # pragma: no cover
+            # This branch only exists to help debug weird behaviour in Numpy,
+            # such as the string problems we had a while back.
+            raise HypothesisException(
+                "Internal error when checking element=%r of %r to array of %r"
+                % (val, val.dtype, result.dtype)
+            ) from err
+        if elem_changed:
+            strategy = self.fill if fill else self.element_strategy
+            if self.dtype.kind == "f":  # pragma: no cover
+                # This logic doesn't trigger in our coverage tests under Numpy 1.24+,
+                # with built-in checks for overflow, but we keep it for good error
+                # messages and compatibility with older versions of Numpy.
+                try:
+                    is_subnormal = 0 < abs(val) < np.finfo(self.dtype).tiny
+                except Exception:
+                    # val may be a non-float that does not support the
+                    # operations __lt__ and __abs__
+                    is_subnormal = False
+                if is_subnormal:
+                    raise InvalidArgument(
+                        f"Generated subnormal float {val} from strategy "
+                        f"{strategy} resulted in {resultidx!r}, probably "
+                        "as a result of NumPy being built with flush-to-zero "
+                        "compiler options. Consider passing "
+                        "allow_subnormal=False."
+                    )
+            raise InvalidArgument(
+                "Generated array element %r from %r cannot be represented as "
+                "dtype %r - instead it becomes %r (type %r).  Consider using a more "
+                "precise strategy, for example passing the `width` argument to "
+                "`floats()`."
+                % (val, strategy, self.dtype, resultidx, type(resultidx))
+            )
+
+    def do_draw(self, data):
+        if 0 in self.shape:
+            return np.zeros(dtype=self.dtype, shape=self.shape)
+
+        # Because Numpy allocates memory for strings at array creation, if we have
+        # an unsized string dtype we'll fill an object array and then cast it back.
+        unsized_string_dtype = (
+            self.dtype.kind in ("S", "a", "U") and self.dtype.itemsize == 0
+        )
+
+        # This could legitimately be a np.empty, but the performance gains for
+        # that would be so marginal that there's really not much point risking
+        # undefined behaviour shenanigans.
+        result = np.zeros(
+            shape=self.array_size, dtype=object if unsized_string_dtype else self.dtype
+        )
+
+        if self.fill.is_empty:
+            # We have no fill value (either because the user explicitly
+            # disabled it or because the default behaviour was used and our
+            # elements strategy does not produce reusable values), so we must
+            # generate a fully dense array with a freshly drawn value for each
+            # entry.
+            if self.unique:
+                elems = st.lists(
+                    self.element_strategy,
+                    min_size=self.array_size,
+                    max_size=self.array_size,
+                    unique=True,
+                )
+                for i, v in enumerate(data.draw(elems)):
+                    self.set_element(v, result, i)
+            else:
+                for i in range(len(result)):
+                    self.set_element(data.draw(self.element_strategy), result, i)
+        else:
+            # We draw numpy arrays as "sparse with an offset". We draw a
+            # collection of index assignments within the array and assign
+            # fresh values from our elements strategy to those indices. If at
+            # the end we have not assigned every element then we draw a single
+            # value from our fill strategy and use that to populate the
+            # remaining positions with that strategy.
+
+            elements = cu.many(
+                data,
+                min_size=0,
+                max_size=self.array_size,
+                # sqrt isn't chosen for any particularly principled reason. It
+                # just grows reasonably quickly but sublinearly, and for small
+                # arrays it represents a decent fraction of the array size.
+                average_size=min(
+                    0.9 * self.array_size,  # ensure small arrays sometimes use fill
+                    max(10, math.sqrt(self.array_size)),  # ...but *only* sometimes
+                ),
+            )
+
+            needs_fill = np.full(self.array_size, True)
+            seen = set()
+
+            while elements.more():
+                i = cu.integer_range(data, 0, self.array_size - 1)
+                if not needs_filli:
+                    elements.reject()
+                    continue
+                self.set_element(data.draw(self.element_strategy), result, i)
+                if self.unique:
+                    if resulti in seen:
+                        elements.reject()
+                        continue
+                    else:
+                        seen.add(resulti)
+                needs_filli = False
+            if needs_fill.any():
+                # We didn't fill all of the indices in the early loop, so we
+                # put a fill value into the rest.
+
+                # We have to do this hilarious little song and dance to work
+                # around numpy's special handling of iterable values. If the
+                # value here were e.g. a tuple then neither array creation
+                # nor putmask would do the right thing. But by creating an
+                # array of size one and then assigning the fill value as a
+                # single element, we both get an array with the right value in
+                # it and putmask will do the right thing by repeating the
+                # values of the array across the mask.
+                one_element = np.zeros(
+                    shape=1, dtype=object if unsized_string_dtype else self.dtype
+                )
+                self.set_element(data.draw(self.fill), one_element, 0, fill=True)
+                if unsized_string_dtype:
+                    one_element = one_element.astype(self.dtype)
+                fill_value = one_element0
+                if self.unique:
+                    try:
+                        is_nan = np.isnan(fill_value)
+                    except TypeError:
+                        is_nan = False
+
+                    if not is_nan:
+                        raise InvalidArgument(
+                            f"Cannot fill unique array with non-NaN value {fill_value!r}"
+                        )
+
+                np.putmask(result, needs_fill, one_element)
+
+        if unsized_string_dtype:
+            out = result.astype(self.dtype)
+            mismatch = out != result
+            if mismatch.any():
+                raise InvalidArgument(
+                    "Array elements %r cannot be represented as dtype %r - instead "
+                    "they become %r.  Use a more precise strategy, e.g. without "
+                    "trailing null bytes, as this will be an error future versions."
+                    % (resultmismatch, self.dtype, outmismatch)
+                )
+            result = out
+
+        result = result.reshape(self.shape).copy()
+
+        assert result.base is None
+
+        return result
+
+
+@check_function
+def fill_for(elements, unique, fill, name=""):
+    if fill is None:
+        if unique or not elements.has_reusable_values:
+            fill = st.nothing()
+        else:
+            fill = elements
+    else:
+        check_strategy(fill, f"{name}.fill" if name else "fill")
+    return fill
+
+
+D = TypeVar("D", bound="DTypeLike")
+
+
+@defines_strategy(force_reusable_values=True)
+def arrays(
+    dtype: UnionD, st.SearchStrategyD,
+    shape: Unionint, st.SearchStrategyint, Shape, st.SearchStrategyShape,
+    *,
+    elements: OptionalUnionst.SearchStrategyAny, Mappingstr, Any = None,
+    fill: Optionalst.SearchStrategyAny = None,
+    unique: bool = False,
+) -> "st.SearchStrategyNDArrayD":
+    r"""Returns a strategy for generating :class:`numpy:numpy.ndarray`\ s.
+
+    * ``dtype`` may be any valid input to :class:`~numpy:numpy.dtype`
+      (this includes :class:`~numpy:numpy.dtype` objects), or a strategy that
+      generates such values.
+    * ``shape`` may be an integer >= 0, a tuple of such integers, or a
+      strategy that generates such values.
+    * ``elements`` is a strategy for generating values to put in the array.
+      If it is None a suitable value will be inferred based on the dtype,
+      which may give any legal value (including eg NaN for floats).
+      If a mapping, it will be passed as ``**kwargs`` to ``from_dtype()``
+    * ``fill`` is a strategy that may be used to generate a single background
+      value for the array. If None, a suitable default will be inferred
+      based on the other arguments. If set to
+      :func:`~hypothesis.strategies.nothing` then filling
+      behaviour will be disabled entirely and every element will be generated
+      independently.
+    * ``unique`` specifies if the elements of the array should all be
+      distinct from one another. Note that in this case multiple NaN values
+      may still be allowed. If fill is also set, the only valid values for
+      it to return are NaN values (anything for which :obj:`numpy:numpy.isnan`
+      returns True. So e.g. for complex numbers ``nan+1j`` is also a valid fill).
+      Note that if ``unique`` is set to ``True`` the generated values must be
+      hashable.
+
+    Arrays of specified ``dtype`` and ``shape`` are generated for example
+    like this:
+
+    .. code-block:: pycon
+
+      >>> import numpy as np
+      >>> arrays(np.int8, (2, 3)).example()
+      array(-8,  6,  3,
+             -6,  4,  6, dtype=int8)
+      >>> arrays(np.float, 3, elements=st.floats(0, 1)).example()
+      array( 0.88974794,  0.77387938,  0.1977879 )
+
+    Array values are generated in two parts:
+
+    1. Some subset of the coordinates of the array are populated with a value
+       drawn from the elements strategy (or its inferred form).
+    2. If any coordinates were not assigned in the previous step, a single
+       value is drawn from the ``fill`` strategy and is assigned to all remaining
+       places.
+
+    You can set :func:`fill=nothing() <hypothesis.strategies.nothing>` to
+    disable this behaviour and draw a value for every element.
+
+    If ``fill=None``, then it will attempt to infer the correct behaviour
+    automatically. If ``unique`` is ``True``, no filling will occur by default.
+    Otherwise, if it looks safe to reuse the values of elements across
+    multiple coordinates (this will be the case for any inferred strategy, and
+    for most of the builtins, but is not the case for mutable values or
+    strategies built with flatmap, map, composite, etc) then it will use the
+    elements strategy as the fill, else it will default to having no fill.
+
+    Having a fill helps Hypothesis craft high quality examples, but its
+    main importance is when the array generated is large: Hypothesis is
+    primarily designed around testing small examples. If you have arrays with
+    hundreds or more elements, having a fill value is essential if you want
+    your tests to run in reasonable time.
+    """
+    # We support passing strategies as arguments for convenience, or at least
+    # for legacy reasons, but don't want to pay the perf cost of a composite
+    # strategy (i.e. repeated argument handling and validation) when it's not
+    # needed.  So we get the best of both worlds by recursing with flatmap,
+    # but only when it's actually needed.
+    if isinstance(dtype, st.SearchStrategy):
+        return dtype.flatmap(
+            lambda d: arrays(d, shape, elements=elements, fill=fill, unique=unique)
+        )
+    if isinstance(shape, st.SearchStrategy):
+        return shape.flatmap(
+            lambda s: arrays(dtype, s, elements=elements, fill=fill, unique=unique)
+        )
+    # From here on, we're only dealing with values and it's relatively simple.
+    dtype = np.dtype(dtype)
+    assert isinstance(dtype, np.dtype)  # help mypy out a bit...
+    if elements is None or isinstance(elements, Mapping):
+        if dtype.kind in ("m", "M") and "" not in dtype.str:
+            # For datetime and timedelta dtypes, we have a tricky situation -
+            # because they *may or may not* specify a unit as part of the dtype.
+            # If not, we flatmap over the various resolutions so that array
+            # elements have consistent units but units may vary between arrays.
+            return (
+                st.sampled_from(TIME_RESOLUTIONS)
+                .map((dtype.str + "{}").format)
+                .flatmap(lambda d: arrays(d, shape=shape, fill=fill, unique=unique))
+            )
+        elements = from_dtype(dtype, **(elements or {}))
+    check_strategy(elements, "elements")
+    if isinstance(shape, int):
+        shape = (shape,)
+    shape = tuple(shape)
+    check_argument(
+        all(isinstance(s, int) for s in shape),
+        "Array shape must be integer in each dimension, provided shape was {}",
+        shape,
+    )
+    fill = fill_for(elements=elements, unique=unique, fill=fill)
+    return ArrayStrategy(elements, shape, dtype, fill, unique)
+
+
+@defines_strategy()
+def scalar_dtypes() -> st.SearchStrategynp.dtype:
+    """Return a strategy that can return any non-flexible scalar dtype."""
+    return st.one_of(
+        boolean_dtypes(),
+        integer_dtypes(),
+        unsigned_integer_dtypes(),
+        floating_dtypes(),
+        complex_number_dtypes(),
+        datetime64_dtypes(),
+        timedelta64_dtypes(),
+    )
+
+
+def defines_dtype_strategy(strat: T) -> T:
+    @defines_strategy()
+    @proxies(strat)
+    def inner(*args, **kwargs):
+        return strat(*args, **kwargs).map(np.dtype)
+
+    return inner
+
+
+@defines_dtype_strategy
+def boolean_dtypes() -> st.SearchStrategynp.dtype:
+    return st.just("?")
+
+
+def dtype_factory(kind, sizes, valid_sizes, endianness):
+    # Utility function, shared logic for most integer and string types
+    valid_endian = ("?", "<", "=", ">")
+    check_argument(
+        endianness in valid_endian,
+        "Unknown endianness: was {}, must be in {}",
+        endianness,
+        valid_endian,
+    )
+    if valid_sizes is not None:
+        if isinstance(sizes, int):
+            sizes = (sizes,)
+        check_argument(sizes, "Dtype must have at least one possible size.")
+        check_argument(
+            all(s in valid_sizes for s in sizes),
+            "Invalid sizes: was {} must be an item or sequence in {}",
+            sizes,
+            valid_sizes,
+        )
+        if all(isinstance(s, int) for s in sizes):
+            sizes = sorted({s // 8 for s in sizes})
+    strat = st.sampled_from(sizes)
+    if "{}" not in kind:
+        kind += "{}"
+    if endianness == "?":
+        return strat.map(("<" + kind).format) | strat.map((">" + kind).format)
+    return strat.map((endianness + kind).format)
+
+
+@defines_dtype_strategy
+def unsigned_integer_dtypes(
+    *, endianness: str = "?", sizes: Sequenceint = (8, 16, 32, 64)
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for unsigned integer dtypes.
+
+    endianness may be ``<`` for little-endian, ``>`` for big-endian,
+    ``=`` for native byte order, or ``?`` to allow either byte order.
+    This argument only applies to dtypes of more than one byte.
+
+    sizes must be a collection of integer sizes in bits.  The default
+    (8, 16, 32, 64) covers the full range of sizes.
+    """
+    return dtype_factory("u", sizes, (8, 16, 32, 64), endianness)
+
+
+@defines_dtype_strategy
+def integer_dtypes(
+    *, endianness: str = "?", sizes: Sequenceint = (8, 16, 32, 64)
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for signed integer dtypes.
+
+    endianness and sizes are treated as for
+    :func:`unsigned_integer_dtypes`.
+    """
+    return dtype_factory("i", sizes, (8, 16, 32, 64), endianness)
+
+
+@defines_dtype_strategy
+def floating_dtypes(
+    *, endianness: str = "?", sizes: Sequenceint = (16, 32, 64)
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for floating-point dtypes.
+
+    sizes is the size in bits of floating-point number.  Some machines support
+    96- or 128-bit floats, but these are not generated by default.
+
+    Larger floats (96 and 128 bit real parts) are not supported on all
+    platforms and therefore disabled by default.  To generate these dtypes,
+    include these values in the sizes argument.
+    """
+    return dtype_factory("f", sizes, (16, 32, 64, 96, 128), endianness)
+
+
+@defines_dtype_strategy
+def complex_number_dtypes(
+    *, endianness: str = "?", sizes: Sequenceint = (64, 128)
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for complex-number dtypes.
+
+    sizes is the total size in bits of a complex number, which consists
+    of two floats.  Complex halves (a 16-bit real part) are not supported
+    by numpy and will not be generated by this strategy.
+    """
+    return dtype_factory("c", sizes, (64, 128, 192, 256), endianness)
+
+
+@check_function
+def validate_time_slice(max_period, min_period):
+    check_argument(
+        max_period in TIME_RESOLUTIONS,
+        "max_period {} must be a valid resolution in {}",
+        max_period,
+        TIME_RESOLUTIONS,
+    )
+    check_argument(
+        min_period in TIME_RESOLUTIONS,
+        "min_period {} must be a valid resolution in {}",
+        min_period,
+        TIME_RESOLUTIONS,
+    )
+    start = TIME_RESOLUTIONS.index(max_period)
+    end = TIME_RESOLUTIONS.index(min_period) + 1
+    check_argument(
+        start < end,
+        "max_period {} must be earlier in sequence {} than min_period {}",
+        max_period,
+        TIME_RESOLUTIONS,
+        min_period,
+    )
+    return TIME_RESOLUTIONSstart:end
+
+
+@defines_dtype_strategy
+def datetime64_dtypes(
+    *, max_period: str = "Y", min_period: str = "ns", endianness: str = "?"
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for datetime64 dtypes, with various precisions from
+    year to attosecond."""
+    return dtype_factory(
+        "datetime64{}",
+        validate_time_slice(max_period, min_period),
+        TIME_RESOLUTIONS,
+        endianness,
+    )
+
+
+@defines_dtype_strategy
+def timedelta64_dtypes(
+    *, max_period: str = "Y", min_period: str = "ns", endianness: str = "?"
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for timedelta64 dtypes, with various precisions from
+    year to attosecond."""
+    return dtype_factory(
+        "timedelta64{}",
+        validate_time_slice(max_period, min_period),
+        TIME_RESOLUTIONS,
+        endianness,
+    )
+
+
+@defines_dtype_strategy
+def byte_string_dtypes(
+    *, endianness: str = "?", min_len: int = 1, max_len: int = 16
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for generating bytestring dtypes, of various lengths
+    and byteorder.
+
+    While Hypothesis' string strategies can generate empty strings, string
+    dtypes with length 0 indicate that size is still to be determined, so
+    the minimum length for string dtypes is 1.
+    """
+    order_check("len", 1, min_len, max_len)
+    return dtype_factory("S", list(range(min_len, max_len + 1)), None, endianness)
+
+
+@defines_dtype_strategy
+def unicode_string_dtypes(
+    *, endianness: str = "?", min_len: int = 1, max_len: int = 16
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for generating unicode string dtypes, of various
+    lengths and byteorder.
+
+    While Hypothesis' string strategies can generate empty strings, string
+    dtypes with length 0 indicate that size is still to be determined, so
+    the minimum length for string dtypes is 1.
+    """
+    order_check("len", 1, min_len, max_len)
+    return dtype_factory("U", list(range(min_len, max_len + 1)), None, endianness)
+
+
+def _no_title_is_name_of_a_titled_field(ls):
+    seen = set()
+    for title_and_name, *_ in ls:
+        if isinstance(title_and_name, tuple):
+            if seen.intersection(title_and_name):  # pragma: no cover
+                # Our per-element filters below make this as rare as possible,
+                # so it's not always covered.
+                return False
+            seen.update(title_and_name)
+    return True
+
+
+@defines_dtype_strategy
+def array_dtypes(
+    subtype_strategy: st.SearchStrategynp.dtype = scalar_dtypes(),
+    *,
+    min_size: int = 1,
+    max_size: int = 5,
+    allow_subarrays: bool = False,
+) -> st.SearchStrategynp.dtype:
+    """Return a strategy for generating array (compound) dtypes, with members
+    drawn from the given subtype strategy."""
+    order_check("size", 0, min_size, max_size)
+    # The empty string is replaced by f{idx}; see #1963 for details.  Much easier to
+    # insist that field names be unique and just boost f{idx} strings manually.
+    field_names = st.integers(0, 127).map("f{}".format) | st.text(min_size=1)
+    name_titles = st.one_of(
+        field_names,
+        st.tuples(field_names, field_names).filter(lambda ns: ns0 != ns1),
+    )
+    elements = st.tuples(name_titles, subtype_strategy)
+    if allow_subarrays:
+        elements |= st.tuples(
+            name_titles, subtype_strategy, array_shapes(max_dims=2, max_side=2)
+        )
+    return st.lists(
+        elements=elements,
+        min_size=min_size,
+        max_size=max_size,
+        unique_by=(
+            # Deduplicate by both name and title for efficiency before filtering.
+            # (Field names must be unique, as must titles, and no intersections)
+            lambda d: d0 if isinstance(d0, str) else d00,
+            lambda d: d0 if isinstance(d0, str) else d01,
+        ),
+    ).filter(_no_title_is_name_of_a_titled_field)
+
+
+@defines_strategy()
+def nested_dtypes(
+    subtype_strategy: st.SearchStrategynp.dtype = scalar_dtypes(),
+    *,
+    max_leaves: int = 10,
+    max_itemsize: Optionalint = None,
+) -> st.SearchStrategynp.dtype:
+    """Return the most-general dtype strategy.
+
+    Elements drawn from this strategy may be simple (from the
+    subtype_strategy), or several such values drawn from
+    :func:`array_dtypes` with ``allow_subarrays=True``. Subdtypes in an
+    array dtype may be nested to any depth, subject to the max_leaves
+    argument.
+    """
+    return st.recursive(
+        subtype_strategy,
+        lambda x: array_dtypes(x, allow_subarrays=True),
+        max_leaves=max_leaves,
+    ).filter(lambda d: max_itemsize is None or d.itemsize <= max_itemsize)
+
+
+@proxies(_valid_tuple_axes)
+def valid_tuple_axes(*args, **kwargs):
+    return _valid_tuple_axes(*args, **kwargs)
+
+
+valid_tuple_axes.__doc__ = f"""
+    Return a strategy for generating permissible tuple-values for the
+    ``axis`` argument for a numpy sequential function (e.g.
+    :func:`numpy:numpy.sum`), given an array of the specified
+    dimensionality.
+
+    {_valid_tuple_axes.__doc__}
+    """
+
+
+@proxies(_mutually_broadcastable_shapes)
+def mutually_broadcastable_shapes(*args, **kwargs):
+    return _mutually_broadcastable_shapes(*args, **kwargs)
+
+
+mutually_broadcastable_shapes.__doc__ = f"""
+    {_mutually_broadcastable_shapes.__doc__}
+
+    **Use with Generalised Universal Function signatures**
+
+    A :doc:`universal function <numpy:reference/ufuncs>` (or ufunc for short) is a function
+    that operates on ndarrays in an element-by-element fashion, supporting array
+    broadcasting, type casting, and several other standard features.
+    A :doc:`generalised ufunc <numpy:reference/c-api/generalized-ufuncs>` operates on
+    sub-arrays rather than elements, based on the "signature" of the function.
+    Compare e.g. :obj:`numpy.add() <numpy:numpy.add>` (ufunc) to
+    :obj:`numpy.matmul() <numpy:numpy.matmul>` (gufunc).
+
+    To generate shapes for a gufunc, you can pass the ``signature`` argument instead of
+    ``num_shapes``.  This must be a gufunc signature string; which you can write by
+    hand or access as e.g. ``np.matmul.signature`` on generalised ufuncs.
+
+    In this case, the ``side`` arguments are applied to the 'core dimensions' as well,
+    ignoring any frozen dimensions.  ``base_shape``  and the ``dims`` arguments are
+    applied to the 'loop dimensions', and if necessary, the dimensionality of each
+    shape is silently capped to respect the 32-dimension limit.
+
+    The generated ``result_shape`` is the real result shape of applying the gufunc
+    to arrays of the generated ``input_shapes``, even where this is different to
+    broadcasting the loop dimensions.
+
+    gufunc-compatible shapes shrink their loop dimensions as above, towards omitting
+    optional core dimensions, and smaller-size core dimensions.
+
+    .. code-block:: pycon
+
+        >>> # np.matmul.signature == "(m?,n),(n,p?)->(m?,p?)"
+        >>> for _ in range(3):
+        ...     mutually_broadcastable_shapes(signature=np.matmul.signature).example()
+        BroadcastableShapes(input_shapes=((2,), (2,)), result_shape=())
+        BroadcastableShapes(input_shapes=((3, 4, 2), (1, 2)), result_shape=(3, 4))
+        BroadcastableShapes(input_shapes=((4, 2), (1, 2, 3)), result_shape=(4, 3))
+
+    """
+
+
+@defines_strategy()
+def basic_indices(
+    shape: Shape,
+    *,
+    min_dims: int = 0,
+    max_dims: Optionalint = None,
+    allow_newaxis: bool = False,
+    allow_ellipsis: bool = True,
+) -> st.SearchStrategyBasicIndex:
+    """Return a strategy for :doc:`basic indexes <numpy:reference/arrays.indexing>` of
+    arrays with the specified shape, which may include dimensions of size zero.
+
+    It generates tuples containing some mix of integers, :obj:`python:slice`
+    objects, ``...`` (an ``Ellipsis``), and ``None``. When a length-one tuple
+    would be generated, this strategy may instead return the element which will
+    index the first axis, e.g. ``5`` instead of ``(5,)``.
+
+    * ``shape`` is the shape of the array that will be indexed, as a tuple of
+      positive integers. This must be at least two-dimensional for a tuple to be
+      a valid index; for one-dimensional arrays use
+      :func:`~hypothesis.strategies.slices` instead.
+    * ``min_dims`` is the minimum dimensionality of the resulting array from use
+      of the generated index. When ``min_dims == 0``, scalars and zero-dimensional
+      arrays are both allowed.
+    * ``max_dims`` is the the maximum dimensionality of the resulting array,
+      defaulting to ``len(shape) if not allow_newaxis else
+      max(len(shape), min_dims) + 2``.
+    * ``allow_newaxis`` specifies whether ``None`` is allowed in the index.
+    * ``allow_ellipsis`` specifies whether ``...`` is allowed in the index.
+    """
+    # Arguments to exclude scalars, zero-dim arrays, and dims of size zero were
+    # all considered and rejected.  We want users to explicitly consider those
+    # cases if they're dealing in general indexers, and while it's fiddly we can
+    # back-compatibly add them later (hence using kwonlyargs).
+    check_type(tuple, shape, "shape")
+    check_argument(
+        all(isinstance(x, int) and x >= 0 for x in shape),
+        f"shape={shape!r}, but all dimensions must be non-negative integers.",
+    )
+    check_type(bool, allow_ellipsis, "allow_ellipsis")
+    check_type(bool, allow_newaxis, "allow_newaxis")
+    check_type(int, min_dims, "min_dims")
+    if min_dims > len(shape) and not allow_newaxis:
+        note_deprecation(
+            f"min_dims={min_dims} is larger than len(shape)={len(shape)}, "
+            "but allow_newaxis=False makes it impossible for an indexing "
+            "operation to add dimensions.",
+            since="2021-09-15",
+            has_codemod=False,
+        )
+    check_valid_dims(min_dims, "min_dims")
+
+    if max_dims is None:
+        if allow_newaxis:
+            max_dims = min(max(len(shape), min_dims) + 2, NDIM_MAX)
+        else:
+            max_dims = min(len(shape), NDIM_MAX)
+    else:
+        check_type(int, max_dims, "max_dims")
+        if max_dims > len(shape) and not allow_newaxis:
+            note_deprecation(
+                f"max_dims={max_dims} is larger than len(shape)={len(shape)}, "
+                "but allow_newaxis=False makes it impossible for an indexing "
+                "operation to add dimensions.",
+                since="2021-09-15",
+                has_codemod=False,
+            )
+    check_valid_dims(max_dims, "max_dims")
+
+    order_check("dims", 0, min_dims, max_dims)
+
+    return BasicIndexStrategy(
+        shape,
+        min_dims=min_dims,
+        max_dims=max_dims,
+        allow_ellipsis=allow_ellipsis,
+        allow_newaxis=allow_newaxis,
+        allow_fewer_indices_than_dims=True,
+    )
+
+
+@defines_strategy()
+def integer_array_indices(
+    shape: Shape,
+    *,
+    result_shape: st.SearchStrategyShape = array_shapes(),
+    dtype: D = np.int_,
+) -> "st.SearchStrategyTupleNDArrayD, ...":
+    """Return a search strategy for tuples of integer-arrays that, when used
+    to index into an array of shape ``shape``, given an array whose shape
+    was drawn from ``result_shape``.
+
+    Examples from this strategy shrink towards the tuple of index-arrays::
+
+        len(shape) * (np.zeros(drawn_result_shape, dtype), )
+
+    * ``shape`` a tuple of integers that indicates the shape of the array,
+      whose indices are being generated.
+    * ``result_shape`` a strategy for generating tuples of integers, which
+      describe the shape of the resulting index arrays. The default is
+      :func:`~hypothesis.extra.numpy.array_shapes`.  The shape drawn from
+      this strategy determines the shape of the array that will be produced
+      when the corresponding example from ``integer_array_indices`` is used
+      as an index.
+    * ``dtype`` the integer data type of the generated index-arrays. Negative
+      integer indices can be generated if a signed integer type is specified.
+
+    Recall that an array can be indexed using a tuple of integer-arrays to
+    access its members in an arbitrary order, producing an array with an
+    arbitrary shape. For example:
+
+    .. code-block:: pycon
+
+        >>> from numpy import array
+        >>> x = array(-0, -1, -2, -3, -4)
+        >>> ind = (array(4, 0, 0, 1),)  # a tuple containing a 2D integer-array
+        >>> xind  # the resulting array is commensurate with the indexing array(s)
+        array(-4,  0,
+               0, -1)
+
+    Note that this strategy does not accommodate all variations of so-called
+    'advanced indexing', as prescribed by NumPy's nomenclature.  Combinations
+    of basic and advanced indexes are too complex to usefully define in a
+    standard strategy; we leave application-specific strategies to the user.
+    Advanced-boolean indexing can be defined as ``arrays(shape=..., dtype=bool)``,
+    and is similarly left to the user.
+    """
+    check_type(tuple, shape, "shape")
+    check_argument(
+        shape and all(isinstance(x, int) and x > 0 for x in shape),
+        f"shape={shape!r} must be a non-empty tuple of integers > 0",
+    )
+    check_strategy(result_shape, "result_shape")
+    check_argument(
+        np.issubdtype(dtype, np.integer), f"dtype={dtype!r} must be an integer dtype"
+    )
+    signed = np.issubdtype(dtype, np.signedinteger)
+
+    def array_for(index_shape, size):
+        return arrays(
+            dtype=dtype,
+            shape=index_shape,
+            elements=st.integers(-size if signed else 0, size - 1),
+        )
+
+    return result_shape.flatmap(
+        lambda index_shape: st.tuples(*(array_for(index_shape, size) for size in shape))
+    )
+
+
+def _unpack_generic(thing):
+    # get_origin and get_args fail on python<3.9 because (some of) the
+    # relevant types do not inherit from _GenericAlias.  So just pick the
+    # value out directly.
+    real_thing = getattr(thing, "__origin__", None)
+    if real_thing is not None:
+        return (real_thing, getattr(thing, "__args__", ()))
+    else:
+        return (thing, ())
+
+
+def _unpack_dtype(dtype):
+    dtype_args = getattr(dtype, "__args__", ())
+    if dtype_args:
+        assert len(dtype_args) == 1
+        if isinstance(dtype_args0, TypeVar):
+            # numpy.dtype+ScalarType
+            assert dtype_args0.__bound__ == np.generic
+            dtype = Any
+        else:
+            # plain dtype
+            dtype = dtype_args0
+    return dtype
+
+
+def _dtype_and_shape_from_args(args):
+    if len(args) <= 1:
+        # Zero args: ndarray, _SupportsArray
+        # One arg: ndarraytype, _SupportsArraytype
+        shape = Any
+        dtype = _unpack_dtype(args0) if args else Any
+    else:
+        # Two args: ndarrayshape, type, NDArray*
+        assert len(args) == 2
+        shape = args0
+        assert shape is Any
+        dtype = _unpack_dtype(args1)
+    return (
+        scalar_dtypes() if dtype is Any else np.dtype(dtype),
+        array_shapes(max_dims=2) if shape is Any else shape,
+    )
+
+
+def _from_type(thing: TypeEx) -> Optionalst.SearchStrategyEx:
+    """Called by st.from_type to try to infer a strategy for thing using numpy.
+
+    If we can infer a numpy-specific strategy for thing, we return that; otherwise,
+    we return None.
+    """
+
+    base_strats = st.one_of(
+        
+            st.booleans(),
+            st.integers(),
+            st.floats(),
+            st.complex_numbers(),
+            st.text(),
+            st.binary(),
+        
+    )
+    # don't mix strings and non-ascii bytestrings (ex: '', b'\x80'). See
+    # https://github.com/numpy/numpy/issues/23899.
+    base_strats_ascii = st.one_of(
+        
+            st.booleans(),
+            st.integers(),
+            st.floats(),
+            st.complex_numbers(),
+            st.text(),
+            st.binary().filter(bytes.isascii),
+        
+    )
+
+    if thing == np.dtype:
+        # Note: Parameterized dtypes and DTypeLike are not supported.
+        return st.one_of(
+            scalar_dtypes(),
+            byte_string_dtypes(),
+            unicode_string_dtypes(),
+            array_dtypes(),
+            nested_dtypes(),
+        )
+
+    if thing == ArrayLike:
+        # We override the default type resolution to ensure the "coercible to
+        # array" contract is honoured. See
+        # https://github.com/HypothesisWorks/hypothesis/pull/3670#issuecomment-1578140422.
+        # The actual type is (as of np 1.24), with
+        # scalars:=bool, int, float, complex, str, bytes:
+        # Union
+        #     _SupportsArray,
+        #     _NestedSequence_SupportsArray,
+        #     *scalars,
+        #     _NestedSequenceUnion*scalars
+        # 
+        return st.one_of(
+            # *scalars
+            base_strats,
+            # The two recursive strategies below cover the following cases:
+            # - _SupportsArray (using plain ndarrays)
+            # - _NestedSequenceUnion*scalars (but excluding non-ascii binary)
+            # - _NestedSequence_SupportsArray (but with a single leaf element
+            # .  to avoid the issue of unequally sized leaves)
+            st.recursive(st.lists(base_strats_ascii), extend=st.tuples),
+            st.recursive(st.from_type(np.ndarray), extend=st.tuples),
+        )
+
+    if isinstance(thing, type) and issubclass(thing, np.generic):
+        dtype = np.dtype(thing)
+        return from_dtype(dtype) if dtype.kind not in "OV" else None
+
+    real_thing, args = _unpack_generic(thing)
+
+    if real_thing == _NestedSequence:
+        # We have to override the default resolution to ensure sequences are of
+        # equal length. Actually they are still not, if the arg specialization
+        # returns arbitrary-shaped sequences or arrays - hence the even more special
+        # resolution of ArrayLike, above.
+        assert len(args) <= 1
+        base_strat = st.from_type(args0) if args else base_strats
+        return st.one_of(
+            st.lists(base_strat),
+            st.recursive(st.tuples(), st.tuples),
+            st.recursive(st.tuples(base_strat), st.tuples),
+            st.recursive(st.tuples(base_strat, base_strat), st.tuples),
+        )
+
+    if real_thing in np.ndarray, _SupportsArray:
+        dtype, shape = _dtype_and_shape_from_args(args)
+        return arrays(dtype, shape)
+
+    # We didn't find a type to resolve, continue
+    return None

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/pandas Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/pandas/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/pandas/impl.py Added

@@ -0,0 +1,765 @@
+# 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/.
+
+from collections import OrderedDict, abc
+from copy import copy
+from datetime import datetime, timedelta
+from typing import Any, List, Optional, Sequence, Set, Union
+
+import attr
+import numpy as np
+import pandas
+
+from hypothesis import strategies as st
+from hypothesis._settings import note_deprecation
+from hypothesis.control import reject
+from hypothesis.errors import InvalidArgument
+from hypothesis.extra import numpy as npst
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.coverage import check, check_function
+from hypothesis.internal.reflection import get_pretty_function_description
+from hypothesis.internal.validation import (
+    check_type,
+    check_valid_interval,
+    check_valid_size,
+    try_convert,
+)
+from hypothesis.strategies._internal.strategies import Ex, check_strategy
+from hypothesis.strategies._internal.utils import cacheable, defines_strategy
+
+try:
+    from pandas.api.types import is_categorical_dtype
+except ImportError:
+
+    def is_categorical_dtype(dt):
+        if isinstance(dt, np.dtype):
+            return False
+        return dt == "category"
+
+
+try:
+    from pandas.core.arrays.integer import IntegerDtype
+except ImportError:
+    IntegerDtype = ()
+
+
+def dtype_for_elements_strategy(s):
+    return st.shared(
+        s.map(lambda x: pandas.Series(x).dtype),
+        key=("hypothesis.extra.pandas.dtype_for_elements_strategy", s),
+    )
+
+
+def infer_dtype_if_necessary(dtype, values, elements, draw):
+    if dtype is None and not values:
+        return draw(dtype_for_elements_strategy(elements))
+    return dtype
+
+
+@check_function
+def elements_and_dtype(elements, dtype, source=None):
+    if source is None:
+        prefix = ""
+    else:
+        prefix = f"{source}."
+
+    if elements is not None:
+        check_strategy(elements, f"{prefix}elements")
+    else:
+        with check("dtype is not None"):
+            if dtype is None:
+                raise InvalidArgument(
+                    f"At least one of {prefix}elements or {prefix}dtype must be provided."
+                )
+
+    with check("is_categorical_dtype"):
+        if is_categorical_dtype(dtype):
+            raise InvalidArgument(
+                f"{prefix}dtype is categorical, which is currently unsupported"
+            )
+
+    if isinstance(dtype, type) and issubclass(dtype, IntegerDtype):
+        raise InvalidArgument(
+            f"Passed dtype={dtype!r} is a dtype class, please pass in an instance of this class."
+            "Otherwise it would be treated as dtype=object"
+        )
+
+    if isinstance(dtype, type) and np.dtype(dtype).kind == "O" and dtype is not object:
+        err_msg = f"Passed dtype={dtype!r} is not a valid Pandas dtype."
+        if issubclass(dtype, datetime):
+            err_msg += ' To generate valid datetimes, pass `dtype="datetime64ns"`'
+            raise InvalidArgument(err_msg)
+        elif issubclass(dtype, timedelta):
+            err_msg += ' To generate valid timedeltas, pass `dtype="timedelta64ns"`'
+            raise InvalidArgument(err_msg)
+        note_deprecation(
+            f"{err_msg}  We'll treat it as "
+            "dtype=object for now, but this will be an error in a future version.",
+            since="2021-12-31",
+            has_codemod=False,
+        )
+
+    if isinstance(dtype, st.SearchStrategy):
+        raise InvalidArgument(
+            f"Passed dtype={dtype!r} is a strategy, but we require a concrete dtype "
+            "here.  See https://stackoverflow.com/q/74355937 for workaround patterns."
+        )
+
+    _get_subclasses = getattr(IntegerDtype, "__subclasses__", list)
+    dtype = {t.name: t() for t in _get_subclasses()}.get(dtype, dtype)
+
+    if isinstance(dtype, IntegerDtype):
+        is_na_dtype = True
+        dtype = np.dtype(dtype.name.lower())
+    elif dtype is not None:
+        is_na_dtype = False
+        dtype = try_convert(np.dtype, dtype, "dtype")
+    else:
+        is_na_dtype = False
+
+    if elements is None:
+        elements = npst.from_dtype(dtype)
+        if is_na_dtype:
+            elements = st.none() | elements
+    elif dtype is not None:
+
+        def convert_element(value):
+            if is_na_dtype and value is None:
+                return None
+            name = f"draw({prefix}elements)"
+            try:
+                return np.array(value, dtype=dtype)0
+            except (TypeError, ValueError):
+                raise InvalidArgument(
+                    "Cannot convert %s=%r of type %s to dtype %s"
+                    % (name, value, type(value).__name__, dtype.str)
+                ) from None
+
+        elements = elements.map(convert_element)
+    assert elements is not None
+
+    return elements, dtype
+
+
+class ValueIndexStrategy(st.SearchStrategy):
+    def __init__(self, elements, dtype, min_size, max_size, unique, name):
+        super().__init__()
+        self.elements = elements
+        self.dtype = dtype
+        self.min_size = min_size
+        self.max_size = max_size
+        self.unique = unique
+        self.name = name
+
+    def do_draw(self, data):
+        result = 
+        seen = set()
+
+        iterator = cu.many(
+            data,
+            min_size=self.min_size,
+            max_size=self.max_size,
+            average_size=(self.min_size + self.max_size) / 2,
+        )
+
+        while iterator.more():
+            elt = data.draw(self.elements)
+
+            if self.unique:
+                if elt in seen:
+                    iterator.reject()
+                    continue
+                seen.add(elt)
+            result.append(elt)
+
+        dtype = infer_dtype_if_necessary(
+            dtype=self.dtype, values=result, elements=self.elements, draw=data.draw
+        )
+        return pandas.Index(
+            result, dtype=dtype, tupleize_cols=False, name=data.draw(self.name)
+        )
+
+
+DEFAULT_MAX_SIZE = 10
+
+
+@cacheable
+@defines_strategy()
+def range_indexes(
+    min_size: int = 0,
+    max_size: Optionalint = None,
+    name: st.SearchStrategyOptionalstr = st.none(),
+) -> st.SearchStrategypandas.RangeIndex:
+    """Provides a strategy which generates an :class:`~pandas.Index` whose
+    values are 0, 1, ..., n for some n.
+
+    Arguments:
+
+    * min_size is the smallest number of elements the index can have.
+    * max_size is the largest number of elements the index can have. If None
+      it will default to some suitable value based on min_size.
+    * name is the name of the index. If st.none(), the index will have no name.
+    """
+    check_valid_size(min_size, "min_size")
+    check_valid_size(max_size, "max_size")
+    if max_size is None:
+        max_size = min(min_size + DEFAULT_MAX_SIZE, 2**63 - 1)
+    check_valid_interval(min_size, max_size, "min_size", "max_size")
+    check_strategy(name)
+
+    return st.builds(pandas.RangeIndex, st.integers(min_size, max_size), name=name)
+
+
+@cacheable
+@defines_strategy()
+def indexes(
+    *,
+    elements: Optionalst.SearchStrategyEx = None,
+    dtype: Any = None,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+    unique: bool = True,
+    name: st.SearchStrategyOptionalstr = st.none(),
+) -> st.SearchStrategypandas.Index:
+    """Provides a strategy for producing a :class:`pandas.Index`.
+
+    Arguments:
+
+    * elements is a strategy which will be used to generate the individual
+      values of the index. If None, it will be inferred from the dtype. Note:
+      even if the elements strategy produces tuples, the generated value
+      will not be a MultiIndex, but instead be a normal index whose elements
+      are tuples.
+    * dtype is the dtype of the resulting index. If None, it will be inferred
+      from the elements strategy. At least one of dtype or elements must be
+      provided.
+    * min_size is the minimum number of elements in the index.
+    * max_size is the maximum number of elements in the index. If None then it
+      will default to a suitable small size. If you want larger indexes you
+      should pass a max_size explicitly.
+    * unique specifies whether all of the elements in the resulting index
+      should be distinct.
+    * name is a strategy for strings or ``None``, which will be passed to
+      the :class:`pandas.Index` constructor.
+    """
+    check_valid_size(min_size, "min_size")
+    check_valid_size(max_size, "max_size")
+    check_valid_interval(min_size, max_size, "min_size", "max_size")
+    check_type(bool, unique, "unique")
+
+    elements, dtype = elements_and_dtype(elements, dtype)
+
+    if max_size is None:
+        max_size = min_size + DEFAULT_MAX_SIZE
+    return ValueIndexStrategy(elements, dtype, min_size, max_size, unique, name)
+
+
+@defines_strategy()
+def series(
+    *,
+    elements: Optionalst.SearchStrategyEx = None,
+    dtype: Any = None,
+    index: Optionalst.SearchStrategyUnionSequence, pandas.Index = None,
+    fill: Optionalst.SearchStrategyEx = None,
+    unique: bool = False,
+    name: st.SearchStrategyOptionalstr = st.none(),
+) -> st.SearchStrategypandas.Series:
+    """Provides a strategy for producing a :class:`pandas.Series`.
+
+    Arguments:
+
+    * elements: a strategy that will be used to generate the individual
+      values in the series. If None, we will attempt to infer a suitable
+      default from the dtype.
+
+    * dtype: the dtype of the resulting series and may be any value
+      that can be passed to :class:`numpy.dtype`. If None, will use
+      pandas's standard behaviour to infer it from the type of the elements
+      values. Note that if the type of values that comes out of your
+      elements strategy varies, then so will the resulting dtype of the
+      series.
+
+    * index: If not None, a strategy for generating indexes for the
+      resulting Series. This can generate either :class:`pandas.Index`
+      objects or any sequence of values (which will be passed to the
+      Index constructor).
+
+      You will probably find it most convenient to use the
+      :func:`~hypothesis.extra.pandas.indexes` or
+      :func:`~hypothesis.extra.pandas.range_indexes` function to produce
+      values for this argument.
+
+    * name: is a strategy for strings or ``None``, which will be passed to
+      the :class:`pandas.Series` constructor.
+
+    Usage:
+
+    .. code-block:: pycon
+
+        >>> series(dtype=int).example()
+        0   -2001747478
+        1    1153062837
+    """
+    if index is None:
+        index = range_indexes()
+    else:
+        check_strategy(index, "index")
+
+    elements, np_dtype = elements_and_dtype(elements, dtype)
+    index_strategy = index
+
+    # if it is converted to an object, use object for series type
+    if (
+        np_dtype is not None
+        and np_dtype.kind == "O"
+        and not isinstance(dtype, IntegerDtype)
+    ):
+        dtype = np_dtype
+
+    @st.composite
+    def result(draw):
+        index = draw(index_strategy)
+
+        if len(index) > 0:
+            if dtype is not None:
+                result_data = draw(
+                    npst.arrays(
+                        dtype=object,
+                        elements=elements,
+                        shape=len(index),
+                        fill=fill,
+                        unique=unique,
+                    )
+                ).tolist()
+            else:
+                result_data = list(
+                    draw(
+                        npst.arrays(
+                            dtype=object,
+                            elements=elements,
+                            shape=len(index),
+                            fill=fill,
+                            unique=unique,
+                        )
+                    ).tolist()
+                )
+            return pandas.Series(result_data, index=index, dtype=dtype, name=draw(name))
+        else:
+            return pandas.Series(
+                (),
+                index=index,
+                dtype=dtype
+                if dtype is not None
+                else draw(dtype_for_elements_strategy(elements)),
+                name=draw(name),
+            )
+
+    return result()
+
+
+@attr.s(slots=True)
+class column:
+    """Data object for describing a column in a DataFrame.
+
+    Arguments:
+
+    * name: the column name, or None to default to the column position. Must
+      be hashable, but can otherwise be any value supported as a pandas column
+      name.
+    * elements: the strategy for generating values in this column, or None
+      to infer it from the dtype.
+    * dtype: the dtype of the column, or None to infer it from the element
+      strategy. At least one of dtype or elements must be provided.
+    * fill: A default value for elements of the column. See
+      :func:`~hypothesis.extra.numpy.arrays` for a full explanation.
+    * unique: If all values in this column should be distinct.
+    """
+
+    name = attr.ib(default=None)
+    elements = attr.ib(default=None)
+    dtype = attr.ib(default=None, repr=get_pretty_function_description)
+    fill = attr.ib(default=None)
+    unique = attr.ib(default=False)
+
+
+def columns(
+    names_or_number: Unionint, Sequencestr,
+    *,
+    dtype: Any = None,
+    elements: Optionalst.SearchStrategyEx = None,
+    fill: Optionalst.SearchStrategyEx = None,
+    unique: bool = False,
+) -> Listcolumn:
+    """A convenience function for producing a list of :class:`column` objects
+    of the same general shape.
+
+    The names_or_number argument is either a sequence of values, the
+    elements of which will be used as the name for individual column
+    objects, or a number, in which case that many unnamed columns will
+    be created. All other arguments are passed through verbatim to
+    create the columns.
+    """
+    if isinstance(names_or_number, (int, float)):
+        names: ListUnionint, str, None = None * names_or_number
+    else:
+        names = list(names_or_number)
+    return 
+        column(name=n, dtype=dtype, elements=elements, fill=fill, unique=unique)
+        for n in names
+    
+
+
+@defines_strategy()
+def data_frames(
+    columns: OptionalSequencecolumn = None,
+    *,
+    rows: Optionalst.SearchStrategyUniondict, SequenceAny = None,
+    index: Optionalst.SearchStrategyEx = None,
+) -> st.SearchStrategypandas.DataFrame:
+    """Provides a strategy for producing a :class:`pandas.DataFrame`.
+
+    Arguments:
+
+    * columns: An iterable of :class:`column` objects describing the shape
+      of the generated DataFrame.
+
+    * rows: A strategy for generating a row object. Should generate
+      either dicts mapping column names to values or a sequence mapping
+      column position to the value in that position (note that unlike the
+      :class:`pandas.DataFrame` constructor, single values are not allowed
+      here. Passing e.g. an integer is an error, even if there is only one
+      column).
+
+      At least one of rows and columns must be provided. If both are
+      provided then the generated rows will be validated against the
+      columns and an error will be raised if they don't match.
+
+      Caveats on using rows:
+
+      * In general you should prefer using columns to rows, and only use
+        rows if the columns interface is insufficiently flexible to
+        describe what you need - you will get better performance and
+        example quality that way.
+      * If you provide rows and not columns, then the shape and dtype of
+        the resulting DataFrame may vary. e.g. if you have a mix of int
+        and float in the values for one column in your row entries, the
+        column will sometimes have an integral dtype and sometimes a float.
+
+    * index: If not None, a strategy for generating indexes for the
+      resulting DataFrame. This can generate either :class:`pandas.Index`
+      objects or any sequence of values (which will be passed to the
+      Index constructor).
+
+      You will probably find it most convenient to use the
+      :func:`~hypothesis.extra.pandas.indexes` or
+      :func:`~hypothesis.extra.pandas.range_indexes` function to produce
+      values for this argument.
+
+    Usage:
+
+    The expected usage pattern is that you use :class:`column` and
+    :func:`columns` to specify a fixed shape of the DataFrame you want as
+    follows. For example the following gives a two column data frame:
+
+    .. code-block:: pycon
+
+        >>> from hypothesis.extra.pandas import column, data_frames
+        >>> data_frames(
+        ... column('A', dtype=int), column('B', dtype=float)).example()
+                    A              B
+        0  2021915903  1.793898e+232
+        1  1146643993            inf
+        2 -2096165693   1.000000e+07
+
+    If you want the values in different columns to interact in some way you
+    can use the rows argument. For example the following gives a two column
+    DataFrame where the value in the first column is always at most the value
+    in the second:
+
+    .. code-block:: pycon
+
+        >>> from hypothesis.extra.pandas import column, data_frames
+        >>> import hypothesis.strategies as st
+        >>> data_frames(
+        ...     rows=st.tuples(st.floats(allow_nan=False),
+        ...                    st.floats(allow_nan=False)).map(sorted)
+        ... ).example()
+                       0             1
+        0  -3.402823e+38  9.007199e+15
+        1 -1.562796e-298  5.000000e-01
+
+    You can also combine the two:
+
+    .. code-block:: pycon
+
+        >>> from hypothesis.extra.pandas import columns, data_frames
+        >>> import hypothesis.strategies as st
+        >>> data_frames(
+        ...     columns=columns("lo", "hi", dtype=float),
+        ...     rows=st.tuples(st.floats(allow_nan=False),
+        ...                    st.floats(allow_nan=False)).map(sorted)
+        ... ).example()
+                 lo            hi
+        0   9.314723e-49  4.353037e+45
+        1  -9.999900e-01  1.000000e+07
+        2 -2.152861e+134 -1.069317e-73
+
+    (Note that the column dtype must still be specified and will not be
+    inferred from the rows. This restriction may be lifted in future).
+
+    Combining rows and columns has the following behaviour:
+
+    * The column names and dtypes will be used.
+    * If the column is required to be unique, this will be enforced.
+    * Any values missing from the generated rows will be provided using the
+      column's fill.
+    * Any values in the row not present in the column specification (if
+      dicts are passed, if there are keys with no corresponding column name,
+      if sequences are passed if there are too many items) will result in
+      InvalidArgument being raised.
+    """
+    if index is None:
+        index = range_indexes()
+    else:
+        check_strategy(index, "index")
+
+    index_strategy = index
+
+    if columns is None:
+        if rows is None:
+            raise InvalidArgument("At least one of rows and columns must be provided")
+        else:
+
+            @st.composite
+            def rows_only(draw):
+                index = draw(index_strategy)
+
+                @check_function
+                def row():
+                    result = draw(rows)
+                    check_type(abc.Iterable, result, "draw(row)")
+                    return result
+
+                if len(index) > 0:
+                    return pandas.DataFrame(row() for _ in index, index=index)
+                else:
+                    # If we haven't drawn any rows we need to draw one row and
+                    # then discard it so that we get a consistent shape for the
+                    # DataFrame.
+                    base = pandas.DataFrame(row())
+                    return base.drop(0)
+
+            return rows_only()
+
+    assert columns is not None
+    cols = try_convert(tuple, columns, "columns")
+
+    rewritten_columns = 
+    column_names: Setstr = set()
+
+    for i, c in enumerate(cols):
+        check_type(column, c, f"columns{i}")
+
+        c = copy(c)
+        if c.name is None:
+            label = f"columns{i}"
+            c.name = i
+        else:
+            label = c.name
+            try:
+                hash(c.name)
+            except TypeError:
+                raise InvalidArgument(
+                    f"Column names must be hashable, but columns{i}.name was "
+                    f"{c.name!r} of type {type(c.name).__name__}, which cannot be hashed."
+                ) from None
+
+        if c.name in column_names:
+            raise InvalidArgument(f"duplicate definition of column name {c.name!r}")
+
+        column_names.add(c.name)
+
+        c.elements, _ = elements_and_dtype(c.elements, c.dtype, label)
+
+        if c.dtype is None and rows is not None:
+            raise InvalidArgument(
+                "Must specify a dtype for all columns when combining rows with columns."
+            )
+
+        c.fill = npst.fill_for(
+            fill=c.fill, elements=c.elements, unique=c.unique, name=label
+        )
+
+        rewritten_columns.append(c)
+
+    if rows is None:
+
+        @st.composite
+        def just_draw_columns(draw):
+            index = draw(index_strategy)
+            local_index_strategy = st.just(index)
+
+            data = OrderedDict((c.name, None) for c in rewritten_columns)
+
+            # Depending on how the columns are going to be generated we group
+            # them differently to get better shrinking. For columns with fill
+            # enabled, the elements can be shrunk independently of the size,
+            # so we can just shrink by shrinking the index then shrinking the
+            # length and are generally much more free to move data around.
+
+            # For columns with no filling the problem is harder, and drawing
+            # them like that would result in rows being very far apart from
+            # each other in the underlying data stream, which gets in the way
+            # of shrinking. So what we do is reorder and draw those columns
+            # row wise, so that the values of each row are next to each other.
+            # This makes life easier for the shrinker when deleting blocks of
+            # data.
+            columns_without_fill = c for c in rewritten_columns if c.fill.is_empty
+
+            if columns_without_fill:
+                for c in columns_without_fill:
+                    datac.name = pandas.Series(
+                        np.zeros(shape=len(index), dtype=object),
+                        index=index,
+                        dtype=c.dtype,
+                    )
+                seen = {c.name: set() for c in columns_without_fill if c.unique}
+
+                for i in range(len(index)):
+                    for c in columns_without_fill:
+                        if c.unique:
+                            for _ in range(5):
+                                value = draw(c.elements)
+                                if value not in seenc.name:
+                                    seenc.name.add(value)
+                                    break
+                            else:
+                                reject()
+                        else:
+                            value = draw(c.elements)
+                        try:
+                            datac.namei = value
+                        except ValueError as err:  # pragma: no cover
+                            # This just works in Pandas 1.4 and later, but gives
+                            # a confusing error on previous versions.
+                            if c.dtype is None and not isinstance(
+                                value, (float, int, str, bool, datetime, timedelta)
+                            ):
+                                raise ValueError(
+                                    f"Failed to add value={value!r} to column "
+                                    f"{c.name} with dtype=None.  Maybe passing "
+                                    "dtype=object would help?"
+                                ) from err
+                            # Unclear how this could happen, but users find a way...
+                            raise
+
+            for c in rewritten_columns:
+                if not c.fill.is_empty:
+                    datac.name = draw(
+                        series(
+                            index=local_index_strategy,
+                            dtype=c.dtype,
+                            elements=c.elements,
+                            fill=c.fill,
+                            unique=c.unique,
+                        )
+                    )
+
+            return pandas.DataFrame(data, index=index)
+
+        return just_draw_columns()
+    else:
+
+        @st.composite
+        def assign_rows(draw):
+            index = draw(index_strategy)
+
+            result = pandas.DataFrame(
+                OrderedDict(
+                    (
+                        c.name,
+                        pandas.Series(
+                            np.zeros(dtype=c.dtype, shape=len(index)), dtype=c.dtype
+                        ),
+                    )
+                    for c in rewritten_columns
+                ),
+                index=index,
+            )
+
+            fills = {}
+
+            any_unique = any(c.unique for c in rewritten_columns)
+
+            if any_unique:
+                all_seen = set() if c.unique else None for c in rewritten_columns
+                while all_seen-1 is None:
+                    all_seen.pop()
+
+            for row_index in range(len(index)):
+                for _ in range(5):
+                    original_row = draw(rows)
+                    row = original_row
+                    if isinstance(row, dict):
+                        as_list = None * len(rewritten_columns)
+                        for i, c in enumerate(rewritten_columns):
+                            try:
+                                as_listi = rowc.name
+                            except KeyError:
+                                try:
+                                    as_listi = fillsi
+                                except KeyError:
+                                    if c.fill.is_empty:
+                                        raise InvalidArgument(
+                                            f"Empty fill strategy in {c!r} cannot "
+                                            f"complete row {original_row!r}"
+                                        ) from None
+                                    fillsi = draw(c.fill)
+                                    as_listi = fillsi
+                        for k in row:
+                            if k not in column_names:
+                                raise InvalidArgument(
+                                    "Row %r contains column %r not in columns %r)"
+                                    % (row, k, c.name for c in rewritten_columns)
+                                )
+                        row = as_list
+                    if any_unique:
+                        has_duplicate = False
+                        for seen, value in zip(all_seen, row):
+                            if seen is None:
+                                continue
+                            if value in seen:
+                                has_duplicate = True
+                                break
+                            seen.add(value)
+                        if has_duplicate:
+                            continue
+                    row = list(try_convert(tuple, row, "draw(rows)"))
+
+                    if len(row) > len(rewritten_columns):
+                        raise InvalidArgument(
+                            f"Row {original_row!r} contains too many entries. Has "
+                            f"{len(row)} but expected at most {len(rewritten_columns)}"
+                        )
+                    while len(row) < len(rewritten_columns):
+                        c = rewritten_columnslen(row)
+                        if c.fill.is_empty:
+                            raise InvalidArgument(
+                                f"Empty fill strategy in {c!r} cannot "
+                                f"complete row {original_row!r}"
+                            )
+                        row.append(draw(c.fill))
+                    result.ilocrow_index = row
+                    break
+                else:
+                    reject()
+            return result
+
+        return assign_rows()

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/pytestplugin.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/pytz.py Added

@@ -0,0 +1,54 @@
+# 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/.
+
+"""
+----------------
+hypothesispytz
+----------------
+
+This module provides :pypi:`pytz` timezones.
+
+You can use this strategy to make
+:py:func:`hypothesis.strategies.datetimes` and
+:py:func:`hypothesis.strategies.times` produce timezone-aware values.
+"""
+
+import datetime as dt
+
+import pytz
+from pytz.tzfile import StaticTzInfo  # type: ignore  # considered private by typeshed
+
+from hypothesis import strategies as st
+from hypothesis.strategies._internal.utils import cacheable, defines_strategy
+
+__all__ = "timezones"
+
+
+@cacheable
+@defines_strategy()
+def timezones() -> st.SearchStrategydt.tzinfo:
+    """Any timezone in the Olsen database, as a pytz tzinfo object.
+
+    This strategy minimises to UTC, or the smallest possible fixed
+    offset, and is designed for use with
+    :py:func:`hypothesis.strategies.datetimes`.
+    """
+    all_timezones = pytz.timezone(tz) for tz in pytz.all_timezones
+    # Some timezones have always had a constant offset from UTC.  This makes
+    # them simpler than timezones with daylight savings, and the smaller the
+    # absolute offset the simpler they are.  Of course, UTC is even simpler!
+    static: list = pytz.UTC
+    static += sorted(
+        (t for t in all_timezones if isinstance(t, StaticTzInfo)),
+        key=lambda tz: abs(tz.utcoffset(dt.datetime(2000, 1, 1))),
+    )
+    # Timezones which have changed UTC offset; best ordered by name.
+    dynamic = tz for tz in all_timezones if tz not in static
+    return st.sampled_from(static + dynamic)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/extra/redis.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/__init__.py Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/cache.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/cathetus.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/charmap.py Added

@@ -0,0 +1,369 @@
+# 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 gzip
+import json
+import os
+import sys
+import tempfile
+import unicodedata
+from typing import Dict, Tuple
+
+from hypothesis.configuration import mkdir_p, storage_directory
+from hypothesis.errors import InvalidArgument
+
+intervals = TupleTupleint, int, ...
+cache_type = DictTupleTuplestr, ..., int, int, intervals, intervals
+
+
+def charmap_file():
+    return storage_directory(
+        "unicode_data", unicodedata.unidata_version, "charmap.json.gz"
+    )
+
+
+_charmap = None
+
+
+def charmap():
+    """Return a dict that maps a Unicode category, to a tuple of 2-tuples
+    covering the codepoint intervals for characters in that category.
+
+    >>> charmap()'Co'
+    ((57344, 63743), (983040, 1048573), (1048576, 1114109))
+    """
+    global _charmap
+    # Best-effort caching in the face of missing files and/or unwritable
+    # filesystems is fairly simple: check if loaded, else try loading,
+    # else calculate and try writing the cache.
+    if _charmap is None:
+        f = charmap_file()
+        try:
+            with gzip.GzipFile(f, "rb") as i:
+                tmp_charmap = dict(json.load(i))
+
+        except Exception:
+            # This loop is reduced to using only local variables for performance;
+            # indexing and updating containers is a ~3x slowdown.  This doesn't fix
+            # https://github.com/HypothesisWorks/hypothesis/issues/2108 but it helps.
+            category = unicodedata.category  # Local variable -> ~20% speedup!
+            tmp_charmap = {}
+            last_cat = category(chr(0))
+            last_start = 0
+            for i in range(1, sys.maxunicode + 1):
+                cat = category(chr(i))
+                if cat != last_cat:
+                    tmp_charmap.setdefault(last_cat, ).append(last_start, i - 1)
+                    last_cat, last_start = cat, i
+            tmp_charmap.setdefault(last_cat, ).append(last_start, sys.maxunicode)
+
+            try:
+                # Write the Unicode table atomically
+                tmpdir = storage_directory("tmp")
+                mkdir_p(tmpdir)
+                fd, tmpfile = tempfile.mkstemp(dir=tmpdir)
+                os.close(fd)
+                # Explicitly set the mtime to get reproducible output
+                with gzip.GzipFile(tmpfile, "wb", mtime=1) as o:
+                    result = json.dumps(sorted(tmp_charmap.items()))
+                    o.write(result.encode())
+
+                os.renames(tmpfile, f)
+            except Exception:
+                pass
+
+        # convert between lists and tuples
+        _charmap = {
+            k: tuple(tuple(pair) for pair in pairs) for k, pairs in tmp_charmap.items()
+        }
+        # each value is a tuple of 2-tuples (that is, tuples of length 2)
+        # and that both elements of that tuple are integers.
+        for vs in _charmap.values():
+            ints = list(sum(vs, ()))
+            assert all(isinstance(x, int) for x in ints)
+            assert ints == sorted(ints)
+            assert all(len(tup) == 2 for tup in vs)
+
+    assert _charmap is not None
+    return _charmap
+
+
+_categories = None
+
+
+def categories():
+    """Return a tuple of Unicode categories in a normalised order.
+
+    >>> categories() # doctest: +ELLIPSIS
+    ('Zl', 'Zp', 'Co', 'Me', 'Pc', ..., 'Cc', 'Cs')
+    """
+    global _categories
+    if _categories is None:
+        cm = charmap()
+        _categories = sorted(cm.keys(), key=lambda c: len(cmc))
+        _categories.remove("Cc")  # Other, Control
+        _categories.remove("Cs")  # Other, Surrogate
+        _categories.append("Cc")
+        _categories.append("Cs")
+    return tuple(_categories)
+
+
+def as_general_categories(cats, name="cats"):
+    """Return a tuple of Unicode categories in a normalised order.
+
+    This function expands one-letter designations of a major class to include
+    all subclasses:
+
+    >>> as_general_categories('N')
+    ('Nd', 'Nl', 'No')
+
+    See section 4.5 of the Unicode standard for more on classes:
+    https://www.unicode.org/versions/Unicode10.0.0/ch04.pdf
+
+    If the collection ``cats`` includes any elements that do not represent a
+    major class or a class with subclass, a deprecation warning is raised.
+    """
+    if cats is None:
+        return None
+    major_classes = ("L", "M", "N", "P", "S", "Z", "C")
+    cs = categories()
+    out = set(cats)
+    for c in cats:
+        if c in major_classes:
+            out.discard(c)
+            out.update(x for x in cs if x.startswith(c))
+        elif c not in cs:
+            raise InvalidArgument(
+                f"In {name}={cats!r}, {c!r} is not a valid Unicode category."
+            )
+    return tuple(c for c in cs if c in out)
+
+
+def _union_intervals(x, y):
+    """Merge two sequences of intervals into a single tuple of intervals.
+
+    Any integer bounded by `x` or `y` is also bounded by the result.
+
+    >>> _union_intervals((3, 10), (1, 2), (5, 17))
+    ((1, 17),)
+    """
+    if not x:
+        return tuple((u, v) for u, v in y)
+    if not y:
+        return tuple((u, v) for u, v in x)
+    intervals = sorted(x + y, reverse=True)
+    result = intervals.pop()
+    while intervals:
+        # 1. intervals is in descending order
+        # 2. pop() takes from the RHS.
+        # 3. (a, b) was popped 1st, then (u, v) was popped 2nd
+        # 4. Therefore: a <= u
+        # 5. We assume that u <= v and a <= b
+        # 6. So we need to handle 2 cases of overlap, and one disjoint case
+        #    |   u--v     |   u----v   |       u--v  |
+        #    |   a----b   |   a--b     |  a--b       |
+        u, v = intervals.pop()
+        a, b = result-1
+        if u <= b + 1:
+            # Overlap cases
+            result-1 = (a, max(v, b))
+        else:
+            # Disjoint case
+            result.append((u, v))
+    return tuple(result)
+
+
+def _subtract_intervals(x, y):
+    """Set difference for lists of intervals. That is, returns a list of
+    intervals that bounds all values bounded by x that are not also bounded by
+    y. x and y are expected to be in sorted order.
+
+    For example _subtract_intervals((1, 10), (2, 3), (9, 15)) would
+    return (1, 1), (4, 8), removing the values 2, 3, 9 and 10 from the
+    interval.
+    """
+    if not y:
+        return tuple(x)
+    x = list(map(list, x))
+    i = 0
+    j = 0
+    result = 
+    while i < len(x) and j < len(y):
+        # Iterate in parallel over x and y. j stays pointing at the smallest
+        # interval in the left hand side that could still overlap with some
+        # element of x at index >= i.
+        # Similarly, i is not incremented until we know that it does not
+        # overlap with any element of y at index >= j.
+
+        xl, xr = xi
+        assert xl <= xr
+        yl, yr = yj
+        assert yl <= yr
+
+        if yr < xl:
+            # The interval at yj is strictly to the left of the interval at
+            # xi, so will not overlap with it or any later interval of x.
+            j += 1
+        elif yl > xr:
+            # The interval at yj is strictly to the right of the interval at
+            # xi, so all of xi goes into the result as no further intervals
+            # in y will intersect it.
+            result.append(xi)
+            i += 1
+        elif yl <= xl:
+            if yr >= xr:
+                # xi is contained entirely in yj, so we just skip over it
+                # without adding it to the result.
+                i += 1
+            else:
+                # The beginning of xi is contained in yj, so we update the
+                # left endpoint of xi to remove this, and increment j as we
+                # now have moved past it. Note that this is not added to the
+                # result as is, as more intervals from y may intersect it so it
+                # may need updating further.
+                xi0 = yr + 1
+                j += 1
+        else:
+            # yl > xl, so the left hand part of xi is not contained in yj,
+            # so there are some values we should add to the result.
+            result.append((xl, yl - 1))
+
+            if yr + 1 <= xr:
+                # If yj finishes before xi does, there may be some values
+                # in xi left that should go in the result (or they may be
+                # removed by a later interval in y), so we update xi to
+                # reflect that and increment j because it no longer overlaps
+                # with any remaining element of x.
+                xi0 = yr + 1
+                j += 1
+            else:
+                # Every element of xi other than the initial part we have
+                # already added is contained in yj, so we move to the next
+                # interval.
+                i += 1
+    # Any remaining intervals in x do not overlap with any of y, as if they did
+    # we would not have incremented j to the end, so can be added to the result
+    # as they are.
+    result.extend(xi:)
+    return tuple(map(tuple, result))
+
+
+def _intervals(s):
+    """Return a tuple of intervals, covering the codepoints of characters in
+    `s`.
+
+    >>> _intervals('abcdef0123456789')
+    ((48, 57), (97, 102))
+    """
+    intervals = tuple((ord(c), ord(c)) for c in sorted(s))
+    return _union_intervals(intervals, intervals)
+
+
+category_index_cache = {(): ()}
+
+
+def _category_key(exclude, include):
+    """Return a normalised tuple of all Unicode categories that are in
+    `include`, but not in `exclude`.
+
+    If include is None then default to including all categories.
+    Any item in include that is not a unicode character will be excluded.
+
+    >>> _category_key(exclude='So', include='Lu', 'Me', 'Cs', 'So')
+    ('Me', 'Lu', 'Cs')
+    """
+    cs = categories()
+    if include is None:
+        include = set(cs)
+    else:
+        include = set(include)
+    exclude = set(exclude or ())
+    assert include.issubset(cs)
+    assert exclude.issubset(cs)
+    include -= exclude
+    return tuple(c for c in cs if c in include)
+
+
+def _query_for_key(key):
+    """Return a tuple of codepoint intervals covering characters that match one
+    or more categories in the tuple of categories `key`.
+
+    >>> _query_for_key(categories())
+    ((0, 1114111),)
+    >>> _query_for_key(('Zl', 'Zp', 'Co'))
+    ((8232, 8233), (57344, 63743), (983040, 1048573), (1048576, 1114109))
+    """
+    try:
+        return category_index_cachekey
+    except KeyError:
+        pass
+    assert key
+    if set(key) == set(categories()):
+        result = ((0, sys.maxunicode),)
+    else:
+        result = _union_intervals(_query_for_key(key:-1), charmap()key-1)
+    category_index_cachekey = result
+    return result
+
+
+limited_category_index_cache: cache_type = {}
+
+
+def query(
+    exclude_categories=(),
+    include_categories=None,
+    min_codepoint=None,
+    max_codepoint=None,
+    include_characters="",
+    exclude_characters="",
+):
+    """Return a tuple of intervals covering the codepoints for all characters
+    that meet the criteria (min_codepoint <= codepoint(c) <= max_codepoint and
+    any(cat in include_categories for cat in categories(c)) and all(cat not in
+    exclude_categories for cat in categories(c)) or (c in include_characters)
+
+    >>> query()
+    ((0, 1114111),)
+    >>> query(min_codepoint=0, max_codepoint=128)
+    ((0, 128),)
+    >>> query(min_codepoint=0, max_codepoint=128, include_categories='Lu')
+    ((65, 90),)
+    >>> query(min_codepoint=0, max_codepoint=128, include_categories='Lu',
+    ...       include_characters='☃')
+    ((65, 90), (9731, 9731))
+    """
+    if min_codepoint is None:
+        min_codepoint = 0
+    if max_codepoint is None:
+        max_codepoint = sys.maxunicode
+    catkey = _category_key(exclude_categories, include_categories)
+    character_intervals = _intervals(include_characters or "")
+    exclude_intervals = _intervals(exclude_characters or "")
+    qkey = (
+        catkey,
+        min_codepoint,
+        max_codepoint,
+        character_intervals,
+        exclude_intervals,
+    )
+    try:
+        return limited_category_index_cacheqkey
+    except KeyError:
+        pass
+    base = _query_for_key(catkey)
+    result = 
+    for u, v in base:
+        if v >= min_codepoint and u <= max_codepoint:
+            result.append((max(u, min_codepoint), min(v, max_codepoint)))
+    result = tuple(result)
+    result = _union_intervals(result, character_intervals)
+    result = _subtract_intervals(result, exclude_intervals)
+    limited_category_index_cacheqkey = result
+    return result

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/compat.py Added

@@ -0,0 +1,279 @@
+# 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 codecs
+import inspect
+import platform
+import sys
+import typing
+from functools import partial
+from typing import Any, ForwardRef, Tuple
+
+try:
+    from typing import get_args as get_args
+except ImportError:
+    # remove at Python 3.7 end-of-life
+    from collections.abc import Callable as _Callable
+
+    def get_args(
+        tp: Any,
+    ) -> TupleAny, ...:  # pragma: no cover
+        """
+        Examples
+        --------
+        >>> assert get_args(int) == ()
+        >>> assert get_args(Dictstr, int) == (str, int)
+        >>> assert get_args(Unionint, UnionT, int, strint) == (int, str)
+        >>> assert get_args(Unionint, TupleT, intstr) == (int, Tuplestr, int)
+        >>> assert get_args(Callable, Tint) == (, int)
+        """
+        if hasattr(tp, "__origin__") and hasattr(tp, "__args__"):
+            args = tp.__args__
+            if (
+                getattr(tp, "__origin__", None) is _Callable
+                and args
+                and args0 is not Ellipsis
+            ):
+                args = (list(args:-1), args-1)
+            return args
+        return ()
+
+
+try:
+    from typing import get_origin as get_origin
+except ImportError:
+    # remove at Python 3.7 end-of-life
+    from collections.abc import Callable as _Callable  # noqa: F811
+
+    def get_origin(tp: Any) -> typing.OptionalAny:  # type: ignore # pragma: no cover
+        """Get the unsubscripted version of a type.
+        This supports generic types, Callable, Tuple, Union, Literal, Final and ClassVar.
+        Return None for unsupported types. Examples::
+            get_origin(Literal42) is Literal
+            get_origin(int) is None
+            get_origin(ClassVarint) is ClassVar
+            get_origin(Generic) is Generic
+            get_origin(GenericT) is Generic
+            get_origin(UnionT, int) is Union
+            get_origin(ListTupleT, Tint) == list
+        """
+        if hasattr(tp, "__origin__"):
+            return tp.__origin__
+        if tp is typing.Generic:
+            return typing.Generic
+        return None
+
+
+try:
+    BaseExceptionGroup = BaseExceptionGroup
+    ExceptionGroup = ExceptionGroup  # pragma: no cover
+except NameError:
+    from exceptiongroup import (
+        BaseExceptionGroup as BaseExceptionGroup,
+        ExceptionGroup as ExceptionGroup,
+    )
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from typing_extensions import Concatenate as Concatenate, ParamSpec as ParamSpec
+else:
+    try:
+        from typing import Concatenate as Concatenate, ParamSpec as ParamSpec
+    except ImportError:
+        try:
+            from typing_extensions import (
+                Concatenate as Concatenate,
+                ParamSpec as ParamSpec,
+            )
+        except ImportError:
+            Concatenate, ParamSpec = None, None
+
+PYPY = platform.python_implementation() == "PyPy"
+GRAALPY = platform.python_implementation() == "GraalVM"
+WINDOWS = platform.system() == "Windows"
+
+
+def escape_unicode_characters(s: str) -> str:
+    return codecs.encode(s, "unicode_escape").decode("ascii")
+
+
+def int_from_bytes(data: typing.Unionbytes, bytearray) -> int:
+    return int.from_bytes(data, "big")
+
+
+def int_to_bytes(i: int, size: int) -> bytes:
+    return i.to_bytes(size, "big")
+
+
+def int_to_byte(i: int) -> bytes:
+    return bytes(i)
+
+
+def is_typed_named_tuple(cls):
+    """Return True if cls is probably a subtype of `typing.NamedTuple`.
+
+    Unfortunately types created with `class T(NamedTuple):` actually
+    subclass `tuple` directly rather than NamedTuple.  This is annoying,
+    and means we just have to hope that nobody defines a different tuple
+    subclass with similar attributes.
+    """
+    return (
+        issubclass(cls, tuple)
+        and hasattr(cls, "_fields")
+        and (hasattr(cls, "_field_types") or hasattr(cls, "__annotations__"))
+    )
+
+
+def _hint_and_args(x):
+    return (x,) + get_args(x)
+
+
+def get_type_hints(thing):
+    """Like the typing version, but tries harder and never errors.
+
+    Tries harder: if the thing to inspect is a class but typing.get_type_hints
+    raises an error or returns no hints, then this function will try calling it
+    on the __init__ method. This second step often helps with user-defined
+    classes on older versions of Python. The third step we take is trying
+    to fetch types from the __signature__ property.
+    They override any other ones we found earlier.
+
+    Never errors: instead of raising TypeError for uninspectable objects, or
+    NameError for unresolvable forward references, just return an empty dict.
+    """
+    if isinstance(thing, partial):
+        from hypothesis.internal.reflection import get_signature
+
+        bound = set(get_signature(thing.func).parameters).difference(
+            get_signature(thing).parameters
+        )
+        return {k: v for k, v in get_type_hints(thing.func).items() if k not in bound}
+
+    kwargs = {} if sys.version_info:2 < (3, 9) else {"include_extras": True}
+
+    try:
+        hints = typing.get_type_hints(thing, **kwargs)
+    except (AttributeError, TypeError, NameError):  # pragma: no cover
+        hints = {}
+
+    if inspect.isclass(thing):
+        try:
+            hints.update(typing.get_type_hints(thing.__init__, **kwargs))
+        except (TypeError, NameError, AttributeError):
+            pass
+
+    try:
+        if hasattr(thing, "__signature__"):
+            # It is possible for the signature and annotations attributes to
+            # differ on an object due to renamed arguments.
+            from hypothesis.internal.reflection import get_signature
+            from hypothesis.strategies._internal.types import is_a_type
+
+            vkinds = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+            for p in get_signature(thing).parameters.values():
+                if (
+                    p.kind not in vkinds
+                    and is_a_type(p.annotation)
+                    and p.annotation is not p.empty
+                ):
+                    p_hint = p.annotation
+
+                    # Defer to `get_type_hints` if signature annotation is, or
+                    # contains, a forward reference that is otherwise resolved.
+                    if any(
+                        isinstance(sig_hint, ForwardRef)
+                        and not isinstance(hint, ForwardRef)
+                        for sig_hint, hint in zip(
+                            _hint_and_args(p.annotation),
+                            _hint_and_args(hints.get(p.name, Any)),
+                        )
+                    ):
+                        p_hint = hintsp.name
+                    if p.default is None:
+                        hintsp.name = typing.Optionalp_hint
+                    else:
+                        hintsp.name = p_hint
+    except (AttributeError, TypeError, NameError):  # pragma: no cover
+        pass
+
+    return hints
+
+
+def update_code_location(code, newfile, newlineno):
+    """Take a code object and lie shamelessly about where it comes from.
+
+    Why do we want to do this? It's for really shallow reasons involving
+    hiding the hypothesis_temporary_module code from test runners like
+    pytest's verbose mode. This is a vastly disproportionate terrible
+    hack that I've done purely for vanity, and if you're reading this
+    code you're probably here because it's broken something and now
+    you're angry at me. Sorry.
+    """
+    if hasattr(code, "replace"):
+        # Python 3.8 added positional-only params (PEP 570), and thus changed
+        # the layout of code objects.  In beta1, the `.replace()` method was
+        # added to facilitate future-proof code.  See BPO-37032 for details.
+        return code.replace(co_filename=newfile, co_firstlineno=newlineno)
+
+    else:  # pragma: no cover
+        # This field order is accurate for 3.5 - 3.7, but not 3.8 when a new field
+        # was added for positional-only arguments.  However it also added a .replace()
+        # method that we use instead of field indices, so they're fine as-is.
+        CODE_FIELD_ORDER = 
+            "co_argcount",
+            "co_kwonlyargcount",
+            "co_nlocals",
+            "co_stacksize",
+            "co_flags",
+            "co_code",
+            "co_consts",
+            "co_names",
+            "co_varnames",
+            "co_filename",
+            "co_name",
+            "co_firstlineno",
+            "co_lnotab",
+            "co_freevars",
+            "co_cellvars",
+        
+        unpacked = getattr(code, name) for name in CODE_FIELD_ORDER
+        unpackedCODE_FIELD_ORDER.index("co_filename") = newfile
+        unpackedCODE_FIELD_ORDER.index("co_firstlineno") = newlineno
+        return type(code)(*unpacked)
+
+
+# Under Python 2, math.floor and math.ceil returned floats, which cannot
+# represent large integers - eg `float(2**53) == float(2**53 + 1)`.
+# We therefore implement them entirely in (long) integer operations.
+# We still use the same trick on Python 3, because Numpy values and other
+# custom __floor__ or __ceil__ methods may convert via floats.
+# See issue #1667, Numpy issue 9068.
+def floor(x):
+    y = int(x)
+    if y != x and x < 0:
+        return y - 1
+    return y
+
+
+def ceil(x):
+    y = int(x)
+    if y != x and x > 0:
+        return y + 1
+    return y
+
+
+def bad_django_TestCase(runner):
+    if runner is None or "django.test" not in sys.modules:
+        return False
+    else:  # pragma: no cover
+        if not isinstance(runner, sys.modules"django.test".TransactionTestCase):
+            return False
+
+        from hypothesis.extra.django._impl import HypothesisTestCase
+
+        return not isinstance(runner, HypothesisTestCase)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/__init__.py Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/choicetree.py Added

@@ -0,0 +1,160 @@
+# 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/.
+
+from collections import defaultdict
+from random import Random
+from typing import Callable, Dict, Iterable, List, Optional, Sequence
+
+from hypothesis.internal.conjecture.junkdrawer import LazySequenceCopy, pop_random
+
+
+def prefix_selection_order(
+    prefix: Sequenceint,
+) -> Callableint, int, Iterableint:
+    """Select choices starting from ``prefix```,
+    preferring to move left then wrapping around
+    to the right."""
+
+    def selection_order(depth: int, n: int) -> Iterableint:
+        if depth < len(prefix):
+            i = prefixdepth
+            if i >= n:
+                i = n - 1
+            yield from range(i, -1, -1)
+            yield from range(n - 1, i, -1)
+        else:
+            yield from range(n - 1, -1, -1)
+
+    return selection_order
+
+
+def random_selection_order(random: Random) -> Callableint, int, Iterableint:
+    """Select choices uniformly at random."""
+
+    def selection_order(depth: int, n: int) -> Iterableint:
+        pending = LazySequenceCopy(range(n))
+        while pending:
+            yield pop_random(random, pending)
+
+    return selection_order
+
+
+class Chooser:
+    """A source of nondeterminism for use in shrink passes."""
+
+    def __init__(
+        self,
+        tree: "ChoiceTree",
+        selection_order: Callableint, int, Iterableint,
+    ):
+        self.__selection_order = selection_order
+        self.__node_trail = tree.root
+        self.__choices: "Listint" = 
+        self.__finished = False
+
+    def choose(
+        self,
+        values: Sequenceint,
+        condition: Callableint, bool = lambda x: True,
+    ) -> int:
+        """Return some element of values satisfying the condition
+        that will not lead to an exhausted branch, or raise DeadBranch
+        if no such element exist".
+        """
+        assert not self.__finished
+        node = self.__node_trail-1
+        if node.live_child_count is None:
+            node.live_child_count = len(values)
+            node.n = len(values)
+
+        assert node.live_child_count > 0 or len(values) == 0
+
+        for i in self.__selection_order(len(self.__choices), len(values)):
+            if node.live_child_count == 0:
+                break
+            if not node.childreni.exhausted:
+                v = valuesi
+                if condition(v):
+                    self.__choices.append(i)
+                    self.__node_trail.append(node.childreni)
+                    return v
+                else:
+                    node.childreni = DeadNode
+                    node.live_child_count -= 1
+        assert node.live_child_count == 0
+        raise DeadBranch()
+
+    def finish(self) -> Sequenceint:
+        """Record the decisions made in the underlying tree and return
+        a prefix that can be used for the next Chooser to be used."""
+        self.__finished = True
+        assert len(self.__node_trail) == len(self.__choices) + 1
+
+        result = tuple(self.__choices)
+
+        self.__node_trail-1.live_child_count = 0
+        while len(self.__node_trail) > 1 and self.__node_trail-1.exhausted:
+            self.__node_trail.pop()
+            assert len(self.__node_trail) == len(self.__choices)
+            i = self.__choices.pop()
+            target = self.__node_trail-1
+            target.childreni = DeadNode
+            assert target.live_child_count is not None
+            target.live_child_count -= 1
+
+        return result
+
+
+class ChoiceTree:
+    """Records sequences of choices made during shrinking so that we
+    can track what parts of a pass has run. Used to create Chooser
+    objects that are the main interface that a pass uses to make
+    decisions about what to do.
+    """
+
+    def __init__(self) -> None:
+        self.root = TreeNode()
+
+    @property
+    def exhausted(self) -> bool:
+        return self.root.exhausted
+
+    def step(
+        self,
+        selection_order: Callableint, int, Iterableint,
+        f: CallableChooser, None,
+    ) -> Sequenceint:
+        assert not self.exhausted
+
+        chooser = Chooser(self, selection_order)
+        try:
+            f(chooser)
+        except DeadBranch:
+            pass
+        return chooser.finish()
+
+
+class TreeNode:
+    def __init__(self) -> None:
+        self.children: Dictint, TreeNode = defaultdict(TreeNode)
+        self.live_child_count: "Optionalint" = None
+        self.n: "Optionalint" = None
+
+    @property
+    def exhausted(self) -> bool:
+        return self.live_child_count == 0
+
+
+DeadNode = TreeNode()
+DeadNode.live_child_count = 0
+
+
+class DeadBranch(Exception):
+    pass

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/data.py Added

@@ -0,0 +1,1149 @@
+# 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 time
+from collections import defaultdict
+from enum import IntEnum
+from random import Random
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    FrozenSet,
+    Hashable,
+    Iterable,
+    Iterator,
+    List,
+    NoReturn,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+
+import attr
+
+from hypothesis.errors import Frozen, InvalidArgument, StopTest
+from hypothesis.internal.compat import int_from_bytes, int_to_bytes
+from hypothesis.internal.conjecture.junkdrawer import IntList, uniform
+from hypothesis.internal.conjecture.utils import calc_label_from_name
+
+if TYPE_CHECKING:
+    from typing_extensions import dataclass_transform
+
+    from hypothesis.strategies import SearchStrategy
+    from hypothesis.strategies._internal.strategies import Ex
+else:
+
+    def dataclass_transform():
+        def wrapper(tp):
+            return tp
+
+        return wrapper
+
+
+TOP_LABEL = calc_label_from_name("top")
+DRAW_BYTES_LABEL = calc_label_from_name("draw_bytes() in ConjectureData")
+
+
+InterestingOrigin = Tuple
+    TypeBaseException, str, int, TupleAny, ..., TupleTupleAny, ..., ...
+
+TargetObservations = DictOptionalstr, Unionint, float
+
+
+class ExtraInformation:
+    """A class for holding shared state on a ``ConjectureData`` that should
+    be added to the final ``ConjectureResult``."""
+
+    def __repr__(self) -> str:
+        return "ExtraInformation({})".format(
+            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
+        )
+
+    def has_information(self) -> bool:
+        return bool(self.__dict__)
+
+
+class Status(IntEnum):
+    OVERRUN = 0
+    INVALID = 1
+    VALID = 2
+    INTERESTING = 3
+
+    def __repr__(self) -> str:
+        return f"Status.{self.name}"
+
+
+@dataclass_transform()
+@attr.s(frozen=True, slots=True, auto_attribs=True)
+class StructuralCoverageTag:
+    label: int
+
+
+STRUCTURAL_COVERAGE_CACHE: Dictint, StructuralCoverageTag = {}
+
+
+def structural_coverage(label: int) -> StructuralCoverageTag:
+    try:
+        return STRUCTURAL_COVERAGE_CACHElabel
+    except KeyError:
+        return STRUCTURAL_COVERAGE_CACHE.setdefault(label, StructuralCoverageTag(label))
+
+
+class Example:
+    """Examples track the hierarchical structure of draws from the byte stream,
+    within a single test run.
+
+    Examples are created to mark regions of the byte stream that might be
+    useful to the shrinker, such as:
+    - The bytes used by a single draw from a strategy.
+    - Useful groupings within a strategy, such as individual list elements.
+    - Strategy-like helper functions that aren't first-class strategies.
+    - Each lowest-level draw of bits or bytes from the byte stream.
+    - A single top-level example that spans the entire input.
+
+    Example-tracking allows the shrinker to try "high-level" transformations,
+    such as rearranging or deleting the elements of a list, without having
+    to understand their exact representation in the byte stream.
+
+    Rather than store each ``Example`` as a rich object, it is actually
+    just an index into the ``Examples`` class defined below. This has two
+    purposes: Firstly, for most properties of examples we will never need
+    to allocate storage at all, because most properties are not used on
+    most examples. Secondly, by storing the properties as compact lists
+    of integers, we save a considerable amount of space compared to
+    Python's normal object size.
+
+    This does have the downside that it increases the amount of allocation
+    we do, and slows things down as a result, in some usage patterns because
+    we repeatedly allocate the same Example or int objects, but it will
+    often dramatically reduce our memory usage, so is worth it.
+    """
+
+    __slots__ = ("owner", "index")
+
+    def __init__(self, owner: "Examples", index: int) -> None:
+        self.owner = owner
+        self.index = index
+
+    def __eq__(self, other: object) -> bool:
+        if self is other:
+            return True
+        if not isinstance(other, Example):
+            return NotImplemented
+        return (self.owner is other.owner) and (self.index == other.index)
+
+    def __ne__(self, other: object) -> bool:
+        if self is other:
+            return False
+        if not isinstance(other, Example):
+            return NotImplemented
+        return (self.owner is not other.owner) or (self.index != other.index)
+
+    def __repr__(self) -> str:
+        return f"examples{self.index}"
+
+    @property
+    def label(self) -> int:
+        """A label is an opaque value that associates each example with its
+        approximate origin, such as a particular strategy class or a particular
+        kind of draw."""
+        return self.owner.labelsself.owner.label_indicesself.index
+
+    @property
+    def parent(self):
+        """The index of the example that this one is nested directly within."""
+        if self.index == 0:
+            return None
+        return self.owner.parentageself.index
+
+    @property
+    def start(self) -> int:
+        """The position of the start of this example in the byte stream."""
+        return self.owner.startsself.index
+
+    @property
+    def end(self) -> int:
+        """The position directly after the last byte in this byte stream.
+        i.e. the example corresponds to the half open region start, end).
+        """
+        return self.owner.endsself.index
+
+    @property
+    def depth(self):
+        """Depth of this example in the example tree. The top-level example has a
+        depth of 0."""
+        return self.owner.depthsself.index
+
+    @property
+    def trivial(self):
+        """An example is "trivial" if it only contains forced bytes and zero bytes.
+        All examples start out as trivial, and then get marked non-trivial when
+        we see a byte that is neither forced nor zero."""
+        return self.index in self.owner.trivial
+
+    @property
+    def discarded(self) -> bool:
+        """True if this is example's ``stop_example`` call had ``discard`` set to
+        ``True``. This means we believe that the shrinker should be able to delete
+        this example completely, without affecting the value produced by its enclosing
+        strategy. Typically set when a rejection sampler decides to reject a
+        generated value and try again."""
+        return self.index in self.owner.discarded
+
+    @property
+    def length(self) -> int:
+        """The number of bytes in this example."""
+        return self.end - self.start
+
+    @property
+    def children(self) -> "ListExample":
+        """The list of all examples with this as a parent, in increasing index
+        order."""
+        return self.owneri for i in self.owner.childrenself.index
+
+
+class ExampleProperty:
+    """There are many properties of examples that we calculate by
+    essentially rerunning the test case multiple times based on the
+    calls which we record in ExampleRecord.
+
+    This class defines a visitor, subclasses of which can be used
+    to calculate these properties.
+    """
+
+    def __init__(self, examples: "Examples"):
+        self.example_stack: "Listint" = 
+        self.examples = examples
+        self.bytes_read = 0
+        self.example_count = 0
+        self.block_count = 0
+
+    def run(self) -> Any:
+        """Rerun the test case with this visitor and return the
+        results of ``self.finish()``."""
+        self.begin()
+        blocks = self.examples.blocks
+        for record in self.examples.trail:
+            if record == DRAW_BITS_RECORD:
+                self.__push(0)
+                self.bytes_read = blocks.endpointsself.block_count
+                self.block(self.block_count)
+                self.block_count += 1
+                self.__pop(False)
+            elif record >= START_EXAMPLE_RECORD:
+                self.__push(record - START_EXAMPLE_RECORD)
+            else:
+                assert record in (
+                    STOP_EXAMPLE_DISCARD_RECORD,
+                    STOP_EXAMPLE_NO_DISCARD_RECORD,
+                )
+                self.__pop(record == STOP_EXAMPLE_DISCARD_RECORD)
+        return self.finish()
+
+    def __push(self, label_index: int) -> None:
+        i = self.example_count
+        assert i < len(self.examples)
+        self.start_example(i, label_index)
+        self.example_count += 1
+        self.example_stack.append(i)
+
+    def __pop(self, discarded: bool) -> None:
+        i = self.example_stack.pop()
+        self.stop_example(i, discarded)
+
+    def begin(self) -> None:
+        """Called at the beginning of the run to initialise any
+        relevant state."""
+        self.result = IntList.of_length(len(self.examples))
+
+    def start_example(self, i: int, label_index: int) -> None:
+        """Called at the start of each example, with ``i`` the
+        index of the example and ``label_index`` the index of
+        its label in ``self.examples.labels``."""
+
+    def block(self, i: int) -> None:
+        """Called with each ``draw_bits`` call, with ``i`` the index of the
+        corresponding block in ``self.examples.blocks``"""
+
+    def stop_example(self, i: int, discarded: bool) -> None:
+        """Called at the end of each example, with ``i`` the
+        index of the example and ``discarded`` being ``True`` if ``stop_example``
+        was called with ``discard=True``."""
+
+    def finish(self) -> Any:
+        return self.result
+
+
+def calculated_example_property(cls: TypeExampleProperty) -> Any:
+    """Given an ``ExampleProperty`` as above we use this decorator
+    to transform it into a lazy property on the ``Examples`` class,
+    which has as its value the result of calling ``cls.run()``,
+    computed the first time the property is accessed.
+
+    This has the slightly weird result that we are defining nested
+    classes which get turned into properties."""
+    name = cls.__name__
+    cache_name = "__" + name
+
+    def lazy_calculate(self: "Examples") -> IntList:
+        result = getattr(self, cache_name, None)
+        if result is None:
+            result = cls(self).run()
+            setattr(self, cache_name, result)
+        return result
+
+    lazy_calculate.__name__ = cls.__name__
+    lazy_calculate.__qualname__ = cls.__qualname__
+    return property(lazy_calculate)
+
+
+DRAW_BITS_RECORD = 0
+STOP_EXAMPLE_DISCARD_RECORD = 1
+STOP_EXAMPLE_NO_DISCARD_RECORD = 2
+START_EXAMPLE_RECORD = 3
+
+
+class ExampleRecord:
+    """Records the series of ``start_example``, ``stop_example``, and
+    ``draw_bits`` calls so that these may be stored in ``Examples`` and
+    replayed when we need to know about the structure of individual
+    ``Example`` objects.
+
+    Note that there is significant similarity between this class and
+    ``DataObserver``, and the plan is to eventually unify them, but
+    they currently have slightly different functions and implementations.
+    """
+
+    def __init__(self) -> None:
+        self.labels = DRAW_BYTES_LABEL
+        self.__index_of_labels: "OptionalDictint, int" = {DRAW_BYTES_LABEL: 0}
+        self.trail = IntList()
+
+    def freeze(self) -> None:
+        self.__index_of_labels = None
+
+    def start_example(self, label: int) -> None:
+        assert self.__index_of_labels is not None
+        try:
+            i = self.__index_of_labelslabel
+        except KeyError:
+            i = self.__index_of_labels.setdefault(label, len(self.labels))
+            self.labels.append(label)
+        self.trail.append(START_EXAMPLE_RECORD + i)
+
+    def stop_example(self, discard: bool) -> None:
+        if discard:
+            self.trail.append(STOP_EXAMPLE_DISCARD_RECORD)
+        else:
+            self.trail.append(STOP_EXAMPLE_NO_DISCARD_RECORD)
+
+    def draw_bits(self, n: int, forced: Optionalint) -> None:
+        self.trail.append(DRAW_BITS_RECORD)
+
+
+class Examples:
+    """A lazy collection of ``Example`` objects, derived from
+    the record of recorded behaviour in ``ExampleRecord``.
+
+    Behaves logically as if it were a list of ``Example`` objects,
+    but actually mostly exists as a compact store of information
+    for them to reference into. All properties on here are best
+    understood as the backing storage for ``Example`` and are
+    described there.
+    """
+
+    def __init__(self, record: ExampleRecord, blocks: "Blocks") -> None:
+        self.trail = record.trail
+        self.labels = record.labels
+        self.__length = (
+            self.trail.count(STOP_EXAMPLE_DISCARD_RECORD)
+            + record.trail.count(STOP_EXAMPLE_NO_DISCARD_RECORD)
+            + record.trail.count(DRAW_BITS_RECORD)
+        )
+        self.blocks = blocks
+        self.__children: "OptionalListSequenceint" = None
+
+    class _starts_and_ends(ExampleProperty):
+        def begin(self):
+            self.starts = IntList.of_length(len(self.examples))
+            self.ends = IntList.of_length(len(self.examples))
+
+        def start_example(self, i: int, label_index: int) -> None:
+            self.startsi = self.bytes_read
+
+        def stop_example(self, i: int, discarded: bool) -> None:
+            self.endsi = self.bytes_read
+
+        def finish(self) -> TupleIntList, IntList:
+            return (self.starts, self.ends)
+
+    starts_and_ends: "TupleIntList, IntList" = calculated_example_property(
+        _starts_and_ends
+    )
+
+    @property
+    def starts(self) -> IntList:
+        return self.starts_and_ends0
+
+    @property
+    def ends(self) -> IntList:
+        return self.starts_and_ends1
+
+    class _discarded(ExampleProperty):
+        def begin(self) -> None:
+            self.result: "Setint" = set()  # type: ignore  # IntList in parent class
+
+        def finish(self) -> FrozenSetint:
+            return frozenset(self.result)
+
+        def stop_example(self, i: int, discarded: bool) -> None:
+            if discarded:
+                self.result.add(i)
+
+    discarded: FrozenSetint = calculated_example_property(_discarded)
+
+    class _trivial(ExampleProperty):
+        def begin(self) -> None:
+            self.nontrivial = IntList.of_length(len(self.examples))
+            self.result: "Setint" = set()  # type: ignore  # IntList in parent class
+
+        def block(self, i: int) -> None:
+            if not self.examples.blocks.trivial(i):
+                self.nontrivialself.example_stack-1 = 1
+
+        def stop_example(self, i: int, discarded: bool) -> None:
+            if self.nontriviali:
+                if self.example_stack:
+                    self.nontrivialself.example_stack-1 = 1
+            else:
+                self.result.add(i)
+
+        def finish(self) -> FrozenSetint:
+            return frozenset(self.result)
+
+    trivial: FrozenSetint = calculated_example_property(_trivial)
+
+    class _parentage(ExampleProperty):
+        def stop_example(self, i: int, discarded: bool) -> None:
+            if i > 0:
+                self.resulti = self.example_stack-1
+
+    parentage: IntList = calculated_example_property(_parentage)
+
+    class _depths(ExampleProperty):
+        def begin(self):
+            self.result = IntList.of_length(len(self.examples))
+
+        def start_example(self, i: int, label_index: int) -> None:
+            self.resulti = len(self.example_stack)
+
+    depths: IntList = calculated_example_property(_depths)
+
+    class _label_indices(ExampleProperty):
+        def start_example(self, i: int, label_index: int) -> None:
+            self.resulti = label_index
+
+    label_indices: IntList = calculated_example_property(_label_indices)
+
+    class _mutator_groups(ExampleProperty):
+        def begin(self) -> None:
+            self.groups: "DictTupleint, int, Listint" = defaultdict(list)
+
+        def start_example(self, i: int, label_index: int) -> None:
+            depth = len(self.example_stack)
+            self.groupslabel_index, depth.append(i)
+
+        def finish(self) -> IterableIterableint:
+            # Discard groups with only one example, since the mutator can't
+            # do anything useful with them.
+            return g for g in self.groups.values() if len(g) >= 2
+
+    mutator_groups: ListListint = calculated_example_property(_mutator_groups)
+
+    @property
+    def children(self) -> ListSequenceint:
+        if self.__children is None:
+            children = IntList() for _ in range(len(self))
+            for i, p in enumerate(self.parentage):
+                if i > 0:
+                    childrenp.append(i)
+            # Replace empty children lists with a tuple to reduce
+            # memory usage.
+            for i, c in enumerate(children):
+                if not c:
+                    childreni = ()  # type: ignore
+            self.__children = children  # type: ignore
+        return self.__children  # type: ignore
+
+    def __len__(self) -> int:
+        return self.__length
+
+    def __getitem__(self, i: int) -> Example:
+        assert isinstance(i, int)
+        n = len(self)
+        if i < -n or i >= n:
+            raise IndexError(f"Index {i} out of range -{n}, {n})")
+        if i < 0:
+            i += n
+        return Example(self, i)
+
+
+@dataclass_transform()
+@attr.s(slots=True, frozen=True)
+class Block:
+    """Blocks track the flat list of lowest-level draws from the byte stream,
+    within a single test run.
+
+    Block-tracking allows the shrinker to try "low-level"
+    transformations, such as minimizing the numeric value of an
+    individual call to ``draw_bits``.
+    """
+
+    start: int = attr.ib()
+    end: int = attr.ib()
+
+    # Index of this block inside the overall list of blocks.
+    index: int = attr.ib()
+
+    # True if this block's byte values were forced by a write operation.
+    # As long as the bytes before this block remain the same, modifying this
+    # block's bytes will have no effect.
+    forced: bool = attr.ib(repr=False)
+
+    # True if this block's byte values are all 0. Reading this flag can be
+    # more convenient than explicitly checking a slice for non-zero bytes.
+    all_zero: bool = attr.ib(repr=False)
+
+    @property
+    def bounds(self) -> Tupleint, int:
+        return (self.start, self.end)
+
+    @property
+    def length(self) -> int:
+        return self.end - self.start
+
+    @property
+    def trivial(self) -> bool:
+        return self.forced or self.all_zero
+
+
+class Blocks:
+    """A lazily calculated list of blocks for a particular ``ConjectureResult``
+    or ``ConjectureData`` object.
+
+    Pretends to be a list containing ``Block`` objects but actually only
+    contains their endpoints right up until the point where you want to
+    access the actual block, at which point it is constructed.
+
+    This is designed to be as space efficient as possible, so will at
+    various points silently transform its representation into one
+    that is better suited for the current access pattern.
+
+    In addition, it has a number of convenience methods for accessing
+    properties of the block object at index ``i`` that should generally
+    be preferred to using the Block objects directly, as it will not
+    have to allocate the actual object."""
+
+    __slots__ = ("endpoints", "owner", "__blocks", "__count", "__sparse")
+    owner: "UnionConjectureData, ConjectureResult, None"
+    __blocks: UnionDictint, Block, ListOptionalBlock
+
+    def __init__(self, owner: "ConjectureData") -> None:
+        self.owner = owner
+        self.endpoints = IntList()
+        self.__blocks = {}
+        self.__count = 0
+        self.__sparse = True
+
+    def add_endpoint(self, n: int) -> None:
+        """Add n to the list of endpoints."""
+        assert isinstance(self.owner, ConjectureData)
+        self.endpoints.append(n)
+
+    def transfer_ownership(self, new_owner: "ConjectureResult") -> None:
+        """Used to move ``Blocks`` over to a ``ConjectureResult`` object
+        when that is read to be used and we no longer want to keep the
+        whole ``ConjectureData`` around."""
+        assert isinstance(new_owner, ConjectureResult)
+        self.owner = new_owner
+        self.__check_completion()
+
+    def start(self, i: int) -> int:
+        """Equivalent to selfi.start."""
+        i = self._check_index(i)
+
+        if i == 0:
+            return 0
+        else:
+            return self.end(i - 1)
+
+    def end(self, i: int) -> int:
+        """Equivalent to selfi.end."""
+        return self.endpointsi
+
+    def bounds(self, i: int) -> Tupleint, int:
+        """Equivalent to selfi.bounds."""
+        return (self.start(i), self.end(i))
+
+    def all_bounds(self) -> IterableTupleint, int:
+        """Equivalent to (b.start, b.end) for b in self."""
+        prev = 0
+        for e in self.endpoints:
+            yield (prev, e)
+            prev = e
+
+    @property
+    def last_block_length(self):
+        return self.end(-1) - self.start(-1)
+
+    def __len__(self) -> int:
+        return len(self.endpoints)
+
+    def __known_block(self, i: int) -> OptionalBlock:
+        try:
+            return self.__blocksi
+        except (KeyError, IndexError):
+            return None
+
+    def trivial(self, i: int) -> Any:
+        """Equivalent to self.blocksi.trivial."""
+        if self.owner is not None:
+            return self.start(i) in self.owner.forced_indices or not any(
+                self.owner.bufferself.start(i) : self.end(i)
+            )
+        else:
+            return selfi.trivial
+
+    def _check_index(self, i: int) -> int:
+        n = len(self)
+        if i < -n or i >= n:
+            raise IndexError(f"Index {i} out of range -{n}, {n})")
+        if i < 0:
+            i += n
+        return i
+
+    def __getitem__(self, i: int) -> Block:
+        i = self._check_index(i)
+        assert i >= 0
+        result = self.__known_block(i)
+        if result is not None:
+            return result
+
+        # We store the blocks as a sparse dict mapping indices to the
+        # actual result, but this isn't the best representation once we
+        # stop being sparse and want to use most of the blocks. Switch
+        # over to a list at that point.
+        if self.__sparse and len(self.__blocks) * 2 >= len(self):
+            new_blocks: "ListOptionalBlock" = None * len(self)
+            assert isinstance(self.__blocks, dict)
+            for k, v in self.__blocks.items():
+                new_blocksk = v
+            self.__sparse = False
+            self.__blocks = new_blocks
+            assert self.__blocksi is None
+
+        start = self.start(i)
+        end = self.end(i)
+
+        # We keep track of the number of blocks that have actually been
+        # instantiated so that when every block that could be instantiated
+        # has been we know that the list is complete and can throw away
+        # some data that we no longer need.
+        self.__count += 1
+
+        # Integrity check: We can't have allocated more blocks than we have
+        # positions for blocks.
+        assert self.__count <= len(self)
+        assert self.owner is not None
+        result = Block(
+            start=start,
+            end=end,
+            index=i,
+            forced=start in self.owner.forced_indices,
+            all_zero=not any(self.owner.bufferstart:end),
+        )
+        try:
+            self.__blocksi = result
+        except IndexError:
+            assert isinstance(self.__blocks, list)
+            assert len(self.__blocks) < len(self)
+            self.__blocks.extend(None * (len(self) - len(self.__blocks)))
+            self.__blocksi = result
+
+        self.__check_completion()
+
+        return result
+
+    def __check_completion(self):
+        """The list of blocks is complete if we have created every ``Block``
+        object that we currently good and know that no more will be created.
+
+        If this happens then we don't need to keep the reference to the
+        owner around, and delete it so that there is no circular reference.
+        The main benefit of this is that the gc doesn't need to run to collect
+        this because normal reference counting is enough.
+        """
+        if self.__count == len(self) and isinstance(self.owner, ConjectureResult):
+            self.owner = None
+
+    def __iter__(self) -> IteratorBlock:
+        for i in range(len(self)):
+            yield selfi
+
+    def __repr__(self) -> str:
+        parts: "Liststr" = 
+        for i in range(len(self)):
+            b = self.__known_block(i)
+            if b is None:
+                parts.append("...")
+            else:
+                parts.append(repr(b))
+        return "Block({})".format(", ".join(parts))
+
+
+class _Overrun:
+    status = Status.OVERRUN
+
+    def __repr__(self):
+        return "Overrun"
+
+    def as_result(self) -> "_Overrun":
+        return self
+
+
+Overrun = _Overrun()
+
+global_test_counter = 0
+
+
+MAX_DEPTH = 100
+
+
+class DataObserver:
+    """Observer class for recording the behaviour of a
+    ConjectureData object, primarily used for tracking
+    the behaviour in the tree cache."""
+
+    def conclude_test(
+        self,
+        status: Status,
+        interesting_origin: OptionalInterestingOrigin,
+    ) -> None:
+        """Called when ``conclude_test`` is called on the
+        observed ``ConjectureData``, with the same arguments.
+
+        Note that this is called after ``freeze`` has completed.
+        """
+
+    def draw_bits(self, n_bits: int, forced: bool, value: int) -> None:
+        """Called when ``draw_bits`` is called on on the
+        observed ``ConjectureData``.
+        * ``n_bits`` is the number of bits drawn.
+        *  ``forced`` is True if the corresponding
+           draw was forced or ``False`` otherwise.
+        * ``value`` is the result that ``draw_bits`` returned.
+        """
+
+    def kill_branch(self) -> None:
+        """Mark this part of the tree as not worth re-exploring."""
+
+
+@dataclass_transform()
+@attr.s(slots=True)
+class ConjectureResult:
+    """Result class storing the parts of ConjectureData that we
+    will care about after the original ConjectureData has outlived its
+    usefulness."""
+
+    status: Status = attr.ib()
+    interesting_origin: OptionalInterestingOrigin = attr.ib()
+    buffer: bytes = attr.ib()
+    blocks: Blocks = attr.ib()
+    output: str = attr.ib()
+    extra_information: OptionalExtraInformation = attr.ib()
+    has_discards: bool = attr.ib()
+    target_observations: TargetObservations = attr.ib()
+    tags: FrozenSetStructuralCoverageTag = attr.ib()
+    forced_indices: FrozenSetint = attr.ib(repr=False)
+    examples: Examples = attr.ib(repr=False)
+    arg_slices: SetTupleint, int = attr.ib(repr=False)
+    slice_comments: DictTupleint, int, str = attr.ib(repr=False)
+
+    index: int = attr.ib(init=False)
+
+    def __attrs_post_init__(self) -> None:
+        self.index = len(self.buffer)
+        self.forced_indices = frozenset(self.forced_indices)
+
+    def as_result(self) -> "ConjectureResult":
+        return self
+
+
+# Masks for masking off the first byte of an n-bit buffer.
+# The appropriate mask is stored at position n % 8.
+BYTE_MASKS = (1 << n) - 1 for n in range(8)
+BYTE_MASKS0 = 255
+
+
+class ConjectureData:
+    @classmethod
+    def for_buffer(
+        cls,
+        buffer: UnionListint, bytes,
+        observer: OptionalDataObserver = None,
+    ) -> "ConjectureData":
+        return cls(len(buffer), buffer, random=None, observer=observer)
+
+    def __init__(
+        self,
+        max_length: int,
+        prefix: UnionListint, bytes, bytearray,
+        random: OptionalRandom,
+        observer: OptionalDataObserver = None,
+    ) -> None:
+        if observer is None:
+            observer = DataObserver()
+        assert isinstance(observer, DataObserver)
+        self.__bytes_drawn = 0
+        self.observer = observer
+        self.max_length = max_length
+        self.is_find = False
+        self.overdraw = 0
+        self.__prefix = bytes(prefix)
+        self.__random = random
+
+        assert random is not None or max_length <= len(prefix)
+
+        self.blocks = Blocks(self)
+        self.buffer: "Unionbytes, bytearray" = bytearray()
+        self.index = 0
+        self.output = ""
+        self.status = Status.VALID
+        self.frozen = False
+        global global_test_counter
+        self.testcounter = global_test_counter
+        global_test_counter += 1
+        self.start_time = time.perf_counter()
+        self.events: "UnionSetHashable, FrozenSetHashable" = set()
+        self.forced_indices: "Setint" = set()
+        self.interesting_origin: OptionalInterestingOrigin = None
+        self.draw_times: "Listfloat" = 
+        self.max_depth = 0
+        self.has_discards = False
+
+        self.__result: "OptionalConjectureResult" = None
+
+        # Observations used for targeted search.  They'll be aggregated in
+        # ConjectureRunner.generate_new_examples and fed to TargetSelector.
+        self.target_observations: TargetObservations = {}
+
+        # Tags which indicate something about which part of the search space
+        # this example is in. These are used to guide generation.
+        self.tags: "SetStructuralCoverageTag" = set()
+        self.labels_for_structure_stack: "ListSetint" = 
+
+        # Normally unpopulated but we need this in the niche case
+        # that self.as_result() is Overrun but we still want the
+        # examples for reporting purposes.
+        self.__examples: "OptionalExamples" = None
+
+        # We want the top level example to have depth 0, so we start
+        # at -1.
+        self.depth = -1
+        self.__example_record = ExampleRecord()
+
+        # Slice indices for discrete reportable parts that which-parts-matter can
+        # try varying, to report if the minimal example always fails anyway.
+        self.arg_slices: SetTupleint, int = set()
+        self.slice_comments: DictTupleint, int, str = {}
+
+        self.extra_information = ExtraInformation()
+
+        self.start_example(TOP_LABEL)
+
+    def __repr__(self):
+        return "ConjectureData(%s, %d bytes%s)" % (
+            self.status.name,
+            len(self.buffer),
+            ", frozen" if self.frozen else "",
+        )
+
+    def as_result(self) -> UnionConjectureResult, _Overrun:
+        """Convert the result of running this test into
+        either an Overrun object or a ConjectureResult."""
+
+        assert self.frozen
+        if self.status == Status.OVERRUN:
+            return Overrun
+        if self.__result is None:
+            self.__result = ConjectureResult(
+                status=self.status,
+                interesting_origin=self.interesting_origin,
+                buffer=self.buffer,
+                examples=self.examples,
+                blocks=self.blocks,
+                output=self.output,
+                extra_information=self.extra_information
+                if self.extra_information.has_information()
+                else None,
+                has_discards=self.has_discards,
+                target_observations=self.target_observations,
+                tags=frozenset(self.tags),
+                forced_indices=frozenset(self.forced_indices),
+                arg_slices=self.arg_slices,
+                slice_comments=self.slice_comments,
+            )
+            assert self.__result is not None
+            self.blocks.transfer_ownership(self.__result)
+        return self.__result
+
+    def __assert_not_frozen(self, name: str) -> None:
+        if self.frozen:
+            raise Frozen(f"Cannot call {name} on frozen ConjectureData")
+
+    def note(self, value: Any) -> None:
+        self.__assert_not_frozen("note")
+        if not isinstance(value, str):
+            value = repr(value)
+        self.output += value
+
+    def draw(self, strategy: "SearchStrategyEx", label: Optionalint = None) -> "Ex":
+        if self.is_find and not strategy.supports_find:
+            raise InvalidArgument(
+                f"Cannot use strategy {strategy!r} within a call to find "
+                "(presumably because it would be invalid after the call had ended)."
+            )
+
+        at_top_level = self.depth == 0
+        start_time = None
+        if at_top_level:
+            # We start this timer early, because accessing attributes on a LazyStrategy
+            # can be almost arbitrarily slow.  In cases like characters() and text()
+            # where we cache something expensive, this led to Flaky deadline errors!
+            # See https://github.com/HypothesisWorks/hypothesis/issues/2108
+            start_time = time.perf_counter()
+
+        strategy.validate()
+
+        if strategy.is_empty:
+            self.mark_invalid("strategy is empty")
+
+        if self.depth >= MAX_DEPTH:
+            self.mark_invalid("max depth exceeded")
+
+        if label is None:
+            assert isinstance(strategy.label, int)
+            label = strategy.label
+        self.start_example(label=label)
+        try:
+            if not at_top_level:
+                return strategy.do_draw(self)
+            else:
+                assert start_time is not None
+                strategy.validate()
+                try:
+                    return strategy.do_draw(self)
+                finally:
+                    self.draw_times.append(time.perf_counter() - start_time)
+        finally:
+            self.stop_example()
+
+    def start_example(self, label: int) -> None:
+        self.__assert_not_frozen("start_example")
+        self.depth += 1
+        # Logically it would make sense for this to just be
+        # ``self.depth = max(self.depth, self.max_depth)``, which is what it used to
+        # be until we ran the code under tracemalloc and found a rather significant
+        # chunk of allocation was happening here. This was presumably due to varargs
+        # or the like, but we didn't investigate further given that it was easy
+        # to fix with this check.
+        if self.depth > self.max_depth:
+            self.max_depth = self.depth
+        self.__example_record.start_example(label)
+        self.labels_for_structure_stack.append({label})
+
+    def stop_example(self, discard: bool = False) -> None:
+        if self.frozen:
+            return
+        if discard:
+            self.has_discards = True
+        self.depth -= 1
+        assert self.depth >= -1
+        self.__example_record.stop_example(discard)
+
+        labels_for_structure = self.labels_for_structure_stack.pop()
+
+        if not discard:
+            if self.labels_for_structure_stack:
+                self.labels_for_structure_stack-1.update(labels_for_structure)
+            else:
+                self.tags.update(structural_coverage(l) for l in labels_for_structure)
+
+        if discard:
+            # Once we've discarded an example, every test case starting with
+            # this prefix contains discards. We prune the tree at that point so
+            # as to avoid future test cases bothering with this region, on the
+            # assumption that some example that you could have used instead
+            # there would *not* trigger the discard. This greatly speeds up
+            # test case generation in some cases, because it allows us to
+            # ignore large swathes of the search space that are effectively
+            # redundant.
+            #
+            # A scenario that can cause us problems but which we deliberately
+            # have decided not to support is that if there are side effects
+            # during data generation then you may end up with a scenario where
+            # every good test case generates a discard because the discarded
+            # section sets up important things for later. This is not terribly
+            # likely and all that you see in this case is some degradation in
+            # quality of testing, so we don't worry about it.
+            #
+            # Note that killing the branch does *not* mean we will never
+            # explore below this point, and in particular we may do so during
+            # shrinking. Any explicit request for a data object that starts
+            # with the branch here will work just fine, but novel prefix
+            # generation will avoid it, and we can use it to detect when we
+            # have explored the entire tree (up to redundancy).
+
+            self.observer.kill_branch()
+
+    def note_event(self, event: Hashable) -> None:
+        assert isinstance(self.events, set)
+        self.events.add(event)
+
+    @property
+    def examples(self) -> Examples:
+        assert self.frozen
+        if self.__examples is None:
+            self.__examples = Examples(record=self.__example_record, blocks=self.blocks)
+        return self.__examples
+
+    def freeze(self) -> None:
+        if self.frozen:
+            assert isinstance(self.buffer, bytes)
+            return
+        self.finish_time = time.perf_counter()
+        assert len(self.buffer) == self.index
+
+        # Always finish by closing all remaining examples so that we have a
+        # valid tree.
+        while self.depth >= 0:
+            self.stop_example()
+
+        self.__example_record.freeze()
+
+        self.frozen = True
+
+        self.buffer = bytes(self.buffer)
+        self.events = frozenset(self.events)
+        self.observer.conclude_test(self.status, self.interesting_origin)
+
+    def draw_bits(self, n: int, *, forced: Optionalint = None) -> int:
+        """Return an ``n``-bit integer from the underlying source of
+        bytes. If ``forced`` is set to an integer will instead
+        ignore the underlying source and simulate a draw as if it had
+        returned that integer."""
+        self.__assert_not_frozen("draw_bits")
+        if n == 0:
+            return 0
+        assert n > 0
+        n_bytes = bits_to_bytes(n)
+        self.__check_capacity(n_bytes)
+
+        if forced is not None:
+            buf = int_to_bytes(forced, n_bytes)
+        elif self.__bytes_drawn < len(self.__prefix):
+            index = self.__bytes_drawn
+            buf = self.__prefixindex : index + n_bytes
+            if len(buf) < n_bytes:
+                assert self.__random is not None
+                buf += uniform(self.__random, n_bytes - len(buf))
+        else:
+            assert self.__random is not None
+            buf = uniform(self.__random, n_bytes)
+        buf = bytearray(buf)
+        self.__bytes_drawn += n_bytes
+
+        assert len(buf) == n_bytes
+
+        # If we have a number of bits that is not a multiple of 8
+        # we have to mask off the high bits.
+        buf0 &= BYTE_MASKSn % 8
+        buf = bytes(buf)
+        result = int_from_bytes(buf)
+
+        self.observer.draw_bits(n, forced is not None, result)
+        self.__example_record.draw_bits(n, forced)
+
+        initial = self.index
+
+        assert isinstance(self.buffer, bytearray)
+        self.buffer.extend(buf)
+        self.index = len(self.buffer)
+
+        if forced is not None:
+            self.forced_indices.update(range(initial, self.index))
+
+        self.blocks.add_endpoint(self.index)
+
+        assert result.bit_length() <= n
+        return result
+
+    def draw_bytes(self, n: int) -> bytes:
+        """Draw n bytes from the underlying source."""
+        return int_to_bytes(self.draw_bits(8 * n), n)
+
+    def write(self, string: bytes) -> Optionalbytes:
+        """Write ``string`` to the output buffer."""
+        self.__assert_not_frozen("write")
+        string = bytes(string)
+        if not string:
+            return None
+        self.draw_bits(len(string) * 8, forced=int_from_bytes(string))
+        return self.buffer-len(string) :
+
+    def __check_capacity(self, n: int) -> None:
+        if self.index + n > self.max_length:
+            self.mark_overrun()
+
+    def conclude_test(
+        self,
+        status: Status,
+        interesting_origin: OptionalInterestingOrigin = None,
+    ) -> NoReturn:
+        assert (interesting_origin is None) or (status == Status.INTERESTING)
+        self.__assert_not_frozen("conclude_test")
+        self.interesting_origin = interesting_origin
+        self.status = status
+        self.freeze()
+        raise StopTest(self.testcounter)
+
+    def mark_interesting(
+        self, interesting_origin: OptionalInterestingOrigin = None
+    ) -> NoReturn:
+        self.conclude_test(Status.INTERESTING, interesting_origin)
+
+    def mark_invalid(self, why: Optionalstr = None) -> NoReturn:
+        if why is not None:
+            self.note_event(why)
+        self.conclude_test(Status.INVALID)
+
+    def mark_overrun(self) -> NoReturn:
+        self.conclude_test(Status.OVERRUN)
+
+
+def bits_to_bytes(n: int) -> int:
+    """The number of bytes required to represent an n-bit number.
+    Equivalent to (n + 7) // 8, but slightly faster. This really is
+    called enough times that that matters."""
+    return (n + 7) >> 3

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/datatree.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/dfa Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/dfa/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/dfa/lstar.py Added

@@ -0,0 +1,498 @@
+# 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/.
+
+from bisect import bisect_right, insort
+from collections import Counter
+
+import attr
+
+from hypothesis.errors import InvalidState
+from hypothesis.internal.conjecture.dfa import DFA, cached
+from hypothesis.internal.conjecture.junkdrawer import (
+    IntList,
+    NotFound,
+    SelfOrganisingList,
+    find_integer,
+)
+
+"""
+This module contains an implementation of the L* algorithm
+for learning a deterministic finite automaton based on an
+unknown membership function and a series of examples of
+strings that may or may not satisfy it.
+
+The two relevant papers for understanding this are:
+
+* Angluin, Dana. "Learning regular sets from queries and counterexamples."
+  Information and computation 75.2 (1987): 87-106.
+* Rivest, Ronald L., and Robert E. Schapire. "Inference of finite automata
+  using homing sequences." Information and Computation 103.2 (1993): 299-347.
+  Note that we only use the material from section 4.5 "Improving Angluin's L*
+  algorithm" (page 318), and all of the rest of the material on homing
+  sequences can be skipped.
+
+The former explains the core algorithm, the latter a modification
+we use (which we have further modified) which allows it to
+be implemented more efficiently.
+
+Although we continue to call this L*, we in fact depart heavily from it to the
+point where honestly this is an entirely different algorithm and we should come
+up with a better name.
+
+We have several major departures from the papers:
+
+1. We learn the automaton lazily as we traverse it. This is particularly
+   valuable because if we make many corrections on the same string we only
+   have to learn the transitions that correspond to the string we are
+   correcting on.
+2. We make use of our ``find_integer`` method rather than a binary search
+   as proposed in the Rivest and Schapire paper, as we expect that
+   usually most strings will be mispredicted near the beginning.
+3. We try to learn a smaller alphabet of "interestingly distinct"
+   values. e.g. if all bytes larger than two result in an invalid
+   string, there is no point in distinguishing those bytes. In aid
+   of this we learn a single canonicalisation table which maps integers
+   to smaller integers that we currently think are equivalent, and learn
+   their inequivalence where necessary. This may require more learning
+   steps, as at each stage in the process we might learn either an
+   inequivalent pair of integers or a new experiment, but it may greatly
+   reduce the number of membership queries we have to make.
+
+
+In addition, we have a totally different approach for mapping a string to its
+canonical representative, which will be explained below inline. The general gist
+is that our implementation is much more willing to make mistakes: It will often
+create a DFA that is demonstrably wrong, based on information that it already
+has, but where it is too expensive to discover that before it causes us to
+make a mistake.
+
+A note on performance: This code is not really fast enough for
+us to ever want to run in production on large strings, and this
+is somewhat intrinsic. We should only use it in testing or for
+learning languages offline that we can record for later use.
+
+"""
+
+
+@attr.s(slots=True)
+class DistinguishedState:
+    """Relevant information for a state that we have witnessed as definitely
+    distinct from ones we have previously seen so far."""
+
+    # Index of this state in the learner's list of states
+    index = attr.ib()
+
+    # A string that witnesses this state (i.e. when starting from the origin
+    # and following this string you will end up in this state).
+    label = attr.ib()
+
+    # A boolean as to whether this is an accepting state.
+    accepting = attr.ib()
+
+    # A list of experiments that it is necessary to run to determine whether
+    # a string is in this state. This is stored as a dict mapping experiments
+    # to their expected result. A string is only considered to lead to this
+    # state if ``all(learner.member(s + experiment) == result for experiment,
+    # result in self.experiments.items())``.
+    experiments = attr.ib()
+
+    # A cache of transitions out of this state, mapping bytes to the states
+    # that they lead to.
+    transitions = attr.ib(default=attr.Factory(dict))
+
+
+class LStar:
+    """This class holds the state for learning a DFA. The current DFA can be
+    accessed as the ``dfa`` member of this class. Such a DFA becomes invalid
+    as soon as ``learn`` has been called, and should only be used until the
+    next call to ``learn``.
+
+    Note that many of the DFA methods are on this class, but it is not itself
+    a DFA. The reason for this is that it stores mutable state which can cause
+    the structure of the learned DFA to change in potentially arbitrary ways,
+    making all cached properties become nonsense.
+    """
+
+    def __init__(self, member):
+        self.experiments = 
+        self.__experiment_set = set()
+        self.normalizer = IntegerNormalizer()
+
+        self.__member_cache = {}
+        self.__member = member
+        self.__generation = 0
+
+        # A list of all state objects that correspond to strings we have
+        # seen and can demonstrate map to unique states.
+        self.__states = 
+            DistinguishedState(
+                index=0,
+                label=b"",
+                accepting=self.member(b""),
+                experiments={b"": self.member(b"")},
+            )
+        
+
+        # When we're trying to figure out what state a string leads to we will
+        # end up searching to find a suitable candidate. By putting states in
+        # a self-organising list we ideally minimise the number of lookups.
+        self.__self_organising_states = SelfOrganisingList(self.__states)
+
+        self.start = 0
+
+        self.__dfa_changed()
+
+    def __dfa_changed(self):
+        """Note that something has changed, updating the generation
+        and resetting any cached state."""
+        self.__generation += 1
+        self.dfa = LearnedDFA(self)
+
+    def is_accepting(self, i):
+        """Equivalent to ``self.dfa.is_accepting(i)``"""
+        return self.__statesi.accepting
+
+    def label(self, i):
+        """Returns the string label for state ``i``."""
+        return self.__statesi.label
+
+    def transition(self, i, c):
+        """Equivalent to ``self.dfa.transition(i, c)```"""
+        c = self.normalizer.normalize(c)
+        state = self.__statesi
+        try:
+            return state.transitionsc
+        except KeyError:
+            pass
+
+        # The state that we transition to when reading ``c`` is reached by
+        # this string, because this state is reached by state.label. We thus
+        # want our candidate for the transition to be some state with a label
+        # equivalent to this string.
+        #
+        # We find such a state by looking for one such that all of its listed
+        # experiments agree on the result for its state label and this string.
+        string = state.label + bytes(c)
+
+        # We keep track of some useful experiments for distinguishing this
+        # string from other states, as this both allows us to more accurately
+        # select the state to map to and, if necessary, create the new state
+        # that this string corresponds to with a decent set of starting
+        # experiments.
+        accumulated = {}
+        counts = Counter()
+
+        def equivalent(t):
+            """Checks if ``string`` could possibly lead to state ``t``."""
+            for e, expected in accumulated.items():
+                if self.member(t.label + e) != expected:
+                    countse += 1
+                    return False
+
+            for e, expected in t.experiments.items():
+                result = self.member(string + e)
+                if result != expected:
+                    # We expect most experiments to return False so if we add
+                    # only True ones to our collection of essential experiments
+                    # we keep the size way down and select only ones that are
+                    # likely to provide useful information in future.
+                    if result:
+                        accumulatede = result
+                    return False
+            return True
+
+        try:
+            destination = self.__self_organising_states.find(equivalent)
+        except NotFound:
+            i = len(self.__states)
+            destination = DistinguishedState(
+                index=i,
+                label=string,
+                experiments=accumulated,
+                accepting=self.member(string),
+            )
+            self.__states.append(destination)
+            self.__self_organising_states.add(destination)
+        state.transitionsc = destination.index
+        return destination.index
+
+    def member(self, s):
+        """Check whether this string is a member of the language
+        to be learned."""
+        try:
+            return self.__member_caches
+        except KeyError:
+            result = self.__member(s)
+            self.__member_caches = result
+            return result
+
+    @property
+    def generation(self):
+        """Return an integer value that will be incremented
+        every time the DFA we predict changes."""
+        return self.__generation
+
+    def learn(self, string):
+        """Learn to give the correct answer on this string.
+        That is, after this method completes we will have
+        ``self.dfa.matches(s) == self.member(s)``.
+
+        Note that we do not guarantee that this will remain
+        true in the event that learn is called again with
+        a different string. It is in principle possible that
+        future learning will cause us to make a mistake on
+        this string. However, repeatedly calling learn on
+        each of a set of strings until the generation stops
+        changing is guaranteed to terminate.
+        """
+        string = bytes(string)
+        correct_outcome = self.member(string)
+
+        # We don't want to check this inside the loop because it potentially
+        # causes us to evaluate more of the states than we actually need to,
+        # but if our model is mostly correct then this will be faster because
+        # we only need to evaluate strings that are of the form
+        # ``state + experiment``, which will generally be cached and/or needed
+        # later.
+        if self.dfa.matches(string) == correct_outcome:
+            return
+
+        # In the papers they assume that we only run this process
+        # once, but this is silly - often when you've got a messy
+        # string it will be wrong for many different reasons.
+        #
+        # Thus we iterate this to a fixed point where we repair
+        # the DFA by repeatedly adding experiments until the DFA
+        # agrees with the membership function on this string.
+
+        # First we make sure that normalization is not the source of the
+        # failure to match.
+        while True:
+            normalized = bytes(self.normalizer.normalize(c) for c in string)
+            # We can correctly replace the string with its normalized version
+            # so normalization is not the problem here.
+            if self.member(normalized) == correct_outcome:
+                string = normalized
+                break
+            alphabet = sorted(set(string), reverse=True)
+            target = string
+            for a in alphabet:
+
+                def replace(b):
+                    if a == b:
+                        return target
+                    return bytes(b if c == a else c for c in target)
+
+                self.normalizer.distinguish(a, lambda x: self.member(replace(x)))
+                target = replace(self.normalizer.normalize(a))
+                assert self.member(target) == correct_outcome
+            assert target != normalized
+            self.__dfa_changed()
+
+        if self.dfa.matches(string) == correct_outcome:
+            return
+
+        # Now we know normalization is correct we can attempt to determine if
+        # any of our transitions are wrong.
+        while True:
+            dfa = self.dfa
+
+            states = dfa.start
+
+            def seems_right(n):
+                """After reading n characters from s, do we seem to be
+                in the right state?
+
+                We determine this by replacing the first n characters
+                of s with the label of the state we expect to be in.
+                If we are in the right state, that will replace a substring
+                with an equivalent one so must produce the same answer.
+                """
+                if n > len(string):
+                    return False
+
+                # Populate enough of the states list to know where we are.
+                while n >= len(states):
+                    states.append(dfa.transition(states-1, stringlen(states) - 1))
+
+                return self.member(dfa.label(statesn) + stringn:) == correct_outcome
+
+            assert seems_right(0)
+
+            n = find_integer(seems_right)
+
+            # We got to the end without ever finding ourself in a bad
+            # state, so we must correctly match this string.
+            if n == len(string):
+                assert dfa.matches(string) == correct_outcome
+                break
+
+            # Reading n characters does not put us in a bad state but
+            # reading n + 1 does. This means that the remainder of
+            # the string that we have not read yet is an experiment
+            # that allows us to distinguish the state that we ended
+            # up in from the state that we should have ended up in.
+
+            source = statesn
+            character = stringn
+            wrong_destination = statesn + 1
+
+            # We've made an error in transitioning from ``source`` to
+            # ``wrong_destination`` via ``character``. We now need to update
+            # the DFA so that this transition no longer occurs. Note that we
+            # do not guarantee that the transition is *correct* after this,
+            # only that we don't make this particular error.
+            assert self.transition(source, character) == wrong_destination
+
+            labels_wrong_destination = self.dfa.label(wrong_destination)
+            labels_correct_destination = self.dfa.label(source) + bytes(character)
+
+            ex = stringn + 1 :
+
+            assert self.member(labels_wrong_destination + ex) != self.member(
+                labels_correct_destination + ex
+            )
+
+            # Adding this experiment causes us to distinguish the wrong
+            # destination from the correct one.
+            self.__stateswrong_destination.experimentsex = self.member(
+                labels_wrong_destination + ex
+            )
+
+            # We now clear the cached details that caused us to make this error
+            # so that when we recalculate this transition we get to a
+            # (hopefully now correct) different state.
+            del self.__statessource.transitionscharacter
+            self.__dfa_changed()
+
+            # We immediately recalculate the transition so that we can check
+            # that it has changed as we expect it to have.
+            new_destination = self.transition(source, stringn)
+            assert new_destination != wrong_destination
+
+
+class LearnedDFA(DFA):
+    """This implements a lazily calculated DFA where states
+    are labelled by some string that reaches them, and are
+    distinguished by a membership test and a set of experiments."""
+
+    def __init__(self, lstar):
+        super().__init__()
+        self.__lstar = lstar
+        self.__generation = lstar.generation
+
+    def __check_changed(self):
+        if self.__generation != self.__lstar.generation:
+            raise InvalidState(
+                "The underlying L* model has changed, so this DFA is no longer valid. "
+                "If you want to preserve a previously learned DFA for posterity, call "
+                "canonicalise() on it first."
+            )
+
+    def label(self, i):
+        self.__check_changed()
+        return self.__lstar.label(i)
+
+    @property
+    def start(self):
+        self.__check_changed()
+        return self.__lstar.start
+
+    def is_accepting(self, i):
+        self.__check_changed()
+        return self.__lstar.is_accepting(i)
+
+    def transition(self, i, c):
+        self.__check_changed()
+
+        return self.__lstar.transition(i, c)
+
+    @cached
+    def successor_states(self, state):
+        """Returns all of the distinct states that can be reached via one
+        transition from ``state``, in the lexicographic order of the
+        smallest character that reaches them."""
+        seen = set()
+        result = 
+        for c in self.__lstar.normalizer.representatives():
+            j = self.transition(state, c)
+            if j not in seen:
+                seen.add(j)
+                result.append(j)
+        return tuple(result)
+
+
+class IntegerNormalizer:
+    """A class for replacing non-negative integers with a
+    "canonical" value that is equivalent for all relevant
+    purposes."""
+
+    def __init__(self):
+        # We store canonical values as a sorted list of integers
+        # with each value being treated as equivalent to the largest
+        # integer in the list that is below it.
+        self.__values = IntList(0)
+        self.__cache = {}
+
+    def __repr__(self):
+        return f"IntegerNormalizer({list(self.__values)!r})"
+
+    def __copy__(self):
+        result = IntegerNormalizer()
+        result.__values = IntList(self.__values)
+        return result
+
+    def representatives(self):
+        yield from self.__values
+
+    def normalize(self, value):
+        """Return the canonical integer considered equivalent
+        to ``value``."""
+        try:
+            return self.__cachevalue
+        except KeyError:
+            pass
+        i = bisect_right(self.__values, value) - 1
+        assert i >= 0
+        return self.__cache.setdefault(value, self.__valuesi)
+
+    def distinguish(self, value, test):
+        """Checks whether ``test`` gives the same answer for
+        ``value`` and ``self.normalize(value)``. If it does
+        not, updates the list of canonical values so that
+        it does.
+
+        Returns True if and only if this makes a change to
+        the underlying canonical values."""
+        canonical = self.normalize(value)
+        if canonical == value:
+            return False
+
+        value_test = test(value)
+
+        if test(canonical) == value_test:
+            return False
+
+        self.__cache.clear()
+
+        def can_lower(k):
+            new_canon = value - k
+            if new_canon <= canonical:
+                return False
+            return test(new_canon) == value_test
+
+        new_canon = value - find_integer(can_lower)
+
+        assert new_canon not in self.__values
+
+        insort(self.__values, new_canon)
+
+        assert self.normalize(value) == new_canon
+        return True

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/engine.py Added

@@ -0,0 +1,1098 @@
+# 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 math
+import sys
+import time
+from collections import defaultdict
+from contextlib import contextmanager
+from datetime import timedelta
+from enum import Enum
+from random import Random, getrandbits
+from weakref import WeakKeyDictionary
+
+import attr
+
+from hypothesis import HealthCheck, Phase, Verbosity, settings as Settings
+from hypothesis._settings import local_settings
+from hypothesis.errors import StopTest
+from hypothesis.internal.cache import LRUReusedCache
+from hypothesis.internal.compat import ceil, int_from_bytes
+from hypothesis.internal.conjecture.data import (
+    ConjectureData,
+    ConjectureResult,
+    DataObserver,
+    Overrun,
+    Status,
+)
+from hypothesis.internal.conjecture.datatree import (
+    DataTree,
+    PreviouslyUnseenBehaviour,
+    TreeRecordingObserver,
+)
+from hypothesis.internal.conjecture.junkdrawer import clamp, stack_depth_of_caller
+from hypothesis.internal.conjecture.pareto import NO_SCORE, ParetoFront, ParetoOptimiser
+from hypothesis.internal.conjecture.shrinker import Shrinker, sort_key
+from hypothesis.internal.healthcheck import fail_health_check
+from hypothesis.reporting import base_report, report
+
+MAX_SHRINKS = 500
+CACHE_SIZE = 10000
+MUTATION_POOL_SIZE = 100
+MIN_TEST_CALLS = 10
+BUFFER_SIZE = 8 * 1024
+
+
+@attr.s
+class HealthCheckState:
+    valid_examples = attr.ib(default=0)
+    invalid_examples = attr.ib(default=0)
+    overrun_examples = attr.ib(default=0)
+    draw_times = attr.ib(default=attr.Factory(list))
+
+
+class ExitReason(Enum):
+    max_examples = "settings.max_examples={s.max_examples}"
+    max_iterations = (
+        "settings.max_examples={s.max_examples}, "
+        "but < 10% of examples satisfied assumptions"
+    )
+    max_shrinks = f"shrunk example {MAX_SHRINKS} times"
+    finished = "nothing left to do"
+    flaky = "test was flaky"
+    very_slow_shrinking = "shrinking was very slow"
+
+    def describe(self, settings):
+        return self.value.format(s=settings)
+
+
+class RunIsComplete(Exception):
+    pass
+
+
+class ConjectureRunner:
+    def __init__(
+        self,
+        test_function,
+        settings=None,
+        random=None,
+        database_key=None,
+        ignore_limits=False,
+    ):
+        self._test_function = test_function
+        self.settings = settings or Settings()
+        self.shrinks = 0
+        self.finish_shrinking_deadline = None
+        self.call_count = 0
+        self.valid_examples = 0
+        self.random = random or Random(getrandbits(128))
+        self.database_key = database_key
+        self.ignore_limits = ignore_limits
+
+        # Global dict of per-phase statistics, and a list of per-call stats
+        # which transfer to the global dict at the end of each phase.
+        self.statistics = {}
+        self.stats_per_test_case = 
+
+        self.events_to_strings = WeakKeyDictionary()
+
+        self.interesting_examples = {}
+        # We use call_count because there may be few possible valid_examples.
+        self.first_bug_found_at = None
+        self.last_bug_found_at = None
+
+        self.shrunk_examples = set()
+
+        self.health_check_state = None
+
+        self.tree = DataTree()
+
+        self.best_observed_targets = defaultdict(lambda: NO_SCORE)
+        self.best_examples_of_observed_targets = {}
+
+        # We keep the pareto front in the example database if we have one. This
+        # is only marginally useful at present, but speeds up local development
+        # because it means that large targets will be quickly surfaced in your
+        # testing.
+        if self.database_key is not None and self.settings.database is not None:
+            self.pareto_front = ParetoFront(self.random)
+            self.pareto_front.on_evict(self.on_pareto_evict)
+        else:
+            self.pareto_front = None
+
+        # We want to be able to get the ConjectureData object that results
+        # from running a buffer without recalculating, especially during
+        # shrinking where we need to know about the structure of the
+        # executed test case.
+        self.__data_cache = LRUReusedCache(CACHE_SIZE)
+
+        # We ensure that the test has this much stack space remaining, no matter
+        # the size of the stack when called, to de-flake RecursionErrors (#2494).
+        self.__recursion_limit = sys.getrecursionlimit()
+        self.__pending_call_explanation = None
+
+    def explain_next_call_as(self, explanation):
+        self.__pending_call_explanation = explanation
+
+    def clear_call_explanation(self):
+        self.__pending_call_explanation = None
+
+    @contextmanager
+    def _log_phase_statistics(self, phase):
+        self.stats_per_test_case.clear()
+        start_time = time.perf_counter()
+        try:
+            yield
+        finally:
+            self.statisticsphase + "-phase" = {
+                "duration-seconds": time.perf_counter() - start_time,
+                "test-cases": list(self.stats_per_test_case),
+                "distinct-failures": len(self.interesting_examples),
+                "shrinks-successful": self.shrinks,
+            }
+
+    @property
+    def should_optimise(self):
+        return Phase.target in self.settings.phases
+
+    def __tree_is_exhausted(self):
+        return self.tree.is_exhausted
+
+    def __stoppable_test_function(self, data):
+        """Run ``self._test_function``, but convert a ``StopTest`` exception
+        into a normal return and avoid raising Flaky for RecursionErrors.
+        """
+        depth = stack_depth_of_caller()
+        # Because we add to the recursion limit, to be good citizens we also add
+        # a check for unbounded recursion.  The default limit is 1000, so this can
+        # only ever trigger if something really strange is happening and it's hard
+        # to imagine an intentionally-deeply-recursive use of this code.
+        assert depth <= 1000, (
+            "Hypothesis would usually add %d to the stack depth of %d here, "
+            "but we are already much deeper than expected.  Aborting now, to "
+            "avoid extending the stack limit in an infinite loop..."
+            % (self.__recursion_limit, depth)
+        )
+        try:
+            sys.setrecursionlimit(depth + self.__recursion_limit)
+            self._test_function(data)
+        except StopTest as e:
+            if e.testcounter == data.testcounter:
+                # This StopTest has successfully stopped its test, and can now
+                # be discarded.
+                pass
+            else:
+                # This StopTest was raised by a different ConjectureData. We
+                # need to re-raise it so that it will eventually reach the
+                # correct engine.
+                raise
+        finally:
+            sys.setrecursionlimit(self.__recursion_limit)
+
+    def test_function(self, data):
+        if self.__pending_call_explanation is not None:
+            self.debug(self.__pending_call_explanation)
+            self.__pending_call_explanation = None
+
+        assert isinstance(data.observer, TreeRecordingObserver)
+        self.call_count += 1
+
+        interrupted = False
+        try:
+            self.__stoppable_test_function(data)
+        except KeyboardInterrupt:
+            interrupted = True
+            raise
+        except BaseException:
+            self.save_buffer(data.buffer)
+            raise
+        finally:
+            # No branch, because if we're interrupted we always raise
+            # the KeyboardInterrupt, never continue to the code below.
+            if not interrupted:  # pragma: no branch
+                data.freeze()
+                call_stats = {
+                    "status": data.status.name.lower(),
+                    "runtime": data.finish_time - data.start_time,
+                    "drawtime": math.fsum(data.draw_times),
+                    "events": sorted({self.event_to_string(e) for e in data.events}),
+                }
+                self.stats_per_test_case.append(call_stats)
+                self.__data_cachedata.buffer = data.as_result()
+
+        self.debug_data(data)
+
+        if self.pareto_front is not None and self.pareto_front.add(data.as_result()):
+            self.save_buffer(data.buffer, sub_key=b"pareto")
+
+        assert len(data.buffer) <= BUFFER_SIZE
+
+        if data.status >= Status.VALID:
+            for k, v in data.target_observations.items():
+                self.best_observed_targetsk = max(self.best_observed_targetsk, v)
+
+                if k not in self.best_examples_of_observed_targets:
+                    self.best_examples_of_observed_targetsk = data.as_result()
+                    continue
+
+                existing_example = self.best_examples_of_observed_targetsk
+                existing_score = existing_example.target_observationsk
+
+                if v < existing_score:
+                    continue
+
+                if v > existing_score or sort_key(data.buffer) < sort_key(
+                    existing_example.buffer
+                ):
+                    self.best_examples_of_observed_targetsk = data.as_result()
+
+        if data.status == Status.VALID:
+            self.valid_examples += 1
+
+        if data.status == Status.INTERESTING:
+            key = data.interesting_origin
+            changed = False
+            try:
+                existing = self.interesting_exampleskey
+            except KeyError:
+                changed = True
+                self.last_bug_found_at = self.call_count
+                if self.first_bug_found_at is None:
+                    self.first_bug_found_at = self.call_count
+            else:
+                if sort_key(data.buffer) < sort_key(existing.buffer):
+                    self.shrinks += 1
+                    self.downgrade_buffer(existing.buffer)
+                    self.__data_cache.unpin(existing.buffer)
+                    changed = True
+
+            if changed:
+                self.save_buffer(data.buffer)
+                self.interesting_exampleskey = data.as_result()
+                self.__data_cache.pin(data.buffer)
+                self.shrunk_examples.discard(key)
+
+            if self.shrinks >= MAX_SHRINKS:
+                self.exit_with(ExitReason.max_shrinks)
+
+        if (
+            not self.ignore_limits
+            and self.finish_shrinking_deadline is not None
+            and self.finish_shrinking_deadline < time.perf_counter()
+        ):
+            # See https://github.com/HypothesisWorks/hypothesis/issues/2340
+            report(
+                "WARNING: Hypothesis has spent more than five minutes working to shrink"
+                " a failing example, and stopped because it is making very slow"
+                " progress.  When you re-run your tests, shrinking will resume and may"
+                " take this long before aborting again.\nPLEASE REPORT THIS if you can"
+                " provide a reproducing example, so that we can improve shrinking"
+                " performance for everyone."
+            )
+            self.exit_with(ExitReason.very_slow_shrinking)
+
+        if not self.interesting_examples:
+            # Note that this logic is reproduced to end the generation phase when
+            # we have interesting examples.  Update that too if you change this!
+            # (The doubled implementation is because here we exit the engine entirely,
+            #  while in the other case below we just want to move on to shrinking.)
+            if self.valid_examples >= self.settings.max_examples:
+                self.exit_with(ExitReason.max_examples)
+            if self.call_count >= max(
+                self.settings.max_examples * 10,
+                # We have a high-ish default max iterations, so that tests
+                # don't become flaky when max_examples is too low.
+                1000,
+            ):
+                self.exit_with(ExitReason.max_iterations)
+
+        if self.__tree_is_exhausted():
+            self.exit_with(ExitReason.finished)
+
+        self.record_for_health_check(data)
+
+    def on_pareto_evict(self, data):
+        self.settings.database.delete(self.pareto_key, data.buffer)
+
+    def generate_novel_prefix(self):
+        """Uses the tree to proactively generate a starting sequence of bytes
+        that we haven't explored yet for this test.
+
+        When this method is called, we assume that there must be at
+        least one novel prefix left to find. If there were not, then the
+        test run should have already stopped due to tree exhaustion.
+        """
+        return self.tree.generate_novel_prefix(self.random)
+
+    def record_for_health_check(self, data):
+        # Once we've actually found a bug, there's no point in trying to run
+        # health checks - they'll just mask the actually important information.
+        if data.status == Status.INTERESTING:
+            self.health_check_state = None
+
+        state = self.health_check_state
+
+        if state is None:
+            return
+
+        state.draw_times.extend(data.draw_times)
+
+        if data.status == Status.VALID:
+            state.valid_examples += 1
+        elif data.status == Status.INVALID:
+            state.invalid_examples += 1
+        else:
+            assert data.status == Status.OVERRUN
+            state.overrun_examples += 1
+
+        max_valid_draws = 10
+        max_invalid_draws = 50
+        max_overrun_draws = 20
+
+        assert state.valid_examples <= max_valid_draws
+
+        if state.valid_examples == max_valid_draws:
+            self.health_check_state = None
+            return
+
+        if state.overrun_examples == max_overrun_draws:
+            fail_health_check(
+                self.settings,
+                "Examples routinely exceeded the max allowable size. "
+                f"({state.overrun_examples} examples overran while generating "
+                f"{state.valid_examples} valid ones). Generating examples this large "
+                "will usually lead to bad results. You could try setting max_size "
+                "parameters on your collections and turning max_leaves down on "
+                "recursive() calls.",
+                HealthCheck.data_too_large,
+            )
+        if state.invalid_examples == max_invalid_draws:
+            fail_health_check(
+                self.settings,
+                "It looks like your strategy is filtering out a lot of data. Health "
+                f"check found {state.invalid_examples} filtered examples but only "
+                f"{state.valid_examples} good ones. This will make your tests much "
+                "slower, and also will probably distort the data generation quite a "
+                "lot. You should adapt your strategy to filter less. This can also "
+                "be caused by a low max_leaves parameter in recursive() calls",
+                HealthCheck.filter_too_much,
+            )
+
+        draw_time = sum(state.draw_times)
+
+        # Allow at least the greater of one second or 5x the deadline.  If deadline
+        # is None, allow 30s - the user can disable the healthcheck too if desired.
+        draw_time_limit = 5 * (self.settings.deadline or timedelta(seconds=6))
+        if draw_time > max(1.0, draw_time_limit.total_seconds()):
+            fail_health_check(
+                self.settings,
+                "Data generation is extremely slow: Only produced "
+                f"{state.valid_examples} valid examples in {draw_time:.2f} seconds "
+                f"({state.invalid_examples} invalid ones and {state.overrun_examples} "
+                "exceeded maximum size). Try decreasing size of the data you're "
+                "generating (with e.g. max_size or max_leaves parameters).",
+                HealthCheck.too_slow,
+            )
+
+    def save_buffer(self, buffer, sub_key=None):
+        if self.settings.database is not None:
+            key = self.sub_key(sub_key)
+            if key is None:
+                return
+            self.settings.database.save(key, bytes(buffer))
+
+    def downgrade_buffer(self, buffer):
+        if self.settings.database is not None and self.database_key is not None:
+            self.settings.database.move(self.database_key, self.secondary_key, buffer)
+
+    def sub_key(self, sub_key):
+        if self.database_key is None:
+            return None
+        if sub_key is None:
+            return self.database_key
+        return b".".join((self.database_key, sub_key))
+
+    @property
+    def secondary_key(self):
+        return self.sub_key(b"secondary")
+
+    @property
+    def pareto_key(self):
+        return self.sub_key(b"pareto")
+
+    def debug(self, message):
+        if self.settings.verbosity >= Verbosity.debug:
+            base_report(message)
+
+    @property
+    def report_debug_info(self):
+        return self.settings.verbosity >= Verbosity.debug
+
+    def debug_data(self, data):
+        if not self.report_debug_info:
+            return
+
+        stack = 
+
+        def go(ex):
+            if ex.length == 0:
+                return
+            if len(ex.children) == 0:
+                stack-1.append(int_from_bytes(data.bufferex.start : ex.end))
+            else:
+                node = 
+                stack.append(node)
+
+                for v in ex.children:
+                    go(v)
+                stack.pop()
+                if len(node) == 1:
+                    stack-1.extend(node)
+                else:
+                    stack-1.append(node)
+
+        go(data.examples0)
+        assert len(stack) == 1
+
+        status = repr(data.status)
+
+        if data.status == Status.INTERESTING:
+            status = f"{status} ({data.interesting_origin!r})"
+
+        self.debug(f"{data.index} bytes {stack0!r} -> {status}, {data.output}")
+
+    def run(self):
+        with local_settings(self.settings):
+            try:
+                self._run()
+            except RunIsComplete:
+                pass
+            for v in self.interesting_examples.values():
+                self.debug_data(v)
+            self.debug(
+                "Run complete after %d examples (%d valid) and %d shrinks"
+                % (self.call_count, self.valid_examples, self.shrinks)
+            )
+
+    @property
+    def database(self):
+        if self.database_key is None:
+            return None
+        return self.settings.database
+
+    def has_existing_examples(self):
+        return self.database is not None and Phase.reuse in self.settings.phases
+
+    def reuse_existing_examples(self):
+        """If appropriate (we have a database and have been told to use it),
+        try to reload existing examples from the database.
+
+        If there are a lot we don't try all of them. We always try the
+        smallest example in the database (which is guaranteed to be the
+        last failure) and the largest (which is usually the seed example
+        which the last failure came from but we don't enforce that). We
+        then take a random sampling of the remainder and try those. Any
+        examples that are no longer interesting are cleared out.
+        """
+        if self.has_existing_examples():
+            self.debug("Reusing examples from database")
+            # We have to do some careful juggling here. We have two database
+            # corpora: The primary and secondary. The primary corpus is a
+            # small set of minimized examples each of which has at one point
+            # demonstrated a distinct bug. We want to retry all of these.
+
+            # We also have a secondary corpus of examples that have at some
+            # point demonstrated interestingness (currently only ones that
+            # were previously non-minimal examples of a bug, but this will
+            # likely expand in future). These are a good source of potentially
+            # interesting examples, but there are a lot of them, so we down
+            # sample the secondary corpus to a more manageable size.
+
+            corpus = sorted(
+                self.settings.database.fetch(self.database_key), key=sort_key
+            )
+            factor = 0.1 if (Phase.generate in self.settings.phases) else 1
+            desired_size = max(2, ceil(factor * self.settings.max_examples))
+
+            if len(corpus) < desired_size:
+                extra_corpus = list(self.settings.database.fetch(self.secondary_key))
+
+                shortfall = desired_size - len(corpus)
+
+                if len(extra_corpus) <= shortfall:
+                    extra = extra_corpus
+                else:
+                    extra = self.random.sample(extra_corpus, shortfall)
+                extra.sort(key=sort_key)
+                corpus.extend(extra)
+
+            for existing in corpus:
+                data = self.cached_test_function(existing)
+                if data.status != Status.INTERESTING:
+                    self.settings.database.delete(self.database_key, existing)
+                    self.settings.database.delete(self.secondary_key, existing)
+
+            # If we've not found any interesting examples so far we try some of
+            # the pareto front from the last run.
+            if len(corpus) < desired_size and not self.interesting_examples:
+                desired_extra = desired_size - len(corpus)
+                pareto_corpus = list(self.settings.database.fetch(self.pareto_key))
+                if len(pareto_corpus) > desired_extra:
+                    pareto_corpus = self.random.sample(pareto_corpus, desired_extra)
+                pareto_corpus.sort(key=sort_key)
+
+                for existing in pareto_corpus:
+                    data = self.cached_test_function(existing)
+                    if data not in self.pareto_front:
+                        self.settings.database.delete(self.pareto_key, existing)
+                    if data.status == Status.INTERESTING:
+                        break
+
+    def exit_with(self, reason):
+        if self.ignore_limits:
+            return
+        self.statistics"stopped-because" = reason.describe(self.settings)
+        if self.best_observed_targets:
+            self.statistics"targets" = dict(self.best_observed_targets)
+        self.debug(f"exit_with({reason.name})")
+        self.exit_reason = reason
+        raise RunIsComplete()
+
+    def should_generate_more(self):
+        # End the generation phase where we would have ended it if no bugs had
+        # been found.  This reproduces the exit logic in `self.test_function`,
+        # but with the important distinction that this clause will move on to
+        # the shrinking phase having found one or more bugs, while the other
+        # will exit having found zero bugs.
+        if self.valid_examples >= self.settings.max_examples or self.call_count >= max(
+            self.settings.max_examples * 10, 1000
+        ):  # pragma: no cover
+            return False
+
+        # If we haven't found a bug, keep looking - if we hit any limits on
+        # the number of tests to run that will raise an exception and stop
+        # the run.
+        if not self.interesting_examples:
+            return True
+        # Users who disable shrinking probably want to exit as fast as possible.
+        # If we've found a bug and won't report more than one, stop looking.
+        elif (
+            Phase.shrink not in self.settings.phases
+            or not self.settings.report_multiple_bugs
+        ):
+            return False
+        assert self.first_bug_found_at <= self.last_bug_found_at <= self.call_count
+        # Otherwise, keep searching for between ten and 'a heuristic' calls.
+        # We cap 'calls after first bug' so errors are reported reasonably
+        # soon even for tests that are allowed to run for a very long time,
+        # or sooner if the latest half of our test effort has been fruitless.
+        return self.call_count < MIN_TEST_CALLS or self.call_count < min(
+            self.first_bug_found_at + 1000, self.last_bug_found_at * 2
+        )
+
+    def generate_new_examples(self):
+        if Phase.generate not in self.settings.phases:
+            return
+        if self.interesting_examples:
+            # The example database has failing examples from a previous run,
+            # so we'd rather report that they're still failing ASAP than take
+            # the time to look for additional failures.
+            return
+
+        self.debug("Generating new examples")
+
+        assert self.should_generate_more()
+        zero_data = self.cached_test_function(bytes(BUFFER_SIZE))
+        if zero_data.status > Status.OVERRUN:
+            self.__data_cache.pin(zero_data.buffer)
+
+        if zero_data.status == Status.OVERRUN or (
+            zero_data.status == Status.VALID and len(zero_data.buffer) * 2 > BUFFER_SIZE
+        ):
+            fail_health_check(
+                self.settings,
+                "The smallest natural example for your test is extremely "
+                "large. This makes it difficult for Hypothesis to generate "
+                "good examples, especially when trying to reduce failing ones "
+                "at the end. Consider reducing the size of your data if it is "
+                "of a fixed size. You could also fix this by improving how "
+                "your data shrinks (see https://hypothesis.readthedocs.io/en/"
+                "latest/data.html#shrinking for details), or by introducing "
+                "default values inside your strategy. e.g. could you replace "
+                "some arguments with their defaults by using "
+                "one_of(none(), some_complex_strategy)?",
+                HealthCheck.large_base_example,
+            )
+
+        self.health_check_state = HealthCheckState()
+
+        # We attempt to use the size of the minimal generated test case starting
+        # from a given novel prefix as a guideline to generate smaller test
+        # cases for an initial period, by restriscting ourselves to test cases
+        # that are not much larger than it.
+        #
+        # Calculating the actual minimal generated test case is hard, so we
+        # take a best guess that zero extending a prefix produces the minimal
+        # test case starting with that prefix (this is true for our built in
+        # strategies). This is only a reasonable thing to do if the resulting
+        # test case is valid. If we regularly run into situations where it is
+        # not valid then this strategy is a waste of time, so we want to
+        # abandon it early. In order to do this we track how many times in a
+        # row it has failed to work, and abort small test case generation when
+        # it has failed too many times in a row.
+        consecutive_zero_extend_is_invalid = 0
+
+        # We control growth during initial example generation, for two
+        # reasons:
+        #
+        # * It gives us an opportunity to find small examples early, which
+        #   gives us a fast path for easy to find bugs.
+        # * It avoids low probability events where we might end up
+        #   generating very large examples during health checks, which
+        #   on slower machines can trigger HealthCheck.too_slow.
+        #
+        # The heuristic we use is that we attempt to estimate the smallest
+        # extension of this prefix, and limit the size to no more than
+        # an order of magnitude larger than that. If we fail to estimate
+        # the size accurately, we skip over this prefix and try again.
+        #
+        # We need to tune the example size based on the initial prefix,
+        # because any fixed size might be too small, and any size based
+        # on the strategy in general can fall afoul of strategies that
+        # have very different sizes for different prefixes.
+        small_example_cap = clamp(10, self.settings.max_examples // 10, 50)
+
+        optimise_at = max(self.settings.max_examples // 2, small_example_cap + 1)
+        ran_optimisations = False
+
+        while self.should_generate_more():
+            prefix = self.generate_novel_prefix()
+            assert len(prefix) <= BUFFER_SIZE
+            if (
+                self.valid_examples <= small_example_cap
+                and self.call_count <= 5 * small_example_cap
+                and not self.interesting_examples
+                and consecutive_zero_extend_is_invalid < 5
+            ):
+                minimal_example = self.cached_test_function(
+                    prefix + bytes(BUFFER_SIZE - len(prefix))
+                )
+
+                if minimal_example.status < Status.VALID:
+                    consecutive_zero_extend_is_invalid += 1
+                    continue
+
+                consecutive_zero_extend_is_invalid = 0
+
+                minimal_extension = len(minimal_example.buffer) - len(prefix)
+
+                max_length = min(len(prefix) + minimal_extension * 10, BUFFER_SIZE)
+
+                # We could end up in a situation where even though the prefix was
+                # novel when we generated it, because we've now tried zero extending
+                # it not all possible continuations of it will be novel. In order to
+                # avoid making redundant test calls, we rerun it in simulation mode
+                # first. If this has a predictable result, then we don't bother
+                # running the test function for real here. If however we encounter
+                # some novel behaviour, we try again with the real test function,
+                # starting from the new novel prefix that has discovered.
+                try:
+                    trial_data = self.new_conjecture_data(
+                        prefix=prefix, max_length=max_length
+                    )
+                    self.tree.simulate_test_function(trial_data)
+                    continue
+                except PreviouslyUnseenBehaviour:
+                    pass
+
+                # If the simulation entered part of the tree that has been killed,
+                # we don't want to run this.
+                if trial_data.observer.killed:
+                    continue
+
+                # We might have hit the cap on number of examples we should
+                # run when calculating the minimal example.
+                if not self.should_generate_more():
+                    break
+
+                prefix = trial_data.buffer
+            else:
+                max_length = BUFFER_SIZE
+
+            data = self.new_conjecture_data(prefix=prefix, max_length=max_length)
+
+            self.test_function(data)
+
+            self.generate_mutations_from(data)
+
+            # Although the optimisations are logically a distinct phase, we
+            # actually normally run them as part of example generation. The
+            # reason for this is that we cannot guarantee that optimisation
+            # actually exhausts our budget: It might finish running and we
+            # discover that actually we still could run a bunch more test cases
+            # if we want.
+            if (
+                self.valid_examples >= max(small_example_cap, optimise_at)
+                and not ran_optimisations
+            ):
+                ran_optimisations = True
+                self.optimise_targets()
+
+    def generate_mutations_from(self, data):
+        # A thing that is often useful but rarely happens by accident is
+        # to generate the same value at multiple different points in the
+        # test case.
+        #
+        # Rather than make this the responsibility of individual strategies
+        # we implement a small mutator that just takes parts of the test
+        # case with the same label and tries replacing one of them with a
+        # copy of the other and tries running it. If we've made a good
+        # guess about what to put where, this will run a similar generated
+        # test case with more duplication.
+        if (
+            # An OVERRUN doesn't have enough information about the test
+            # case to mutate, so we just skip those.
+            data.status >= Status.INVALID
+            # This has a tendency to trigger some weird edge cases during
+            # generation so we don't let it run until we're done with the
+            # health checks.
+            and self.health_check_state is None
+        ):
+            initial_calls = self.call_count
+            failed_mutations = 0
+
+            while (
+                self.should_generate_more()
+                # We implement fairly conservative checks for how long we
+                # we should run mutation for, as it's generally not obvious
+                # how helpful it is for any given test case.
+                and self.call_count <= initial_calls + 5
+                and failed_mutations <= 5
+            ):
+                groups = data.examples.mutator_groups
+                if not groups:
+                    break
+
+                group = self.random.choice(groups)
+
+                ex1, ex2 = (
+                    data.examplesi for i in sorted(self.random.sample(group, 2))
+                )
+                assert ex1.end <= ex2.start
+
+                replacements = data.buffere.start : e.end for e in ex1, ex2
+
+                replacement = self.random.choice(replacements)
+
+                try:
+                    # We attempt to replace both the the examples with
+                    # whichever choice we made. Note that this might end
+                    # up messing up and getting the example boundaries
+                    # wrong - labels matching are only a best guess as to
+                    # whether the two are equivalent - but it doesn't
+                    # really matter. It may not achieve the desired result
+                    # but it's still a perfectly acceptable choice sequence.
+                    # to try.
+                    new_data = self.cached_test_function(
+                        data.buffer: ex1.start
+                        + replacement
+                        + data.bufferex1.end : ex2.start
+                        + replacement
+                        + data.bufferex2.end :,
+                        # We set error_on_discard so that we don't end up
+                        # entering parts of the tree we consider redundant
+                        # and not worth exploring.
+                        error_on_discard=True,
+                        extend=BUFFER_SIZE,
+                    )
+                except ContainsDiscard:
+                    failed_mutations += 1
+                    continue
+
+                if (
+                    new_data.status >= data.status
+                    and data.buffer != new_data.buffer
+                    and all(
+                        k in new_data.target_observations
+                        and new_data.target_observationsk >= v
+                        for k, v in data.target_observations.items()
+                    )
+                ):
+                    data = new_data
+                    failed_mutations = 0
+                else:
+                    failed_mutations += 1
+
+    def optimise_targets(self):
+        """If any target observations have been made, attempt to optimise them
+        all."""
+        if not self.should_optimise:
+            return
+        from hypothesis.internal.conjecture.optimiser import Optimiser
+
+        # We want to avoid running the optimiser for too long in case we hit
+        # an unbounded target score. We start this off fairly conservatively
+        # in case interesting examples are easy to find and then ramp it up
+        # on an exponential schedule so we don't hamper the optimiser too much
+        # if it needs a long time to find good enough improvements.
+        max_improvements = 10
+        while True:
+            prev_calls = self.call_count
+
+            any_improvements = False
+
+            for target, data in list(self.best_examples_of_observed_targets.items()):
+                optimiser = Optimiser(
+                    self, data, target, max_improvements=max_improvements
+                )
+                optimiser.run()
+                if optimiser.improvements > 0:
+                    any_improvements = True
+
+            if self.interesting_examples:
+                break
+
+            max_improvements *= 2
+
+            if any_improvements:
+                continue
+
+            self.pareto_optimise()
+
+            if prev_calls == self.call_count:
+                break
+
+    def pareto_optimise(self):
+        if self.pareto_front is not None:
+            ParetoOptimiser(self).run()
+
+    def _run(self):
+        with self._log_phase_statistics("reuse"):
+            self.reuse_existing_examples()
+        with self._log_phase_statistics("generate"):
+            self.generate_new_examples()
+            # We normally run the targeting phase mixed in with the generate phase,
+            # but if we've been asked to run it but not generation then we have to
+            # run it explciitly on its own here.
+            if Phase.generate not in self.settings.phases:
+                self.optimise_targets()
+        with self._log_phase_statistics("shrink"):
+            self.shrink_interesting_examples()
+        self.exit_with(ExitReason.finished)
+
+    def new_conjecture_data(self, prefix, max_length=BUFFER_SIZE, observer=None):
+        return ConjectureData(
+            prefix=prefix,
+            max_length=max_length,
+            random=self.random,
+            observer=observer or self.tree.new_observer(),
+        )
+
+    def new_conjecture_data_for_buffer(self, buffer):
+        return ConjectureData.for_buffer(buffer, observer=self.tree.new_observer())
+
+    def shrink_interesting_examples(self):
+        """If we've found interesting examples, try to replace each of them
+        with a minimal interesting example with the same interesting_origin.
+
+        We may find one or more examples with a new interesting_origin
+        during the shrink process. If so we shrink these too.
+        """
+        if Phase.shrink not in self.settings.phases or not self.interesting_examples:
+            return
+
+        self.debug("Shrinking interesting examples")
+
+        # If the shrinking phase takes more than five minutes, abort it early and print
+        # a warning.   Many CI systems will kill a build after around ten minutes with
+        # no output, and appearing to hang isn't great for interactive use either -
+        # showing partially-shrunk examples is better than quitting with no examples!
+        self.finish_shrinking_deadline = time.perf_counter() + 300
+
+        for prev_data in sorted(
+            self.interesting_examples.values(), key=lambda d: sort_key(d.buffer)
+        ):
+            assert prev_data.status == Status.INTERESTING
+            data = self.new_conjecture_data_for_buffer(prev_data.buffer)
+            self.test_function(data)
+            if data.status != Status.INTERESTING:
+                self.exit_with(ExitReason.flaky)
+
+        self.clear_secondary_key()
+
+        while len(self.shrunk_examples) < len(self.interesting_examples):
+            target, example = min(
+                (
+                    (k, v)
+                    for k, v in self.interesting_examples.items()
+                    if k not in self.shrunk_examples
+                ),
+                key=lambda kv: (sort_key(kv1.buffer), sort_key(repr(kv0))),
+            )
+            self.debug(f"Shrinking {target!r}")
+
+            if not self.settings.report_multiple_bugs:
+                # If multi-bug reporting is disabled, we shrink our currently-minimal
+                # failure, allowing 'slips' to any bug with a smaller minimal example.
+                self.shrink(example, lambda d: d.status == Status.INTERESTING)
+                return
+
+            def predicate(d):
+                if d.status < Status.INTERESTING:
+                    return False
+                return d.interesting_origin == target
+
+            self.shrink(example, predicate)
+
+            self.shrunk_examples.add(target)
+
+    def clear_secondary_key(self):
+        if self.has_existing_examples():
+            # If we have any smaller examples in the secondary corpus, now is
+            # a good time to try them to see if they work as shrinks. They
+            # probably won't, but it's worth a shot and gives us a good
+            # opportunity to clear out the database.
+
+            # It's not worth trying the primary corpus because we already
+            # tried all of those in the initial phase.
+            corpus = sorted(
+                self.settings.database.fetch(self.secondary_key), key=sort_key
+            )
+            for c in corpus:
+                primary = {v.buffer for v in self.interesting_examples.values()}
+
+                cap = max(map(sort_key, primary))
+
+                if sort_key(c) > cap:
+                    break
+                else:
+                    self.cached_test_function(c)
+                    # We unconditionally remove c from the secondary key as it
+                    # is either now primary or worse than our primary example
+                    # of this reason for interestingness.
+                    self.settings.database.delete(self.secondary_key, c)
+
+    def shrink(self, example, predicate=None, allow_transition=None):
+        s = self.new_shrinker(example, predicate, allow_transition)
+        s.shrink()
+        return s.shrink_target
+
+    def new_shrinker(self, example, predicate=None, allow_transition=None):
+        return Shrinker(
+            self,
+            example,
+            predicate,
+            allow_transition,
+            explain=Phase.explain in self.settings.phases,
+        )
+
+    def cached_test_function(self, buffer, error_on_discard=False, extend=0):
+        """Checks the tree to see if we've tested this buffer, and returns the
+        previous result if we have.
+
+        Otherwise we call through to ``test_function``, and return a
+        fresh result.
+
+        If ``error_on_discard`` is set to True this will raise ``ContainsDiscard``
+        in preference to running the actual test function. This is to allow us
+        to skip test cases we expect to be redundant in some cases. Note that
+        it may be the case that we don't raise ``ContainsDiscard`` even if the
+        result has discards if we cannot determine from previous runs whether
+        it will have a discard.
+        """
+        buffer = bytes(buffer):BUFFER_SIZE
+
+        max_length = min(BUFFER_SIZE, len(buffer) + extend)
+
+        def check_result(result):
+            assert result is Overrun or (
+                isinstance(result, ConjectureResult) and result.status != Status.OVERRUN
+            )
+            return result
+
+        try:
+            cached = check_result(self.__data_cachebuffer)
+            if cached.status > Status.OVERRUN or extend == 0:
+                return cached
+        except KeyError:
+            pass
+
+        if error_on_discard:
+
+            class DiscardObserver(DataObserver):
+                def kill_branch(self):
+                    raise ContainsDiscard()
+
+            observer = DiscardObserver()
+        else:
+            observer = DataObserver()
+
+        dummy_data = self.new_conjecture_data(
+            prefix=buffer, max_length=max_length, observer=observer
+        )
+
+        try:
+            self.tree.simulate_test_function(dummy_data)
+        except PreviouslyUnseenBehaviour:
+            pass
+        else:
+            if dummy_data.status > Status.OVERRUN:
+                dummy_data.freeze()
+                try:
+                    return self.__data_cachedummy_data.buffer
+                except KeyError:
+                    pass
+            else:
+                self.__data_cachebuffer = Overrun
+                return Overrun
+
+        # We didn't find a match in the tree, so we need to run the test
+        # function normally. Note that test_function will automatically
+        # add this to the tree so we don't need to update the cache.
+
+        result = None
+
+        data = self.new_conjecture_data(
+            prefix=max((buffer, dummy_data.buffer), key=len), max_length=max_length
+        )
+        self.test_function(data)
+        result = check_result(data.as_result())
+        if extend == 0 or (result is not Overrun and len(result.buffer) <= len(buffer)):
+            self.__data_cachebuffer = result
+        return result
+
+    def event_to_string(self, event):
+        if isinstance(event, str):
+            return event
+        try:
+            return self.events_to_stringsevent
+        except (KeyError, TypeError):
+            pass
+        result = str(event)
+        try:
+            self.events_to_stringsevent = result
+        except TypeError:
+            pass
+        return result
+
+    def passing_buffers(self, prefix=b""):
+        """Return a collection of bytestrings which cause the test to pass.
+
+        Optionally restrict this by a certain prefix, which is useful for explain mode.
+        """
+        return frozenset(
+            buf
+            for buf in self.__data_cache
+            if buf.startswith(prefix) and self.__data_cachebuf.status == Status.VALID
+        )
+
+
+class ContainsDiscard(Exception):
+    pass

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/floats.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/junkdrawer.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/optimiser.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/pareto.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinker.py Added

@@ -0,0 +1,1598 @@
+# 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/.
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Dict
+
+import attr
+
+from hypothesis.internal.compat import int_from_bytes, int_to_bytes
+from hypothesis.internal.conjecture.choicetree import (
+    ChoiceTree,
+    prefix_selection_order,
+    random_selection_order,
+)
+from hypothesis.internal.conjecture.data import ConjectureData, ConjectureResult, Status
+from hypothesis.internal.conjecture.floats import (
+    DRAW_FLOAT_LABEL,
+    float_to_lex,
+    lex_to_float,
+)
+from hypothesis.internal.conjecture.junkdrawer import (
+    binary_search,
+    find_integer,
+    replace_all,
+)
+from hypothesis.internal.conjecture.shrinking import Float, Integer, Lexical, Ordering
+from hypothesis.internal.conjecture.shrinking.learned_dfas import SHRINKING_DFAS
+
+if TYPE_CHECKING:
+    from hypothesis.internal.conjecture.engine import ConjectureRunner
+
+
+def sort_key(buffer):
+    """Returns a sort key such that "simpler" buffers are smaller than
+    "more complicated" ones.
+
+    We define sort_key so that x is simpler than y if x is shorter than y or if
+    they have the same length and x < y lexicographically. This is called the
+    shortlex order.
+
+    The reason for using the shortlex order is:
+
+    1. If x is shorter than y then that means we had to make fewer decisions
+       in constructing the test case when we ran x than we did when we ran y.
+    2. If x is the same length as y then replacing a byte with a lower byte
+       corresponds to reducing the value of an integer we drew with draw_bits
+       towards zero.
+    3. We want a total order, and given (2) the natural choices for things of
+       the same size are either the lexicographic or colexicographic orders
+       (the latter being the lexicographic order of the reverse of the string).
+       Because values drawn early in generation potentially get used in more
+       places they potentially have a more significant impact on the final
+       result, so it makes sense to prioritise reducing earlier values over
+       later ones. This makes the lexicographic order the more natural choice.
+    """
+    return (len(buffer), buffer)
+
+
+SHRINK_PASS_DEFINITIONS: Dictstr, "ShrinkPassDefinition" = {}
+
+
+@attr.s()
+class ShrinkPassDefinition:
+    """A shrink pass bundles together a large number of local changes to
+    the current shrink target.
+
+    Each shrink pass is defined by some function and some arguments to that
+    function. The ``generate_arguments`` function returns all arguments that
+    might be useful to run on the current shrink target.
+
+    The guarantee made by methods defined this way is that after they are
+    called then *either* the shrink target has changed *or* each of
+    ``fn(*args)`` has been called for every ``args`` in ``generate_arguments(self)``.
+    No guarantee is made that all of these will be called if the shrink target
+    changes.
+    """
+
+    run_with_chooser = attr.ib()
+
+    @property
+    def name(self):
+        return self.run_with_chooser.__name__
+
+    def __attrs_post_init__(self):
+        assert self.name not in SHRINK_PASS_DEFINITIONS, self.name
+        SHRINK_PASS_DEFINITIONSself.name = self
+
+
+def defines_shrink_pass():
+    """A convenient decorator for defining shrink passes."""
+
+    def accept(run_step):
+        ShrinkPassDefinition(run_with_chooser=run_step)
+
+        def run(self):
+            raise NotImplementedError("Shrink passes should not be run directly")
+
+        run.__name__ = run_step.__name__
+        run.is_shrink_pass = True
+        return run
+
+    return accept
+
+
+class Shrinker:
+    """A shrinker is a child object of a ConjectureRunner which is designed to
+    manage the associated state of a particular shrink problem. That is, we
+    have some initial ConjectureData object and some property of interest
+    that it satisfies, and we want to find a ConjectureData object with a
+    shortlex (see sort_key above) smaller buffer that exhibits the same
+    property.
+
+    Currently the only property of interest we use is that the status is
+    INTERESTING and the interesting_origin takes on some fixed value, but we
+    may potentially be interested in other use cases later.
+    However we assume that data with a status < VALID never satisfies the predicate.
+
+    The shrinker keeps track of a value shrink_target which represents the
+    current best known ConjectureData object satisfying the predicate.
+    It refines this value by repeatedly running *shrink passes*, which are
+    methods that perform a series of transformations to the current shrink_target
+    and evaluate the underlying test function to find new ConjectureData
+    objects. If any of these satisfy the predicate, the shrink_target
+    is updated automatically. Shrinking runs until no shrink pass can
+    improve the shrink_target, at which point it stops. It may also be
+    terminated if the underlying engine throws RunIsComplete, but that
+    is handled by the calling code rather than the Shrinker.
+
+    =======================
+    Designing Shrink Passes
+    =======================
+
+    Generally a shrink pass is just any function that calls
+    cached_test_function and/or incorporate_new_buffer a number of times,
+    but there are a couple of useful things to bear in mind.
+
+    A shrink pass *makes progress* if running it changes self.shrink_target
+    (i.e. it tries a shortlex smaller ConjectureData object satisfying
+    the predicate). The desired end state of shrinking is to find a
+    value such that no shrink pass can make progress, i.e. that we
+    are at a local minimum for each shrink pass.
+
+    In aid of this goal, the main invariant that a shrink pass much
+    satisfy is that whether it makes progress must be deterministic.
+    It is fine (encouraged even) for the specific progress it makes
+    to be non-deterministic, but if you run a shrink pass, it makes
+    no progress, and then you immediately run it again, it should
+    never succeed on the second time. This allows us to stop as soon
+    as we have run each shrink pass and seen no progress on any of
+    them.
+
+    This means that e.g. it's fine to try each of N deletions
+    or replacements in a random order, but it's not OK to try N random
+    deletions (unless you have already shrunk at least once, though we
+    don't currently take advantage of this loophole).
+
+    Shrink passes need to be written so as to be robust against
+    change in the underlying shrink target. It is generally safe
+    to assume that the shrink target does not change prior to the
+    point of first modification - e.g. if you change no bytes at
+    index ``i``, all examples whose start is ``<= i`` still exist,
+    as do all blocks, and the data object is still of length
+    ``>= i + 1``. This can only be violated by bad user code which
+    relies on an external source of non-determinism.
+
+    When the underlying shrink_target changes, shrink
+    passes should not run substantially more test_function calls
+    on success than they do on failure. Say, no more than a constant
+    factor more. In particular shrink passes should not iterate to a
+    fixed point.
+
+    This means that shrink passes are often written with loops that
+    are carefully designed to do the right thing in the case that no
+    shrinks occurred and try to adapt to any changes to do a reasonable
+    job. e.g. say we wanted to write a shrink pass that tried deleting
+    each individual byte (this isn't an especially good choice,
+    but it leads to a simple illustrative example), we might do it
+    by iterating over the buffer like so:
+
+    .. code-block:: python
+
+        i = 0
+        while i < len(self.shrink_target.buffer):
+            if not self.incorporate_new_buffer(
+                self.shrink_target.buffer:i + self.shrink_target.bufferi + 1 :
+            ):
+                i += 1
+
+    The reason for writing the loop this way is that i is always a
+    valid index into the current buffer, even if the current buffer
+    changes as a result of our actions. When the buffer changes,
+    we leave the index where it is rather than restarting from the
+    beginning, and carry on. This means that the number of steps we
+    run in this case is always bounded above by the number of steps
+    we would run if nothing works.
+
+    Another thing to bear in mind about shrink pass design is that
+    they should prioritise *progress*. If you have N operations that
+    you need to run, you should try to order them in such a way as
+    to avoid stalling, where you have long periods of test function
+    invocations where no shrinks happen. This is bad because whenever
+    we shrink we reduce the amount of work the shrinker has to do
+    in future, and often speed up the test function, so we ideally
+    wanted those shrinks to happen much earlier in the process.
+
+    Sometimes stalls are inevitable of course - e.g. if the pass
+    makes no progress, then the entire thing is just one long stall,
+    but it's helpful to design it so that stalls are less likely
+    in typical behaviour.
+
+    The two easiest ways to do this are:
+
+    * Just run the N steps in random order. As long as a
+      reasonably large proportion of the operations succeed, this
+      guarantees the expected stall length is quite short. The
+      book keeping for making sure this does the right thing when
+      it succeeds can be quite annoying.
+    * When you have any sort of nested loop, loop in such a way
+      that both loop variables change each time. This prevents
+      stalls which occur when one particular value for the outer
+      loop is impossible to make progress on, rendering the entire
+      inner loop into a stall.
+
+    However, although progress is good, too much progress can be
+    a bad sign! If you're *only* seeing successful reductions,
+    that's probably a sign that you are making changes that are
+    too timid. Two useful things to offset this:
+
+    * It's worth writing shrink passes which are *adaptive*, in
+      the sense that when operations seem to be working really
+      well we try to bundle multiple of them together. This can
+      often be used to turn what would be O(m) successful calls
+      into O(log(m)).
+    * It's often worth trying one or two special minimal values
+      before trying anything more fine grained (e.g. replacing
+      the whole thing with zero).
+
+    """
+
+    def derived_value(fn):  # noqa: B902
+        """It's useful during shrinking to have access to derived values of
+        the current shrink target.
+
+        This decorator allows you to define these as cached properties. They
+        are calculated once, then cached until the shrink target changes, then
+        recalculated the next time they are used."""
+
+        def accept(self):
+            try:
+                return self.__derived_valuesfn.__name__
+            except KeyError:
+                return self.__derived_values.setdefault(fn.__name__, fn(self))
+
+        accept.__name__ = fn.__name__
+        return property(accept)
+
+    def __init__(self, engine, initial, predicate, allow_transition, explain):
+        """Create a shrinker for a particular engine, with a given starting
+        point and predicate. When shrink() is called it will attempt to find an
+        example for which predicate is True and which is strictly smaller than
+        initial.
+
+        Note that initial is a ConjectureData object, and predicate
+        takes ConjectureData objects.
+        """
+        assert predicate is not None or allow_transition is not None
+        self.engine: "ConjectureRunner" = engine
+        self.__predicate = predicate or (lambda data: True)
+        self.__allow_transition = allow_transition or (lambda source, destination: True)
+        self.__derived_values = {}
+        self.__pending_shrink_explanation = None
+
+        self.initial_size = len(initial.buffer)
+
+        # We keep track of the current best example on the shrink_target
+        # attribute.
+        self.shrink_target: ConjectureData = initial
+        self.clear_change_tracking()
+        self.shrinks = 0
+
+        # We terminate shrinks that seem to have reached their logical
+        # conclusion: If we've called the underlying test function at
+        # least self.max_stall times since the last time we shrunk,
+        # it's time to stop shrinking.
+        self.max_stall = 200
+        self.initial_calls = self.engine.call_count
+        self.calls_at_last_shrink = self.initial_calls
+
+        self.passes_by_name = {}
+        self.passes = 
+
+        # Extra DFAs that may be installed. This is used solely for
+        # testing and learning purposes.
+        self.extra_dfas = {}
+
+        self.should_explain = explain
+
+    @derived_value  # type: ignore
+    def cached_calculations(self):
+        return {}
+
+    def cached(self, *keys):
+        def accept(f):
+            cache_key = (f.__name__,) + keys
+            try:
+                return self.cached_calculationscache_key
+            except KeyError:
+                return self.cached_calculations.setdefault(cache_key, f())
+
+        return accept
+
+    def add_new_pass(self, run):
+        """Creates a shrink pass corresponding to calling ``run(self)``"""
+
+        definition = SHRINK_PASS_DEFINITIONSrun
+
+        p = ShrinkPass(
+            run_with_chooser=definition.run_with_chooser,
+            shrinker=self,
+            index=len(self.passes),
+        )
+        self.passes.append(p)
+        self.passes_by_namep.name = p
+        return p
+
+    def shrink_pass(self, name):
+        """Return the ShrinkPass object for the pass with the given name."""
+        if isinstance(name, ShrinkPass):
+            return name
+        if name not in self.passes_by_name:
+            self.add_new_pass(name)
+        return self.passes_by_namename
+
+    @derived_value  # type: ignore
+    def match_cache(self):
+        return {}
+
+    def matching_regions(self, dfa):
+        """Returns all pairs (u, v) such that self.bufferu:v is accepted
+        by this DFA."""
+
+        try:
+            return self.match_cachedfa
+        except KeyError:
+            pass
+        results = dfa.all_matching_regions(self.buffer)
+        results.sort(key=lambda t: (t1 - t0, t1))
+        assert all(dfa.matches(self.bufferu:v) for u, v in results)
+        self.match_cachedfa = results
+        return results
+
+    @property
+    def calls(self):
+        """Return the number of calls that have been made to the underlying
+        test function."""
+        return self.engine.call_count
+
+    def consider_new_buffer(self, buffer):
+        """Returns True if after running this buffer the result would be
+        the current shrink_target."""
+        buffer = bytes(buffer)
+        return buffer.startswith(self.buffer) or self.incorporate_new_buffer(buffer)
+
+    def incorporate_new_buffer(self, buffer):
+        """Either runs the test function on this buffer and returns True if
+        that changed the shrink_target, or determines that doing so would
+        be useless and returns False without running it."""
+
+        buffer = bytes(buffer: self.shrink_target.index)
+        # Sometimes an attempt at lexicographic minimization will do the wrong
+        # thing because the buffer has changed under it (e.g. something has
+        # turned into a write, the bit size has changed). The result would be
+        # an invalid string, but it's better for us to just ignore it here as
+        # it turns out to involve quite a lot of tricky book-keeping to get
+        # this right and it's better to just handle it in one place.
+        if sort_key(buffer) >= sort_key(self.shrink_target.buffer):
+            return False
+
+        if self.shrink_target.buffer.startswith(buffer):
+            return False
+
+        previous = self.shrink_target
+        self.cached_test_function(buffer)
+        return previous is not self.shrink_target
+
+    def incorporate_test_data(self, data):
+        """Takes a ConjectureData or Overrun object updates the current
+        shrink_target if this data represents an improvement over it."""
+        if data.status < Status.VALID or data is self.shrink_target:
+            return
+        if (
+            self.__predicate(data)
+            and sort_key(data.buffer) < sort_key(self.shrink_target.buffer)
+            and self.__allow_transition(self.shrink_target, data)
+        ):
+            self.update_shrink_target(data)
+
+    def cached_test_function(self, buffer):
+        """Returns a cached version of the underlying test function, so
+        that the result is either an Overrun object (if the buffer is
+        too short to be a valid test case) or a ConjectureData object
+        with status >= INVALID that would result from running this buffer."""
+
+        buffer = bytes(buffer)
+        result = self.engine.cached_test_function(buffer)
+        self.incorporate_test_data(result)
+        if self.calls - self.calls_at_last_shrink >= self.max_stall:
+            raise StopShrinking()
+        return result
+
+    def debug(self, msg):
+        self.engine.debug(msg)
+
+    @property
+    def random(self):
+        return self.engine.random
+
+    def shrink(self):
+        """Run the full set of shrinks and update shrink_target.
+
+        This method is "mostly idempotent" - calling it twice is unlikely to
+        have any effect, though it has a non-zero probability of doing so.
+        """
+        # We assume that if an all-zero block of bytes is an interesting
+        # example then we're not going to do better than that.
+        # This might not technically be true: e.g. for integers() | booleans()
+        # the simplest example is actually 1, 0. Missing this case is fairly
+        # harmless and this allows us to make various simplifying assumptions
+        # about the structure of the data (principally that we're never
+        # operating on a block of all zero bytes so can use non-zeroness as a
+        # signpost of complexity).
+        if not any(self.shrink_target.buffer) or self.incorporate_new_buffer(
+            bytes(len(self.shrink_target.buffer))
+        ):
+            self.explain()
+            return
+
+        try:
+            self.greedy_shrink()
+        except StopShrinking:
+            # If we stopped shrinking because we're making slow progress (instead of
+            # reaching a local optimum), don't run the explain-phase logic.
+            self.should_explain = False
+        finally:
+            if self.engine.report_debug_info:
+
+                def s(n):
+                    return "s" if n != 1 else ""
+
+                total_deleted = self.initial_size - len(self.shrink_target.buffer)
+                calls = self.engine.call_count - self.initial_calls
+
+                self.debug(
+                    "---------------------\n"
+                    "Shrink pass profiling\n"
+                    "---------------------\n\n"
+                    f"Shrinking made a total of {calls} call{s(calls)} of which "
+                    f"{self.shrinks} shrank. This deleted {total_deleted} bytes out "
+                    f"of {self.initial_size}."
+                )
+                for useful in True, False:
+                    self.debug("")
+                    if useful:
+                        self.debug("Useful passes:")
+                    else:
+                        self.debug("Useless passes:")
+                    self.debug("")
+                    for p in sorted(
+                        self.passes, key=lambda t: (-t.calls, t.deletions, t.shrinks)
+                    ):
+                        if p.calls == 0:
+                            continue
+                        if (p.shrinks != 0) != useful:
+                            continue
+
+                        self.debug(
+                            "  * %s made %d call%s of which "
+                            "%d shrank, deleting %d byte%s."
+                            % (
+                                p.name,
+                                p.calls,
+                                s(p.calls),
+                                p.shrinks,
+                                p.deletions,
+                                s(p.deletions),
+                            )
+                        )
+                self.debug("")
+        self.explain()
+
+    def explain(self):
+        if not self.should_explain or not self.shrink_target.arg_slices:
+            return
+        from hypothesis.internal.conjecture.engine import BUFFER_SIZE
+
+        self.max_stall = 1e999
+        shrink_target = self.shrink_target
+        buffer = shrink_target.buffer
+        chunks = defaultdict(list)
+
+        # Before we start running experiments, let's check for known inputs which would
+        # make them redundant.  The shrinking process means that we've already tried many
+        # variations on the minimal example, so this can save a lot of time.
+        seen_passing_buffers = self.engine.passing_buffers(
+            prefix=buffer: min(self.shrink_target.arg_slices)0
+        )
+
+        # Now that we've shrunk to a minimal failing example, it's time to try
+        # varying each part that we've noted will go in the final report.  Consider
+        # slices in largest-first order
+        for start, end in sorted(
+            self.shrink_target.arg_slices, key=lambda x: (-(x1 - x0), x)
+        ):
+            # Check for any previous examples that match the prefix and suffix,
+            # so we can skip if we found a passing example while shrinking.
+            if any(
+                seen.startswith(buffer:start) and seen.endswith(bufferend:)
+                for seen in seen_passing_buffers
+            ):
+                continue
+
+            # Run our experiments
+            n_same_failures = 0
+            note = "or any other generated value"
+            # TODO: is 100 same-failures out of 500 attempts a good heuristic?
+            for n_attempt in range(500):  # pragma: no branch
+                # no-branch here because we don't coverage-test the abort-at-500 logic.
+
+                if n_attempt - 10 > n_same_failures * 5:
+                    # stop early if we're seeing mostly invalid examples
+                    break  # pragma: no cover
+
+                buf_attempt_fixed = bytearray(buffer)
+                buf_attempt_fixedstart:end = 
+                    self.random.randint(0, 255) for _ in range(end - start)
+                
+                result = self.engine.cached_test_function(
+                    buf_attempt_fixed, extend=BUFFER_SIZE - len(buf_attempt_fixed)
+                )
+
+                # Turns out this was a variable-length part, so grab the infix...
+                if result.status == Status.OVERRUN:
+                    continue  # pragma: no cover
+                if not (
+                    len(buf_attempt_fixed) == len(result.buffer)
+                    and result.buffer.endswith(bufferend:)
+                ):
+                    for ex, res in zip(shrink_target.examples, result.examples):
+                        assert ex.start == res.start
+                        assert ex.start <= start
+                        assert ex.label == res.label
+                        if start == ex.start and end == ex.end:
+                            res_end = res.end
+                            break
+                    else:
+                        raise NotImplementedError("Expected matching prefixes")
+
+                    buf_attempt_fixed = (
+                        buffer:start + result.bufferstart:res_end + bufferend:
+                    )
+                    chunks(start, end).append(result.bufferstart:res_end)
+                    result = self.engine.cached_test_function(buf_attempt_fixed)
+
+                    if (
+                        result.status == Status.OVERRUN
+                        or len(buf_attempt_fixed) != len(result.buffer)
+                        or not result.buffer.endswith(bufferend:)
+                    ):
+                        raise NotImplementedError("This should never happen")
+                else:
+                    chunks(start, end).append(result.bufferstart:end)
+
+                if shrink_target is not self.shrink_target:  # pragma: no cover
+                    # If we've shrunk further without meaning to, bail out.
+                    self.shrink_target.slice_comments.clear()
+                    return
+                if result.status == Status.VALID:
+                    # The test passed, indicating that this param can't vary freely.
+                    # However, it's really hard to write a simple and reliable covering
+                    # test, because of our `seen_passing_buffers` check above.
+                    break  # pragma: no cover
+                elif self.__predicate(result):  # pragma: no branch
+                    n_same_failures += 1
+                    if n_same_failures >= 100:
+                        self.shrink_target.slice_comments(start, end) = note
+                        break
+
+        # Finally, if we've found multiple independently-variable parts, check whether
+        # they can all be varied together.
+        if len(self.shrink_target.slice_comments) <= 1:
+            return
+        n_same_failures_together = 0
+        chunks_by_start_index = sorted(chunks.items())
+        for _ in range(500):  # pragma: no branch
+            # no-branch here because we don't coverage-test the abort-at-500 logic.
+            new_buf = bytearray()
+            prev_end = 0
+            for (start, end), ls in chunks_by_start_index:
+                assert prev_end <= start < end, "these chunks must be nonoverlapping"
+                new_buf.extend(bufferprev_end:start)
+                new_buf.extend(self.random.choice(ls))
+                prev_end = end
+
+            result = self.engine.cached_test_function(new_buf)
+
+            # This *can't* be a shrink because none of the components were.
+            assert shrink_target is self.shrink_target
+            if result.status == Status.VALID:
+                self.shrink_target.slice_comments
+                    (0, 0)
+                 = "The test sometimes passed when commented parts were varied together."
+                break  # Test passed, this param can't vary freely.
+            elif self.__predicate(result):  # pragma: no branch
+                n_same_failures_together += 1
+                if n_same_failures_together >= 100:
+                    self.shrink_target.slice_comments
+                        (0, 0)
+                     = "The test always failed when commented parts were varied together."
+                    break
+
+    def greedy_shrink(self):
+        """Run a full set of greedy shrinks (that is, ones that will only ever
+        move to a better target) and update shrink_target appropriately.
+
+        This method iterates to a fixed point and so is idempontent - calling
+        it twice will have exactly the same effect as calling it once.
+        """
+        self.fixate_shrink_passes(
+            
+                block_program("X" * 5),
+                block_program("X" * 4),
+                block_program("X" * 3),
+                block_program("X" * 2),
+                block_program("X" * 1),
+                "pass_to_descendant",
+                "reorder_examples",
+                "minimize_floats",
+                "minimize_duplicated_blocks",
+                block_program("-XX"),
+                "minimize_individual_blocks",
+                block_program("--X"),
+                "redistribute_block_pairs",
+                "lower_blocks_together",
+            
+            + dfa_replacement(n) for n in SHRINKING_DFAS
+        )
+
+    @derived_value  # type: ignore
+    def shrink_pass_choice_trees(self):
+        return defaultdict(ChoiceTree)
+
+    def fixate_shrink_passes(self, passes):
+        """Run steps from each pass in ``passes`` until the current shrink target
+        is a fixed point of all of them."""
+        passes = list(map(self.shrink_pass, passes))
+
+        any_ran = True
+        while any_ran:
+            any_ran = False
+
+            reordering = {}
+
+            # We run remove_discarded after every pass to do cleanup
+            # keeping track of whether that actually works. Either there is
+            # no discarded data and it is basically free, or it reliably works
+            # and deletes data, or it doesn't work. In that latter case we turn
+            # it off for the rest of this loop through the passes, but will
+            # try again once all of the passes have been run.
+            can_discard = self.remove_discarded()
+
+            calls_at_loop_start = self.calls
+
+            # We keep track of how many calls can be made by a single step
+            # without making progress and use this to test how much to pad
+            # out self.max_stall by as we go along.
+            max_calls_per_failing_step = 1
+
+            for sp in passes:
+                if can_discard:
+                    can_discard = self.remove_discarded()
+
+                before_sp = self.shrink_target
+
+                # Run the shrink pass until it fails to make any progress
+                # max_failures times in a row. This implicitly boosts shrink
+                # passes that are more likely to work.
+                failures = 0
+                max_failures = 20
+                while failures < max_failures:
+                    # We don't allow more than max_stall consecutive failures
+                    # to shrink, but this means that if we're unlucky and the
+                    # shrink passes are in a bad order where only the ones at
+                    # the end are useful, if we're not careful this heuristic
+                    # might stop us before we've tried everything. In order to
+                    # avoid that happening, we make sure that there's always
+                    # plenty of breathing room to make it through a single
+                    # iteration of the fixate_shrink_passes loop.
+                    self.max_stall = max(
+                        self.max_stall,
+                        2 * max_calls_per_failing_step
+                        + (self.calls - calls_at_loop_start),
+                    )
+
+                    prev = self.shrink_target
+                    initial_calls = self.calls
+                    # It's better for us to run shrink passes in a deterministic
+                    # order, to avoid repeat work, but this can cause us to create
+                    # long stalls when there are a lot of steps which fail to do
+                    # anything useful. In order to avoid this, once we've noticed
+                    # we're in a stall (i.e. half of max_failures calls have failed
+                    # to do anything) we switch to randomly jumping around. If we
+                    # find a success then we'll resume deterministic order from
+                    # there which, with any luck, is in a new good region.
+                    if not sp.step(random_order=failures >= max_failures // 2):
+                        # step returns False when there is nothing to do because
+                        # the entire choice tree is exhausted. If this happens
+                        # we break because we literally can't run this pass any
+                        # more than we already have until something else makes
+                        # progress.
+                        break
+                    any_ran = True
+
+                    # Don't count steps that didn't actually try to do
+                    # anything as failures. Otherwise, this call is a failure
+                    # if it failed to make any changes to the shrink target.
+                    if initial_calls != self.calls:
+                        if prev is not self.shrink_target:
+                            failures = 0
+                        else:
+                            max_calls_per_failing_step = max(
+                                max_calls_per_failing_step, self.calls - initial_calls
+                            )
+                            failures += 1
+
+                # We reorder the shrink passes so that on our next run through
+                # we try good ones first. The rule is that shrink passes that
+                # did nothing useful are the worst, shrink passes that reduced
+                # the length are the best.
+                if self.shrink_target is before_sp:
+                    reorderingsp = 1
+                elif len(self.buffer) < len(before_sp.buffer):
+                    reorderingsp = -1
+                else:
+                    reorderingsp = 0
+
+            passes.sort(key=reordering.__getitem__)
+
+    @property
+    def buffer(self):
+        return self.shrink_target.buffer
+
+    @property
+    def blocks(self):
+        return self.shrink_target.blocks
+
+    @property
+    def examples(self):
+        return self.shrink_target.examples
+
+    def all_block_bounds(self):
+        return self.shrink_target.blocks.all_bounds()
+
+    @derived_value  # type: ignore
+    def examples_by_label(self):
+        """An index of all examples grouped by their label, with
+        the examples stored in their normal index order."""
+
+        examples_by_label = defaultdict(list)
+        for ex in self.examples:
+            examples_by_labelex.label.append(ex)
+        return dict(examples_by_label)
+
+    @derived_value  # type: ignore
+    def distinct_labels(self):
+        return sorted(self.examples_by_label, key=str)
+
+    @defines_shrink_pass()
+    def pass_to_descendant(self, chooser):
+        """Attempt to replace each example with a descendant example.
+
+        This is designed to deal with strategies that call themselves
+        recursively. For example, suppose we had:
+
+        binary_tree = st.deferred(
+            lambda: st.one_of(
+                st.integers(), st.tuples(binary_tree, binary_tree)))
+
+        This pass guarantees that we can replace any binary tree with one of
+        its subtrees - each of those will create an interval that the parent
+        could validly be replaced with, and this pass will try doing that.
+
+        This is pretty expensive - it takes O(len(intervals)^2) - so we run it
+        late in the process when we've got the number of intervals as far down
+        as possible.
+        """
+
+        label = chooser.choose(
+            self.distinct_labels, lambda l: len(self.examples_by_labell) >= 2
+        )
+
+        ls = self.examples_by_labellabel
+
+        i = chooser.choose(range(len(ls) - 1))
+
+        ancestor = lsi
+
+        if i + 1 == len(ls) or lsi + 1.start >= ancestor.end:
+            return
+
+        @self.cached(label, i)
+        def descendants():
+            lo = i + 1
+            hi = len(ls)
+            while lo + 1 < hi:
+                mid = (lo + hi) // 2
+                if lsmid.start >= ancestor.end:
+                    hi = mid
+                else:
+                    lo = mid
+            return t for t in lsi + 1 : hi if t.length < ancestor.length
+
+        descendant = chooser.choose(descendants, lambda ex: ex.length > 0)
+
+        assert ancestor.start <= descendant.start
+        assert ancestor.end >= descendant.end
+        assert descendant.length < ancestor.length
+
+        self.incorporate_new_buffer(
+            self.buffer: ancestor.start
+            + self.bufferdescendant.start : descendant.end
+            + self.bufferancestor.end :
+        )
+
+    def lower_common_block_offset(self):
+        """Sometimes we find ourselves in a situation where changes to one part
+        of the byte stream unlock changes to other parts. Sometimes this is
+        good, but sometimes this can cause us to exhibit exponential slow
+        downs!
+
+        e.g. suppose we had the following:
+
+        m = draw(integers(min_value=0))
+        n = draw(integers(min_value=0))
+        assert abs(m - n) > 1
+
+        If this fails then we'll end up with a loop where on each iteration we
+        reduce each of m and n by 2 - m can't go lower because of n, then n
+        can't go lower because of m.
+
+        This will take us O(m) iterations to complete, which is exponential in
+        the data size, as we gradually zig zag our way towards zero.
+
+        This can only happen if we're failing to reduce the size of the byte
+        stream: The number of iterations that reduce the length of the byte
+        stream is bounded by that length.
+
+        So what we do is this: We keep track of which blocks are changing, and
+        then if there's some non-zero common offset to them we try and minimize
+        them all at once by lowering that offset.
+
+        This may not work, and it definitely won't get us out of all possible
+        exponential slow downs (an example of where it doesn't is where the
+        shape of the blocks changes as a result of this bouncing behaviour),
+        but it fails fast when it doesn't work and gets us out of a really
+        nastily slow case when it does.
+        """
+        if len(self.__changed_blocks) <= 1:
+            return
+
+        current = self.shrink_target
+
+        blocked = current.bufferu:v for u, v in self.all_block_bounds()
+
+        changed = 
+            i
+            for i in sorted(self.__changed_blocks)
+            if not self.shrink_target.blocksi.trivial
+        
+
+        if not changed:
+            return
+
+        ints = int_from_bytes(blockedi) for i in changed
+        offset = min(ints)
+        assert offset > 0
+
+        for i in range(len(ints)):
+            intsi -= offset
+
+        def reoffset(o):
+            new_blocks = list(blocked)
+            for i, v in zip(changed, ints):
+                new_blocksi = int_to_bytes(v + o, len(blockedi))
+            return self.incorporate_new_buffer(b"".join(new_blocks))
+
+        Integer.shrink(offset, reoffset, random=self.random)
+        self.clear_change_tracking()
+
+    def clear_change_tracking(self):
+        self.__last_checked_changed_at = self.shrink_target
+        self.__all_changed_blocks = set()
+
+    def mark_changed(self, i):
+        self.__changed_blocks.add(i)
+
+    @property
+    def __changed_blocks(self):
+        if self.__last_checked_changed_at is not self.shrink_target:
+            prev_target = self.__last_checked_changed_at
+            new_target = self.shrink_target
+            assert prev_target is not new_target
+            prev = prev_target.buffer
+            new = new_target.buffer
+            assert sort_key(new) < sort_key(prev)
+
+            if (
+                len(new_target.blocks) != len(prev_target.blocks)
+                or new_target.blocks.endpoints != prev_target.blocks.endpoints
+            ):
+                self.__all_changed_blocks = set()
+            else:
+                blocks = new_target.blocks
+
+                # Index of last block whose contents have been modified, found
+                # by checking if the tail past this point has been modified.
+                last_changed = binary_search(
+                    0,
+                    len(blocks),
+                    lambda i: prevblocks.start(i) : != newblocks.start(i) :,
+                )
+
+                # Index of the first block whose contents have been changed,
+                # because we know that this predicate is true for zero (because
+                # the prefix from the start is empty), so the result must be True
+                # for the bytes from the start of this block and False for the
+                # bytes from the end, hence the change is in this block.
+                first_changed = binary_search(
+                    0,
+                    len(blocks),
+                    lambda i: prev: blocks.start(i) == new: blocks.start(i),
+                )
+
+                # Between these two changed regions we now do a linear scan to
+                # check if any specific block values have changed.
+                for i in range(first_changed, last_changed + 1):
+                    u, v = blocks.bounds(i)
+                    if i not in self.__all_changed_blocks and prevu:v != newu:v:
+                        self.__all_changed_blocks.add(i)
+            self.__last_checked_changed_at = new_target
+        assert self.__last_checked_changed_at is self.shrink_target
+        return self.__all_changed_blocks
+
+    def update_shrink_target(self, new_target):
+        assert isinstance(new_target, ConjectureResult)
+        self.shrinks += 1
+        # If we are just taking a long time to shrink we don't want to
+        # trigger this heuristic, so whenever we shrink successfully
+        # we give ourselves a bit of breathing room to make sure we
+        # would find a shrink that took that long to find the next time.
+        # The case where we're taking a long time but making steady
+        # progress is handled by `finish_shrinking_deadline` in engine.py
+        self.max_stall = max(
+            self.max_stall, (self.calls - self.calls_at_last_shrink) * 2
+        )
+        self.calls_at_last_shrink = self.calls
+        self.shrink_target = new_target
+        self.__derived_values = {}
+
+    def try_shrinking_blocks(self, blocks, b):
+        """Attempts to replace each block in the blocks list with b. Returns
+        True if it succeeded (which may include some additional modifications
+        to shrink_target).
+
+        In current usage it is expected that each of the blocks currently have
+        the same value, although this is not essential. Note that b must be
+        < the block at min(blocks) or this is not a valid shrink.
+
+        This method will attempt to do some small amount of work to delete data
+        that occurs after the end of the blocks. This is useful for cases where
+        there is some size dependency on the value of a block.
+        """
+        initial_attempt = bytearray(self.shrink_target.buffer)
+        for i, block in enumerate(blocks):
+            if block >= len(self.blocks):
+                blocks = blocks:i
+                break
+            u, v = self.blocksblock.bounds
+            n = min(self.blocksblock.length, len(b))
+            initial_attemptv - n : v = b-n:
+
+        if not blocks:
+            return False
+
+        start = self.shrink_target.blocksblocks0.start
+        end = self.shrink_target.blocksblocks-1.end
+
+        initial_data = self.cached_test_function(initial_attempt)
+
+        if initial_data is self.shrink_target:
+            self.lower_common_block_offset()
+            return True
+
+        # If this produced something completely invalid we ditch it
+        # here rather than trying to persevere.
+        if initial_data.status < Status.VALID:
+            return False
+
+        # We've shrunk inside our group of blocks, so we have no way to
+        # continue. (This only happens when shrinking more than one block at
+        # a time).
+        if len(initial_data.buffer) < v:
+            return False
+
+        lost_data = len(self.shrink_target.buffer) - len(initial_data.buffer)
+
+        # If this did not in fact cause the data size to shrink we
+        # bail here because it's not worth trying to delete stuff from
+        # the remainder.
+        if lost_data <= 0:
+            return False
+
+        # We now look for contiguous regions to delete that might help fix up
+        # this failed shrink. We only look for contiguous regions of the right
+        # lengths because doing anything more than that starts to get very
+        # expensive. See minimize_individual_blocks for where we
+        # try to be more aggressive.
+        regions_to_delete = {(end, end + lost_data)}
+
+        for j in (blocks-1 + 1, blocks-1 + 2):
+            if j >= min(len(initial_data.blocks), len(self.blocks)):
+                continue
+            # We look for a block very shortly after the last one that has
+            # lost some of its size, and try to delete from the beginning so
+            # that it retains the same integer value. This is a bit of a hyper
+            # specific trick designed to make our integers() strategy shrink
+            # well.
+            r1, s1 = self.shrink_target.blocksj.bounds
+            r2, s2 = initial_data.blocksj.bounds
+            lost = (s1 - r1) - (s2 - r2)
+            # Apparently a coverage bug? An assert False in the body of this
+            # will reliably fail, but it shows up as uncovered.
+            if lost <= 0 or r1 != r2:  # pragma: no cover
+                continue
+            regions_to_delete.add((r1, r1 + lost))
+
+        for ex in self.shrink_target.examples:
+            if ex.start > start:
+                continue
+            if ex.end <= end:
+                continue
+
+            replacement = initial_data.examplesex.index
+
+            in_original = c for c in ex.children if c.start >= end
+
+            in_replaced = c for c in replacement.children if c.start >= end
+
+            if len(in_replaced) >= len(in_original) or not in_replaced:
+                continue
+
+            # We've found an example where some of the children went missing
+            # as a result of this change, and just replacing it with the data
+            # it would have had and removing the spillover didn't work. This
+            # means that some of its children towards the right must be
+            # important, so we try to arrange it so that it retains its
+            # rightmost children instead of its leftmost.
+            regions_to_delete.add(
+                (in_original0.start, in_original-len(in_replaced).start)
+            )
+
+        for u, v in sorted(regions_to_delete, key=lambda x: x1 - x0, reverse=True):
+            try_with_deleted = bytearray(initial_attempt)
+            del try_with_deletedu:v
+            if self.incorporate_new_buffer(try_with_deleted):
+                return True
+        return False
+
+    def remove_discarded(self):
+        """Try removing all bytes marked as discarded.
+
+        This is primarily to deal with data that has been ignored while
+        doing rejection sampling - e.g. as a result of an integer range, or a
+        filtered strategy.
+
+        Such data will also be handled by the adaptive_example_deletion pass,
+        but that pass is necessarily more conservative and will try deleting
+        each interval individually. The common case is that all data drawn and
+        rejected can just be thrown away immediately in one block, so this pass
+        will be much faster than trying each one individually when it works.
+
+        returns False if there is discarded data and removing it does not work,
+        otherwise returns True.
+        """
+        while self.shrink_target.has_discards:
+            discarded = 
+
+            for ex in self.shrink_target.examples:
+                if (
+                    ex.length > 0
+                    and ex.discarded
+                    and (not discarded or ex.start >= discarded-1-1)
+                ):
+                    discarded.append((ex.start, ex.end))
+
+            # This can happen if we have discards but they are all of
+            # zero length. This shouldn't happen very often so it's
+            # faster to check for it here than at the point of example
+            # generation.
+            if not discarded:
+                break
+
+            attempt = bytearray(self.shrink_target.buffer)
+            for u, v in reversed(discarded):
+                del attemptu:v
+
+            if not self.incorporate_new_buffer(attempt):
+                return False
+        return True
+
+    @derived_value  # type: ignore
+    def blocks_by_non_zero_suffix(self):
+        """Returns a list of blocks grouped by their non-zero suffix,
+        as a list of (suffix, indices) pairs, skipping all groupings
+        where there is only one index.
+
+        This is only used for the arguments of minimize_duplicated_blocks.
+        """
+        duplicates = defaultdict(list)
+        for block in self.blocks:
+            duplicatesnon_zero_suffix(self.bufferblock.start : block.end).append(
+                block.index
+            )
+        return duplicates
+
+    @derived_value  # type: ignore
+    def duplicated_block_suffixes(self):
+        return sorted(self.blocks_by_non_zero_suffix)
+
+    @defines_shrink_pass()
+    def minimize_duplicated_blocks(self, chooser):
+        """Find blocks that have been duplicated in multiple places and attempt
+        to minimize all of the duplicates simultaneously.
+
+        This lets us handle cases where two values can't be shrunk
+        independently of each other but can easily be shrunk together.
+        For example if we had something like:
+
+        ls = data.draw(lists(integers()))
+        y = data.draw(integers())
+        assert y not in ls
+
+        Suppose we drew y = 3 and after shrinking we have ls = 3. If we were
+        to replace both 3s with 0, this would be a valid shrink, but if we were
+        to replace either 3 with 0 on its own the test would start passing.
+
+        It is also useful for when that duplication is accidental and the value
+        of the blocks doesn't matter very much because it allows us to replace
+        more values at once.
+        """
+        block = chooser.choose(self.duplicated_block_suffixes)
+        targets = self.blocks_by_non_zero_suffixblock
+        if len(targets) <= 1:
+            return
+        Lexical.shrink(
+            block,
+            lambda b: self.try_shrinking_blocks(targets, b),
+            random=self.random,
+            full=False,
+        )
+
+    @defines_shrink_pass()
+    def minimize_floats(self, chooser):
+        """Some shrinks that we employ that only really make sense for our
+        specific floating point encoding that are hard to discover from any
+        sort of reasonable general principle. This allows us to make
+        transformations like replacing a NaN with an Infinity or replacing
+        a float with its nearest integers that we would otherwise not be
+        able to due to them requiring very specific transformations of
+        the bit sequence.
+
+        We only apply these transformations to blocks that "look like" our
+        standard float encodings because they are only really meaningful
+        there. The logic for detecting this is reasonably precise, but
+        it doesn't matter if it's wrong. These are always valid
+        transformations to make, they just don't necessarily correspond to
+        anything particularly meaningful for non-float values.
+        """
+
+        ex = chooser.choose(
+            self.examples,
+            lambda ex: (
+                ex.label == DRAW_FLOAT_LABEL
+                and len(ex.children) == 2
+                and ex.children1.length == 8
+            ),
+        )
+
+        u = ex.children1.start
+        v = ex.children1.end
+        buf = self.shrink_target.buffer
+        b = bufu:v
+        f = lex_to_float(int_from_bytes(b))
+        b2 = int_to_bytes(float_to_lex(f), 8)
+        if b == b2 or self.consider_new_buffer(buf:u + b2 + bufv:):
+            Float.shrink(
+                f,
+                lambda x: self.consider_new_buffer(
+                    self.shrink_target.buffer:u
+                    + int_to_bytes(float_to_lex(x), 8)
+                    + self.shrink_target.bufferv:
+                ),
+                random=self.random,
+            )
+
+    @defines_shrink_pass()
+    def redistribute_block_pairs(self, chooser):
+        """If there is a sum of generated integers that we need their sum
+        to exceed some bound, lowering one of them requires raising the
+        other. This pass enables that."""
+
+        block = chooser.choose(self.blocks, lambda b: not b.all_zero)
+
+        for j in range(block.index + 1, len(self.blocks)):
+            next_block = self.blocksj
+            if next_block.length == block.length:
+                break
+        else:
+            return
+
+        buffer = self.buffer
+
+        m = int_from_bytes(bufferblock.start : block.end)
+        n = int_from_bytes(buffernext_block.start : next_block.end)
+
+        def boost(k):
+            if k > m:
+                return False
+            attempt = bytearray(buffer)
+            attemptblock.start : block.end = int_to_bytes(m - k, block.length)
+            try:
+                attemptnext_block.start : next_block.end = int_to_bytes(
+                    n + k, next_block.length
+                )
+            except OverflowError:
+                return False
+            return self.consider_new_buffer(attempt)
+
+        find_integer(boost)
+
+    @defines_shrink_pass()
+    def lower_blocks_together(self, chooser):
+        block = chooser.choose(self.blocks, lambda b: not b.all_zero)
+
+        # Choose the next block to be up to eight blocks onwards. We don't
+        # want to go too far (to avoid quadratic time) but it's worth a
+        # reasonable amount of lookahead, especially as we expect most
+        # blocks are zero by this point anyway.
+        next_block = self.blocks
+            chooser.choose(
+                range(block.index + 1, min(len(self.blocks), block.index + 9)),
+                lambda j: not self.blocksj.all_zero,
+            )
+        
+
+        buffer = self.buffer
+
+        m = int_from_bytes(bufferblock.start : block.end)
+        n = int_from_bytes(buffernext_block.start : next_block.end)
+
+        def lower(k):
+            if k > min(m, n):
+                return False
+            attempt = bytearray(buffer)
+            attemptblock.start : block.end = int_to_bytes(m - k, block.length)
+            attemptnext_block.start : next_block.end = int_to_bytes(
+                n - k, next_block.length
+            )
+            assert len(attempt) == len(buffer)
+            return self.consider_new_buffer(attempt)
+
+        find_integer(lower)
+
+    @defines_shrink_pass()
+    def minimize_individual_blocks(self, chooser):
+        """Attempt to minimize each block in sequence.
+
+        This is the pass that ensures that e.g. each integer we draw is a
+        minimum value. So it's the part that guarantees that if we e.g. do
+
+        x = data.draw(integers())
+        assert x < 10
+
+        then in our shrunk example, x = 10 rather than say 97.
+
+        If we are unsuccessful at minimizing a block of interest we then
+        check if that's because it's changing the size of the test case and,
+        if so, we also make an attempt to delete parts of the test case to
+        see if that fixes it.
+
+        We handle most of the common cases in try_shrinking_blocks which is
+        pretty good at clearing out large contiguous blocks of dead space,
+        but it fails when there is data that has to stay in particular places
+        in the list.
+        """
+        block = chooser.choose(self.blocks, lambda b: not b.trivial)
+
+        initial = self.shrink_target
+        u, v = block.bounds
+        i = block.index
+        Lexical.shrink(
+            self.shrink_target.bufferu:v,
+            lambda b: self.try_shrinking_blocks((i,), b),
+            random=self.random,
+            full=False,
+        )
+
+        if self.shrink_target is not initial:
+            return
+
+        lowered = (
+            self.buffer: block.start
+            + int_to_bytes(
+                int_from_bytes(self.bufferblock.start : block.end) - 1, block.length
+            )
+            + self.bufferblock.end :
+        )
+        attempt = self.cached_test_function(lowered)
+        if (
+            attempt.status < Status.VALID
+            or len(attempt.buffer) == len(self.buffer)
+            or len(attempt.buffer) == block.end
+        ):
+            return
+
+        # If it were then the lexical shrink should have worked and we could
+        # never have got here.
+        assert attempt is not self.shrink_target
+
+        @self.cached(block.index)
+        def first_example_after_block():
+            lo = 0
+            hi = len(self.examples)
+            while lo + 1 < hi:
+                mid = (lo + hi) // 2
+                ex = self.examplesmid
+                if ex.start >= block.end:
+                    hi = mid
+                else:
+                    lo = mid
+            return hi
+
+        ex = self.examples
+            chooser.choose(
+                range(first_example_after_block, len(self.examples)),
+                lambda i: self.examplesi.length > 0,
+            )
+        
+
+        u, v = block.bounds
+
+        buf = bytearray(lowered)
+        del bufex.start : ex.end
+        self.incorporate_new_buffer(buf)
+
+    @defines_shrink_pass()
+    def reorder_examples(self, chooser):
+        """This pass allows us to reorder the children of each example.
+
+        For example, consider the following:
+
+        .. code-block:: python
+
+            import hypothesis.strategies as st
+            from hypothesis import given
+
+
+            @given(st.text(), st.text())
+            def test_not_equal(x, y):
+                assert x != y
+
+        Without the ability to reorder x and y this could fail either with
+        ``x=""``, ``y="0"``, or the other way around. With reordering it will
+        reliably fail with ``x=""``, ``y="0"``.
+        """
+        ex = chooser.choose(self.examples)
+        label = chooser.choose(ex.children).label
+
+        group = c for c in ex.children if c.label == label
+        if len(group) <= 1:
+            return
+
+        st = self.shrink_target
+        pieces = st.bufferex.start : ex.end for ex in group
+        endpoints = (ex.start, ex.end) for ex in group
+
+        Ordering.shrink(
+            pieces,
+            lambda ls: self.consider_new_buffer(
+                replace_all(st.buffer, (u, v, r) for (u, v), r in zip(endpoints, ls))
+            ),
+            random=self.random,
+        )
+
+    def run_block_program(self, i, description, original, repeats=1):
+        """Block programs are a mini-DSL for block rewriting, defined as a sequence
+        of commands that can be run at some index into the blocks
+
+        Commands are:
+
+            * "-", subtract one from this block.
+            * "X", delete this block
+
+        If a command does not apply (currently only because it's - on a zero
+        block) the block will be silently skipped over.
+
+        This method runs the block program in ``description`` at block index
+        ``i`` on the ConjectureData ``original``. If ``repeats > 1`` then it
+        will attempt to approximate the results of running it that many times.
+
+        Returns True if this successfully changes the underlying shrink target,
+        else False.
+        """
+        if i + len(description) > len(original.blocks) or i < 0:
+            return False
+        attempt = bytearray(original.buffer)
+        for _ in range(repeats):
+            for k, d in reversed(list(enumerate(description))):
+                j = i + k
+                u, v = original.blocksj.bounds
+                if v > len(attempt):
+                    return False
+                if d == "-":
+                    value = int_from_bytes(attemptu:v)
+                    if value == 0:
+                        return False
+                    else:
+                        attemptu:v = int_to_bytes(value - 1, v - u)
+                elif d == "X":
+                    del attemptu:v
+                else:
+                    raise NotImplementedError(f"Unrecognised command {d!r}")
+        return self.incorporate_new_buffer(attempt)
+
+
+def shrink_pass_family(f):
+    def accept(*args):
+        name = "{}({})".format(f.__name__, ", ".join(map(repr, args)))
+        if name not in SHRINK_PASS_DEFINITIONS:
+
+            def run(self, chooser):
+                return f(self, chooser, *args)
+
+            run.__name__ = name
+            defines_shrink_pass()(run)
+        assert name in SHRINK_PASS_DEFINITIONS
+        return name
+
+    return accept
+
+
+@shrink_pass_family
+def block_program(self, chooser, description):
+    """Mini-DSL for block rewriting. A sequence of commands that will be run
+    over all contiguous sequences of blocks of the description length in order.
+    Commands are:
+
+        * ".", keep this block unchanged
+        * "-", subtract one from this block.
+        * "0", replace this block with zero
+        * "X", delete this block
+
+    If a command does not apply (currently only because it's - on a zero
+    block) the block will be silently skipped over. As a side effect of
+    running a block program its score will be updated.
+    """
+    n = len(description)
+
+    """Adaptively attempt to run the block program at the current
+    index. If this successfully applies the block program ``k`` times
+    then this runs in ``O(log(k))`` test function calls."""
+    i = chooser.choose(range(len(self.shrink_target.blocks) - n))
+    # First, run the block program at the chosen index. If this fails,
+    # don't do any extra work, so that failure is as cheap as possible.
+    if not self.run_block_program(i, description, original=self.shrink_target):
+        return
+
+    # Because we run in a random order we will often find ourselves in the middle
+    # of a region where we could run the block program. We thus start by moving
+    # left to the beginning of that region if possible in order to to start from
+    # the beginning of that region.
+    def offset_left(k):
+        return i - k * n
+
+    i = offset_left(
+        find_integer(
+            lambda k: self.run_block_program(
+                offset_left(k), description, original=self.shrink_target
+            )
+        )
+    )
+
+    original = self.shrink_target
+
+    # Now try to run the block program multiple times here.
+    find_integer(
+        lambda k: self.run_block_program(i, description, original=original, repeats=k)
+    )
+
+
+@shrink_pass_family
+def dfa_replacement(self, chooser, dfa_name):
+    """Use one of our previously learned shrinking DFAs to reduce
+    the current test case. This works by finding a match of the DFA in the
+    current buffer that is not already minimal and attempting to replace it
+    with the minimal string matching that DFA.
+    """
+
+    try:
+        dfa = SHRINKING_DFASdfa_name
+    except KeyError:
+        dfa = self.extra_dfasdfa_name
+
+    matching_regions = self.matching_regions(dfa)
+    minimal = next(dfa.all_matching_strings())
+    u, v = chooser.choose(
+        matching_regions, lambda t: self.buffert0 : t1 != minimal
+    )
+    p = self.bufferu:v
+    assert sort_key(minimal) < sort_key(p)
+    replaced = self.buffer:u + minimal + self.bufferv:
+
+    assert sort_key(replaced) < sort_key(self.buffer)
+
+    self.consider_new_buffer(replaced)
+
+
+@attr.s(slots=True, eq=False)
+class ShrinkPass:
+    run_with_chooser = attr.ib()
+    index = attr.ib()
+    shrinker = attr.ib()
+
+    last_prefix = attr.ib(default=())
+    successes = attr.ib(default=0)
+    calls = attr.ib(default=0)
+    shrinks = attr.ib(default=0)
+    deletions = attr.ib(default=0)
+
+    def step(self, random_order=False):
+        tree = self.shrinker.shrink_pass_choice_treesself
+        if tree.exhausted:
+            return False
+
+        initial_shrinks = self.shrinker.shrinks
+        initial_calls = self.shrinker.calls
+        size = len(self.shrinker.shrink_target.buffer)
+        self.shrinker.engine.explain_next_call_as(self.name)
+
+        if random_order:
+            selection_order = random_selection_order(self.shrinker.random)
+        else:
+            selection_order = prefix_selection_order(self.last_prefix)
+
+        try:
+            self.last_prefix = tree.step(
+                selection_order,
+                lambda chooser: self.run_with_chooser(self.shrinker, chooser),
+            )
+        finally:
+            self.calls += self.shrinker.calls - initial_calls
+            self.shrinks += self.shrinker.shrinks - initial_shrinks
+            self.deletions += size - len(self.shrinker.shrink_target.buffer)
+            self.shrinker.engine.clear_call_explanation()
+        return True
+
+    @property
+    def name(self):
+        return self.run_with_chooser.__name__
+
+
+def non_zero_suffix(b):
+    """Returns the longest suffix of b that starts with a non-zero
+    byte."""
+    i = 0
+    while i < len(b) and bi == 0:
+        i += 1
+    return bi:
+
+
+class StopShrinking(Exception):
+    pass

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/common.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/dfas.py Added

@@ -0,0 +1,337 @@
+# 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 hashlib
+import math
+from itertools import islice
+
+from hypothesis import HealthCheck, settings
+from hypothesis.errors import HypothesisException
+from hypothesis.internal.conjecture.data import ConjectureResult, Status
+from hypothesis.internal.conjecture.dfa.lstar import LStar
+from hypothesis.internal.conjecture.shrinking.learned_dfas import (
+    SHRINKING_DFAS,
+    __file__ as learned_dfa_file,
+)
+
+"""
+This is a module for learning new DFAs that help normalize test
+functions. That is, given a test function that sometimes shrinks
+to one thing and sometimes another, this module is designed to
+help learn new DFA-based shrink passes that will cause it to
+always shrink to the same thing.
+"""
+
+
+class FailedToNormalise(HypothesisException):
+    pass
+
+
+def update_learned_dfas():
+    """Write any modifications to the SHRINKING_DFAS dictionary
+    back to the learned DFAs file."""
+
+    with open(learned_dfa_file) as i:
+        source = i.read()
+
+    lines = source.splitlines()
+
+    i = lines.index("# AUTOGENERATED BEGINS")
+
+    del linesi + 1 :
+
+    lines.append("")
+    lines.append("# fmt: off")
+    lines.append("")
+
+    for k, v in sorted(SHRINKING_DFAS.items()):
+        lines.append(f"SHRINKING_DFAS{k!r} = {v!r}  # noqa: E501")
+
+    lines.append("")
+    lines.append("# fmt: on")
+
+    new_source = "\n".join(lines) + "\n"
+
+    if new_source != source:
+        with open(learned_dfa_file, "w") as o:
+            o.write(new_source)
+
+
+def learn_a_new_dfa(runner, u, v, predicate):
+    """Given two buffers ``u`` and ``v```, learn a DFA that will
+    allow the shrinker to normalise them better. ``u`` and ``v``
+    should not currently shrink to the same test case when calling
+    this function."""
+    from hypothesis.internal.conjecture.shrinker import dfa_replacement, sort_key
+
+    assert predicate(runner.cached_test_function(u))
+    assert predicate(runner.cached_test_function(v))
+
+    u_shrunk = fully_shrink(runner, u, predicate)
+    v_shrunk = fully_shrink(runner, v, predicate)
+
+    u, v = sorted((u_shrunk.buffer, v_shrunk.buffer), key=sort_key)
+
+    assert u != v
+
+    assert not v.startswith(u)
+
+    # We would like to avoid using LStar on large strings as its
+    # behaviour can be quadratic or worse. In order to help achieve
+    # this we peel off a common prefix and suffix of the two final
+    # results and just learn the internal bit where they differ.
+    #
+    # This potentially reduces the length quite far if there's
+    # just one tricky bit of control flow we're struggling to
+    # reduce inside a strategy somewhere and the rest of the
+    # test function reduces fine.
+    if v.endswith(u):
+        prefix = b""
+        suffix = u
+        u_core = b""
+        assert len(u) > 0
+        v_core = v: -len(u)
+    else:
+        i = 0
+        while ui == vi:
+            i += 1
+        prefix = u:i
+        assert u.startswith(prefix)
+        assert v.startswith(prefix)
+
+        i = 1
+        while u-i == v-i:
+            i += 1
+
+        suffix = umax(len(prefix), len(u) + 1 - i) :
+        assert u.endswith(suffix)
+        assert v.endswith(suffix)
+
+        u_core = ulen(prefix) : len(u) - len(suffix)
+        v_core = vlen(prefix) : len(v) - len(suffix)
+
+    assert u == prefix + u_core + suffix, (list(u), list(v))
+    assert v == prefix + v_core + suffix, (list(u), list(v))
+
+    better = runner.cached_test_function(u)
+    worse = runner.cached_test_function(v)
+
+    allow_discards = worse.has_discards or better.has_discards
+
+    def is_valid_core(s):
+        if not (len(u_core) <= len(s) <= len(v_core)):
+            return False
+        buf = prefix + s + suffix
+        result = runner.cached_test_function(buf)
+        return (
+            predicate(result)
+            # Because we're often using this to learn strategies
+            # rather than entire complex test functions, it's
+            # important that our replacements are precise and
+            # don't leave the rest of the test case in a weird
+            # state.
+            and result.buffer == buf
+            # Because the shrinker is good at removing discarded
+            # data, unless we need discards to allow one or both
+            # of u and v to result in valid shrinks, we don't
+            # count attempts that have them as valid. This will
+            # cause us to match fewer strings, which will make
+            # the resulting shrink pass more efficient when run
+            # on test functions it wasn't really intended for.
+            and (allow_discards or not result.has_discards)
+        )
+
+    assert sort_key(u_core) < sort_key(v_core)
+
+    assert is_valid_core(u_core)
+    assert is_valid_core(v_core)
+
+    learner = LStar(is_valid_core)
+
+    prev = -1
+    while learner.generation != prev:
+        prev = learner.generation
+        learner.learn(u_core)
+        learner.learn(v_core)
+
+        # L* has a tendency to learn DFAs which wrap around to
+        # the beginning. We don't want to it to do that unless
+        # it's accurate, so we use these as examples to show
+        # check going around the DFA twice.
+        learner.learn(u_core * 2)
+        learner.learn(v_core * 2)
+
+        if learner.dfa.max_length(learner.dfa.start) > len(v_core):
+            # The language we learn is finite and bounded above
+            # by the length of v_core. This is important in order
+            # to keep our shrink passes reasonably efficient -
+            # otherwise they can match far too much. So whenever
+            # we learn a DFA that could match a string longer
+            # than len(v_core) we fix it by finding the first
+            # string longer than v_core and learning that as
+            # a correction.
+            x = next(learner.dfa.all_matching_strings(min_length=len(v_core) + 1))
+            assert not is_valid_core(x)
+            learner.learn(x)
+            assert not learner.dfa.matches(x)
+            assert learner.generation != prev
+        else:
+            # We mostly care about getting the right answer on the
+            # minimal test case, but because we're doing this offline
+            # anyway we might as well spend a little more time trying
+            # small examples to make sure the learner gets them right.
+            for x in islice(learner.dfa.all_matching_strings(), 100):
+                if not is_valid_core(x):
+                    learner.learn(x)
+                    assert learner.generation != prev
+                    break
+
+    # We've now successfully learned a DFA that works for shrinking
+    # our failed normalisation further. Canonicalise it into a concrete
+    # DFA so we can save it for later.
+    new_dfa = learner.dfa.canonicalise()
+
+    assert math.isfinite(new_dfa.max_length(new_dfa.start))
+
+    shrinker = runner.new_shrinker(runner.cached_test_function(v), predicate)
+
+    assert (len(prefix), len(v) - len(suffix)) in shrinker.matching_regions(new_dfa)
+
+    name = "tmp-dfa-" + repr(new_dfa)
+
+    shrinker.extra_dfasname = new_dfa
+
+    shrinker.fixate_shrink_passes(dfa_replacement(name))
+
+    assert sort_key(shrinker.buffer) < sort_key(v)
+
+    return new_dfa
+
+
+def fully_shrink(runner, test_case, predicate):
+    if not isinstance(test_case, ConjectureResult):
+        test_case = runner.cached_test_function(test_case)
+    while True:
+        shrunk = runner.shrink(test_case, predicate)
+        if shrunk.buffer == test_case.buffer:
+            break
+        test_case = shrunk
+    return test_case
+
+
+def normalize(
+    base_name,
+    test_function,
+    *,
+    required_successes=100,
+    allowed_to_update=False,
+    max_dfas=10,
+    random=None,
+):
+    """Attempt to ensure that this test function successfully normalizes - i.e.
+    whenever it declares a test case to be interesting, we are able
+    to shrink that to the same interesting test case (which logically should
+    be the shortlex minimal interesting test case, though we may not be able
+    to detect if it is).
+
+    Will run until we have seen ``required_successes`` many interesting test
+    cases in a row normalize to the same value.
+
+    If ``allowed_to_update`` is True, whenever we fail to normalize we will
+    learn a new DFA-based shrink pass that allows us to make progress. Any
+    learned DFAs will be written back into the learned DFA file at the end
+    of this function. If ``allowed_to_update`` is False, this will raise an
+    error as soon as it encounters a failure to normalize.
+
+    Additionally, if more than ``max_dfas` DFAs are required to normalize
+    this test function, this function will raise an error - it's essentially
+    designed for small patches that other shrink passes don't cover, and
+    if it's learning too many patches then you need a better shrink pass
+    than this can provide.
+    """
+    # Need import inside the function to avoid circular imports
+    from hypothesis.internal.conjecture.engine import BUFFER_SIZE, ConjectureRunner
+
+    runner = ConjectureRunner(
+        test_function,
+        settings=settings(database=None, suppress_health_check=list(HealthCheck)),
+        ignore_limits=True,
+        random=random,
+    )
+
+    seen = set()
+
+    dfas_added = 0
+
+    found_interesting = False
+    consecutive_successes = 0
+    failures_to_find_interesting = 0
+    while consecutive_successes < required_successes:
+        attempt = runner.cached_test_function(b"", extend=BUFFER_SIZE)
+        if attempt.status < Status.INTERESTING:
+            failures_to_find_interesting += 1
+            assert (
+                found_interesting or failures_to_find_interesting <= 1000
+            ), "Test function seems to have no interesting test cases"
+            continue
+
+        found_interesting = True
+
+        target = attempt.interesting_origin
+
+        def shrinking_predicate(d):
+            return d.status == Status.INTERESTING and d.interesting_origin == target
+
+        if target not in seen:
+            seen.add(target)
+            runner.shrink(attempt, shrinking_predicate)
+            continue
+
+        previous = fully_shrink(
+            runner, runner.interesting_examplestarget, shrinking_predicate
+        )
+        current = fully_shrink(runner, attempt, shrinking_predicate)
+
+        if current.buffer == previous.buffer:
+            consecutive_successes += 1
+            continue
+
+        consecutive_successes = 0
+
+        if not allowed_to_update:
+            raise FailedToNormalise(
+                f"Shrinker failed to normalize {previous.buffer!r} to "
+                f"{current.buffer!r} and we are not allowed to learn new DFAs."
+            )
+
+        if dfas_added >= max_dfas:
+            raise FailedToNormalise(
+                f"Test function is too hard to learn: Added {dfas_added} "
+                "DFAs and still not done."
+            )
+
+        dfas_added += 1
+
+        new_dfa = learn_a_new_dfa(
+            runner, previous.buffer, current.buffer, shrinking_predicate
+        )
+
+        name = base_name + "-" + hashlib.sha256(repr(new_dfa).encode()).hexdigest():10
+
+        # If there is a name collision this DFA should already be being
+        # used for shrinking, so we should have already been able to shrink
+        # v further.
+        assert name not in SHRINKING_DFAS
+        SHRINKING_DFASname = new_dfa
+
+    if dfas_added > 0:
+        # We've learned one or more DFAs in the course of normalising, so now
+        # we update the file to record those for posterity.
+        update_learned_dfas()

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/floats.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/integer.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/learned_dfas.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/lexical.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/shrinking/ordering.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/conjecture/utils.py Added

@@ -0,0 +1,517 @@
+# 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 enum
+import hashlib
+import heapq
+import math
+import sys
+from collections import OrderedDict, abc
+from functools import lru_cache
+from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple, Type, TypeVar, Union
+
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.compat import floor, int_from_bytes
+from hypothesis.internal.floats import int_to_float, next_up
+
+if TYPE_CHECKING:
+    from hypothesis.internal.conjecture.data import ConjectureData
+
+
+LABEL_MASK = 2**64 - 1
+
+
+def calc_label_from_name(name: str) -> int:
+    hashed = hashlib.sha384(name.encode()).digest()
+    return int_from_bytes(hashed:8)
+
+
+def calc_label_from_cls(cls: type) -> int:
+    return calc_label_from_name(cls.__qualname__)
+
+
+def combine_labels(*labels: int) -> int:
+    label = 0
+    for l in labels:
+        label = (label << 1) & LABEL_MASK
+        label ^= l
+    return label
+
+
+INTEGER_RANGE_DRAW_LABEL = calc_label_from_name("another draw in integer_range()")
+BIASED_COIN_LABEL = calc_label_from_name("biased_coin()")
+BIASED_COIN_INNER_LABEL = calc_label_from_name("inside biased_coin()")
+SAMPLE_IN_SAMPLER_LABEL = calc_label_from_name("a sample() in Sampler")
+ONE_FROM_MANY_LABEL = calc_label_from_name("one more from many()")
+
+
+def unbounded_integers(data: "ConjectureData") -> int:
+    size = INT_SIZESINT_SIZES_SAMPLER.sample(data)
+    r = data.draw_bits(size)
+    sign = r & 1
+    r >>= 1
+    if sign:
+        r = -r
+    return int(r)
+
+
+def integer_range(
+    data: "ConjectureData",
+    lower: int,
+    upper: int,
+    center: Optionalint = None,
+    forced: Optionalint = None,
+) -> int:
+    assert lower <= upper
+    assert forced is None or lower <= forced <= upper
+    if lower == upper:
+        # Write a value even when this is trivial so that when a bound depends
+        # on other values we don't suddenly disappear when the gap shrinks to
+        # zero - if that happens then often the data stream becomes misaligned
+        # and we fail to shrink in cases where we really should be able to.
+        data.draw_bits(1, forced=0)
+        return int(lower)
+
+    if center is None:
+        center = lower
+    center = min(max(center, lower), upper)
+
+    if center == upper:
+        above = False
+    elif center == lower:
+        above = True
+    else:
+        force_above = None if forced is None else forced < center
+        above = not data.draw_bits(1, forced=force_above)
+
+    if above:
+        gap = upper - center
+    else:
+        gap = center - lower
+
+    assert gap > 0
+
+    bits = gap.bit_length()
+    probe = gap + 1
+
+    if bits > 24 and data.draw_bits(3, forced=None if forced is None else 0):
+        # For large ranges, we combine the uniform random distribution from draw_bits
+        # with a weighting scheme with moderate chance.  Cutoff at 2 ** 24 so that our
+        # choice of unicode characters is uniform but the 32bit distribution is not.
+        idx = INT_SIZES_SAMPLER.sample(data)
+        bits = min(bits, INT_SIZESidx)
+
+    while probe > gap:
+        data.start_example(INTEGER_RANGE_DRAW_LABEL)
+        probe = data.draw_bits(
+            bits, forced=None if forced is None else abs(forced - center)
+        )
+        data.stop_example(discard=probe > gap)
+
+    if above:
+        result = center + probe
+    else:
+        result = center - probe
+
+    assert lower <= result <= upper
+    assert forced is None or result == forced, (result, forced, center, above)
+    return result
+
+
+T = TypeVar("T")
+
+
+def check_sample(
+    values: UnionTypeenum.Enum, SequenceT, strategy_name: str
+) -> SequenceT:
+    if "numpy" in sys.modules and isinstance(values, sys.modules"numpy".ndarray):
+        if values.ndim != 1:
+            raise InvalidArgument(
+                "Only one-dimensional arrays are supported for sampling, "
+                f"and the given value has {values.ndim} dimensions (shape "
+                f"{values.shape}).  This array would give samples of array slices "
+                "instead of elements!  Use np.ravel(values) to convert "
+                "to a one-dimensional array, or tuple(values) if you "
+                "want to sample slices."
+            )
+    elif not isinstance(values, (OrderedDict, abc.Sequence, enum.EnumMeta)):
+        raise InvalidArgument(
+            f"Cannot sample from {values!r}, not an ordered collection. "
+            f"Hypothesis goes to some length to ensure that the {strategy_name} "
+            "strategy has stable results between runs. To replay a saved "
+            "example, the sampled values must have the same iteration order "
+            "on every run - ruling out sets, dicts, etc due to hash "
+            "randomization. Most cases can simply use `sorted(values)`, but "
+            "mixed types or special values such as math.nan require careful "
+            "handling - and note that when simplifying an example, "
+            "Hypothesis treats earlier values as simpler."
+        )
+    if isinstance(values, range):
+        return values
+    return tuple(values)
+
+
+def choice(data: "ConjectureData", values: SequenceT) -> T:
+    return valuesinteger_range(data, 0, len(values) - 1)
+
+
+FLOAT_PREFIX = 0b1111111111 << 52
+FULL_FLOAT = int_to_float(FLOAT_PREFIX | ((2 << 53) - 1)) - 1
+
+
+def fractional_float(data: "ConjectureData") -> float:
+    return (int_to_float(FLOAT_PREFIX | data.draw_bits(52)) - 1) / FULL_FLOAT
+
+
+def biased_coin(
+    data: "ConjectureData", p: float, *, forced: Optionalbool = None
+) -> bool:
+    """Return True with probability p (assuming a uniform generator),
+    shrinking towards False. If ``forced`` is set to a non-None value, this
+    will always return that value but will write choices appropriate to having
+    drawn that value randomly."""
+
+    # NB this function is vastly more complicated than it may seem reasonable
+    # for it to be. This is because it is used in a lot of places and it's
+    # important for it to shrink well, so it's worth the engineering effort.
+
+    if p <= 0 or p >= 1:
+        bits = 1
+    else:
+        # When there is a meaningful draw, in order to shrink well we will
+        # set things up so that 0 and 1 always correspond to False and True
+        # respectively. This means we want enough bits available that in a
+        # draw we will always have at least one truthy value and one falsey
+        # value.
+        bits = math.ceil(-math.log(min(p, 1 - p), 2))
+    # In order to avoid stupidly large draws where the probability is
+    # effectively zero or one, we treat probabilities of under 2^-64 to be
+    # effectively zero.
+    if bits > 64:
+        # There isn't enough precision near one for this to occur for values
+        # far from 0.
+        p = 0.0
+        bits = 1
+
+    size = 2**bits
+
+    data.start_example(BIASED_COIN_LABEL)
+    while True:
+        # The logic here is a bit complicated and special cased to make it
+        # play better with the shrinker.
+
+        # We imagine partitioning the real interval 0, 1 into 2**n equal parts
+        # and looking at each part and whether its interior is wholly <= p
+        # or wholly >= p. At most one part can be neither.
+
+        # We then pick a random part. If it's wholly on one side or the other
+        # of p then we use that as the answer. If p is contained in the
+        # interval then we start again with a new probability that is given
+        # by the fraction of that interval that was <= our previous p.
+
+        # We then take advantage of the fact that we have control of the
+        # labelling to make this shrink better, using the following tricks:
+
+        # If p is <= 0 or >= 1 the result of this coin is certain. We make sure
+        # to write a byte to the data stream anyway so that these don't cause
+        # difficulties when shrinking.
+        if p <= 0:
+            data.draw_bits(1, forced=0)
+            result = False
+        elif p >= 1:
+            data.draw_bits(1, forced=1)
+            result = True
+        else:
+            falsey = floor(size * (1 - p))
+            truthy = floor(size * p)
+            remainder = size * p - truthy
+
+            if falsey + truthy == size:
+                partial = False
+            else:
+                partial = True
+
+            if forced is None:
+                # We want to get to the point where True is represented by
+                # 1 and False is represented by 0 as quickly as possible, so
+                # we use the remove_discarded machinery in the shrinker to
+                # achieve that by discarding any draws that are > 1 and writing
+                # a suitable draw into the choice sequence at the end of the
+                # loop.
+                data.start_example(BIASED_COIN_INNER_LABEL)
+                i = data.draw_bits(bits)
+                data.stop_example(discard=i > 1)
+            else:
+                i = data.draw_bits(bits, forced=int(forced))
+
+            # We always choose the region that causes us to repeat the loop as
+            # the maximum value, so that shrinking the drawn bits never causes
+            # us to need to draw more data.
+            if partial and i == size - 1:
+                p = remainder
+                continue
+            if falsey == 0:
+                # Every other partition is truthy, so the result is true
+                result = True
+            elif truthy == 0:
+                # Every other partition is falsey, so the result is false
+                result = False
+            elif i <= 1:
+                # We special case so that zero is always false and 1 is always
+                # true which makes shrinking easier because we can always
+                # replace a truthy block with 1. This has the slightly weird
+                # property that shrinking from 2 to 1 can cause the result to
+                # grow, but the shrinker always tries 0 and 1 first anyway, so
+                # this will usually be fine.
+                result = bool(i)
+            else:
+                # Originally everything in the region 0 <= i < falsey was false
+                # and everything above was true. We swapped one truthy element
+                # into this region, so the region becomes 0 <= i <= falsey
+                # except for i = 1. We know i > 1 here, so the test for truth
+                # becomes i > falsey.
+                result = i > falsey
+
+            if i > 1:  # pragma: no branch
+                # Thanks to bytecode optimisations on CPython >= 3.7 and PyPy
+                # (see https://bugs.python.org/issue2506), coverage incorrectly
+                # thinks that this condition is always true.  You can trivially
+                # check by adding `else: assert False` and running the tests.
+                data.draw_bits(bits, forced=int(result))
+        break
+    data.stop_example()
+    return result
+
+
+class Sampler:
+    """Sampler based on Vose's algorithm for the alias method. See
+    http://www.keithschwarz.com/darts-dice-coins/ for a good explanation.
+
+    The general idea is that we store a table of triples (base, alternate, p).
+    base. We then pick a triple uniformly at random, and choose its alternate
+    value with probability p and else choose its base value. The triples are
+    chosen so that the resulting mixture has the right distribution.
+
+    We maintain the following invariants to try to produce good shrinks:
+
+    1. The table is in lexicographic (base, alternate) order, so that choosing
+       an earlier value in the list always lowers (or at least leaves
+       unchanged) the value.
+    2. basei < alternatei, so that shrinking the draw always results in
+       shrinking the chosen element.
+    """
+
+    table: ListTupleint, int, float  # (base_idx, alt_idx, alt_chance)
+
+    def __init__(self, weights: Sequencefloat):
+        n = len(weights)
+
+        table: "listlistint | float | None" = i, None, None for i in range(n)
+
+        total = sum(weights)
+
+        num_type = type(total)
+
+        zero = num_type(0)  # type: ignore
+        one = num_type(1)  # type: ignore
+
+        small: "Listint" = 
+        large: "Listint" = 
+
+        probabilities = w / total for w in weights
+        scaled_probabilities: "Listfloat" = 
+
+        for i, alternate_chance in enumerate(probabilities):
+            scaled = alternate_chance * n
+            scaled_probabilities.append(scaled)
+            if scaled == 1:
+                tablei2 = zero
+            elif scaled < 1:
+                small.append(i)
+            else:
+                large.append(i)
+        heapq.heapify(small)
+        heapq.heapify(large)
+
+        while small and large:
+            lo = heapq.heappop(small)
+            hi = heapq.heappop(large)
+
+            assert lo != hi
+            assert scaled_probabilitieshi > one
+            assert tablelo1 is None
+            tablelo1 = hi
+            tablelo2 = one - scaled_probabilitieslo
+            scaled_probabilitieshi = (
+                scaled_probabilitieshi + scaled_probabilitieslo
+            ) - one
+
+            if scaled_probabilitieshi < 1:
+                heapq.heappush(small, hi)
+            elif scaled_probabilitieshi == 1:
+                tablehi2 = zero
+            else:
+                heapq.heappush(large, hi)
+        while large:
+            tablelarge.pop()2 = zero
+        while small:
+            tablesmall.pop()2 = zero
+
+        self.table: "ListTupleint, int, float" = 
+        for base, alternate, alternate_chance in table:  # type: ignore
+            assert isinstance(base, int)
+            assert isinstance(alternate, int) or alternate is None
+            if alternate is None:
+                self.table.append((base, base, alternate_chance))
+            elif alternate < base:
+                self.table.append((alternate, base, one - alternate_chance))
+            else:
+                self.table.append((base, alternate, alternate_chance))
+        self.table.sort()
+
+    def sample(self, data: "ConjectureData") -> int:
+        data.start_example(SAMPLE_IN_SAMPLER_LABEL)
+        base, alternate, alternate_chance = choice(data, self.table)
+        use_alternate = biased_coin(data, alternate_chance)
+        data.stop_example()
+        if use_alternate:
+            return alternate
+        else:
+            return base
+
+
+INT_SIZES = (8, 16, 32, 64, 128)
+INT_SIZES_SAMPLER = Sampler((4.0, 8.0, 1.0, 1.0, 0.5))
+
+
+class many:
+    """Utility class for collections. Bundles up the logic we use for "should I
+    keep drawing more values?" and handles starting and stopping examples in
+    the right place.
+
+    Intended usage is something like:
+
+    elements = many(data, ...)
+    while elements.more():
+        add_stuff_to_result()
+    """
+
+    def __init__(
+        self,
+        data: "ConjectureData",
+        min_size: int,
+        max_size: Unionint, float,
+        average_size: Unionint, float,
+    ) -> None:
+        assert 0 <= min_size <= average_size <= max_size
+        self.min_size = min_size
+        self.max_size = max_size
+        self.data = data
+        self.p_continue = _calc_p_continue(average_size - min_size, max_size - min_size)
+        self.count = 0
+        self.rejections = 0
+        self.drawn = False
+        self.force_stop = False
+        self.rejected = False
+
+    def more(self) -> bool:
+        """Should I draw another element to add to the collection?"""
+        if self.drawn:
+            self.data.stop_example(discard=self.rejected)
+
+        self.drawn = True
+        self.rejected = False
+
+        self.data.start_example(ONE_FROM_MANY_LABEL)
+
+        if self.min_size == self.max_size:
+            should_continue = self.count < self.min_size
+        else:
+            forced_result = None
+            if self.force_stop:
+                forced_result = False
+            elif self.count < self.min_size:
+                forced_result = True
+            elif self.count >= self.max_size:
+                forced_result = False
+            should_continue = biased_coin(
+                self.data, self.p_continue, forced=forced_result
+            )
+
+        if should_continue:
+            self.count += 1
+            return True
+        else:
+            self.data.stop_example()
+            return False
+
+    def reject(self, why: Optionalstr = None) -> None:
+        """Reject the last example (i.e. don't count it towards our budget of
+        elements because it's not going to go in the final collection)."""
+        assert self.count > 0
+        self.count -= 1
+        self.rejections += 1
+        self.rejected = True
+        # We set a minimum number of rejections before we give up to avoid
+        # failing too fast when we reject the first draw.
+        if self.rejections > max(3, 2 * self.count):
+            if self.count < self.min_size:
+                self.data.mark_invalid(why)
+            else:
+                self.force_stop = True
+
+
+SMALLEST_POSITIVE_FLOAT: float = next_up(0.0) or sys.float_info.min
+
+
+@lru_cache()
+def _calc_p_continue(desired_avg: float, max_size: int) -> float:
+    """Return the p_continue which will generate the desired average size."""
+    assert desired_avg <= max_size, (desired_avg, max_size)
+    if desired_avg == max_size:
+        return 1.0
+    p_continue = 1 - 1.0 / (1 + desired_avg)
+    if p_continue == 0 or max_size == float("inf"):
+        assert 0 <= p_continue < 1, p_continue
+        return p_continue
+    assert 0 < p_continue < 1, p_continue
+    # For small max_size, the infinite-series p_continue is a poor approximation,
+    # and while we can't solve the polynomial a few rounds of iteration quickly
+    # gets us a good approximate solution in almost all cases (sometimes exact!).
+    while _p_continue_to_avg(p_continue, max_size) > desired_avg:
+        # This is impossible over the reals, but *can* happen with floats.
+        p_continue -= 0.0001
+        # If we've reached zero or gone negative, we want to break out of this loop,
+        # and do so even if we're on a system with the unsafe denormals-are-zero flag.
+        # We make that an explicit error in st.floats(), but here we'd prefer to
+        # just get somewhat worse precision on collection lengths.
+        if p_continue < SMALLEST_POSITIVE_FLOAT:
+            p_continue = SMALLEST_POSITIVE_FLOAT
+            break
+    # Let's binary-search our way to a better estimate!  We tried fancier options
+    # like gradient descent, but this is numerically stable and works better.
+    hi = 1.0
+    while desired_avg - _p_continue_to_avg(p_continue, max_size) > 0.01:
+        assert 0 < p_continue < hi, (p_continue, hi)
+        mid = (p_continue + hi) / 2
+        if _p_continue_to_avg(mid, max_size) <= desired_avg:
+            p_continue = mid
+        else:
+            hi = mid
+    assert 0 < p_continue < 1, p_continue
+    assert _p_continue_to_avg(p_continue, max_size) <= desired_avg
+    return p_continue
+
+
+def _p_continue_to_avg(p_continue: float, max_size: int) -> float:
+    """Return the average_size generated by this p_continue and max_size."""
+    if p_continue >= 1:
+        return max_size
+    return (1.0 / (1 - p_continue) - 1) * (1 - p_continue**max_size)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/coverage.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/detection.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/entropy.py Added

@@ -0,0 +1,202 @@
+# 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 contextlib
+import gc
+import random
+import sys
+import warnings
+from itertools import count
+from typing import TYPE_CHECKING, Any, Callable, Hashable, Tuple
+from weakref import WeakValueDictionary
+
+import hypothesis.core
+from hypothesis.errors import HypothesisWarning, InvalidArgument
+from hypothesis.internal.compat import GRAALPY, PYPY
+
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 8):
+        from typing import Protocol
+    else:
+        from typing_extensions import Protocol
+
+    # we can't use this at runtime until from_type supports
+    # protocols -- breaks ghostwriter tests
+    class RandomLike(Protocol):
+        seed: Callable..., Any
+        getstate: Callable, Any
+        setstate: Callable..., Any
+
+else:  # pragma: no cover
+    RandomLike = random.Random
+
+# This is effectively a WeakSet, which allows us to associate the saved states
+# with their respective Random instances even as new ones are registered and old
+# ones go out of scope and get garbage collected.  Keys are ascending integers.
+_RKEY = count()
+RANDOMS_TO_MANAGE: WeakValueDictionary = WeakValueDictionary({next(_RKEY): random})
+
+
+class NumpyRandomWrapper:
+    def __init__(self):
+        assert "numpy" in sys.modules
+        # This class provides a shim that matches the numpy to stdlib random,
+        # and lets us avoid importing Numpy until it's already in use.
+        import numpy.random
+
+        self.seed = numpy.random.seed
+        self.getstate = numpy.random.get_state
+        self.setstate = numpy.random.set_state
+
+
+NP_RANDOM = None
+
+
+if not (PYPY or GRAALPY):
+
+    def _get_platform_base_refcount(r: Any) -> int:
+        return sys.getrefcount(r)
+
+    # Determine the number of refcounts created by function scope for
+    # the given platform / version of Python.
+    _PLATFORM_REF_COUNT = _get_platform_base_refcount(object())
+else:  # pragma: no cover
+    # PYPY and GRAALPY don't have `sys.getrefcount`
+    _PLATFORM_REF_COUNT = -1
+
+
+def register_random(r: RandomLike) -> None:
+    """Register (a weakref to) the given Random-like instance for management by
+    Hypothesis.
+
+    You can pass instances of structural subtypes of ``random.Random``
+    (i.e., objects with seed, getstate, and setstate methods) to
+    ``register_random(r)`` to have their states seeded and restored in the same
+    way as the global PRNGs from the ``random`` and ``numpy.random`` modules.
+
+    All global PRNGs, from e.g. simulation or scheduling frameworks, should
+    be registered to prevent flaky tests. Hypothesis will ensure that the
+    PRNG state is consistent for all test runs, always seeding them to zero and
+    restoring the previous state after the test, or, reproducibly varied if you
+    choose to use the :func:`~hypothesis.strategies.random_module` strategy.
+
+    ``register_random`` only makes `weakrefs
+    <https://docs.python.org/3/library/weakref.html#module-weakref>`_ to ``r``,
+    thus ``r`` will only be managed by Hypothesis as long as it has active
+    references elsewhere at runtime. The pattern ``register_random(MyRandom())``
+    will raise a ``ReferenceError`` to help protect users from this issue.
+    This check does not occur for the PyPy interpreter. See the following example for
+    an illustration of this issue
+
+    .. code-block:: python
+
+
+       def my_BROKEN_hook():
+           r = MyRandomLike()
+
+           # `r` will be garbage collected after the hook resolved
+           # and Hypothesis will 'forget' that it was registered
+           register_random(r)  # Hypothesis will emit a warning
+
+
+       rng = MyRandomLike()
+
+
+       def my_WORKING_hook():
+           register_random(rng)
+    """
+    if not (hasattr(r, "seed") and hasattr(r, "getstate") and hasattr(r, "setstate")):
+        raise InvalidArgument(f"r={r!r} does not have all the required methods")
+
+    if r in RANDOMS_TO_MANAGE.values():
+        return
+
+    if not (PYPY or GRAALPY):  # pragma: no branch
+        # PYPY and GRAALPY do not have `sys.getrefcount`
+        gc.collect()
+        if not gc.get_referrers(r):
+            if sys.getrefcount(r) <= _PLATFORM_REF_COUNT:
+                raise ReferenceError(
+                    f"`register_random` was passed `r={r}` which will be "
+                    "garbage collected immediately after `register_random` creates a "
+                    "weakref to it. This will prevent Hypothesis from managing this "
+                    "source of RNG. See the docs for `register_random` for more "
+                    "details."
+                )
+            else:
+                warnings.warn(
+                    HypothesisWarning(
+                        "It looks like `register_random` was passed an object "
+                        "that could be garbage collected immediately after "
+                        "`register_random` creates a weakref to it. This will "
+                        "prevent Hypothesis from managing this source of RNG. "
+                        "See the docs for `register_random` for more details."
+                    )
+                )
+
+    RANDOMS_TO_MANAGEnext(_RKEY) = r
+
+
+def get_seeder_and_restorer(
+    seed: Hashable = 0,
+) -> TupleCallable, None, Callable, None:
+    """Return a pair of functions which respectively seed all and restore
+    the state of all registered PRNGs.
+
+    This is used by the core engine via `deterministic_PRNG`, and by users
+    via `register_random`.  We support registration of additional random.Random
+    instances (or other objects with seed, getstate, and setstate methods)
+    to force determinism on simulation or scheduling frameworks which avoid
+    using the global random state.  See e.g. #1709.
+    """
+    assert isinstance(seed, int) and 0 <= seed < 2**32
+    states: dict = {}
+
+    if "numpy" in sys.modules:
+        global NP_RANDOM
+        if NP_RANDOM is None:
+            # Protect this from garbage-collection by adding it to global scope
+            NP_RANDOM = RANDOMS_TO_MANAGEnext(_RKEY) = NumpyRandomWrapper()
+
+    def seed_all():
+        assert not states
+        for k, r in RANDOMS_TO_MANAGE.items():
+            statesk = r.getstate()
+            r.seed(seed)
+
+    def restore_all():
+        for k, state in states.items():
+            r = RANDOMS_TO_MANAGE.get(k)
+            if r is not None:  # i.e., hasn't been garbage-collected
+                r.setstate(state)
+        states.clear()
+
+    return seed_all, restore_all
+
+
+@contextlib.contextmanager
+def deterministic_PRNG(seed=0):
+    """Context manager that handles random.seed without polluting global state.
+
+    See issue #1255 and PR #1295 for details and motivation - in short,
+    leaving the global pseudo-random number generator (PRNG) seeded is a very
+    bad idea in principle, and breaks all kinds of independence assumptions
+    in practice.
+    """
+    if hypothesis.core._hypothesis_global_random is None:  # pragma: no cover
+        hypothesis.core._hypothesis_global_random = random.Random()
+        register_random(hypothesis.core._hypothesis_global_random)
+
+    seed_all, restore_all = get_seeder_and_restorer(seed)
+    seed_all()
+    try:
+        yield
+    finally:
+        restore_all()

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/escalation.py Added

@@ -0,0 +1,165 @@
+# 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 contextlib
+import os
+import sys
+import traceback
+from inspect import getframeinfo
+from pathlib import Path
+from typing import Dict
+
+import hypothesis
+from hypothesis.errors import (
+    DeadlineExceeded,
+    HypothesisException,
+    StopTest,
+    UnsatisfiedAssumption,
+    _Trimmable,
+)
+from hypothesis.internal.compat import BaseExceptionGroup
+from hypothesis.utils.dynamicvariables import DynamicVariable
+
+
+def belongs_to(package):
+    if not hasattr(package, "__file__"):  # pragma: no cover
+        return lambda filepath: False
+
+    root = Path(package.__file__).resolve().parent
+    cache = {str: {}, bytes: {}}
+
+    def accept(filepath):
+        ftype = type(filepath)
+        try:
+            return cacheftypefilepath
+        except KeyError:
+            pass
+        try:
+            Path(filepath).resolve().relative_to(root)
+            result = True
+        except Exception:
+            result = False
+        cacheftypefilepath = result
+        return result
+
+    accept.__name__ = f"is_{package.__name__}_file"
+    return accept
+
+
+PREVENT_ESCALATION = os.getenv("HYPOTHESIS_DO_NOT_ESCALATE") == "true"
+
+FILE_CACHE: Dictbytes, bool = {}
+
+
+is_hypothesis_file = belongs_to(hypothesis)
+
+HYPOTHESIS_CONTROL_EXCEPTIONS = (DeadlineExceeded, StopTest, UnsatisfiedAssumption)
+
+
+def escalate_hypothesis_internal_error():
+    if PREVENT_ESCALATION:
+        return
+
+    _, e, tb = sys.exc_info()
+
+    if getattr(e, "hypothesis_internal_never_escalate", False):
+        return
+
+    filepath = None if tb is None else traceback.extract_tb(tb)-10
+    if is_hypothesis_file(filepath) and not isinstance(
+        e, (HypothesisException,) + HYPOTHESIS_CONTROL_EXCEPTIONS
+    ):
+        raise
+
+
+def get_trimmed_traceback(exception=None):
+    """Return the current traceback, minus any frames added by Hypothesis."""
+    if exception is None:
+        _, exception, tb = sys.exc_info()
+    else:
+        tb = exception.__traceback__
+    # Avoid trimming the traceback if we're in verbose mode, or the error
+    # was raised inside Hypothesis
+    if (
+        tb is None
+        or hypothesis.settings.default.verbosity >= hypothesis.Verbosity.debug
+        or is_hypothesis_file(traceback.extract_tb(tb)-10)
+        and not isinstance(exception, _Trimmable)
+    ):
+        return tb
+    while tb.tb_next is not None and (
+        # If the frame is from one of our files, it's been added by Hypothesis.
+        is_hypothesis_file(getframeinfo(tb.tb_frame).filename)
+        # But our `@proxies` decorator overrides the source location,
+        # so we check for an attribute it injects into the frame too.
+        or tb.tb_frame.f_globals.get("__hypothesistracebackhide__") is True
+    ):
+        tb = tb.tb_next
+    return tb
+
+
+def get_interesting_origin(exception):
+    # The `interesting_origin` is how Hypothesis distinguishes between multiple
+    # failures, for reporting and also to replay from the example database (even
+    # if report_multiple_bugs=False).  We traditionally use the exception type and
+    # location, but have extracted this logic in order to see through `except ...:`
+    # blocks and understand the __cause__ (`raise x from y`) or __context__ that
+    # first raised an exception as well as PEP-654 exception groups.
+    tb = get_trimmed_traceback(exception)
+    if tb is None:
+        filename, lineno = None, None
+    else:
+        filename, lineno, *_ = traceback.extract_tb(tb)-1
+    return (
+        type(exception),
+        filename,
+        lineno,
+        # Note that if __cause__ is set it is always equal to __context__, explicitly
+        # to support introspection when debugging, so we can use that unconditionally.
+        get_interesting_origin(exception.__context__) if exception.__context__ else (),
+        # We distinguish exception groups by the inner exceptions, as for __context__
+        tuple(
+            map(get_interesting_origin, exception.exceptions)
+            if isinstance(exception, BaseExceptionGroup)
+            else 
+        ),
+    )
+
+
+current_pytest_item = DynamicVariable(None)
+
+
+def _get_exceptioninfo():
+    # ExceptionInfo was moved to the top-level namespace in Pytest 7.0
+    if "pytest" in sys.modules:
+        with contextlib.suppress(Exception):
+            # From Pytest 7, __init__ warns on direct calls.
+            return sys.modules"pytest".ExceptionInfo.from_exc_info
+    if "_pytest._code" in sys.modules:  # pragma: no cover  # old versions only
+        with contextlib.suppress(Exception):
+            return sys.modules"_pytest._code".ExceptionInfo
+    return None  # pragma: no cover  # coverage tests always use pytest
+
+
+def format_exception(err, tb):
+    # Try using Pytest to match the currently configured traceback style
+    ExceptionInfo = _get_exceptioninfo()
+    if current_pytest_item.value is not None and ExceptionInfo is not None:
+        item = current_pytest_item.value
+        return str(item.repr_failure(ExceptionInfo((type(err), err, tb)))) + "\n"
+
+    # Or use better_exceptions, if that's installed and enabled
+    if "better_exceptions" in sys.modules:
+        better_exceptions = sys.modules"better_exceptions"
+        if sys.excepthook is better_exceptions.excepthook:
+            return "".join(better_exceptions.format_exception(type(err), err, tb))
+
+    # If all else fails, use the standard-library formatting tools
+    return "".join(traceback.format_exception(type(err), err, tb))

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/filtering.py Added

@@ -0,0 +1,297 @@
+# 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/.
+
+"""Tools for understanding predicates, to satisfy them by construction.
+
+For example::
+
+    integers().filter(lambda x: x >= 0) -> integers(min_value=0)
+
+This is intractable in general, but reasonably easy for simple cases involving
+numeric bounds, strings with length or regex constraints, and collection lengths -
+and those are precisely the most common cases.  When they arise in e.g. Pandas
+dataframes, it's also pretty painful to do the constructive version by hand in
+a library; so we prefer to share all the implementation effort here.
+See https://github.com/HypothesisWorks/hypothesis/issues/2701 for details.
+"""
+
+import ast
+import inspect
+import math
+import operator
+from decimal import Decimal
+from fractions import Fraction
+from functools import partial
+from typing import Any, Callable, Dict, NamedTuple, Optional, TypeVar
+
+from hypothesis.internal.compat import ceil, floor
+from hypothesis.internal.floats import next_down, next_up
+from hypothesis.internal.reflection import extract_lambda_source
+
+Ex = TypeVar("Ex")
+Predicate = CallableEx, bool
+
+
+class ConstructivePredicate(NamedTuple):
+    """Return kwargs to the appropriate strategy, and the predicate if needed.
+
+    For example::
+
+        integers().filter(lambda x: x >= 0)
+        -> {"min_value": 0"}, None
+
+        integers().filter(lambda x: x >= 0 and x % 7)
+        -> {"min_value": 0}, lambda x: x % 7
+
+    At least in principle - for now we usually return the predicate unchanged
+    if needed.
+
+    We have a separate get-predicate frontend for each "group" of strategies; e.g.
+    for each numeric type, for strings, for bytes, for collection sizes, etc.
+    """
+
+    kwargs: Dictstr, Any
+    predicate: OptionalPredicate
+
+    @classmethod
+    def unchanged(cls, predicate: Predicate) -> "ConstructivePredicate":
+        return cls({}, predicate)
+
+
+ARG = object()
+
+
+def convert(node: ast.AST, argname: str) -> object:
+    if isinstance(node, ast.Name):
+        if node.id != argname:
+            raise ValueError("Non-local variable")
+        return ARG
+    return ast.literal_eval(node)
+
+
+def comp_to_kwargs(x: ast.AST, op: ast.AST, y: ast.AST, *, argname: str) -> dict:
+    a = convert(x, argname)
+    b = convert(y, argname)
+    num = (int, float)
+    if not (a is ARG and isinstance(b, num)) and not (isinstance(a, num) and b is ARG):
+        # It would be possible to work out if comparisons between two literals
+        # are always true or false, but it's too rare to be worth the complexity.
+        # (and we can't even do `arg == arg`, because what if it's NaN?)
+        raise ValueError("Can't analyse this comparison")
+
+    if isinstance(op, ast.Lt):
+        if a is ARG:
+            return {"max_value": b, "exclude_max": True}
+        return {"min_value": a, "exclude_min": True}
+    elif isinstance(op, ast.LtE):
+        if a is ARG:
+            return {"max_value": b}
+        return {"min_value": a}
+    elif isinstance(op, ast.Eq):
+        if a is ARG:
+            return {"min_value": b, "max_value": b}
+        return {"min_value": a, "max_value": a}
+    elif isinstance(op, ast.GtE):
+        if a is ARG:
+            return {"min_value": b}
+        return {"max_value": a}
+    elif isinstance(op, ast.Gt):
+        if a is ARG:
+            return {"min_value": b, "exclude_min": True}
+        return {"max_value": a, "exclude_max": True}
+    raise ValueError("Unhandled comparison operator")  # e.g. ast.Ne
+
+
+def merge_preds(*con_predicates: ConstructivePredicate) -> ConstructivePredicate:
+    # This function is just kinda messy.  Unfortunately the neatest way
+    # to do this is just to roll out each case and handle them in turn.
+    base = {
+        "min_value": -math.inf,
+        "max_value": math.inf,
+        "exclude_min": False,
+        "exclude_max": False,
+    }
+    predicate = None
+    for kw, p in con_predicates:
+        predicate = p or predicate
+        if "min_value" in kw:
+            if kw"min_value" > base"min_value":
+                base"exclude_min" = kw.get("exclude_min", False)
+                base"min_value" = kw"min_value"
+            elif kw"min_value" == base"min_value":
+                base"exclude_min" |= kw.get("exclude_min", False)
+        if "max_value" in kw:
+            if kw"max_value" < base"max_value":
+                base"exclude_max" = kw.get("exclude_max", False)
+                base"max_value" = kw"max_value"
+            elif kw"max_value" == base"max_value":
+                base"exclude_max" |= kw.get("exclude_max", False)
+
+    if not base"exclude_min":
+        del base"exclude_min"
+        if base"min_value" == -math.inf:
+            del base"min_value"
+    if not base"exclude_max":
+        del base"exclude_max"
+        if base"max_value" == math.inf:
+            del base"max_value"
+    return ConstructivePredicate(base, predicate)
+
+
+def numeric_bounds_from_ast(
+    tree: ast.AST, argname: str, fallback: ConstructivePredicate
+) -> ConstructivePredicate:
+    """Take an AST; return a ConstructivePredicate.
+
+    >>> lambda x: x >= 0
+    {"min_value": 0}, None
+    >>> lambda x: x < 10
+    {"max_value": 10, "exclude_max": True}, None
+    >>> lambda x: x >= y
+    {}, lambda x: x >= y
+
+    See also https://greentreesnakes.readthedocs.io/en/latest/
+    """
+    if isinstance(tree, ast.Compare):
+        ops = tree.ops
+        vals = tree.comparators
+        comparisons = (tree.left, ops0, vals0)
+        for i, (op, val) in enumerate(zip(ops1:, vals1:), start=1):
+            comparisons.append((valsi - 1, op, val))
+        bounds = 
+        for comp in comparisons:
+            try:
+                kwargs = comp_to_kwargs(*comp, argname=argname)
+                bounds.append(ConstructivePredicate(kwargs, None))
+            except ValueError:
+                bounds.append(fallback)
+        return merge_preds(*bounds)
+
+    if isinstance(tree, ast.BoolOp) and isinstance(tree.op, ast.And):
+        return merge_preds(
+            *(numeric_bounds_from_ast(node, argname, fallback) for node in tree.values)
+        )
+
+    return fallback
+
+
+def get_numeric_predicate_bounds(predicate: Predicate) -> ConstructivePredicate:
+    """Shared logic for understanding numeric bounds.
+
+    We then specialise this in the other functions below, to ensure that e.g.
+    all the values are representable in the types that we're planning to generate
+    so that the strategy validation doesn't complain.
+    """
+    unchanged = ConstructivePredicate.unchanged(predicate)
+    if (
+        isinstance(predicate, partial)
+        and len(predicate.args) == 1
+        and not predicate.keywords
+    ):
+        arg = predicate.args0
+        if (
+            (isinstance(arg, Decimal) and Decimal.is_snan(arg))
+            or not isinstance(arg, (int, float, Fraction, Decimal))
+            or math.isnan(arg)
+        ):
+            return unchanged
+        options = {
+            # We're talking about op(arg, x) - the reverse of our usual intuition!
+            operator.lt: {"min_value": arg, "exclude_min": True},  # lambda x: arg < x
+            operator.le: {"min_value": arg},  # lambda x: arg <= x
+            operator.eq: {"min_value": arg, "max_value": arg},  # lambda x: arg == x
+            operator.ge: {"max_value": arg},  # lambda x: arg >= x
+            operator.gt: {"max_value": arg, "exclude_max": True},  # lambda x: arg > x
+        }
+        if predicate.func in options:
+            return ConstructivePredicate(optionspredicate.func, None)
+
+    # This section is a little complicated, but stepping through with comments should
+    # help to clarify it.  We start by finding the source code for our predicate and
+    # parsing it to an abstract syntax tree; if this fails for any reason we bail out
+    # and fall back to standard rejection sampling (a running theme).
+    try:
+        if predicate.__name__ == "<lambda>":
+            source = extract_lambda_source(predicate)
+        else:
+            source = inspect.getsource(predicate)
+        tree: ast.AST = ast.parse(source)
+    except Exception:
+        return unchanged
+
+    # Dig down to the relevant subtree - our tree is probably a Module containing
+    # either a FunctionDef, or an Expr which in turn contains a lambda definition.
+    while isinstance(tree, ast.Module) and len(tree.body) == 1:
+        tree = tree.body0
+    while isinstance(tree, ast.Expr):
+        tree = tree.value
+
+    if isinstance(tree, ast.Lambda) and len(tree.args.args) == 1:
+        return numeric_bounds_from_ast(tree.body, tree.args.args0.arg, unchanged)
+    elif isinstance(tree, ast.FunctionDef) and len(tree.args.args) == 1:
+        if len(tree.body) != 1 or not isinstance(tree.body0, ast.Return):
+            # If the body of the function is anything but `return <expr>`,
+            # i.e. as simple as a lambda, we can't process it (yet).
+            return unchanged
+        argname = tree.args.args0.arg
+        body = tree.body0.value
+        assert isinstance(body, ast.AST)
+        return numeric_bounds_from_ast(body, argname, unchanged)
+    return unchanged
+
+
+def get_integer_predicate_bounds(predicate: Predicate) -> ConstructivePredicate:
+    kwargs, predicate = get_numeric_predicate_bounds(predicate)  # type: ignore
+
+    if "min_value" in kwargs:
+        if kwargs"min_value" == -math.inf:
+            del kwargs"min_value"
+        elif math.isinf(kwargs"min_value"):
+            return ConstructivePredicate({"min_value": 1, "max_value": -1}, None)
+        elif kwargs"min_value" != int(kwargs"min_value"):
+            kwargs"min_value" = ceil(kwargs"min_value")
+        elif kwargs.get("exclude_min", False):
+            kwargs"min_value" = int(kwargs"min_value") + 1
+
+    if "max_value" in kwargs:
+        if kwargs"max_value" == math.inf:
+            del kwargs"max_value"
+        elif math.isinf(kwargs"max_value"):
+            return ConstructivePredicate({"min_value": 1, "max_value": -1}, None)
+        elif kwargs"max_value" != int(kwargs"max_value"):
+            kwargs"max_value" = floor(kwargs"max_value")
+        elif kwargs.get("exclude_max", False):
+            kwargs"max_value" = int(kwargs"max_value") - 1
+
+    kwargs = {k: v for k, v in kwargs.items() if k in {"min_value", "max_value"}}
+    return ConstructivePredicate(kwargs, predicate)
+
+
+def get_float_predicate_bounds(predicate: Predicate) -> ConstructivePredicate:
+    kwargs, predicate = get_numeric_predicate_bounds(predicate)  # type: ignore
+
+    if "min_value" in kwargs:
+        min_value = kwargs"min_value"
+        kwargs"min_value" = float(kwargs"min_value")
+        if min_value < kwargs"min_value" or (
+            min_value == kwargs"min_value" and kwargs.get("exclude_min", False)
+        ):
+            kwargs"min_value" = next_up(kwargs"min_value")
+
+    if "max_value" in kwargs:
+        max_value = kwargs"max_value"
+        kwargs"max_value" = float(kwargs"max_value")
+        if max_value > kwargs"max_value" or (
+            max_value == kwargs"max_value" and kwargs.get("exclude_max", False)
+        ):
+            kwargs"max_value" = next_down(kwargs"max_value")
+
+    kwargs = {k: v for k, v in kwargs.items() if k in {"min_value", "max_value"}}
+    return ConstructivePredicate(kwargs, predicate)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/floats.py Added

@@ -0,0 +1,150 @@
+# 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 math
+import struct
+from sys import float_info
+from typing import Callable, Optional, SupportsFloat
+
+# Format codes for (int, float) sized types, used for byte-wise casts.
+# See https://docs.python.org/3/library/struct.html#format-characters
+STRUCT_FORMATS = {
+    16: ("!H", "!e"),
+    32: ("!I", "!f"),
+    64: ("!Q", "!d"),
+}
+
+
+def reinterpret_bits(x, from_, to):
+    return struct.unpack(to, struct.pack(from_, x))0
+
+
+def float_of(x, width):
+    assert width in (16, 32, 64)
+    if width == 64:
+        return float(x)
+    elif width == 32:
+        return reinterpret_bits(float(x), "!f", "!f")
+    else:
+        return reinterpret_bits(float(x), "!e", "!e")
+
+
+def is_negative(x: SupportsFloat) -> bool:
+    try:
+        return math.copysign(1.0, x) < 0
+    except TypeError:
+        raise TypeError(
+            f"Expected float but got {x!r} of type {type(x).__name__}"
+        ) from None
+
+
+def count_between_floats(x, y, width=64):
+    assert x <= y
+    if is_negative(x):
+        if is_negative(y):
+            return float_to_int(x, width) - float_to_int(y, width) + 1
+        else:
+            return count_between_floats(x, -0.0, width) + count_between_floats(
+                0.0, y, width
+            )
+    else:
+        assert not is_negative(y)
+        return float_to_int(y, width) - float_to_int(x, width) + 1
+
+
+def float_to_int(value, width=64):
+    fmt_int, fmt_flt = STRUCT_FORMATSwidth
+    return reinterpret_bits(value, fmt_flt, fmt_int)
+
+
+def int_to_float(value, width=64):
+    fmt_int, fmt_flt = STRUCT_FORMATSwidth
+    return reinterpret_bits(value, fmt_int, fmt_flt)
+
+
+def next_up(value, width=64):
+    """Return the first float larger than finite `val` - IEEE 754's `nextUp`.
+
+    From https://stackoverflow.com/a/10426033, with thanks to Mark Dickinson.
+    """
+    assert isinstance(value, float), f"{value!r} of type {type(value)}"
+    if math.isnan(value) or (math.isinf(value) and value > 0):
+        return value
+    if value == 0.0 and is_negative(value):
+        return 0.0
+    fmt_int, fmt_flt = STRUCT_FORMATSwidth
+    # Note: n is signed; float_to_int returns unsigned
+    fmt_int = fmt_int.lower()
+    n = reinterpret_bits(value, fmt_flt, fmt_int)
+    if n >= 0:
+        n += 1
+    else:
+        n -= 1
+    return reinterpret_bits(n, fmt_int, fmt_flt)
+
+
+def next_down(value, width=64):
+    return -next_up(-value, width)
+
+
+def next_down_normal(value, width, allow_subnormal):
+    value = next_down(value, width)
+    if (not allow_subnormal) and 0 < abs(value) < width_smallest_normalswidth:
+        return 0.0 if value > 0 else -width_smallest_normalswidth
+    return value
+
+
+def next_up_normal(value, width, allow_subnormal):
+    return -next_down_normal(-value, width, allow_subnormal)
+
+
+# Smallest positive non-zero numbers that is fully representable by an
+# IEEE-754 float, calculated with the width's associated minimum exponent.
+# Values from https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats
+width_smallest_normals = {
+    16: 2 ** -(2 ** (5 - 1) - 2),
+    32: 2 ** -(2 ** (8 - 1) - 2),
+    64: 2 ** -(2 ** (11 - 1) - 2),
+}
+assert width_smallest_normals64 == float_info.min
+
+
+def make_float_clamper(
+    min_float: float = 0.0,
+    max_float: float = math.inf,
+    allow_zero: bool = False,  # Allows +0.0 (even if minfloat > 0)
+) -> OptionalCallablefloat, float:
+    """
+    Return a function that clamps positive floats into the given bounds.
+
+    Returns None when no values are allowed (min > max and zero is not allowed).
+    """
+    if max_float < min_float:
+        if allow_zero:
+            min_float = max_float = 0.0
+        else:
+            return None
+
+    range_size = min(max_float - min_float, float_info.max)
+    mantissa_mask = (1 << 52) - 1
+
+    def float_clamper(float_val: float) -> float:
+        if min_float <= float_val <= max_float:
+            return float_val
+        if float_val == 0.0 and allow_zero:
+            return float_val
+        # Outside bounds; pick a new value, sampled from the allowed range,
+        # using the mantissa bits.
+        mant = float_to_int(float_val) & mantissa_mask
+        float_val = min_float + range_size * (mant / mantissa_mask)
+        # Re-enforce the bounds (just in case of floating point arithmetic error)
+        return max(min_float, min(max_float, float_val))
+
+    return float_clamper

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/healthcheck.py Added

@@ -0,0 +1,27 @@
+# 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/.
+
+from hypothesis.errors import FailedHealthCheck
+
+
+def fail_health_check(settings, message, label):
+    # Tell pytest to omit the body of this function from tracebacks
+    # https://docs.pytest.org/en/latest/example/simple.html#writing-well-integrated-assertion-helpers
+    __tracebackhide__ = True
+
+    if label in settings.suppress_health_check:
+        return
+    message += (
+        "\nSee https://hypothesis.readthedocs.io/en/latest/health"
+        "checks.html for more information about this. "
+        f"If you want to disable just this health check, add {label} "
+        "to the suppress_health_check settings for this test."
+    )
+    raise FailedHealthCheck(message)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/intervalsets.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/lazyformat.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/reflection.py Added

@@ -0,0 +1,638 @@
+# 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/.
+
+"""This file can approximately be considered the collection of hypothesis going
+to really unreasonable lengths to produce pretty output."""
+
+import ast
+import hashlib
+import inspect
+import os
+import re
+import sys
+import textwrap
+import types
+from functools import wraps
+from io import StringIO
+from keyword import iskeyword
+from tokenize import COMMENT, detect_encoding, generate_tokens, untokenize
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Callable
+from unittest.mock import _patch as PatchType
+
+from hypothesis.internal.compat import PYPY, is_typed_named_tuple, update_code_location
+from hypothesis.utils.conventions import not_set
+from hypothesis.vendor.pretty import pretty
+
+if TYPE_CHECKING:
+    from hypothesis.strategies._internal.strategies import T
+
+READTHEDOCS = os.environ.get("READTHEDOCS", None) == "True"
+
+
+def is_mock(obj):
+    """Determine if the given argument is a mock type."""
+
+    # We want to be able to detect these when dealing with various test
+    # args. As they are sneaky and can look like almost anything else,
+    # we'll check this by looking for an attribute with a name that it's really
+    # unlikely to implement accidentally, and that anyone who implements it
+    # deliberately should know what they're doing. This is more robust than
+    # looking for types.
+    return hasattr(obj, "hypothesis_internal_is_this_a_mock_check")
+
+
+def _clean_source(src: str) -> bytes:
+    """Return the source code as bytes, without decorators or comments.
+
+    Because this is part of our database key, we reduce the cache invalidation
+    rate by ignoring decorators, comments, trailing whitespace, and empty lines.
+    We can't just use the (dumped) AST directly because it changes between Python
+    versions (e.g. ast.Constant)
+    """
+    # Get the (one-indexed) line number of the function definition, and drop preceding
+    # lines - i.e. any decorators, so that adding `@example()`s keeps the same key.
+    try:
+        funcdef = ast.parse(src).body0
+        if sys.version_info:2 == (3, 7) or (sys.version_info:2 == (3, 8) and PYPY):
+            # We can't get a line number of the (async) def here, so as a best-effort
+            # approximation we'll use str.split instead and hope for the best.
+            tag = "async def " if isinstance(funcdef, ast.AsyncFunctionDef) else "def "
+            if tag in src:
+                src = tag + src.split(tag, maxsplit=1)1
+        else:
+            src = "".join(src.splitlines(keepends=True)funcdef.lineno - 1 :)
+    except Exception:
+        pass
+    # Remove blank lines and use the tokenize module to strip out comments,
+    # so that those can be changed without changing the database key.
+    try:
+        src = untokenize(
+            t for t in generate_tokens(StringIO(src).readline) if t.type != COMMENT
+        )
+    except Exception:
+        pass
+    # Finally, remove any trailing whitespace and empty lines as a last cleanup.
+    return "\n".join(x.rstrip() for x in src.splitlines() if x.rstrip()).encode()
+
+
+def function_digest(function):
+    """Returns a string that is stable across multiple invocations across
+    multiple processes and is prone to changing significantly in response to
+    minor changes to the function.
+
+    No guarantee of uniqueness though it usually will be.
+    """
+    hasher = hashlib.sha384()
+    try:
+        src = inspect.getsource(function)
+    except (OSError, TypeError):
+        # If we can't actually get the source code, try for the name as a fallback.
+        try:
+            hasher.update(function.__name__.encode())
+        except AttributeError:
+            pass
+    else:
+        hasher.update(_clean_source(src))
+    try:
+        # This is additional to the source code because it can include the effects
+        # of decorators, or of post-hoc assignment to the .__signature__ attribute.
+        hasher.update(repr(get_signature(function)).encode())
+    except Exception:
+        pass
+    try:
+        # We set this in order to distinguish e.g. @pytest.mark.parametrize cases.
+        hasher.update(function._hypothesis_internal_add_digest)
+    except AttributeError:
+        pass
+    return hasher.digest()
+
+
+def check_signature(sig: inspect.Signature) -> None:
+    # Backport from Python 3.11; see https://github.com/python/cpython/pull/92065
+    for p in sig.parameters.values():
+        if iskeyword(p.name) and p.kind is not p.POSITIONAL_ONLY:
+            raise ValueError(
+                f"Signature {sig!r} contains a parameter named {p.name!r}, "
+                f"but this is a SyntaxError because `{p.name}` is a keyword. "
+                "You, or a library you use, must have manually created an "
+                "invalid signature - this will be an error in Python 3.11+"
+            )
+
+
+def get_signature(
+    target: Any, *, follow_wrapped: bool = True, eval_str: bool = False
+) -> inspect.Signature:
+    # Special case for use of `@unittest.mock.patch` decorator, mimicking the
+    # behaviour of getfullargspec instead of reporting unusable arguments.
+    patches = getattr(target, "patchings", None)
+    if isinstance(patches, list) and all(isinstance(p, PatchType) for p in patches):
+        P = inspect.Parameter
+        return inspect.Signature(
+            P("args", P.VAR_POSITIONAL), P("keywargs", P.VAR_KEYWORD)
+        )
+
+    if isinstance(getattr(target, "__signature__", None), inspect.Signature):
+        # This special case covers unusual codegen like Pydantic models
+        sig = target.__signature__
+        check_signature(sig)
+        # And *this* much more complicated block ignores the `self` argument
+        # if that's been (incorrectly) included in the custom signature.
+        if sig.parameters and (inspect.isclass(target) or inspect.ismethod(target)):
+            selfy = next(iter(sig.parameters.values()))
+            if (
+                selfy.name == "self"
+                and selfy.default is inspect.Parameter.empty
+                and selfy.kind.name.startswith("POSITIONAL_")
+            ):
+                return sig.replace(
+                    parameters=v for k, v in sig.parameters.items() if k != "self"
+                )
+        return sig
+    if sys.version_info:2 <= (3, 8) and inspect.isclass(target):
+        # Workaround for subclasses of typing.Generic on Python <= 3.8
+        from hypothesis.strategies._internal.types import is_generic_type
+
+        if is_generic_type(target):
+            sig = inspect.signature(target.__init__)
+            check_signature(sig)
+            return sig.replace(
+                parameters=v for k, v in sig.parameters.items() if k != "self"
+            )
+    # eval_str is only supported by Python 3.10 and newer
+    if sys.version_info:2 >= (3, 10):
+        sig = inspect.signature(
+            target, follow_wrapped=follow_wrapped, eval_str=eval_str
+        )
+    else:
+        sig = inspect.signature(
+            target, follow_wrapped=follow_wrapped
+        )  # pragma: no cover
+    check_signature(sig)
+    return sig
+
+
+def arg_is_required(param):
+    return param.default is inspect.Parameter.empty and param.kind in (
+        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+        inspect.Parameter.KEYWORD_ONLY,
+    )
+
+
+def required_args(target, args=(), kwargs=()):
+    """Return a set of names of required args to target that were not supplied
+    in args or kwargs.
+
+    This is used in builds() to determine which arguments to attempt to
+    fill from type hints.  target may be any callable (including classes
+    and bound methods).  args and kwargs should be as they are passed to
+    builds() - that is, a tuple of values and a dict of names: values.
+    """
+    # We start with a workaround for NamedTuples, which don't have nice inits
+    if inspect.isclass(target) and is_typed_named_tuple(target):
+        provided = set(kwargs) | set(target._fields: len(args))
+        return set(target._fields) - provided
+    # Then we try to do the right thing with inspect.signature
+    try:
+        sig = get_signature(target)
+    except (ValueError, TypeError):
+        return set()
+    return {
+        name
+        for name, param in list(sig.parameters.items())len(args) :
+        if arg_is_required(param) and name not in kwargs
+    }
+
+
+def convert_keyword_arguments(function, args, kwargs):
+    """Returns a pair of a tuple and a dictionary which would be equivalent
+    passed as positional and keyword args to the function. Unless function has
+    kwonlyargs or **kwargs the dictionary will always be empty.
+    """
+    sig = inspect.signature(function, follow_wrapped=False)
+    bound = sig.bind(*args, **kwargs)
+    return bound.args, bound.kwargs
+
+
+def convert_positional_arguments(function, args, kwargs):
+    """Return a tuple (new_args, new_kwargs) where all possible arguments have
+    been moved to kwargs.
+
+    new_args will only be non-empty if function has pos-only args or *args.
+    """
+    sig = inspect.signature(function, follow_wrapped=False)
+    bound = sig.bind(*args, **kwargs)
+    new_args = 
+    new_kwargs = dict(bound.arguments)
+    for p in sig.parameters.values():
+        if p.name in new_kwargs:
+            if p.kind is p.POSITIONAL_ONLY:
+                new_args.append(new_kwargs.pop(p.name))
+            elif p.kind is p.VAR_POSITIONAL:
+                new_args.extend(new_kwargs.pop(p.name))
+            elif p.kind is p.VAR_KEYWORD:
+                assert set(new_kwargsp.name).isdisjoint(set(new_kwargs) - {p.name})
+                new_kwargs.update(new_kwargs.pop(p.name))
+    return tuple(new_args), new_kwargs
+
+
+def ast_arguments_matches_signature(args, sig):
+    assert isinstance(args, ast.arguments)
+    assert isinstance(sig, inspect.Signature)
+    expected = 
+    for node in getattr(args, "posonlyargs", ()):  # New in Python 3.8
+        expected.append((node.arg, inspect.Parameter.POSITIONAL_ONLY))
+    for node in args.args:
+        expected.append((node.arg, inspect.Parameter.POSITIONAL_OR_KEYWORD))
+    if args.vararg is not None:
+        expected.append((args.vararg.arg, inspect.Parameter.VAR_POSITIONAL))
+    for node in args.kwonlyargs:
+        expected.append((node.arg, inspect.Parameter.KEYWORD_ONLY))
+    if args.kwarg is not None:
+        expected.append((args.kwarg.arg, inspect.Parameter.VAR_KEYWORD))
+    return expected == (p.name, p.kind) for p in sig.parameters.values()
+
+
+def is_first_param_referenced_in_function(f):
+    """Is the given name referenced within f?"""
+    try:
+        tree = ast.parse(textwrap.dedent(inspect.getsource(f)))
+    except Exception:
+        return True  # Assume it's OK unless we know otherwise
+    name = list(get_signature(f).parameters)0
+    return any(
+        isinstance(node, ast.Name)
+        and node.id == name
+        and isinstance(node.ctx, ast.Load)
+        for node in ast.walk(tree)
+    )
+
+
+def extract_all_lambdas(tree, matching_signature):
+    lambdas = 
+
+    class Visitor(ast.NodeVisitor):
+        def visit_Lambda(self, node):
+            if ast_arguments_matches_signature(node.args, matching_signature):
+                lambdas.append(node)
+
+    Visitor().visit(tree)
+
+    return lambdas
+
+
+LINE_CONTINUATION = re.compile(r"\\\n")
+WHITESPACE = re.compile(r"\s+")
+PROBABLY_A_COMMENT = re.compile("""#^'"*$""")
+SPACE_FOLLOWS_OPEN_BRACKET = re.compile(r"$ ")
+SPACE_PRECEDES_CLOSE_BRACKET = re.compile(r" $")
+
+
+def extract_lambda_source(f):
+    """Extracts a single lambda expression from the string source. Returns a
+    string indicating an unknown body if it gets confused in any way.
+
+    This is not a good function and I am sorry for it. Forgive me my
+    sins, oh lord
+    """
+    sig = inspect.signature(f)
+    assert sig.return_annotation is inspect.Parameter.empty
+    if sig.parameters:
+        if_confused = f"lambda {str(sig)1:-1}: <unknown>"
+    else:
+        if_confused = "lambda: <unknown>"
+    try:
+        source = inspect.getsource(f)
+    except OSError:
+        return if_confused
+
+    source = LINE_CONTINUATION.sub(" ", source)
+    source = WHITESPACE.sub(" ", source)
+    source = source.strip()
+    if "lambda" not in source and sys.platform == "emscripten":  # pragma: no cover
+        return if_confused  # work around Pyodide bug in inspect.getsource()
+    assert "lambda" in source
+
+    tree = None
+
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        for i in range(len(source) - 1, len("lambda"), -1):
+            prefix = source:i
+            if "lambda" not in prefix:
+                break
+            try:
+                tree = ast.parse(prefix)
+                source = prefix
+                break
+            except SyntaxError:
+                continue
+    if tree is None and source.startswith("@"):
+        # This will always eventually find a valid expression because
+        # the decorator must be a valid Python function call, so will
+        # eventually be syntactically valid and break out of the loop.
+        # Thus, this loop can never terminate normally.
+        for i in range(len(source) + 1):
+            p = source1:i
+            if "lambda" in p:
+                try:
+                    tree = ast.parse(p)
+                    source = p
+                    break
+                except SyntaxError:
+                    pass
+        else:
+            raise NotImplementedError("expected to be unreachable")
+
+    if tree is None:
+        return if_confused
+
+    aligned_lambdas = extract_all_lambdas(tree, matching_signature=sig)
+    if len(aligned_lambdas) != 1:
+        return if_confused
+    lambda_ast = aligned_lambdas0
+    assert lambda_ast.lineno == 1
+
+    # If the source code contains Unicode characters, the bytes of the original
+    # file don't line up with the string indexes, and `col_offset` doesn't match
+    # the string we're using.  We need to convert the source code into bytes
+    # before slicing.
+    #
+    # Under the hood, the inspect module is using `tokenize.detect_encoding` to
+    # detect the encoding of the original source file.  We'll use the same
+    # approach to get the source code as bytes.
+    #
+    # See https://github.com/HypothesisWorks/hypothesis/issues/1700 for an
+    # example of what happens if you don't correct for this.
+    #
+    # Note: if the code doesn't come from a file (but, for example, a doctest),
+    # `getsourcefile` will return `None` and the `open()` call will fail with
+    # an OSError.  Or if `f` is a built-in function, in which case we get a
+    # TypeError.  In both cases, fall back to splitting the Unicode string.
+    # It's not perfect, but it's the best we can do.
+    try:
+        with open(inspect.getsourcefile(f), "rb") as src_f:
+            encoding, _ = detect_encoding(src_f.readline)
+
+        source_bytes = source.encode(encoding)
+        source_bytes = source_byteslambda_ast.col_offset :.strip()
+        source = source_bytes.decode(encoding)
+    except (OSError, TypeError):
+        source = sourcelambda_ast.col_offset :.strip()
+
+    # This ValueError can be thrown in Python 3 if:
+    #
+    #  - There's a Unicode character in the line before the Lambda, and
+    #  - For some reason we can't detect the source encoding of the file
+    #
+    # because slicing on `lambda_ast.col_offset` will account for bytes, but
+    # the slice will be on Unicode characters.
+    #
+    # In practice this seems relatively rare, so we just give up rather than
+    # trying to recover.
+    try:
+        source = sourcesource.index("lambda") :
+    except ValueError:
+        return if_confused
+
+    for i in range(len(source), len("lambda"), -1):  # pragma: no branch
+        try:
+            parsed = ast.parse(source:i)
+            assert len(parsed.body) == 1
+            assert parsed.body
+            if isinstance(parsed.body0.value, ast.Lambda):
+                source = source:i
+                break
+        except SyntaxError:
+            pass
+    lines = source.split("\n")
+    lines = PROBABLY_A_COMMENT.sub("", l) for l in lines
+    source = "\n".join(lines)
+
+    source = WHITESPACE.sub(" ", source)
+    source = SPACE_FOLLOWS_OPEN_BRACKET.sub("(", source)
+    source = SPACE_PRECEDES_CLOSE_BRACKET.sub(")", source)
+    source = source.strip()
+    return source
+
+
+def get_pretty_function_description(f):
+    if not hasattr(f, "__name__"):
+        return repr(f)
+    name = f.__name__
+    if name == "<lambda>":
+        return extract_lambda_source(f)
+    elif isinstance(f, (types.MethodType, types.BuiltinMethodType)):
+        self = f.__self__
+        # Some objects, like `builtins.abs` are of BuiltinMethodType but have
+        # their module as __self__.  This might include c-extensions generally?
+        if not (self is None or inspect.isclass(self) or inspect.ismodule(self)):
+            return f"{self!r}.{name}"
+    elif isinstance(name, str) and getattr(dict, name, object()) is f:
+        # special case for keys/values views in from_type() / ghostwriter output
+        return f"dict.{name}"
+    return name
+
+
+def nicerepr(v):
+    if inspect.isfunction(v):
+        return get_pretty_function_description(v)
+    elif isinstance(v, type):
+        return v.__name__
+    else:
+        # With TypeVar T, show ListT instead of TypeError on List~T
+        return re.sub(r"(\)~(A-Za-z*\)", r"\g<1>\g<2>", pretty(v))
+
+
+def repr_call(f, args, kwargs, reorder=True):
+    # Note: for multi-line pretty-printing, see RepresentationPrinter.repr_call()
+    if reorder:
+        args, kwargs = convert_positional_arguments(f, args, kwargs)
+
+    bits = nicerepr(x) for x in args
+
+    for p in get_signature(f).parameters.values():
+        if p.name in kwargs and not p.kind.name.startswith("VAR_"):
+            bits.append(f"{p.name}={nicerepr(kwargs.pop(p.name))}")
+    if kwargs:
+        for a in sorted(kwargs):
+            bits.append(f"{a}={nicerepr(kwargsa)}")
+
+    rep = nicerepr(f)
+    if rep.startswith("lambda") and ":" in rep:
+        rep = f"({rep})"
+    return rep + "(" + ", ".join(bits) + ")"
+
+
+def check_valid_identifier(identifier):
+    if not identifier.isidentifier():
+        raise ValueError(f"{identifier!r} is not a valid python identifier")
+
+
+eval_cache: dict = {}
+
+
+def source_exec_as_module(source):
+    try:
+        return eval_cachesource
+    except KeyError:
+        pass
+
+    hexdigest = hashlib.sha384(source.encode()).hexdigest()
+    result = ModuleType("hypothesis_temporary_module_" + hexdigest)
+    assert isinstance(source, str)
+    exec(source, result.__dict__)
+    eval_cachesource = result
+    return result
+
+
+COPY_SIGNATURE_SCRIPT = """
+from hypothesis.utils.conventions import not_set
+
+def accept({funcname}):
+    def {name}{signature}:
+        return {funcname}({invocation})
+    return {name}
+""".lstrip()
+
+
+def get_varargs(sig, kind=inspect.Parameter.VAR_POSITIONAL):
+    for p in sig.parameters.values():
+        if p.kind is kind:
+            return p
+    return None
+
+
+def define_function_signature(name, docstring, signature):
+    """A decorator which sets the name, signature and docstring of the function
+    passed into it."""
+    if name == "<lambda>":
+        name = "_lambda_"
+    check_valid_identifier(name)
+    for a in signature.parameters:
+        check_valid_identifier(a)
+
+    used_names = list(signature.parameters) + name
+
+    newsig = signature.replace(
+        parameters=
+            p if p.default is signature.empty else p.replace(default=not_set)
+            for p in (
+                p.replace(annotation=signature.empty)
+                for p in signature.parameters.values()
+            )
+        ,
+        return_annotation=signature.empty,
+    )
+
+    pos_args = 
+        p
+        for p in signature.parameters.values()
+        if p.kind.name.startswith("POSITIONAL_")
+    
+
+    def accept(f):
+        fsig = inspect.signature(f, follow_wrapped=False)
+        must_pass_as_kwargs = 
+        invocation_parts = 
+        for p in pos_args:
+            if p.name not in fsig.parameters and get_varargs(fsig) is None:
+                must_pass_as_kwargs.append(p.name)
+            else:
+                invocation_parts.append(p.name)
+        if get_varargs(signature) is not None:
+            invocation_parts.append("*" + get_varargs(signature).name)
+        for k in must_pass_as_kwargs:
+            invocation_parts.append(f"{k}={k}")
+        for p in signature.parameters.values():
+            if p.kind is p.KEYWORD_ONLY:
+                invocation_parts.append(f"{p.name}={p.name}")
+        varkw = get_varargs(signature, kind=inspect.Parameter.VAR_KEYWORD)
+        if varkw:
+            invocation_parts.append("**" + varkw.name)
+
+        candidate_names = "f" + f"f_{i}" for i in range(1, len(used_names) + 2)
+
+        for funcname in candidate_names:  # pragma: no branch
+            if funcname not in used_names:
+                break
+
+        source = COPY_SIGNATURE_SCRIPT.format(
+            name=name,
+            funcname=funcname,
+            signature=str(newsig),
+            invocation=", ".join(invocation_parts),
+        )
+        result = source_exec_as_module(source).accept(f)
+        result.__doc__ = docstring
+        result.__defaults__ = tuple(
+            p.default
+            for p in signature.parameters.values()
+            if p.default is not signature.empty and "POSITIONAL" in p.kind.name
+        )
+        kwdefaults = {
+            p.name: p.default
+            for p in signature.parameters.values()
+            if p.default is not signature.empty and p.kind is p.KEYWORD_ONLY
+        }
+        if kwdefaults:
+            result.__kwdefaults__ = kwdefaults
+        annotations = {
+            p.name: p.annotation
+            for p in signature.parameters.values()
+            if p.annotation is not signature.empty
+        }
+        if signature.return_annotation is not signature.empty:
+            annotations"return" = signature.return_annotation
+        if annotations:
+            result.__annotations__ = annotations
+        return result
+
+    return accept
+
+
+def impersonate(target):
+    """Decorator to update the attributes of a function so that to external
+    introspectors it will appear to be the target function.
+
+    Note that this updates the function in place, it doesn't return a
+    new one.
+    """
+
+    def accept(f):
+        f.__code__ = update_code_location(
+            f.__code__, target.__code__.co_filename, target.__code__.co_firstlineno
+        )
+        f.__name__ = target.__name__
+        f.__module__ = target.__module__
+        f.__doc__ = target.__doc__
+        f.__globals__"__hypothesistracebackhide__" = True
+        return f
+
+    return accept
+
+
+def proxies(target: "T") -> CallableCallable, "T":
+    replace_sig = define_function_signature(
+        target.__name__.replace("<lambda>", "_lambda_"),  # type: ignore
+        target.__doc__,
+        get_signature(target, follow_wrapped=False),
+    )
+
+    def accept(proxy):
+        return impersonate(target)(wraps(target)(replace_sig(proxy)))
+
+    return accept
+
+
+def is_identity_function(f):
+    # TODO: pattern-match the AST to handle `def ...` identity functions too
+    return bool(re.fullmatch(r"lambda (\w+): \1", get_pretty_function_description(f)))

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/scrutineer.py Added

@@ -0,0 +1,138 @@
+# 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 sys
+from collections import defaultdict
+from functools import lru_cache, reduce
+from os import sep
+from pathlib import Path
+
+from hypothesis._settings import Phase, Verbosity
+from hypothesis.internal.escalation import is_hypothesis_file
+
+
+@lru_cache(maxsize=None)
+def should_trace_file(fname):
+    # fname.startswith("<") indicates runtime code-generation via compile,
+    # e.g. compile("def ...", "<string>", "exec") in e.g. attrs methods.
+    return not (is_hypothesis_file(fname) or fname.startswith("<"))
+
+
+class Tracer:
+    """A super-simple branch coverage tracer."""
+
+    __slots__ = ("branches", "_previous_location")
+
+    def __init__(self):
+        self.branches = set()
+        self._previous_location = None
+
+    def trace(self, frame, event, arg):
+        if event == "call":
+            return self.trace
+        elif event == "line":
+            fname = frame.f_code.co_filename
+            if should_trace_file(fname):
+                current_location = (fname, frame.f_lineno)
+                self.branches.add((self._previous_location, current_location))
+                self._previous_location = current_location
+
+
+UNHELPFUL_LOCATIONS = (
+    # There's a branch which is only taken when an exception is active while exiting
+    # a contextmanager; this is probably after the fault has been triggered.
+    # Similar reasoning applies to a few other standard-library modules: even
+    # if the fault was later, these still aren't useful locations to report!
+    f"{sep}contextlib.py",
+    f"{sep}inspect.py",
+    f"{sep}re.py",
+    f"{sep}re{sep}__init__.py",  # refactored in Python 3.11
+    f"{sep}warnings.py",
+    # Quite rarely, the first AFNP line is in Pytest's internals.
+    f"{sep}_pytest{sep}assertion{sep}rewrite.py",
+    f"{sep}_pytest{sep}_io{sep}saferepr.py",
+)
+
+
+def get_explaining_locations(traces):
+    # Traces is a dictinteresting_origin | None, setfrozensettuplestr, int
+    # Each trace in the set might later become a Counter instead of frozenset.
+    if not traces:
+        return {}
+
+    unions = {origin: set().union(*values) for origin, values in traces.items()}
+    seen_passing = {None}.union(*unions.pop(None, set()))
+
+    always_failing_never_passing = {
+        origin: reduce(set.intersection, set().union(*v) for v in values)
+        - seen_passing
+        for origin, values in traces.items()
+        if origin is not None
+    }
+
+    # Build the observed parts of the control-flow graph for each origin
+    cf_graphs = {origin: defaultdict(set) for origin in unions}
+    for origin, seen_arcs in unions.items():
+        for src, dst in seen_arcs:
+            cf_graphsoriginsrc.add(dst)
+        assert cf_graphsoriginNone, "Expected start node with >=1 successor"
+
+    # For each origin, our explanation is the always_failing_never_passing lines
+    # which are reachable from the start node (None) without passing through another
+    # AFNP line.  So here's a whatever-first search with early stopping:
+    explanations = defaultdict(set)
+    for origin in unions:
+        queue = {None}
+        seen = set()
+        while queue:
+            assert queue.isdisjoint(seen), f"Intersection: {queue & seen}"
+            src = queue.pop()
+            seen.add(src)
+            if src in always_failing_never_passingorigin:
+                explanationsorigin.add(src)
+            else:
+                queue.update(cf_graphsoriginsrc - seen)
+
+    # The last step is to filter out explanations that we know would be uninformative.
+    # When this is the first AFNP location, we conclude that Scrutineer missed the
+    # real divergence (earlier in the trace) and drop that unhelpful explanation.
+    return {
+        origin: {loc for loc in afnp_locs if not loc0.endswith(UNHELPFUL_LOCATIONS)}
+        for origin, afnp_locs in explanations.items()
+    }
+
+
+LIB_DIR = str(Path(sys.executable).parent / "lib")
+EXPLANATION_STUB = (
+    "Explanation:",
+    "    These lines were always and only run by failing examples:",
+)
+
+
+def make_report(explanations, cap_lines_at=5):
+    report = defaultdict(list)
+    for origin, locations in explanations.items():
+        report_lines = f"        {fname}:{lineno}" for fname, lineno in locations
+        report_lines.sort(key=lambda line: (line.startswith(LIB_DIR), line))
+        if len(report_lines) > cap_lines_at + 1:
+            msg = "        (and {} more with settings.verbosity >= verbose)"
+            report_linescap_lines_at: = msg.format(len(report_linescap_lines_at:))
+        if report_lines:  # We might have filtered out every location as uninformative.
+            reportorigin = list(EXPLANATION_STUB) + report_lines
+    return report
+
+
+def explanatory_lines(traces, settings):
+    if Phase.explain in settings.phases and sys.gettrace() and not traces:
+        return defaultdict(list)
+    # Return human-readable report lines summarising the traces
+    explanations = get_explaining_locations(traces)
+    max_lines = 5 if settings.verbosity <= Verbosity.normal else float("inf")
+    return make_report(explanations, cap_lines_at=max_lines)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/internal/validation.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/provisional.py Added

@@ -0,0 +1,180 @@
+# 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/.
+
+"""This module contains various provisional APIs and strategies.
+
+It is intended for internal use, to ease code reuse, and is not stable.
+Point releases may move or break the contents at any time!
+
+Internet strategies should conform to :rfc:`3986` or the authoritative
+definitions it links to.  If not, report the bug!
+"""
+# https://tools.ietf.org/html/rfc3696
+
+import string
+from importlib import resources
+
+from hypothesis import strategies as st
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.strategies._internal.utils import defines_strategy
+
+URL_SAFE_CHARACTERS = frozenset(string.ascii_letters + string.digits + "$-_.+!*'(),~")
+FRAGMENT_SAFE_CHARACTERS = URL_SAFE_CHARACTERS | {"?", "/"}
+
+
+# This file is sourced from http://data.iana.org/TLD/tlds-alpha-by-domain.txt
+# The file contains additional information about the date that it was last updated.
+try:  # pragma: no cover
+    traversable = resources.files("hypothesis.vendor") / "tlds-alpha-by-domain.txt"
+    _comment, *_tlds = traversable.read_text(encoding="utf-8").splitlines()
+except (AttributeError, ValueError):  # pragma: no cover  # .files() was added in 3.9
+    _comment, *_tlds = resources.read_text(
+        "hypothesis.vendor", "tlds-alpha-by-domain.txt", encoding="utf-8"
+    ).splitlines()
+assert _comment.startswith("#")
+
+# Remove special-use domain names from the list. For more discussion
+# see https://github.com/HypothesisWorks/hypothesis/pull/3572
+TOP_LEVEL_DOMAINS = "COM" + sorted((d for d in _tlds if d != "ARPA"), key=len)
+
+
+class DomainNameStrategy(st.SearchStrategy):
+    @staticmethod
+    def clean_inputs(minimum, maximum, value, variable_name):
+        if value is None:
+            value = maximum
+        elif not isinstance(value, int):
+            raise InvalidArgument(
+                f"Expected integer but {variable_name} is a {type(value).__name__}"
+            )
+        elif not minimum <= value <= maximum:
+            raise InvalidArgument(
+                f"Invalid value {minimum!r} < {variable_name}={value!r} < {maximum!r}"
+            )
+        return value
+
+    def __init__(self, max_length=None, max_element_length=None):
+        """
+        A strategy for :rfc:`1035` fully qualified domain names.
+
+        The upper limit for max_length is 255 in accordance with :rfc:`1035#section-2.3.4`
+        The lower limit for max_length is 4, corresponding to a two letter domain
+        with a single letter subdomain.
+        The upper limit for max_element_length is 63 in accordance with :rfc:`1035#section-2.3.4`
+        The lower limit for max_element_length is 1 in accordance with :rfc:`1035#section-2.3.4`
+        """
+        # https://tools.ietf.org/html/rfc1035#section-2.3.4
+
+        max_length = self.clean_inputs(4, 255, max_length, "max_length")
+        max_element_length = self.clean_inputs(
+            1, 63, max_element_length, "max_element_length"
+        )
+
+        super().__init__()
+        self.max_length = max_length
+        self.max_element_length = max_element_length
+
+        # These regular expressions are constructed to match the documented
+        # information in https://tools.ietf.org/html/rfc1035#section-2.3.1
+        # which defines the allowed syntax of a subdomain string.
+        if self.max_element_length == 1:
+            self.label_regex = r"a-zA-Z"
+        elif self.max_element_length == 2:
+            self.label_regex = r"a-zA-Za-zA-Z0-9?"
+        else:
+            maximum_center_character_pattern_repetitions = self.max_element_length - 2
+            self.label_regex = r"a-zA-Z(a-zA-Z0-9\-{0,%d}a-zA-Z0-9)?" % (
+                maximum_center_character_pattern_repetitions,
+            )
+
+    def do_draw(self, data):
+        # 1 - Select a valid top-level domain (TLD) name
+        # 2 - Check that the number of characters in our selected TLD won't
+        # prevent us from generating at least a 1 character subdomain.
+        # 3 - Randomize the TLD between upper and lower case characters.
+        domain = data.draw(
+            st.sampled_from(TOP_LEVEL_DOMAINS)
+            .filter(lambda tld: len(tld) + 2 <= self.max_length)
+            .flatmap(
+                lambda tld: st.tuples(
+                    *(st.sampled_from(c.lower(), c.upper()) for c in tld)
+                ).map("".join)
+            )
+        )
+        # RFC-5890 s2.3.1 says such labels are reserved, and since we don't
+        # want to bother with xn-- punycode labels we'll exclude them all.
+        elem_st = st.from_regex(self.label_regex, fullmatch=True).filter(
+            lambda label: len(label) < 4 or label2:4 != "--"
+        )
+        # The maximum possible number of subdomains is 126,
+        # 1 character subdomain + 1 '.' character, * 126 = 252,
+        # with a max of 255, that leaves 3 characters for a TLD.
+        # Allowing any more subdomains would not leave enough
+        # characters for even the shortest possible TLDs.
+        elements = cu.many(data, min_size=1, average_size=3, max_size=126)
+        while elements.more():
+            # Generate a new valid subdomain using the regex strategy.
+            sub_domain = data.draw(elem_st)
+            if len(domain) + len(sub_domain) >= self.max_length:
+                data.stop_example(discard=True)
+                break
+            domain = sub_domain + "." + domain
+        return domain
+
+
+@defines_strategy(force_reusable_values=True)
+def domains(
+    *, max_length: int = 255, max_element_length: int = 63
+) -> st.SearchStrategystr:
+    """Generate :rfc:`1035` compliant fully qualified domain names."""
+    return DomainNameStrategy(
+        max_length=max_length, max_element_length=max_element_length
+    )
+
+
+# The `urls()` strategy uses this to generate URL fragments (e.g. "#foo").
+# It has been extracted to top-level so that we can test it independently
+# of `urls()`, which helps with getting non-flaky coverage of the lambda.
+_url_fragments_strategy = (
+    st.lists(
+        st.builds(
+            lambda char, encode: f"%{ord(char):02X}"
+            if (encode or char not in FRAGMENT_SAFE_CHARACTERS)
+            else char,
+            st.characters(min_codepoint=0, max_codepoint=255),
+            st.booleans(),
+        ),
+        min_size=1,
+    )
+    .map("".join)
+    .map("#{}".format)
+)
+
+
+@defines_strategy(force_reusable_values=True)
+def urls() -> st.SearchStrategystr:
+    """A strategy for :rfc:`3986`, generating http/https URLs."""
+
+    def url_encode(s):
+        return "".join(c if c in URL_SAFE_CHARACTERS else "%%%02X" % ord(c) for c in s)
+
+    schemes = st.sampled_from("http", "https")
+    ports = st.integers(min_value=0, max_value=2**16 - 1).map(":{}".format)
+    paths = st.lists(st.text(string.printable).map(url_encode)).map("/".join)
+
+    return st.builds(
+        "{}://{}{}/{}{}".format,
+        schemes,
+        domains(),
+        st.just("") | ports,
+        paths,
+        st.just("") | _url_fragments_strategy,
+    )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/py.typed Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/reporting.py Added

@@ -0,0 +1,64 @@
+# 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 inspect
+
+from hypothesis._settings import Verbosity, settings
+from hypothesis.internal.compat import escape_unicode_characters
+from hypothesis.utils.dynamicvariables import DynamicVariable
+
+
+def default(value):
+    try:
+        print(value)
+    except UnicodeEncodeError:
+        print(escape_unicode_characters(value))
+
+
+reporter = DynamicVariable(default)
+
+
+def current_reporter():
+    return reporter.value
+
+
+def with_reporter(new_reporter):
+    return reporter.with_value(new_reporter)
+
+
+def current_verbosity():
+    return settings.default.verbosity
+
+
+def to_text(textish):
+    if inspect.isfunction(textish):
+        textish = textish()
+    if isinstance(textish, bytes):
+        textish = textish.decode()
+    return textish
+
+
+def verbose_report(text):
+    if current_verbosity() >= Verbosity.verbose:
+        base_report(text)
+
+
+def debug_report(text):
+    if current_verbosity() >= Verbosity.debug:
+        base_report(text)
+
+
+def report(text):
+    if current_verbosity() >= Verbosity.normal:
+        base_report(text)
+
+
+def base_report(text):
+    current_reporter()(to_text(text))

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/stateful.py Added

@@ -0,0 +1,944 @@
+# 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/.
+
+"""This module provides support for a stateful style of testing, where tests
+attempt to find a sequence of operations that cause a breakage rather than just
+a single value.
+
+Notably, the set of steps available at any point may depend on the
+execution to date.
+"""
+
+import inspect
+from copy import copy
+from functools import lru_cache
+from io import StringIO
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Union,
+    overload,
+)
+from unittest import TestCase
+
+import attr
+
+from hypothesis import strategies as st
+from hypothesis._settings import (
+    HealthCheck,
+    Verbosity,
+    note_deprecation,
+    settings as Settings,
+)
+from hypothesis.control import _current_build_context, current_build_context
+from hypothesis.core import TestFunc, given
+from hypothesis.errors import InvalidArgument, InvalidDefinition
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.healthcheck import fail_health_check
+from hypothesis.internal.reflection import (
+    function_digest,
+    get_pretty_function_description,
+    nicerepr,
+    proxies,
+)
+from hypothesis.internal.validation import check_type
+from hypothesis.reporting import current_verbosity, report
+from hypothesis.strategies._internal.featureflags import FeatureStrategy
+from hypothesis.strategies._internal.strategies import (
+    Ex,
+    Ex_Inv,
+    OneOfStrategy,
+    SearchStrategy,
+    check_strategy,
+)
+from hypothesis.vendor.pretty import RepresentationPrinter
+
+STATE_MACHINE_RUN_LABEL = cu.calc_label_from_name("another state machine step")
+SHOULD_CONTINUE_LABEL = cu.calc_label_from_name("should we continue drawing")
+
+
+class _OmittedArgument:
+    """Sentinel class to prevent overlapping overloads in type hints. See comments
+    above the overloads of @rule."""
+
+
+class TestCaseProperty:  # pragma: no cover
+    def __get__(self, obj, typ=None):
+        if obj is not None:
+            typ = type(obj)
+        return typ._to_test_case()
+
+    def __set__(self, obj, value):
+        raise AttributeError("Cannot set TestCase")
+
+    def __delete__(self, obj):
+        raise AttributeError("Cannot delete TestCase")
+
+
+def run_state_machine_as_test(state_machine_factory, *, settings=None, _min_steps=0):
+    """Run a state machine definition as a test, either silently doing nothing
+    or printing a minimal breaking program and raising an exception.
+
+    state_machine_factory is anything which returns an instance of
+    RuleBasedStateMachine when called with no arguments - it can be a class or a
+    function. settings will be used to control the execution of the test.
+    """
+    if settings is None:
+        try:
+            settings = state_machine_factory.TestCase.settings
+            check_type(Settings, settings, "state_machine_factory.TestCase.settings")
+        except AttributeError:
+            settings = Settings(deadline=None, suppress_health_check=list(HealthCheck))
+    check_type(Settings, settings, "settings")
+    check_type(int, _min_steps, "_min_steps")
+    if _min_steps < 0:
+        # Because settings can vary via e.g. profiles, settings.stateful_step_count
+        # overrides this argument and we don't bother cross-validating.
+        raise InvalidArgument(f"_min_steps={_min_steps} must be non-negative.")
+
+    @settings
+    @given(st.data())
+    def run_state_machine(factory, data):
+        cd = data.conjecture_data
+        machine = factory()
+        check_type(RuleBasedStateMachine, machine, "state_machine_factory()")
+        cd.hypothesis_runner = machine
+
+        print_steps = (
+            current_build_context().is_final or current_verbosity() >= Verbosity.debug
+        )
+        try:
+            if print_steps:
+                report(f"state = {machine.__class__.__name__}()")
+            machine.check_invariants(settings)
+            max_steps = settings.stateful_step_count
+            steps_run = 0
+
+            while True:
+                # We basically always want to run the maximum number of steps,
+                # but need to leave a small probability of terminating early
+                # in order to allow for reducing the number of steps once we
+                # find a failing test case, so we stop with probability of
+                # 2 ** -16 during normal operation but force a stop when we've
+                # generated enough steps.
+                cd.start_example(STATE_MACHINE_RUN_LABEL)
+                must_stop = None
+                if steps_run >= max_steps:
+                    must_stop = True
+                elif steps_run <= _min_steps:
+                    must_stop = False
+                if cu.biased_coin(cd, 2**-16, forced=must_stop):
+                    break
+                steps_run += 1
+
+                # Choose a rule to run, preferring an initialize rule if there are
+                # any which have not been run yet.
+                if machine._initialize_rules_to_run:
+                    init_rules = 
+                        st.tuples(st.just(rule), st.fixed_dictionaries(rule.arguments))
+                        for rule in machine._initialize_rules_to_run
+                    
+                    rule, data = cd.draw(st.one_of(init_rules))
+                    machine._initialize_rules_to_run.remove(rule)
+                else:
+                    rule, data = cd.draw(machine._rules_strategy)
+
+                # Pretty-print the values this rule was called with *before* calling
+                # _add_result_to_targets, to avoid printing arguments which are also
+                # a return value using the variable name they are assigned to.
+                # See https://github.com/HypothesisWorks/hypothesis/issues/2341
+                if print_steps:
+                    data_to_print = {
+                        k: machine._pretty_print(v) for k, v in data.items()
+                    }
+
+                # Assign 'result' here in case executing the rule fails below
+                result = multiple()
+                try:
+                    data = dict(data)
+                    for k, v in list(data.items()):
+                        if isinstance(v, VarReference):
+                            datak = machine.names_to_valuesv.name
+                    result = rule.function(machine, **data)
+                    if rule.targets:
+                        if isinstance(result, MultipleResults):
+                            for single_result in result.values:
+                                machine._add_result_to_targets(
+                                    rule.targets, single_result
+                                )
+                        else:
+                            machine._add_result_to_targets(rule.targets, result)
+                    elif result is not None:
+                        fail_health_check(
+                            settings,
+                            "Rules should return None if they have no target bundle, "
+                            f"but {rule.function.__qualname__} returned {result!r}",
+                            HealthCheck.return_value,
+                        )
+                finally:
+                    if print_steps:
+                        # 'result' is only used if the step has target bundles.
+                        # If it does, and the result is a 'MultipleResult',
+                        # then 'print_step' prints a multi-variable assignment.
+                        machine._print_step(rule, data_to_print, result)
+                machine.check_invariants(settings)
+                cd.stop_example()
+        finally:
+            if print_steps:
+                report("state.teardown()")
+            machine.teardown()
+
+    # Use a machine digest to identify stateful tests in the example database
+    run_state_machine.hypothesis.inner_test._hypothesis_internal_add_digest = (
+        function_digest(state_machine_factory)
+    )
+    # Copy some attributes so @seed and @reproduce_failure "just work"
+    run_state_machine._hypothesis_internal_use_seed = getattr(
+        state_machine_factory, "_hypothesis_internal_use_seed", None
+    )
+    run_state_machine._hypothesis_internal_use_reproduce_failure = getattr(
+        state_machine_factory, "_hypothesis_internal_use_reproduce_failure", None
+    )
+    run_state_machine._hypothesis_internal_print_given_args = False
+
+    run_state_machine(state_machine_factory)
+
+
+class StateMachineMeta(type):
+    def __setattr__(cls, name, value):
+        if name == "settings" and isinstance(value, Settings):
+            raise AttributeError(
+                (
+                    "Assigning {cls}.settings = {value} does nothing. Assign "
+                    "to {cls}.TestCase.settings, or use @{value} as a decorator "
+                    "on the {cls} class."
+                ).format(cls=cls.__name__, value=value)
+            )
+        return super().__setattr__(name, value)
+
+
+class RuleBasedStateMachine(metaclass=StateMachineMeta):
+    """A RuleBasedStateMachine gives you a structured way to define state machines.
+
+    The idea is that a state machine carries a bunch of types of data
+    divided into Bundles, and has a set of rules which may read data
+    from bundles (or just from normal strategies) and push data onto
+    bundles. At any given point a random applicable rule will be
+    executed.
+    """
+
+    _rules_per_class: Dicttype, Listclassmethod = {}
+    _invariants_per_class: Dicttype, Listclassmethod = {}
+    _initializers_per_class: Dicttype, Listclassmethod = {}
+
+    def __init__(self) -> None:
+        if not self.rules():
+            raise InvalidDefinition(f"Type {type(self).__name__} defines no rules")
+        self.bundles: Dictstr, list = {}
+        self.name_counter = 1
+        self.names_to_values: Dictstr, Any = {}
+        self.__stream = StringIO()
+        self.__printer = RepresentationPrinter(
+            self.__stream, context=_current_build_context.value
+        )
+        self._initialize_rules_to_run = copy(self.initialize_rules())
+        self._rules_strategy = RuleStrategy(self)
+
+    def _pretty_print(self, value):
+        if isinstance(value, VarReference):
+            return value.name
+        self.__stream.seek(0)
+        self.__stream.truncate(0)
+        self.__printer.output_width = 0
+        self.__printer.buffer_width = 0
+        self.__printer.buffer.clear()
+        self.__printer.pretty(value)
+        self.__printer.flush()
+        return self.__stream.getvalue()
+
+    def __repr__(self):
+        return f"{type(self).__name__}({nicerepr(self.bundles)})"
+
+    def _new_name(self):
+        result = f"v{self.name_counter}"
+        self.name_counter += 1
+        return result
+
+    def _last_names(self, n):
+        assert self.name_counter > n
+        count = self.name_counter
+        return f"v{i}" for i in range(count - n, count)
+
+    def bundle(self, name):
+        return self.bundles.setdefault(name, )
+
+    @classmethod
+    def initialize_rules(cls):
+        try:
+            return cls._initializers_per_classcls
+        except KeyError:
+            pass
+
+        cls._initializers_per_classcls = 
+        for _, v in inspect.getmembers(cls):
+            r = getattr(v, INITIALIZE_RULE_MARKER, None)
+            if r is not None:
+                cls._initializers_per_classcls.append(r)
+        return cls._initializers_per_classcls
+
+    @classmethod
+    def rules(cls):
+        try:
+            return cls._rules_per_classcls
+        except KeyError:
+            pass
+
+        cls._rules_per_classcls = 
+        for _, v in inspect.getmembers(cls):
+            r = getattr(v, RULE_MARKER, None)
+            if r is not None:
+                cls._rules_per_classcls.append(r)
+        return cls._rules_per_classcls
+
+    @classmethod
+    def invariants(cls):
+        try:
+            return cls._invariants_per_classcls
+        except KeyError:
+            pass
+
+        target = 
+        for _, v in inspect.getmembers(cls):
+            i = getattr(v, INVARIANT_MARKER, None)
+            if i is not None:
+                target.append(i)
+        cls._invariants_per_classcls = target
+        return cls._invariants_per_classcls
+
+    def _print_step(self, rule, data, result):
+        self.step_count = getattr(self, "step_count", 0) + 1
+        output_assignment = ""
+        if rule.targets:
+            if isinstance(result, MultipleResults):
+                if len(result.values) == 1:
+                    output_assignment = f"({self._last_names(1)0},) = "
+                elif result.values:
+                    output_names = self._last_names(len(result.values))
+                    output_assignment = ", ".join(output_names) + " = "
+            else:
+                output_assignment = self._last_names(1)0 + " = "
+        report(
+            "{}state.{}({})".format(
+                output_assignment,
+                rule.function.__name__,
+                ", ".join("%s=%s" % kv for kv in data.items()),
+            )
+        )
+
+    def _add_result_to_targets(self, targets, result):
+        name = self._new_name()
+        self.__printer.singleton_pprinters.setdefault(
+            id(result), lambda obj, p, cycle: p.text(name)
+        )
+        self.names_to_valuesname = result
+        for target in targets:
+            self.bundles.setdefault(target, ).append(VarReference(name))
+
+    def check_invariants(self, settings):
+        for invar in self.invariants():
+            if self._initialize_rules_to_run and not invar.check_during_init:
+                continue
+            if not all(precond(self) for precond in invar.preconditions):
+                continue
+            if (
+                current_build_context().is_final
+                or settings.verbosity >= Verbosity.debug
+            ):
+                report(f"state.{invar.function.__name__}()")
+            result = invar.function(self)
+            if result is not None:
+                fail_health_check(
+                    settings,
+                    "The return value of an @invariant is always ignored, but "
+                    f"{invar.function.__qualname__} returned {result!r} "
+                    "instead of None",
+                    HealthCheck.return_value,
+                )
+
+    def teardown(self):
+        """Called after a run has finished executing to clean up any necessary
+        state.
+
+        Does nothing by default.
+        """
+
+    TestCase = TestCaseProperty()
+
+    @classmethod
+    @lru_cache()
+    def _to_test_case(cls):
+        class StateMachineTestCase(TestCase):
+            settings = Settings(deadline=None, suppress_health_check=list(HealthCheck))
+
+            def runTest(self):
+                run_state_machine_as_test(cls)
+
+            runTest.is_hypothesis_test = True
+
+        StateMachineTestCase.__name__ = cls.__name__ + ".TestCase"
+        StateMachineTestCase.__qualname__ = cls.__qualname__ + ".TestCase"
+        return StateMachineTestCase
+
+
+@attr.s()
+class Rule:
+    targets = attr.ib()
+    function = attr.ib(repr=get_pretty_function_description)
+    arguments = attr.ib()
+    preconditions = attr.ib()
+    bundles = attr.ib(init=False)
+
+    def __attrs_post_init__(self):
+        arguments = {}
+        bundles = 
+        for k, v in sorted(self.arguments.items()):
+            assert not isinstance(v, BundleReferenceStrategy)
+            if isinstance(v, Bundle):
+                bundles.append(v)
+                consume = isinstance(v, BundleConsumer)
+                argumentsk = BundleReferenceStrategy(v.name, consume)
+            else:
+                argumentsk = v
+        self.bundles = tuple(bundles)
+        self.arguments_strategy = st.fixed_dictionaries(arguments)
+
+
+self_strategy = st.runner()
+
+
+class BundleReferenceStrategy(SearchStrategy):
+    def __init__(self, name, consume=False):
+        self.name = name
+        self.consume = consume
+
+    def do_draw(self, data):
+        machine = data.draw(self_strategy)
+        bundle = machine.bundle(self.name)
+        if not bundle:
+            data.mark_invalid()
+        # Shrink towards the right rather than the left. This makes it easier
+        # to delete data generated earlier, as when the error is towards the
+        # end there can be a lot of hard to remove padding.
+        position = cu.integer_range(data, 0, len(bundle) - 1, center=len(bundle))
+        if self.consume:
+            return bundle.pop(position)
+        else:
+            return bundleposition
+
+
+class Bundle(SearchStrategyEx):
+    def __init__(self, name: str, consume: bool = False) -> None:
+        self.name = name
+        self.__reference_strategy = BundleReferenceStrategy(name, consume)
+
+    def do_draw(self, data):
+        machine = data.draw(self_strategy)
+        reference = data.draw(self.__reference_strategy)
+        return machine.names_to_valuesreference.name
+
+    def __repr__(self):
+        consume = self.__reference_strategy.consume
+        if consume is False:
+            return f"Bundle(name={self.name!r})"
+        return f"Bundle(name={self.name!r}, consume={consume!r})"
+
+    def calc_is_empty(self, recur):
+        # We assume that a bundle will grow over time
+        return False
+
+    def available(self, data):
+        # ``self_strategy`` is an instance of the ``st.runner()`` strategy.
+        # Hence drawing from it only returns the current state machine without
+        # modifying the underlying buffer.
+        machine = data.draw(self_strategy)
+        return bool(machine.bundle(self.name))
+
+
+class BundleConsumer(BundleEx):
+    def __init__(self, bundle: BundleEx) -> None:
+        super().__init__(bundle.name, consume=True)
+
+
+def consumes(bundle: BundleEx) -> SearchStrategyEx:
+    """When introducing a rule in a RuleBasedStateMachine, this function can
+    be used to mark bundles from which each value used in a step with the
+    given rule should be removed. This function returns a strategy object
+    that can be manipulated and combined like any other.
+
+    For example, a rule declared with
+
+    ``@rule(value1=b1, value2=consumes(b2), value3=lists(consumes(b3)))``
+
+    will consume a value from Bundle ``b2`` and several values from Bundle
+    ``b3`` to populate ``value2`` and ``value3`` each time it is executed.
+    """
+    if not isinstance(bundle, Bundle):
+        raise TypeError("Argument to be consumed must be a bundle.")
+    return BundleConsumer(bundle)
+
+
+@attr.s()
+class MultipleResults(IterableEx):
+    values = attr.ib()
+
+    def __iter__(self):
+        return iter(self.values)
+
+
+# We need to use an invariant typevar here to avoid a mypy error, as covariant
+# typevars cannot be used as parameters.
+def multiple(*args: Ex_Inv) -> MultipleResultsEx_Inv:
+    """This function can be used to pass multiple results to the target(s) of
+    a rule. Just use ``return multiple(result1, result2, ...)`` in your rule.
+
+    It is also possible to use ``return multiple()`` with no arguments in
+    order to end a rule without passing any result.
+    """
+    return MultipleResults(args)
+
+
+def _convert_targets(targets, target):
+    """Single validator and converter for target arguments."""
+    if target is not None:
+        if targets:
+            raise InvalidArgument(
+                "Passing both targets=%r and target=%r is redundant - pass "
+                "targets=%r instead." % (targets, target, tuple(targets) + (target,))
+            )
+        targets = (target,)
+
+    converted_targets = 
+    for t in targets:
+        if not isinstance(t, Bundle):
+            msg = "Got invalid target %r of type %r, but all targets must be Bundles."
+            if isinstance(t, OneOfStrategy):
+                msg += (
+                    "\nIt looks like you passed `one_of(a, b)` or `a | b` as "
+                    "a target.  You should instead pass `targets=(a, b)` to "
+                    "add the return value of this rule to both the `a` and "
+                    "`b` bundles, or define a rule for each target if it "
+                    "should be added to exactly one."
+                )
+            raise InvalidArgument(msg % (t, type(t)))
+        while isinstance(t, Bundle):
+            if isinstance(t, BundleConsumer):
+                note_deprecation(
+                    f"Using consumes({t.name}) doesn't makes sense in this context.  "
+                    "This will be an error in a future version of Hypothesis.",
+                    since="2021-09-08",
+                    has_codemod=False,
+                )
+            t = t.name
+        converted_targets.append(t)
+    return tuple(converted_targets)
+
+
+RULE_MARKER = "hypothesis_stateful_rule"
+INITIALIZE_RULE_MARKER = "hypothesis_stateful_initialize_rule"
+PRECONDITIONS_MARKER = "hypothesis_stateful_preconditions"
+INVARIANT_MARKER = "hypothesis_stateful_invariant"
+
+
+_RuleType = Callable..., UnionMultipleResultsEx, Ex
+_RuleWrapper = Callable_RuleTypeEx, _RuleTypeEx
+
+
+# We cannot exclude `target` or `targets` from any of these signatures because
+# otherwise they would be matched against the `kwargs`, either leading to
+# overlapping overloads of incompatible return types, or a concrete
+# implementation that does not accept all overloaded variant signatures.
+# Although it is possible to reorder the variants to fix the former, it will
+# always lead to the latter, as then the omitted parameter could be typed as
+# a `SearchStrategy`, which the concrete implementation does not accept.
+#
+# Omitted `targets` parameters, where the default value is used, are typed with
+# a special `_OmittedArgument` type. We cannot type them as `Tuple()`, because
+# `Tuple()` is a subtype of `SequenceBundleEx`, leading to signature
+# overlaps with incompatible return types. The `_OmittedArgument` type will never be
+# encountered at runtime, and exists solely to annotate the default of `targets`.
+# PEP 661 (Sentinel Values) might provide a more elegant alternative in the future.
+#
+# We could've also annotated `targets` as `Tuple_OmittedArgument`, but then when
+# both `target` and `targets` are provided, mypy describes the type error as an
+# invalid argument type for `targets` (expected `Tuple_OmittedArgument`, got ...).
+# By annotating it as a bare `_OmittedArgument` type, mypy's error will warn that
+# there is no overloaded signature matching the call, which is more descriptive.
+#
+# When `target` xor `targets` is provided, the function to decorate must return
+# a value whose type matches the one stored in the bundle. When neither are
+# provided, the function to decorate must return nothing. There is no variant
+# for providing `target` and `targets`, as these parameters are mutually exclusive.
+@overload
+def rule(
+    *,
+    targets: SequenceBundleEx,
+    target: None = ...,
+    **kwargs: SearchStrategy,
+) -> _RuleWrapperEx:  # pragma: no cover
+    ...
+
+
+@overload
+def rule(
+    *, target: BundleEx, targets: _OmittedArgument = ..., **kwargs: SearchStrategy
+) -> _RuleWrapperEx:  # pragma: no cover
+    ...
+
+
+@overload
+def rule(
+    *,
+    target: None = ...,
+    targets: _OmittedArgument = ...,
+    **kwargs: SearchStrategy,
+) -> CallableCallable..., None, Callable..., None:  # pragma: no cover
+    ...
+
+
+def rule(
+    *,
+    targets: UnionSequenceBundleEx, _OmittedArgument = (),
+    target: OptionalBundleEx = None,
+    **kwargs: SearchStrategy,
+) -> Union_RuleWrapperEx, CallableCallable..., None, Callable..., None:
+    """Decorator for RuleBasedStateMachine. Any Bundle present in ``target`` or
+    ``targets`` will define where the end result of this function should go. If
+    both are empty then the end result will be discarded.
+
+    ``target`` must be a Bundle, or if the result should go to multiple
+    bundles you can pass a tuple of them as the ``targets`` argument.
+    It is invalid to use both arguments for a single rule.  If the result
+    should go to exactly one of several bundles, define a separate rule for
+    each case.
+
+    kwargs then define the arguments that will be passed to the function
+    invocation. If their value is a Bundle, or if it is ``consumes(b)``
+    where ``b`` is a Bundle, then values that have previously been produced
+    for that bundle will be provided. If ``consumes`` is used, the value
+    will also be removed from the bundle.
+
+    Any other kwargs should be strategies and values from them will be
+    provided.
+    """
+    converted_targets = _convert_targets(targets, target)
+    for k, v in kwargs.items():
+        check_strategy(v, name=k)
+
+    def accept(f):
+        if getattr(f, INVARIANT_MARKER, None):
+            raise InvalidDefinition(
+                "A function cannot be used for both a rule and an invariant.",
+                Settings.default,
+            )
+        existing_rule = getattr(f, RULE_MARKER, None)
+        existing_initialize_rule = getattr(f, INITIALIZE_RULE_MARKER, None)
+        if existing_rule is not None or existing_initialize_rule is not None:
+            raise InvalidDefinition(
+                "A function cannot be used for two distinct rules. ", Settings.default
+            )
+        preconditions = getattr(f, PRECONDITIONS_MARKER, ())
+        rule = Rule(
+            targets=converted_targets,
+            arguments=kwargs,
+            function=f,
+            preconditions=preconditions,
+        )
+
+        @proxies(f)
+        def rule_wrapper(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        setattr(rule_wrapper, RULE_MARKER, rule)
+        return rule_wrapper
+
+    return accept
+
+
+# See also comments of `rule`'s overloads.
+@overload
+def initialize(
+    *,
+    targets: SequenceBundleEx,
+    target: None = ...,
+    **kwargs: SearchStrategy,
+) -> _RuleWrapperEx:  # pragma: no cover
+    ...
+
+
+@overload
+def initialize(
+    *, target: BundleEx, targets: _OmittedArgument = ..., **kwargs: SearchStrategy
+) -> _RuleWrapperEx:  # pragma: no cover
+    ...
+
+
+@overload
+def initialize(
+    *,
+    target: None = ...,
+    targets: _OmittedArgument = ...,
+    **kwargs: SearchStrategy,
+) -> CallableCallable..., None, Callable..., None:  # pragma: no cover
+    ...
+
+
+def initialize(
+    *,
+    targets: UnionSequenceBundleEx, _OmittedArgument = (),
+    target: OptionalBundleEx = None,
+    **kwargs: SearchStrategy,
+) -> Union_RuleWrapperEx, CallableCallable..., None, Callable..., None:
+    """Decorator for RuleBasedStateMachine.
+
+    An initialize decorator behaves like a rule, but all ``@initialize()`` decorated
+    methods will be called before any ``@rule()`` decorated methods, in an arbitrary
+    order.  Each ``@initialize()`` method will be called exactly once per run, unless
+    one raises an exception - after which only the ``.teardown()`` method will be run.
+    ``@initialize()`` methods may not have preconditions.
+    """
+    converted_targets = _convert_targets(targets, target)
+    for k, v in kwargs.items():
+        check_strategy(v, name=k)
+
+    def accept(f):
+        if getattr(f, INVARIANT_MARKER, None):
+            raise InvalidDefinition(
+                "A function cannot be used for both a rule and an invariant.",
+                Settings.default,
+            )
+        existing_rule = getattr(f, RULE_MARKER, None)
+        existing_initialize_rule = getattr(f, INITIALIZE_RULE_MARKER, None)
+        if existing_rule is not None or existing_initialize_rule is not None:
+            raise InvalidDefinition(
+                "A function cannot be used for two distinct rules. ", Settings.default
+            )
+        preconditions = getattr(f, PRECONDITIONS_MARKER, ())
+        if preconditions:
+            raise InvalidDefinition(
+                "An initialization rule cannot have a precondition. ", Settings.default
+            )
+        rule = Rule(
+            targets=converted_targets,
+            arguments=kwargs,
+            function=f,
+            preconditions=preconditions,
+        )
+
+        @proxies(f)
+        def rule_wrapper(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        setattr(rule_wrapper, INITIALIZE_RULE_MARKER, rule)
+        return rule_wrapper
+
+    return accept
+
+
+@attr.s()
+class VarReference:
+    name = attr.ib()
+
+
+# There are multiple alternatives for annotating the `precond` type, all of them
+# have drawbacks. See https://github.com/HypothesisWorks/hypothesis/pull/3068#issuecomment-906642371
+def precondition(precond: CallableAny, bool) -> CallableTestFunc, TestFunc:
+    """Decorator to apply a precondition for rules in a RuleBasedStateMachine.
+    Specifies a precondition for a rule to be considered as a valid step in the
+    state machine, which is more efficient than using :func:`~hypothesis.assume`
+    within the rule.  The ``precond`` function will be called with the instance of
+    RuleBasedStateMachine and should return True or False. Usually it will need
+    to look at attributes on that instance.
+
+    For example::
+
+        class MyTestMachine(RuleBasedStateMachine):
+            state = 1
+
+            @precondition(lambda self: self.state != 0)
+            @rule(numerator=integers())
+            def divide_with(self, numerator):
+                self.state = numerator / self.state
+
+    If multiple preconditions are applied to a single rule, it is only considered
+    a valid step when all of them return True.  Preconditions may be applied to
+    invariants as well as rules.
+    """
+
+    def decorator(f):
+        @proxies(f)
+        def precondition_wrapper(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        existing_initialize_rule = getattr(f, INITIALIZE_RULE_MARKER, None)
+        if existing_initialize_rule is not None:
+            raise InvalidDefinition(
+                "An initialization rule cannot have a precondition. ", Settings.default
+            )
+
+        rule = getattr(f, RULE_MARKER, None)
+        invariant = getattr(f, INVARIANT_MARKER, None)
+        if rule is not None:
+            assert invariant is None
+            new_rule = attr.evolve(rule, preconditions=rule.preconditions + (precond,))
+            setattr(precondition_wrapper, RULE_MARKER, new_rule)
+        elif invariant is not None:
+            assert rule is None
+            new_invariant = attr.evolve(
+                invariant, preconditions=invariant.preconditions + (precond,)
+            )
+            setattr(precondition_wrapper, INVARIANT_MARKER, new_invariant)
+        else:
+            setattr(
+                precondition_wrapper,
+                PRECONDITIONS_MARKER,
+                getattr(f, PRECONDITIONS_MARKER, ()) + (precond,),
+            )
+
+        return precondition_wrapper
+
+    return decorator
+
+
+@attr.s()
+class Invariant:
+    function = attr.ib(repr=get_pretty_function_description)
+    preconditions = attr.ib()
+    check_during_init = attr.ib()
+
+
+def invariant(*, check_during_init: bool = False) -> CallableTestFunc, TestFunc:
+    """Decorator to apply an invariant for rules in a RuleBasedStateMachine.
+    The decorated function will be run after every rule and can raise an
+    exception to indicate failed invariants.
+
+    For example::
+
+        class MyTestMachine(RuleBasedStateMachine):
+            state = 1
+
+            @invariant()
+            def is_nonzero(self):
+                assert self.state != 0
+
+    By default, invariants are only checked after all
+    :func:`@initialize() <hypothesis.stateful.initialize>` rules have been run.
+    Pass ``check_during_init=True`` for invariants which can also be checked
+    during initialization.
+    """
+    check_type(bool, check_during_init, "check_during_init")
+
+    def accept(f):
+        if getattr(f, RULE_MARKER, None) or getattr(f, INITIALIZE_RULE_MARKER, None):
+            raise InvalidDefinition(
+                "A function cannot be used for both a rule and an invariant.",
+                Settings.default,
+            )
+        existing_invariant = getattr(f, INVARIANT_MARKER, None)
+        if existing_invariant is not None:
+            raise InvalidDefinition(
+                "A function cannot be used for two distinct invariants.",
+                Settings.default,
+            )
+        preconditions = getattr(f, PRECONDITIONS_MARKER, ())
+        invar = Invariant(
+            function=f,
+            preconditions=preconditions,
+            check_during_init=check_during_init,
+        )
+
+        @proxies(f)
+        def invariant_wrapper(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        setattr(invariant_wrapper, INVARIANT_MARKER, invar)
+        return invariant_wrapper
+
+    return accept
+
+
+LOOP_LABEL = cu.calc_label_from_name("RuleStrategy loop iteration")
+
+
+class RuleStrategy(SearchStrategy):
+    def __init__(self, machine):
+        super().__init__()
+        self.machine = machine
+        self.rules = list(machine.rules())
+
+        self.enabled_rules_strategy = st.shared(
+            FeatureStrategy(), key=("enabled rules", machine)
+        )
+
+        # The order is a bit arbitrary. Primarily we're trying to group rules
+        # that write to the same location together, and to put rules with no
+        # target first as they have less effect on the structure. We order from
+        # fewer to more arguments on grounds that it will plausibly need less
+        # data. This probably won't work especially well and we could be
+        # smarter about it, but it's better than just doing it in definition
+        # order.
+        self.rules.sort(
+            key=lambda rule: (
+                sorted(rule.targets),
+                len(rule.arguments),
+                rule.function.__name__,
+            )
+        )
+
+    def __repr__(self):
+        return "{}(machine={}({{...}}))".format(
+            self.__class__.__name__,
+            self.machine.__class__.__name__,
+        )
+
+    def do_draw(self, data):
+        if not any(self.is_valid(rule) for rule in self.rules):
+            msg = f"No progress can be made from state {self.machine!r}"
+            raise InvalidDefinition(msg) from None
+
+        feature_flags = data.draw(self.enabled_rules_strategy)
+
+        # Note: The order of the filters here is actually quite important,
+        # because checking is_enabled makes choices, so increases the size of
+        # the choice sequence. This means that if we are in a case where many
+        # rules are invalid we will make a lot more choices if we ask if they
+        # are enabled before we ask if they are valid, so our test cases will
+        # be artificially large.
+        rule = data.draw(
+            st.sampled_from(self.rules)
+            .filter(self.is_valid)
+            .filter(lambda r: feature_flags.is_enabled(r.function.__name__))
+        )
+
+        return (rule, data.draw(rule.arguments_strategy))
+
+    def is_valid(self, rule):
+        if not all(precond(self.machine) for precond in rule.preconditions):
+            return False
+
+        for b in rule.bundles:
+            bundle = self.machine.bundle(b.name)
+            if not bundle:
+                return False
+        return True

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/statistics.py Added

@@ -0,0 +1,124 @@
+# 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 math
+from collections import Counter
+
+from hypothesis.utils.dynamicvariables import DynamicVariable
+
+collector = DynamicVariable(None)
+
+
+def note_statistics(stats_dict):
+    callback = collector.value
+    if callback is not None:
+        callback(stats_dict)
+
+
+def describe_targets(best_targets):
+    """Return a list of lines describing the results of `target`, if any."""
+    # These lines are included in the general statistics description below,
+    # but also printed immediately below failing examples to alleviate the
+    # "threshold problem" where shrinking can make severe bug look trivial.
+    # See https://github.com/HypothesisWorks/hypothesis/issues/2180
+    if not best_targets:
+        return 
+    elif len(best_targets) == 1:
+        label, score = next(iter(best_targets.items()))
+        return f"Highest target score: {score:g}  (label={label!r})"
+    else:
+        lines = "Highest target scores:"
+        for label, score in sorted(best_targets.items(), key=lambda x: x::-1):
+            lines.append(f"{score:>16g}  (label={label!r})")
+        return lines
+
+
+def format_ms(times):
+    """Format `times` into a string representing approximate milliseconds.
+
+    `times` is a collection of durations in seconds.
+    """
+    ordered = sorted(times)
+    n = len(ordered) - 1
+    assert n >= 0
+    lower = int(orderedint(math.floor(n * 0.05)) * 1000)
+    upper = int(orderedint(math.ceil(n * 0.95)) * 1000)
+    if upper == 0:
+        return "< 1ms"
+    elif lower == upper:
+        return f"~ {lower}ms"
+    else:
+        return f"~ {lower}-{upper} ms"
+
+
+def describe_statistics(stats_dict):
+    """Return a multi-line string describing the passed run statistics.
+
+    `stats_dict` must be a dictionary of data in the format collected by
+    `hypothesis.internal.conjecture.engine.ConjectureRunner.statistics`.
+
+    We DO NOT promise that this format will be stable or supported over
+    time, but do aim to make it reasonably useful for downstream users.
+    It's also meant to support benchmarking for research purposes.
+
+    This function is responsible for the report which is printed in the
+    terminal for our pytest --hypothesis-show-statistics option.
+    """
+    lines = stats_dict"nodeid" + ":\n" if "nodeid" in stats_dict else 
+    prev_failures = 0
+    for phase in "reuse", "generate", "shrink":
+        d = stats_dict.get(phase + "-phase", {})
+        # Basic information we report for every phase
+        cases = d.get("test-cases", )
+        if not cases:
+            continue
+        statuses = Counter(t"status" for t in cases)
+        runtime_ms = format_ms(t"runtime" for t in cases)
+        drawtime_ms = format_ms(t"drawtime" for t in cases)
+        lines.append(
+            f"  - during {phase} phase ({d'duration-seconds':.2f} seconds):\n"
+            f"    - Typical runtimes: {runtime_ms}, of which {drawtime_ms} in data generation\n"
+            f"    - {statuses'valid'} passing examples, {statuses'interesting'} "
+            f"failing examples, {statuses'invalid' + statuses'overrun'} invalid examples"
+        )
+        # If we've found new distinct failures in this phase, report them
+        distinct_failures = d"distinct-failures" - prev_failures
+        if distinct_failures:
+            plural = distinct_failures > 1
+            lines.append(
+                "    - Found {}{} distinct error{} in this phase".format(
+                    distinct_failures, " more" * bool(prev_failures), "s" * plural
+                )
+            )
+        prev_failures = d"distinct-failures"
+        # Report events during the generate phase, if there were any
+        if phase == "generate":
+            events = Counter(sum((t"events" for t in cases), ))
+            if events:
+                lines.append("    - Events:")
+                lines += 
+                    f"      * {100 * v / len(cases):.2f}%, {k}"
+                    for k, v in sorted(events.items(), key=lambda x: (-x1, x0))
+                
+        # Some additional details on the shrinking phase
+        if phase == "shrink":
+            lines.append(
+                "    - Tried {} shrinks of which {} were successful".format(
+                    len(cases), d"shrinks-successful"
+                )
+            )
+        lines.append("")
+
+    target_lines = describe_targets(stats_dict.get("targets", {}))
+    if target_lines:
+        lines.append("  - " + target_lines0)
+        lines.extend("    " + l for l in target_lines1:)
+    lines.append("  - Stopped because " + stats_dict"stopped-because")
+    return "\n".join(lines)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/attrs.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/collections.py Added

@@ -0,0 +1,337 @@
+# 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 copy
+from typing import Any, Iterable, Tuple, overload
+
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.conjecture.junkdrawer import LazySequenceCopy
+from hypothesis.internal.conjecture.utils import combine_labels
+from hypothesis.internal.reflection import is_identity_function
+from hypothesis.strategies._internal.strategies import (
+    T3,
+    T4,
+    T5,
+    Ex,
+    MappedSearchStrategy,
+    SearchStrategy,
+    T,
+    check_strategy,
+    filter_not_satisfied,
+)
+from hypothesis.strategies._internal.utils import cacheable, defines_strategy
+
+
+class TupleStrategy(SearchStrategy):
+    """A strategy responsible for fixed length tuples based on heterogeneous
+    strategies for each of their elements."""
+
+    def __init__(self, strategies: IterableSearchStrategyAny):
+        super().__init__()
+        self.element_strategies = tuple(strategies)
+
+    def do_validate(self):
+        for s in self.element_strategies:
+            s.validate()
+
+    def calc_label(self):
+        return combine_labels(
+            self.class_label, *(s.label for s in self.element_strategies)
+        )
+
+    def __repr__(self):
+        tuple_string = ", ".join(map(repr, self.element_strategies))
+        return f"TupleStrategy(({tuple_string}))"
+
+    def calc_has_reusable_values(self, recur):
+        return all(recur(e) for e in self.element_strategies)
+
+    def do_draw(self, data):
+        return tuple(data.draw(e) for e in self.element_strategies)
+
+    def calc_is_empty(self, recur):
+        return any(recur(e) for e in self.element_strategies)
+
+
+@overload
+def tuples() -> SearchStrategyTuple():  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def tuples(__a1: SearchStrategyEx) -> SearchStrategyTupleEx:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def tuples(
+    __a1: SearchStrategyEx, __a2: SearchStrategyT
+) -> SearchStrategyTupleEx, T:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def tuples(
+    __a1: SearchStrategyEx, __a2: SearchStrategyT, __a3: SearchStrategyT3
+) -> SearchStrategyTupleEx, T, T3:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def tuples(
+    __a1: SearchStrategyEx,
+    __a2: SearchStrategyT,
+    __a3: SearchStrategyT3,
+    __a4: SearchStrategyT4,
+) -> SearchStrategyTupleEx, T, T3, T4:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def tuples(
+    __a1: SearchStrategyEx,
+    __a2: SearchStrategyT,
+    __a3: SearchStrategyT3,
+    __a4: SearchStrategyT4,
+    __a5: SearchStrategyT5,
+) -> SearchStrategyTupleEx, T, T3, T4, T5:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def tuples(
+    *args: SearchStrategyAny,
+) -> SearchStrategyTupleAny, ...:  # pragma: no cover
+    ...
+
+
+@cacheable
+@defines_strategy()
+def tuples(*args: SearchStrategyAny) -> SearchStrategyTupleAny, ...:  # noqa: F811
+    """Return a strategy which generates a tuple of the same length as args by
+    generating the value at index i from argsi.
+
+    e.g. tuples(integers(), integers()) would generate a tuple of length
+    two with both values an integer.
+
+    Examples from this strategy shrink by shrinking their component parts.
+    """
+    for arg in args:
+        check_strategy(arg)
+
+    return TupleStrategy(args)
+
+
+class ListStrategy(SearchStrategy):
+    """A strategy for lists which takes a strategy for its elements and the
+    allowed lengths, and generates lists with the correct size and contents."""
+
+    _nonempty_filters: tuple = (bool, len, tuple, list)
+
+    def __init__(self, elements, min_size=0, max_size=float("inf")):
+        super().__init__()
+        self.min_size = min_size or 0
+        self.max_size = max_size if max_size is not None else float("inf")
+        assert 0 <= self.min_size <= self.max_size
+        self.average_size = min(
+            max(self.min_size * 2, self.min_size + 5),
+            0.5 * (self.min_size + self.max_size),
+        )
+        self.element_strategy = elements
+
+    def calc_label(self):
+        return combine_labels(self.class_label, self.element_strategy.label)
+
+    def do_validate(self):
+        self.element_strategy.validate()
+        if self.is_empty:
+            raise InvalidArgument(
+                "Cannot create non-empty lists with elements drawn from "
+                f"strategy {self.element_strategy!r} because it has no values."
+            )
+        if self.element_strategy.is_empty and 0 < self.max_size < float("inf"):
+            raise InvalidArgument(
+                f"Cannot create a collection of max_size={self.max_size!r}, "
+                "because no elements can be drawn from the element strategy "
+                f"{self.element_strategy!r}"
+            )
+
+    def calc_is_empty(self, recur):
+        if self.min_size == 0:
+            return False
+        else:
+            return recur(self.element_strategy)
+
+    def do_draw(self, data):
+        if self.element_strategy.is_empty:
+            assert self.min_size == 0
+            return 
+
+        elements = cu.many(
+            data,
+            min_size=self.min_size,
+            max_size=self.max_size,
+            average_size=self.average_size,
+        )
+        result = 
+        while elements.more():
+            result.append(data.draw(self.element_strategy))
+        return result
+
+    def __repr__(self):
+        return "{}({!r}, min_size={!r}, max_size={!r})".format(
+            self.__class__.__name__, self.element_strategy, self.min_size, self.max_size
+        )
+
+    def filter(self, condition):
+        if condition in self._nonempty_filters or is_identity_function(condition):
+            assert self.max_size >= 1, "Always-empty is special cased in st.lists()"
+            if self.min_size >= 1:
+                return self
+            new = copy.copy(self)
+            new.min_size = 1
+            return new
+        return super().filter(condition)
+
+
+class UniqueListStrategy(ListStrategy):
+    def __init__(self, elements, min_size, max_size, keys, tuple_suffixes):
+        super().__init__(elements, min_size, max_size)
+        self.keys = keys
+        self.tuple_suffixes = tuple_suffixes
+
+    def do_draw(self, data):
+        if self.element_strategy.is_empty:
+            assert self.min_size == 0
+            return 
+
+        elements = cu.many(
+            data,
+            min_size=self.min_size,
+            max_size=self.max_size,
+            average_size=self.average_size,
+        )
+        seen_sets = tuple(set() for _ in self.keys)
+        result = 
+
+        # We construct a filtered strategy here rather than using a check-and-reject
+        # approach because some strategies have special logic for generation under a
+        # filter, and FilteredStrategy can consolidate multiple filters.
+        def not_yet_in_unique_list(val):
+            return all(key(val) not in seen for key, seen in zip(self.keys, seen_sets))
+
+        filtered = self.element_strategy._filter_for_filtered_draw(
+            not_yet_in_unique_list
+        )
+        while elements.more():
+            value = filtered.do_filtered_draw(data)
+            if value is filter_not_satisfied:
+                elements.reject("Aborted test because unable to satisfy {filtered!r}")
+            else:
+                for key, seen in zip(self.keys, seen_sets):
+                    seen.add(key(value))
+                if self.tuple_suffixes is not None:
+                    value = (value,) + data.draw(self.tuple_suffixes)
+                result.append(value)
+        assert self.max_size >= len(result) >= self.min_size
+        return result
+
+
+class UniqueSampledListStrategy(UniqueListStrategy):
+    def do_draw(self, data):
+        should_draw = cu.many(
+            data,
+            min_size=self.min_size,
+            max_size=self.max_size,
+            average_size=self.average_size,
+        )
+        seen_sets = tuple(set() for _ in self.keys)
+        result = 
+
+        remaining = LazySequenceCopy(self.element_strategy.elements)
+
+        while remaining and should_draw.more():
+            i = len(remaining) - 1
+            j = cu.integer_range(data, 0, i)
+            if j != i:
+                remainingi, remainingj = remainingj, remainingi
+            value = self.element_strategy._transform(remaining.pop())
+
+            if value is not filter_not_satisfied and all(
+                key(value) not in seen for key, seen in zip(self.keys, seen_sets)
+            ):
+                for key, seen in zip(self.keys, seen_sets):
+                    seen.add(key(value))
+                if self.tuple_suffixes is not None:
+                    value = (value,) + data.draw(self.tuple_suffixes)
+                result.append(value)
+            else:
+                should_draw.reject(
+                    "UniqueSampledListStrategy filter not satisfied or value already seen"
+                )
+        assert self.max_size >= len(result) >= self.min_size
+        return result
+
+
+class FixedKeysDictStrategy(MappedSearchStrategy):
+    """A strategy which produces dicts with a fixed set of keys, given a
+    strategy for each of their equivalent values.
+
+    e.g. {'foo' : some_int_strategy} would generate dicts with the single
+    key 'foo' mapping to some integer.
+    """
+
+    def __init__(self, strategy_dict):
+        self.dict_type = type(strategy_dict)
+        self.keys = tuple(strategy_dict.keys())
+        super().__init__(strategy=TupleStrategy(strategy_dictk for k in self.keys))
+
+    def calc_is_empty(self, recur):
+        return recur(self.mapped_strategy)
+
+    def __repr__(self):
+        return f"FixedKeysDictStrategy({self.keys!r}, {self.mapped_strategy!r})"
+
+    def pack(self, value):
+        return self.dict_type(zip(self.keys, value))
+
+
+class FixedAndOptionalKeysDictStrategy(SearchStrategy):
+    """A strategy which produces dicts with a fixed set of keys, given a
+    strategy for each of their equivalent values.
+
+    e.g. {'foo' : some_int_strategy} would generate dicts with the single
+    key 'foo' mapping to some integer.
+    """
+
+    def __init__(self, strategy_dict, optional):
+        self.required = strategy_dict
+        self.fixed = FixedKeysDictStrategy(strategy_dict)
+        self.optional = optional
+
+    def calc_is_empty(self, recur):
+        return recur(self.fixed)
+
+    def __repr__(self):
+        return f"FixedAndOptionalKeysDictStrategy({self.required!r}, {self.optional!r})"
+
+    def do_draw(self, data):
+        result = data.draw(self.fixed)
+        remaining = k for k, v in self.optional.items() if not v.is_empty
+        should_draw = cu.many(
+            data, min_size=0, max_size=len(remaining), average_size=len(remaining) / 2
+        )
+        while should_draw.more():
+            j = cu.integer_range(data, 0, len(remaining) - 1)
+            remaining-1, remainingj = remainingj, remaining-1
+            key = remaining.pop()
+            resultkey = data.draw(self.optionalkey)
+        return result

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/core.py Added

@@ -0,0 +1,2253 @@
+# 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 enum
+import math
+import operator
+import random
+import re
+import string
+import sys
+import typing
+import warnings
+from decimal import Context, Decimal, localcontext
+from fractions import Fraction
+from functools import lru_cache, reduce
+from inspect import Parameter, Signature, isabstract, isclass, signature
+from types import FunctionType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    Callable,
+    Dict,
+    FrozenSet,
+    Hashable,
+    Iterable,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from uuid import UUID
+
+import attr
+
+from hypothesis._settings import note_deprecation
+from hypothesis.control import cleanup, current_build_context, note
+from hypothesis.errors import (
+    InvalidArgument,
+    ResolutionFailed,
+    RewindRecursive,
+    SmallSearchSpaceWarning,
+)
+from hypothesis.internal.cathetus import cathetus
+from hypothesis.internal.charmap import as_general_categories
+from hypothesis.internal.compat import (
+    Concatenate,
+    ParamSpec,
+    ceil,
+    floor,
+    get_type_hints,
+    is_typed_named_tuple,
+)
+from hypothesis.internal.conjecture.utils import (
+    calc_label_from_cls,
+    check_sample,
+    integer_range,
+)
+from hypothesis.internal.entropy import get_seeder_and_restorer
+from hypothesis.internal.floats import float_of
+from hypothesis.internal.reflection import (
+    define_function_signature,
+    get_pretty_function_description,
+    get_signature,
+    is_first_param_referenced_in_function,
+    nicerepr,
+    repr_call,
+    required_args,
+)
+from hypothesis.internal.validation import (
+    check_type,
+    check_valid_integer,
+    check_valid_interval,
+    check_valid_magnitude,
+    check_valid_size,
+    check_valid_sizes,
+    try_convert,
+)
+from hypothesis.strategies._internal import SearchStrategy, check_strategy
+from hypothesis.strategies._internal.collections import (
+    FixedAndOptionalKeysDictStrategy,
+    FixedKeysDictStrategy,
+    ListStrategy,
+    TupleStrategy,
+    UniqueListStrategy,
+    UniqueSampledListStrategy,
+    tuples,
+)
+from hypothesis.strategies._internal.deferred import DeferredStrategy
+from hypothesis.strategies._internal.functions import FunctionStrategy
+from hypothesis.strategies._internal.lazy import LazyStrategy, unwrap_strategies
+from hypothesis.strategies._internal.misc import just, none, nothing
+from hypothesis.strategies._internal.numbers import (
+    IntegersStrategy,
+    Real,
+    floats,
+    integers,
+)
+from hypothesis.strategies._internal.recursive import RecursiveStrategy
+from hypothesis.strategies._internal.shared import SharedStrategy
+from hypothesis.strategies._internal.strategies import (
+    Ex,
+    SampledFromStrategy,
+    T,
+    one_of,
+)
+from hypothesis.strategies._internal.strings import (
+    FixedSizeBytes,
+    OneCharStringStrategy,
+    TextStrategy,
+)
+from hypothesis.strategies._internal.utils import cacheable, defines_strategy
+from hypothesis.utils.conventions import not_set
+from hypothesis.vendor.pretty import RepresentationPrinter
+
+if sys.version_info >= (3, 10):
+    from types import EllipsisType as EllipsisType
+elif typing.TYPE_CHECKING:  # pragma: no cover
+    from builtins import ellipsis as EllipsisType
+else:
+    EllipsisType = type(Ellipsis)  # pragma: no cover
+
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+elif TYPE_CHECKING:
+    from typing_extensions import Protocol
+else:  # pragma: no cover
+    Protocol = object
+
+
+@cacheable
+@defines_strategy()
+def booleans() -> SearchStrategybool:
+    """Returns a strategy which generates instances of :class:`python:bool`.
+
+    Examples from this strategy will shrink towards ``False`` (i.e.
+    shrinking will replace ``True`` with ``False`` where possible).
+    """
+    return SampledFromStrategy(False, True, repr_="booleans()")
+
+
+@overload
+def sampled_from(elements: SequenceT) -> SearchStrategyT:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def sampled_from(elements: Typeenum.Enum) -> SearchStrategyAny:  # pragma: no cover
+    # `SearchStrategyEnum` is unreliable due to metaclass issues.
+    ...
+
+
+@overload  # noqa: F811
+def sampled_from(
+    elements: UnionTypeenum.Enum, SequenceAny
+) -> SearchStrategyAny:  # pragma: no cover
+    ...
+
+
+@defines_strategy(try_non_lazy=True)  # noqa: F811
+def sampled_from(
+    elements: UnionTypeenum.Enum, SequenceAny
+) -> SearchStrategyAny:
+    """Returns a strategy which generates any value present in ``elements``.
+
+    Note that as with :func:`~hypothesis.strategies.just`, values will not be
+    copied and thus you should be careful of using mutable data.
+
+    ``sampled_from`` supports ordered collections, as well as
+    :class:`~python:enum.Enum` objects.  :class:`~python:enum.Flag` objects
+    may also generate any combination of their members.
+
+    Examples from this strategy shrink by replacing them with values earlier in
+    the list. So e.g. ``sampled_from(10, 1)`` will shrink by trying to replace
+    1 values with 10, and ``sampled_from(1, 10)`` will shrink by trying to
+    replace 10 values with 1.
+
+    It is an error to sample from an empty sequence, because returning :func:`nothing`
+    makes it too easy to silently drop parts of compound strategies.  If you need
+    that behaviour, use ``sampled_from(seq) if seq else nothing()``.
+    """
+    values = check_sample(elements, "sampled_from")
+    if not values:
+        if (
+            isinstance(elements, type)
+            and issubclass(elements, enum.Enum)
+            and vars(elements).get("__annotations__")
+        ):
+            # See https://github.com/HypothesisWorks/hypothesis/issues/2923
+            raise InvalidArgument(
+                f"Cannot sample from {elements.__module__}.{elements.__name__} "
+                "because it contains no elements.  It does however have annotations, "
+                "so maybe you tried to write an enum as if it was a dataclass?"
+            )
+        raise InvalidArgument("Cannot sample from a length-zero sequence.")
+    if len(values) == 1:
+        return just(values0)
+    if isinstance(elements, type) and issubclass(elements, enum.Enum):
+        repr_ = f"sampled_from({elements.__module__}.{elements.__name__})"
+    else:
+        repr_ = f"sampled_from({elements!r})"
+    if isclass(elements) and issubclass(elements, enum.Flag):
+        # Combinations of enum.Flag members are also members.  We generate
+        # these dynamically, because static allocation takes O(2^n) memory.
+        # LazyStrategy is used for the ease of force_repr.
+        inner = sets(sampled_from(list(values)), min_size=1).map(
+            lambda s: reduce(operator.or_, s)
+        )
+        return LazyStrategy(lambda: inner, args=, kwargs={}, force_repr=repr_)
+    return SampledFromStrategy(values, repr_)
+
+
+def identity(x):
+    return x
+
+
+@cacheable
+@defines_strategy()
+def lists(
+    elements: SearchStrategyEx,
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+    unique_by: Union
+        None,
+        CallableEx, Hashable,
+        TupleCallableEx, Hashable, ...,
+     = None,
+    unique: bool = False,
+) -> SearchStrategyListEx:
+    """Returns a list containing values drawn from elements with length in the
+    interval min_size, max_size (no bounds in that direction if these are
+    None). If max_size is 0, only the empty list will be drawn.
+
+    If ``unique`` is True (or something that evaluates to True), we compare direct
+    object equality, as if unique_by was ``lambda x: x``. This comparison only
+    works for hashable types.
+
+    If ``unique_by`` is not None it must be a callable or tuple of callables
+    returning a hashable type when given a value drawn from elements. The
+    resulting list will satisfy the condition that for ``i`` != ``j``,
+    ``unique_by(resulti)`` != ``unique_by(resultj)``.
+
+    If ``unique_by`` is a tuple of callables the uniqueness will be respective
+    to each callable.
+
+    For example, the following will produce two columns of integers with both
+    columns being unique respectively.
+
+    .. code-block:: pycon
+
+        >>> twoints = st.tuples(st.integers(), st.integers())
+        >>> st.lists(twoints, unique_by=(lambda x: x0, lambda x: x1))
+
+    Examples from this strategy shrink by trying to remove elements from the
+    list, and by shrinking each individual element of the list.
+    """
+    check_valid_sizes(min_size, max_size)
+    check_strategy(elements, "elements")
+    if unique:
+        if unique_by is not None:
+            raise InvalidArgument(
+                "cannot specify both unique and unique_by "
+                "(you probably only want to set unique_by)"
+            )
+        else:
+            unique_by = identity
+
+    if max_size == 0:
+        return builds(list)
+    if unique_by is not None:
+        if not (callable(unique_by) or isinstance(unique_by, tuple)):
+            raise InvalidArgument(
+                f"unique_by={unique_by!r} is not a callable or tuple of callables"
+            )
+        if callable(unique_by):
+            unique_by = (unique_by,)
+        if len(unique_by) == 0:
+            raise InvalidArgument("unique_by is empty")
+        for i, f in enumerate(unique_by):
+            if not callable(f):
+                raise InvalidArgument(f"unique_by{i}={f!r} is not a callable")
+        # Note that lazy strategies automatically unwrap when passed to a defines_strategy
+        # function.
+        tuple_suffixes = None
+        if (
+            # We're generating a list of tuples unique by the first element, perhaps
+            # via st.dictionaries(), and this will be more efficient if we rearrange
+            # our strategy somewhat to draw the first element then draw add the rest.
+            isinstance(elements, TupleStrategy)
+            and len(elements.element_strategies) >= 1
+            and len(unique_by) == 1
+            and (
+                # Introspection for either `itemgetter(0)`, or `lambda x: x0`
+                isinstance(unique_by0, operator.itemgetter)
+                and repr(unique_by0) == "operator.itemgetter(0)"
+                or isinstance(unique_by0, FunctionType)
+                and re.fullmatch(
+                    get_pretty_function_description(unique_by0),
+                    r"lambda (a-z+): \1\0\",
+                )
+            )
+        ):
+            unique_by = (identity,)
+            tuple_suffixes = TupleStrategy(elements.element_strategies1:)
+            elements = elements.element_strategies0
+
+        # UniqueSampledListStrategy offers a substantial performance improvement for
+        # unique arrays with few possible elements, e.g. of eight-bit integer types.
+        if (
+            isinstance(elements, IntegersStrategy)
+            and None not in (elements.start, elements.end)
+            and (elements.end - elements.start) <= 255
+        ):
+            elements = SampledFromStrategy(
+                sorted(range(elements.start, elements.end + 1), key=abs)
+                if elements.end < 0 or elements.start > 0
+                else list(range(0, elements.end + 1))
+                + list(range(-1, elements.start - 1, -1))
+            )
+
+        if isinstance(elements, SampledFromStrategy):
+            element_count = len(elements.elements)
+            if min_size > element_count:
+                raise InvalidArgument(
+                    f"Cannot create a collection of min_size={min_size!r} unique "
+                    f"elements with values drawn from only {element_count} distinct "
+                    "elements"
+                )
+
+            if max_size is not None:
+                max_size = min(max_size, element_count)
+            else:
+                max_size = element_count
+
+            return UniqueSampledListStrategy(
+                elements=elements,
+                max_size=max_size,
+                min_size=min_size,
+                keys=unique_by,
+                tuple_suffixes=tuple_suffixes,
+            )
+
+        return UniqueListStrategy(
+            elements=elements,
+            max_size=max_size,
+            min_size=min_size,
+            keys=unique_by,
+            tuple_suffixes=tuple_suffixes,
+        )
+    return ListStrategy(elements, min_size=min_size, max_size=max_size)
+
+
+@cacheable
+@defines_strategy()
+def sets(
+    elements: SearchStrategyEx,
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+) -> SearchStrategySetEx:
+    """This has the same behaviour as lists, but returns sets instead.
+
+    Note that Hypothesis cannot tell if values are drawn from elements
+    are hashable until running the test, so you can define a strategy
+    for sets of an unhashable type but it will fail at test time.
+
+    Examples from this strategy shrink by trying to remove elements from the
+    set, and by shrinking each individual element of the set.
+    """
+    return lists(
+        elements=elements, min_size=min_size, max_size=max_size, unique=True
+    ).map(set)
+
+
+@cacheable
+@defines_strategy()
+def frozensets(
+    elements: SearchStrategyEx,
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+) -> SearchStrategyFrozenSetEx:
+    """This is identical to the sets function but instead returns
+    frozensets."""
+    return lists(
+        elements=elements, min_size=min_size, max_size=max_size, unique=True
+    ).map(frozenset)
+
+
+class PrettyIter:
+    def __init__(self, values):
+        self._values = values
+        self._iter = iter(self._values)
+
+    def __iter__(self):
+        return self._iter
+
+    def __next__(self):
+        return next(self._iter)
+
+    def __repr__(self):
+        return f"iter({self._values!r})"
+
+
+@defines_strategy()
+def iterables(
+    elements: SearchStrategyEx,
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+    unique_by: Union
+        None,
+        CallableEx, Hashable,
+        TupleCallableEx, Hashable, ...,
+     = None,
+    unique: bool = False,
+) -> SearchStrategyIterableEx:
+    """This has the same behaviour as lists, but returns iterables instead.
+
+    Some iterables cannot be indexed (e.g. sets) and some do not have a
+    fixed length (e.g. generators). This strategy produces iterators,
+    which cannot be indexed and do not have a fixed length. This ensures
+    that you do not accidentally depend on sequence behaviour.
+    """
+    return lists(
+        elements=elements,
+        min_size=min_size,
+        max_size=max_size,
+        unique_by=unique_by,
+        unique=unique,
+    ).map(PrettyIter)
+
+
+@defines_strategy()
+def fixed_dictionaries(
+    mapping: DictT, SearchStrategyEx,
+    *,
+    optional: OptionalDictT, SearchStrategyEx = None,
+) -> SearchStrategyDictT, Ex:
+    """Generates a dictionary of the same type as mapping with a fixed set of
+    keys mapping to strategies. ``mapping`` must be a dict subclass.
+
+    Generated values have all keys present in mapping, in iteration order,
+    with the corresponding values drawn from mappingkey.
+
+    If ``optional`` is passed, the generated value *may or may not* contain each
+    key from ``optional`` and a value drawn from the corresponding strategy.
+    Generated values may contain optional keys in an arbitrary order.
+
+    Examples from this strategy shrink by shrinking each individual value in
+    the generated dictionary, and omitting optional key-value pairs.
+    """
+    check_type(dict, mapping, "mapping")
+    for k, v in mapping.items():
+        check_strategy(v, f"mapping{k!r}")
+    if optional is not None:
+        check_type(dict, optional, "optional")
+        for k, v in optional.items():
+            check_strategy(v, f"optional{k!r}")
+        if type(mapping) != type(optional):
+            raise InvalidArgument(
+                "Got arguments of different types: mapping=%s, optional=%s"
+                % (nicerepr(type(mapping)), nicerepr(type(optional)))
+            )
+        if set(mapping) & set(optional):
+            raise InvalidArgument(
+                "The following keys were in both mapping and optional, "
+                f"which is invalid: {set(mapping) & set(optional)!r}"
+            )
+        return FixedAndOptionalKeysDictStrategy(mapping, optional)
+    return FixedKeysDictStrategy(mapping)
+
+
+@cacheable
+@defines_strategy()
+def dictionaries(
+    keys: SearchStrategyEx,
+    values: SearchStrategyT,
+    *,
+    dict_class: type = dict,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+) -> SearchStrategyDictEx, T:
+    # Describing the exact dict_class to Mypy drops the key and value types,
+    # so we report DictK, V instead of MappingAny, Any for now.  Sorry!
+    """Generates dictionaries of type ``dict_class`` with keys drawn from the ``keys``
+    argument and values drawn from the ``values`` argument.
+
+    The size parameters have the same interpretation as for
+    :func:`~hypothesis.strategies.lists`.
+
+    Examples from this strategy shrink by trying to remove keys from the
+    generated dictionary, and by shrinking each generated key and value.
+    """
+    check_valid_sizes(min_size, max_size)
+    if max_size == 0:
+        return fixed_dictionaries(dict_class())
+    check_strategy(keys, "keys")
+    check_strategy(values, "values")
+
+    return lists(
+        tuples(keys, values),
+        min_size=min_size,
+        max_size=max_size,
+        unique_by=operator.itemgetter(0),
+    ).map(dict_class)
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def characters(
+    *,
+    whitelist_categories: OptionalSequencestr = None,
+    blacklist_categories: OptionalSequencestr = None,
+    blacklist_characters: OptionalSequencestr = None,
+    min_codepoint: Optionalint = None,
+    max_codepoint: Optionalint = None,
+    whitelist_characters: OptionalSequencestr = None,
+) -> SearchStrategystr:
+    r"""Generates characters, length-one :class:`python:str`\ ings,
+    following specified filtering rules.
+
+    - When no filtering rules are specified, any character can be produced.
+    - If ``min_codepoint`` or ``max_codepoint`` is specified, then only
+      characters having a codepoint in that range will be produced.
+    - If ``whitelist_categories`` is specified, then only characters from those
+      Unicode categories will be produced. This is a further restriction,
+      characters must also satisfy ``min_codepoint`` and ``max_codepoint``.
+    - If ``blacklist_categories`` is specified, then any character from those
+      categories will not be produced.  Any overlap between
+      ``whitelist_categories`` and ``blacklist_categories`` will raise an
+      exception, as each character can only belong to a single class.
+    - If ``whitelist_characters`` is specified, then any additional characters
+      in that list will also be produced.
+    - If ``blacklist_characters`` is specified, then any characters in
+      that list will be not be produced. Any overlap between
+      ``whitelist_characters`` and ``blacklist_characters`` will raise an
+      exception.
+
+    The ``_codepoint`` arguments must be integers between zero and
+    :obj:`python:sys.maxunicode`.  The ``_characters`` arguments must be
+    collections of length-one unicode strings, such as a unicode string.
+
+    The ``_categories`` arguments must be used to specify either the
+    one-letter Unicode major category or the two-letter Unicode
+    `general category`_.  For example, ``('Nd', 'Lu')`` signifies "Number,
+    decimal digit" and "Letter, uppercase".  A single letter ('major category')
+    can be given to match all corresponding categories, for example ``'P'``
+    for characters in any punctuation category.
+
+    .. _general category: https://wikipedia.org/wiki/Unicode_character_property
+
+    Examples from this strategy shrink towards the codepoint for ``'0'``,
+    or the first allowable codepoint after it if ``'0'`` is excluded.
+    """
+    check_valid_size(min_codepoint, "min_codepoint")
+    check_valid_size(max_codepoint, "max_codepoint")
+    check_valid_interval(min_codepoint, max_codepoint, "min_codepoint", "max_codepoint")
+    if (
+        min_codepoint is None
+        and max_codepoint is None
+        and whitelist_categories is None
+        and blacklist_categories is None
+        and whitelist_characters is not None
+    ):
+        raise InvalidArgument(
+            "Nothing is excluded by other arguments, so passing only "
+            f"whitelist_characters={whitelist_characters!r} would have no effect.  "
+            "Also pass whitelist_categories=(), or use "
+            f"sampled_from({whitelist_characters!r}) instead."
+        )
+    blacklist_characters = blacklist_characters or ""
+    whitelist_characters = whitelist_characters or ""
+    overlap = set(blacklist_characters).intersection(whitelist_characters)
+    if overlap:
+        raise InvalidArgument(
+            f"Characters {sorted(overlap)!r} are present in both "
+            f"whitelist_characters={whitelist_characters!r}, and "
+            f"blacklist_characters={blacklist_characters!r}"
+        )
+    blacklist_categories = as_general_categories(
+        blacklist_categories, "blacklist_categories"
+    )
+    if (
+        whitelist_categories is not None
+        and not whitelist_categories
+        and not whitelist_characters
+    ):
+        raise InvalidArgument(
+            "When whitelist_categories is an empty collection and there are "
+            "no characters specified in whitelist_characters, nothing can "
+            "be generated by the characters() strategy."
+        )
+    whitelist_categories = as_general_categories(
+        whitelist_categories, "whitelist_categories"
+    )
+    both_cats = set(blacklist_categories or ()).intersection(whitelist_categories or ())
+    if both_cats:
+        raise InvalidArgument(
+            f"Categories {sorted(both_cats)!r} are present in both "
+            f"whitelist_categories={whitelist_categories!r}, and "
+            f"blacklist_categories={blacklist_categories!r}"
+        )
+
+    return OneCharStringStrategy(
+        whitelist_categories=whitelist_categories,
+        blacklist_categories=blacklist_categories,
+        blacklist_characters=blacklist_characters,
+        min_codepoint=min_codepoint,
+        max_codepoint=max_codepoint,
+        whitelist_characters=whitelist_characters,
+    )
+
+
+# Cache size is limited by sys.maxunicode, but passing None makes it slightly faster.
+@lru_cache(maxsize=None)
+def _check_is_single_character(c):
+    # In order to mitigate the performance cost of this check, we use a shared cache,
+    # even at the cost of showing the culprit strategy in the error message.
+    if not isinstance(c, str):
+        type_ = get_pretty_function_description(type(c))
+        raise InvalidArgument(f"Got non-string {c!r} (type {type_})")
+    if len(c) != 1:
+        raise InvalidArgument(f"Got {c!r} (length {len(c)} != 1)")
+    return c
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def text(
+    alphabet: UnionSequencestr, SearchStrategystr = characters(
+        blacklist_categories=("Cs",)
+    ),
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+) -> SearchStrategystr:
+    """Generates strings with characters drawn from ``alphabet``, which should
+    be a collection of length one strings or a strategy generating such strings.
+
+    The default alphabet strategy can generate the full unicode range but
+    excludes surrogate characters because they are invalid in the UTF-8
+    encoding.  You can use :func:`~hypothesis.strategies.characters` without
+    arguments to find surrogate-related bugs such as :bpo:`34454`.
+
+    ``min_size`` and ``max_size`` have the usual interpretations.
+    Note that Python measures string length by counting codepoints: U+00C5
+    ``Å`` is a single character, while U+0041 U+030A ``Å`` is two - the ``A``,
+    and a combining ring above.
+
+    Examples from this strategy shrink towards shorter strings, and with the
+    characters in the text shrinking as per the alphabet strategy.
+    This strategy does not :func:`~python:unicodedata.normalize` examples,
+    so generated strings may be in any or none of the 'normal forms'.
+    """
+    check_valid_sizes(min_size, max_size)
+    if isinstance(alphabet, SearchStrategy):
+        char_strategy = unwrap_strategies(alphabet)
+        if isinstance(char_strategy, SampledFromStrategy):
+            # Check this via the up-front validation logic below, and incidentally
+            # convert into a `characters()` strategy for standard text shrinking.
+            return text(char_strategy.elements, min_size=min_size, max_size=max_size)
+        elif not isinstance(char_strategy, OneCharStringStrategy):
+            char_strategy = char_strategy.map(_check_is_single_character)
+    else:
+        non_string = c for c in alphabet if not isinstance(c, str)
+        if non_string:
+            raise InvalidArgument(
+                "The following elements in alphabet are not unicode "
+                f"strings:  {non_string!r}"
+            )
+        not_one_char = c for c in alphabet if len(c) != 1
+        if not_one_char:
+            raise InvalidArgument(
+                "The following elements in alphabet are not of length one, "
+                f"which leads to violation of size constraints:  {not_one_char!r}"
+            )
+        char_strategy = (
+            characters(whitelist_categories=(), whitelist_characters=alphabet)
+            if alphabet
+            else nothing()
+        )
+    if (max_size == 0 or char_strategy.is_empty) and not min_size:
+        return just("")
+    return TextStrategy(char_strategy, min_size=min_size, max_size=max_size)
+
+
+@cacheable
+@defines_strategy()
+def from_regex(
+    regex: UnionAnyStr, PatternAnyStr, *, fullmatch: bool = False
+) -> SearchStrategyAnyStr:
+    r"""Generates strings that contain a match for the given regex (i.e. ones
+    for which :func:`python:re.search` will return a non-None result).
+
+    ``regex`` may be a pattern or :func:`compiled regex <python:re.compile>`.
+    Both byte-strings and unicode strings are supported, and will generate
+    examples of the same type.
+
+    You can use regex flags such as :obj:`python:re.IGNORECASE` or
+    :obj:`python:re.DOTALL` to control generation. Flags can be passed either
+    in compiled regex or inside the pattern with a ``(?iLmsux)`` group.
+
+    Some regular expressions are only partly supported - the underlying
+    strategy checks local matching and relies on filtering to resolve
+    context-dependent expressions.  Using too many of these constructs may
+    cause health-check errors as too many examples are filtered out. This
+    mainly includes (positive or negative) lookahead and lookbehind groups.
+
+    If you want the generated string to match the whole regex you should use
+    boundary markers. So e.g. ``r"\A.\Z"`` will return a single character
+    string, while ``"."`` will return any string, and ``r"\A.$"`` will return
+    a single character optionally followed by a ``"\n"``.
+    Alternatively, passing ``fullmatch=True`` will ensure that the whole
+    string is a match, as if you had used the ``\A`` and ``\Z`` markers.
+
+    Examples from this strategy shrink towards shorter strings and lower
+    character values, with exact behaviour that may depend on the pattern.
+    """
+    check_type(bool, fullmatch, "fullmatch")
+    # TODO: We would like to move this to the top level, but pending some major
+    # refactoring it's hard to do without creating circular imports.
+    from hypothesis.strategies._internal.regex import regex_strategy
+
+    return regex_strategy(regex, fullmatch)
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def binary(
+    *,
+    min_size: int = 0,
+    max_size: Optionalint = None,
+) -> SearchStrategybytes:
+    """Generates :class:`python:bytes`.
+
+    The generated :class:`python:bytes` will have a length of at least ``min_size``
+    and at most ``max_size``.  If ``max_size`` is None there is no upper limit.
+
+    Examples from this strategy shrink towards smaller strings and lower byte
+    values.
+    """
+    check_valid_sizes(min_size, max_size)
+    if min_size == max_size:
+        return FixedSizeBytes(min_size)
+    return lists(
+        integers(min_value=0, max_value=255), min_size=min_size, max_size=max_size
+    ).map(bytes)
+
+
+@cacheable
+@defines_strategy()
+def randoms(
+    *,
+    note_method_calls: bool = False,
+    use_true_random: bool = False,
+) -> SearchStrategyrandom.Random:
+    """Generates instances of ``random.Random``. The generated Random instances
+    are of a special HypothesisRandom subclass.
+
+    - If ``note_method_calls`` is set to ``True``, Hypothesis will print the
+      randomly drawn values in any falsifying test case. This can be helpful
+      for debugging the behaviour of randomized algorithms.
+    - If ``use_true_random`` is set to ``True`` then values will be drawn from
+      their usual distribution, otherwise they will actually be Hypothesis
+      generated values (and will be shrunk accordingly for any failing test
+      case). Setting ``use_true_random=False`` will tend to expose bugs that
+      would occur with very low probability when it is set to True, and this
+      flag should only be set to True when your code relies on the distribution
+      of values for correctness.
+    """
+    check_type(bool, note_method_calls, "note_method_calls")
+    check_type(bool, use_true_random, "use_true_random")
+
+    from hypothesis.strategies._internal.random import RandomStrategy
+
+    return RandomStrategy(
+        use_true_random=use_true_random, note_method_calls=note_method_calls
+    )
+
+
+class RandomSeeder:
+    def __init__(self, seed):
+        self.seed = seed
+
+    def __repr__(self):
+        return f"RandomSeeder({self.seed!r})"
+
+
+class RandomModule(SearchStrategy):
+    def do_draw(self, data):
+        # It would be unsafe to do run this method more than once per test case,
+        # because cleanup() runs tasks in FIFO order (at time of writing!).
+        # Fortunately, the random_module() strategy wraps us in shared(), so
+        # it's cached for all but the first of any number of calls.
+        seed = data.draw(integers(0, 2**32 - 1))
+        seed_all, restore_all = get_seeder_and_restorer(seed)
+        seed_all()
+        cleanup(restore_all)
+        return RandomSeeder(seed)
+
+
+@cacheable
+@defines_strategy()
+def random_module() -> SearchStrategyRandomSeeder:
+    """The Hypothesis engine handles PRNG state for the stdlib and Numpy random
+    modules internally, always seeding them to zero and restoring the previous
+    state after the test.
+
+    If having a fixed seed would unacceptably weaken your tests, and you
+    cannot use a ``random.Random`` instance provided by
+    :func:`~hypothesis.strategies.randoms`, this strategy calls
+    :func:`python:random.seed` with an arbitrary integer and passes you
+    an opaque object whose repr displays the seed value for debugging.
+    If ``numpy.random`` is available, that state is also managed.
+
+    Examples from these strategy shrink to seeds closer to zero.
+    """
+    return shared(RandomModule(), key="hypothesis.strategies.random_module()")
+
+
+class BuildsStrategy(SearchStrategy):
+    def __init__(self, target, args, kwargs):
+        self.target = target
+        self.args = args
+        self.kwargs = kwargs
+
+    def do_draw(self, data):
+        args = data.draw(a) for a in self.args
+        kwargs = {k: data.draw(v) for k, v in self.kwargs.items()}
+        try:
+            obj = self.target(*args, **kwargs)
+        except TypeError as err:
+            if (
+                isinstance(self.target, type)
+                and issubclass(self.target, enum.Enum)
+                and not (self.args or self.kwargs)
+            ):
+                name = self.target.__module__ + "." + self.target.__qualname__
+                raise InvalidArgument(
+                    f"Calling {name} with no arguments raised an error - "
+                    f"try using sampled_from({name}) instead of builds({name})"
+                ) from err
+            if not (self.args or self.kwargs):
+                from .types import is_a_new_type, is_generic_type
+
+                if is_a_new_type(self.target) or is_generic_type(self.target):
+                    raise InvalidArgument(
+                        f"Calling {self.target!r} with no arguments raised an "
+                        f"error - try using from_type({self.target!r}) instead "
+                        f"of builds({self.target!r})"
+                    ) from err
+            if getattr(self.target, "__no_type_check__", None) is True:
+                # Note: could use PEP-678 __notes__ here.  Migrate over once we're
+                # using an `exceptiongroup` backport with support for that.
+                raise TypeError(
+                    "This might be because the @no_type_check decorator prevented "
+                    "Hypothesis from inferring a strategy for some required arguments."
+                ) from err
+            raise
+
+        current_build_context().record_call(obj, self.target, args, kwargs)
+        return obj
+
+    def validate(self):
+        tuples(*self.args).validate()
+        fixed_dictionaries(self.kwargs).validate()
+
+    def __repr__(self):
+        bits = get_pretty_function_description(self.target)
+        bits.extend(map(repr, self.args))
+        bits.extend(f"{k}={v!r}" for k, v in self.kwargs.items())
+        return f"builds({', '.join(bits)})"
+
+
+# The ideal signature builds(target, /, *args, **kwargs) is unfortunately a
+# SyntaxError before Python 3.8 so we emulate it with manual argument unpacking.
+# Note that for the benefit of documentation and introspection tools, we set the
+# __signature__ attribute to show the semantic rather than actual signature.
+@cacheable
+@defines_strategy()
+def builds(
+    *callable_and_args: UnionCallable..., Ex, SearchStrategyAny,
+    **kwargs: UnionSearchStrategyAny, EllipsisType,
+) -> SearchStrategyEx:
+    """Generates values by drawing from ``args`` and ``kwargs`` and passing
+    them to the callable (provided as the first positional argument) in the
+    appropriate argument position.
+
+    e.g. ``builds(target, integers(), flag=booleans())`` would draw an
+    integer ``i`` and a boolean ``b`` and call ``target(i, flag=b)``.
+
+    If the callable has type annotations, they will be used to infer a strategy
+    for required arguments that were not passed to builds.  You can also tell
+    builds to infer a strategy for an optional argument by passing ``...``
+    (:obj:`python:Ellipsis`) as a keyword argument to builds, instead of a strategy for
+    that argument to the callable.
+
+    If the callable is a class defined with :pypi:`attrs`, missing required
+    arguments will be inferred from the attribute on a best-effort basis,
+    e.g. by checking :ref:`attrs standard validators <attrs:api-validators>`.
+    Dataclasses are handled natively by the inference from type hints.
+
+    Examples from this strategy shrink by shrinking the argument values to
+    the callable.
+    """
+    if not callable_and_args:
+        raise InvalidArgument(  # pragma: no cover
+            "builds() must be passed a callable as the first positional "
+            "argument, but no positional arguments were given."
+        )
+    target, args = callable_and_args0, callable_and_args1:
+    if not callable(target):
+        raise InvalidArgument(
+            "The first positional argument to builds() must be a callable "
+            "target to construct."
+        )
+
+    if ... in args:  # type: ignore  # we only annotated the allowed types
+        # Avoid an implementation nightmare juggling tuples and worse things
+        raise InvalidArgument(
+            "... was passed as a positional argument to "
+            "builds(), but is only allowed as a keyword arg"
+        )
+    required = required_args(target, args, kwargs)
+    to_infer = {k for k, v in kwargs.items() if v is ...}
+    if required or to_infer:
+        if isinstance(target, type) and attr.has(target):
+            # Use our custom introspection for attrs classes
+            from hypothesis.strategies._internal.attrs import from_attrs
+
+            return from_attrs(target, args, kwargs, required | to_infer)
+        # Otherwise, try using type hints
+        hints = get_type_hints(target)
+        if to_infer - set(hints):
+            badargs = ", ".join(sorted(to_infer - set(hints)))
+            raise InvalidArgument(
+                f"passed ... for {badargs}, but we cannot infer a strategy "
+                "because these arguments have no type annotation"
+            )
+        infer_for = {k: v for k, v in hints.items() if k in (required | to_infer)}
+        if infer_for:
+            from hypothesis.strategies._internal.types import _global_type_lookup
+
+            for kw, t in infer_for.items():
+                if (
+                    getattr(t, "__module__", None) in ("builtins", "typing")
+                    or t in _global_type_lookup
+                ):
+                    kwargskw = from_type(t)
+                else:
+                    # We defer resolution of these type annotations so that the obvious
+                    # approach to registering recursive types just works.  See
+                    # https://github.com/HypothesisWorks/hypothesis/issues/3026
+                    kwargskw = deferred(lambda t=t: from_type(t))  # type: ignore
+    return BuildsStrategy(target, args, kwargs)
+
+
+if sys.version_info:2 >= (3, 8):
+    # See notes above definition - this signature is compatible and better
+    # matches the semantics of the function.  Great for documentation!
+    sig = signature(builds)
+    args, kwargs = sig.parameters.values()
+    builds = define_function_signature(
+        name=builds.__name__,
+        docstring=builds.__doc__,
+        signature=sig.replace(
+            parameters=
+                Parameter(
+                    name="target",
+                    kind=Parameter.POSITIONAL_ONLY,
+                    annotation=Callable..., Ex,
+                ),
+                args.replace(name="args", annotation=SearchStrategyAny),
+                kwargs,
+            
+        ),
+    )(builds)
+
+
+@cacheable
+@defines_strategy(never_lazy=True)
+def from_type(thing: TypeEx) -> SearchStrategyEx:
+    """Looks up the appropriate search strategy for the given type.
+
+    ``from_type`` is used internally to fill in missing arguments to
+    :func:`~hypothesis.strategies.builds` and can be used interactively
+    to explore what strategies are available or to debug type resolution.
+
+    You can use :func:`~hypothesis.strategies.register_type_strategy` to
+    handle your custom types, or to globally redefine certain strategies -
+    for example excluding NaN from floats, or use timezone-aware instead of
+    naive time and datetime strategies.
+
+    The resolution logic may be changed in a future version, but currently
+    tries these five options:
+
+    1. If ``thing`` is in the default lookup mapping or user-registered lookup,
+       return the corresponding strategy.  The default lookup covers all types
+       with Hypothesis strategies, including extras where possible.
+    2. If ``thing`` is from the :mod:`python:typing` module, return the
+       corresponding strategy (special logic).
+    3. If ``thing`` has one or more subtypes in the merged lookup, return
+       the union of the strategies for those types that are not subtypes of
+       other elements in the lookup.
+    4. Finally, if ``thing`` has type annotations for all required arguments,
+       and is not an abstract class, it is resolved via
+       :func:`~hypothesis.strategies.builds`.
+    5. Because :mod:`abstract types <python:abc>` cannot be instantiated,
+       we treat abstract types as the union of their concrete subclasses.
+       Note that this lookup works via inheritance but not via
+       :obj:`~python:abc.ABCMeta.register`, so you may still need to use
+       :func:`~hypothesis.strategies.register_type_strategy`.
+
+    There is a valuable recipe for leveraging ``from_type()`` to generate
+    "everything except" values from a specified type. I.e.
+
+    .. code-block:: python
+
+        def everything_except(excluded_types):
+            return (
+                from_type(type)
+                .flatmap(from_type)
+                .filter(lambda x: not isinstance(x, excluded_types))
+            )
+
+    For example, ``everything_except(int)`` returns a strategy that can
+    generate anything that ``from_type()`` can ever generate, except for
+    instances of :class:`python:int`, and excluding instances of types
+    added via :func:`~hypothesis.strategies.register_type_strategy`.
+
+    This is useful when writing tests which check that invalid input is
+    rejected in a certain way.
+    """
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            return _from_type(thing, )
+    except Exception:
+        return _from_type_deferred(thing)
+
+
+def _from_type_deferred(thing: TypeEx) -> SearchStrategyEx:
+    # This tricky little dance is because we want to show the repr of the actual
+    # underlying strategy wherever possible, as a form of user education, but
+    # would prefer to fall back to the default "from_type(...)" repr instead of
+    # "deferred(...)" for recursive types or invalid arguments.
+    return LazyStrategy(
+        lambda thing: deferred(lambda: _from_type(thing, )),
+        (thing,),
+        {},
+        force_repr=f"from_type({thing!r})",
+    )
+
+
+def _from_type(thing: TypeEx, recurse_guard: ListTypeEx) -> SearchStrategyEx:
+    # TODO: We would like to move this to the top level, but pending some major
+    # refactoring it's hard to do without creating circular imports.
+    from hypothesis.strategies._internal import types
+
+    def as_strategy(strat_or_callable, thing, final=True):
+        # User-provided strategies need some validation, and callables even more
+        # of it.  We do this in three places, hence the helper function
+        if not isinstance(strat_or_callable, SearchStrategy):
+            assert callable(strat_or_callable)  # Validated in register_type_strategy
+            strategy = strat_or_callable(thing)
+        else:
+            strategy = strat_or_callable
+        if not isinstance(strategy, SearchStrategy):
+            raise ResolutionFailed(
+                f"Error: {thing} was registered for {nicerepr(strat_or_callable)}, "
+                f"but returned non-strategy {strategy!r}"
+            )
+        if strategy.is_empty:
+            raise ResolutionFailed(f"Error: {thing!r} resolved to an empty strategy")
+        return strategy
+
+    def from_type_guarded(thing):
+        """Returns the result of producer, or ... if recursion on thing is encountered"""
+        if thing in recurse_guard:
+            raise RewindRecursive(thing)
+        recurse_guard.append(thing)
+        try:
+            return _from_type(thing, recurse_guard)
+        except RewindRecursive as rr:
+            if rr.target != thing:
+                raise
+            return ...  # defer resolution
+        finally:
+            recurse_guard.pop()
+
+    # Let registered extra modules handle their own recognized types first, before
+    # e.g. Unions are resolved
+    if thing not in types._global_type_lookup:
+        for module, resolver in types._global_extra_lookup.items():
+            if module in sys.modules:
+                strat = resolver(thing)
+                if strat is not None:
+                    return strat
+    if not isinstance(thing, type):
+        if types.is_a_new_type(thing):
+            # Check if we have an explicitly registered strategy for this thing,
+            # resolve it so, and otherwise resolve as for the base type.
+            if thing in types._global_type_lookup:
+                return as_strategy(types._global_type_lookupthing, thing)
+            return _from_type(thing.__supertype__, recurse_guard)
+        # Unions are not instances of `type` - but we still want to resolve them!
+        if types.is_a_union(thing):
+            args = sorted(thing.__args__, key=types.type_sorting_key)
+            return one_of(_from_type(t, recurse_guard) for t in args)
+    if not types.is_a_type(thing):
+        if isinstance(thing, str):
+            # See https://github.com/HypothesisWorks/hypothesis/issues/3016
+            raise InvalidArgument(
+                f"Got {thing!r} as a type annotation, but the forward-reference "
+                "could not be resolved from a string to a type.  Consider using "
+                "`from __future__ import annotations` instead of forward-reference "
+                "strings."
+            )
+        raise InvalidArgument(f"thing={thing!r} must be a type")  # pragma: no cover
+    if thing in types.NON_RUNTIME_TYPES:
+        # Some code like `st.from_type(TypeAlias)` does not make sense.
+        # Because there are types in python that do not exist in runtime.
+        raise InvalidArgument(
+            f"Could not resolve {thing!r} to a strategy, "
+            f"because there is no such thing as a runtime instance of {thing!r}"
+        )
+    # Now that we know `thing` is a type, the first step is to check for an
+    # explicitly registered strategy. This is the best (and hopefully most
+    # common) way to resolve a type to a strategy.  Note that the value in the
+    # lookup may be a strategy or a function from type -> strategy; and we
+    # convert empty results into an explicit error.
+    try:
+        if thing in types._global_type_lookup:
+            return as_strategy(types._global_type_lookupthing, thing)
+    except TypeError:  # pragma: no cover
+        # This is due to a bizarre divergence in behaviour under Python 3.9.0:
+        # typing.Callable, foo has __args__ = (foo,) but collections.abc.Callable
+        # has __args__ = (, foo); and as a result is non-hashable.
+        pass
+    if (
+        hasattr(typing, "_TypedDictMeta")
+        and type(thing) is typing._TypedDictMeta
+        or hasattr(types.typing_extensions, "_TypedDictMeta")  # type: ignore
+        and type(thing) is types.typing_extensions._TypedDictMeta  # type: ignore
+    ):  # pragma: no cover
+        # The __optional_keys__ attribute may or may not be present, but if there's no
+        # way to tell and we just have to assume that everything is required.
+        # See https://github.com/python/cpython/pull/17214 for details.
+        optional = set(getattr(thing, "__optional_keys__", ()))
+        anns = {}
+        for k, v in get_type_hints(thing).items():
+            origin = getattr(v, "__origin__", None)
+            if origin in types.RequiredTypes + types.NotRequiredTypes:
+                if origin in types.NotRequiredTypes:
+                    optional.add(k)
+                else:
+                    optional.discard(k)
+                try:
+                    v = v.__args__0
+                except IndexError:
+                    raise InvalidArgument(
+                        f"`{k}: {v.__name__}` is not a valid type annotation"
+                    ) from None
+            annsk = from_type_guarded(v)
+            if annsk is ...:
+                annsk = _from_type_deferred(v)
+        if (
+            (not anns)
+            and thing.__annotations__
+            and ".<locals>." in getattr(thing, "__qualname__", "")
+        ):
+            raise InvalidArgument("Failed to retrieve type annotations for local type")
+        return fixed_dictionaries(  # type: ignore
+            mapping={k: v for k, v in anns.items() if k not in optional},
+            optional={k: v for k, v in anns.items() if k in optional},
+        )
+    # We also have a special case for TypeVars.
+    # They are represented as instances like `~T` when they come here.
+    # We need to work with their type instead.
+    if isinstance(thing, TypeVar) and type(thing) in types._global_type_lookup:
+        return as_strategy(types._global_type_lookuptype(thing), thing)
+
+    # If there's no explicitly registered strategy, maybe a subtype of thing
+    # is registered - if so, we can resolve it to the subclass strategy.
+    # We'll start by checking if thing is from from the typing module,
+    # because there are several special cases that don't play well with
+    # subclass and instance checks.
+    if isinstance(thing, types.typing_root_type) or (
+        sys.version_info:2 >= (3, 9)
+        and isinstance(getattr(thing, "__origin__", None), type)
+        and getattr(thing, "__args__", None)
+    ):
+        return types.from_typing_type(thing)
+    # If it's not from the typing module, we get all registered types that are
+    # a subclass of `thing` and are not themselves a subtype of any other such
+    # type.  For example, `Number -> integers() | floats()`, but bools() is
+    # not included because bool is a subclass of int as well as Number.
+    strategies = 
+        as_strategy(v, thing, final=False)
+        for k, v in sorted(types._global_type_lookup.items(), key=repr)
+        if isinstance(k, type)
+        and issubclass(k, thing)
+        and sum(types.try_issubclass(k, typ) for typ in types._global_type_lookup) == 1
+    
+    if any(not s.is_empty for s in strategies):
+        return one_of(strategies)
+    # If we don't have a strategy registered for this type or any subtype, we
+    # may be able to fall back on type annotations.
+    if issubclass(thing, enum.Enum):
+        return sampled_from(thing)
+    # Finally, try to build an instance by calling the type object.  Unlike builds(),
+    # this block *does* try to infer strategies for arguments with default values.
+    # That's because of the semantic different; builds() -> "call this with ..."
+    # so we only infer when *not* doing so would be an error; from_type() -> "give
+    # me arbitrary instances" so the greater variety is acceptable.
+    # And if it's *too* varied, express your opinions with register_type_strategy()
+    if not isabstract(thing):
+        # If we know that builds(thing) will fail, give a better error message
+        required = required_args(thing)
+        if required and not (
+            required.issubset(get_type_hints(thing))
+            or attr.has(thing)
+            or is_typed_named_tuple(thing)  # weird enough that we have a specific check
+        ):
+            raise ResolutionFailed(
+                f"Could not resolve {thing!r} to a strategy; consider "
+                "using register_type_strategy"
+            )
+        try:
+            hints = get_type_hints(thing)
+            params = get_signature(thing).parameters
+        except Exception:
+            params = {}  # type: ignore
+        kwargs = {}
+        for k, p in params.items():
+            if (
+                k in hints
+                and k != "return"
+                and p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY)
+            ):
+                kwargsk = from_type_guarded(hintsk)
+                if p.default is not Parameter.empty and kwargsk is not ...:
+                    kwargsk = just(p.default) | kwargsk
+        if params and not kwargs:
+            from_type_repr = repr_call(from_type, (thing,), {})
+            builds_repr = repr_call(builds, (thing,), {})
+            warnings.warn(
+                f"{from_type_repr} resolved to {builds_repr}, because we could not "
+                "find any (non-varargs) arguments. Use st.register_type_strategy() "
+                "to resolve to a strategy which can generate more than one value, "
+                "or silence this warning.",
+                SmallSearchSpaceWarning,
+            )
+        return builds(thing, **kwargs)
+    # And if it's an abstract type, we'll resolve to a union of subclasses instead.
+    subclasses = thing.__subclasses__()
+    if not subclasses:
+        raise ResolutionFailed(
+            f"Could not resolve {thing!r} to a strategy, because it is an abstract "
+            "type without any subclasses. Consider using register_type_strategy"
+        )
+    subclass_strategies = nothing()
+    for sc in subclasses:
+        try:
+            subclass_strategies |= _from_type(sc, recurse_guard)
+        except Exception:
+            pass
+    if subclass_strategies.is_empty:
+        # We're unable to resolve subclasses now, but we might be able to later -
+        # so we'll just go back to the mixed distribution.
+        return sampled_from(subclasses).flatmap(lambda t: _from_type(t, recurse_guard))
+    return subclass_strategies
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def fractions(
+    min_value: OptionalUnionReal, str = None,
+    max_value: OptionalUnionReal, str = None,
+    *,
+    max_denominator: Optionalint = None,
+) -> SearchStrategyFraction:
+    """Returns a strategy which generates Fractions.
+
+    If ``min_value`` is not None then all generated values are no less than
+    ``min_value``.  If ``max_value`` is not None then all generated values are no
+    greater than ``max_value``.  ``min_value`` and ``max_value`` may be anything accepted
+    by the :class:`~fractions.Fraction` constructor.
+
+    If ``max_denominator`` is not None then the denominator of any generated
+    values is no greater than ``max_denominator``. Note that ``max_denominator`` must
+    be None or a positive integer.
+
+    Examples from this strategy shrink towards smaller denominators, then
+    closer to zero.
+    """
+    min_value = try_convert(Fraction, min_value, "min_value")
+    max_value = try_convert(Fraction, max_value, "max_value")
+    # These assertions tell Mypy what happened in try_convert
+    assert min_value is None or isinstance(min_value, Fraction)
+    assert max_value is None or isinstance(max_value, Fraction)
+
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+    check_valid_integer(max_denominator, "max_denominator")
+
+    if max_denominator is not None:
+        if max_denominator < 1:
+            raise InvalidArgument(f"max_denominator={max_denominator!r} must be >= 1")
+        if min_value is not None and min_value.denominator > max_denominator:
+            raise InvalidArgument(
+                f"The min_value={min_value!r} has a denominator greater than the "
+                f"max_denominator={max_denominator!r}"
+            )
+        if max_value is not None and max_value.denominator > max_denominator:
+            raise InvalidArgument(
+                f"The max_value={max_value!r} has a denominator greater than the "
+                f"max_denominator={max_denominator!r}"
+            )
+
+    if min_value is not None and min_value == max_value:
+        return just(min_value)
+
+    def dm_func(denom):
+        """Take denom, construct numerator strategy, and build fraction."""
+        # Four cases of algebra to get integer bounds and scale factor.
+        min_num, max_num = None, None
+        if max_value is None and min_value is None:
+            pass
+        elif min_value is None:
+            max_num = denom * max_value.numerator
+            denom *= max_value.denominator
+        elif max_value is None:
+            min_num = denom * min_value.numerator
+            denom *= min_value.denominator
+        else:
+            low = min_value.numerator * max_value.denominator
+            high = max_value.numerator * min_value.denominator
+            scale = min_value.denominator * max_value.denominator
+            # After calculating our integer bounds and scale factor, we remove
+            # the gcd to avoid drawing more bytes for the example than needed.
+            # Note that `div` can be at most equal to `scale`.
+            div = math.gcd(scale, math.gcd(low, high))
+            min_num = denom * low // div
+            max_num = denom * high // div
+            denom *= scale // div
+
+        return builds(
+            Fraction, integers(min_value=min_num, max_value=max_num), just(denom)
+        )
+
+    if max_denominator is None:
+        return integers(min_value=1).flatmap(dm_func)
+
+    return (
+        integers(1, max_denominator)
+        .flatmap(dm_func)
+        .map(lambda f: f.limit_denominator(max_denominator))
+    )
+
+
+def _as_finite_decimal(
+    value: UnionReal, str, None, name: str, allow_infinity: Optionalbool
+) -> OptionalDecimal:
+    """Convert decimal bounds to decimals, carefully."""
+    assert name in ("min_value", "max_value")
+    if value is None:
+        return None
+    if not isinstance(value, Decimal):
+        with localcontext(Context()):  # ensure that default traps are enabled
+            value = try_convert(Decimal, value, name)
+    assert isinstance(value, Decimal)
+    if value.is_finite():
+        return value
+    if value.is_infinite() and (value < 0 if "min" in name else value > 0):
+        if allow_infinity or allow_infinity is None:
+            return None
+        raise InvalidArgument(
+            f"allow_infinity={allow_infinity!r}, but {name}={value!r}"
+        )
+    # This could be infinity, quiet NaN, or signalling NaN
+    raise InvalidArgument(f"Invalid {name}={value!r}")
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def decimals(
+    min_value: OptionalUnionReal, str = None,
+    max_value: OptionalUnionReal, str = None,
+    *,
+    allow_nan: Optionalbool = None,
+    allow_infinity: Optionalbool = None,
+    places: Optionalint = None,
+) -> SearchStrategyDecimal:
+    """Generates instances of :class:`python:decimal.Decimal`, which may be:
+
+    - A finite rational number, between ``min_value`` and ``max_value``.
+    - Not a Number, if ``allow_nan`` is True.  None means "allow NaN, unless
+      ``min_value`` and ``max_value`` are not None".
+    - Positive or negative infinity, if ``max_value`` and ``min_value``
+      respectively are None, and ``allow_infinity`` is not False.  None means
+      "allow infinity, unless excluded by the min and max values".
+
+    Note that where floats have one ``NaN`` value, Decimals have four: signed,
+    and either *quiet* or *signalling*.  See `the decimal module docs
+    <https://docs.python.org/3/library/decimal.html#special-values>`_ for
+    more information on special values.
+
+    If ``places`` is not None, all finite values drawn from the strategy will
+    have that number of digits after the decimal place.
+
+    Examples from this strategy do not have a well defined shrink order but
+    try to maximize human readability when shrinking.
+    """
+    # Convert min_value and max_value to Decimal values, and validate args
+    check_valid_integer(places, "places")
+    if places is not None and places < 0:
+        raise InvalidArgument(f"places={places!r} may not be negative")
+    min_value = _as_finite_decimal(min_value, "min_value", allow_infinity)
+    max_value = _as_finite_decimal(max_value, "max_value", allow_infinity)
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+    if allow_infinity and (None not in (min_value, max_value)):
+        raise InvalidArgument("Cannot allow infinity between finite bounds")
+    # Set up a strategy for finite decimals.  Note that both floating and
+    # fixed-point decimals require careful handling to remain isolated from
+    # any external precision context - in short, we always work out the
+    # required precision for lossless operation and use context methods.
+    if places is not None:
+        # Fixed-point decimals are basically integers with a scale factor
+        def ctx(val):
+            """Return a context in which this value is lossless."""
+            precision = ceil(math.log10(abs(val) or 1)) + places + 1
+            return Context(prec=max(precision, 1))
+
+        def int_to_decimal(val):
+            context = ctx(val)
+            return context.quantize(context.multiply(val, factor), factor)
+
+        factor = Decimal(10) ** -places
+        min_num, max_num = None, None
+        if min_value is not None:
+            min_num = ceil(ctx(min_value).divide(min_value, factor))
+        if max_value is not None:
+            max_num = floor(ctx(max_value).divide(max_value, factor))
+        if min_num is not None and max_num is not None and min_num > max_num:
+            raise InvalidArgument(
+                f"There are no decimals with {places} places between "
+                f"min_value={min_value!r} and max_value={max_value!r}"
+            )
+        strat = integers(min_num, max_num).map(int_to_decimal)
+    else:
+        # Otherwise, they're like fractions featuring a power of ten
+        def fraction_to_decimal(val):
+            precision = (
+                ceil(math.log10(abs(val.numerator) or 1) + math.log10(val.denominator))
+                + 1
+            )
+            return Context(prec=precision or 1).divide(
+                Decimal(val.numerator), val.denominator
+            )
+
+        strat = fractions(min_value, max_value).map(fraction_to_decimal)
+    # Compose with sampled_from for infinities and NaNs as appropriate
+    special: ListDecimal = 
+    if allow_nan or (allow_nan is None and (None in (min_value, max_value))):
+        special.extend(map(Decimal, ("NaN", "-NaN", "sNaN", "-sNaN")))
+    if allow_infinity or (allow_infinity is None and max_value is None):
+        special.append(Decimal("Infinity"))
+    if allow_infinity or (allow_infinity is None and min_value is None):
+        special.append(Decimal("-Infinity"))
+    return strat | (sampled_from(special) if special else nothing())
+
+
+@defines_strategy(never_lazy=True)
+def recursive(
+    base: SearchStrategyEx,
+    extend: CallableSearchStrategyAny, SearchStrategyT,
+    *,
+    max_leaves: int = 100,
+) -> SearchStrategyUnionT, Ex:
+    """base: A strategy to start from.
+
+    extend: A function which takes a strategy and returns a new strategy.
+
+    max_leaves: The maximum number of elements to be drawn from base on a given
+    run.
+
+    This returns a strategy ``S`` such that ``S = extend(base | S)``. That is,
+    values may be drawn from base, or from any strategy reachable by mixing
+    applications of | and extend.
+
+    An example may clarify: ``recursive(booleans(), lists)`` would return a
+    strategy that may return arbitrarily nested and mixed lists of booleans.
+    So e.g. ``False``, ``True``, ``False, ``, and ``True`` are
+    all valid values to be drawn from that strategy.
+
+    Examples from this strategy shrink by trying to reduce the amount of
+    recursion and by shrinking according to the shrinking behaviour of base
+    and the result of extend.
+
+    """
+
+    return RecursiveStrategy(base, extend, max_leaves)
+
+
+class PermutationStrategy(SearchStrategy):
+    def __init__(self, values):
+        self.values = values
+
+    def do_draw(self, data):
+        # Reversed Fisher-Yates shuffle: swap each element with itself or with
+        # a later element.  This shrinks i==j for each element, i.e. to no
+        # change.  We don't consider the last element as it's always a no-op.
+        result = list(self.values)
+        for i in range(len(result) - 1):
+            j = integer_range(data, i, len(result) - 1)
+            resulti, resultj = resultj, resulti
+        return result
+
+
+@defines_strategy()
+def permutations(values: SequenceT) -> SearchStrategyListT:
+    """Return a strategy which returns permutations of the ordered collection
+    ``values``.
+
+    Examples from this strategy shrink by trying to become closer to the
+    original order of values.
+    """
+    values = check_sample(values, "permutations")
+    if not values:
+        return builds(list)
+
+    return PermutationStrategy(values)
+
+
+class CompositeStrategy(SearchStrategy):
+    def __init__(self, definition, args, kwargs):
+        self.definition = definition
+        self.args = args
+        self.kwargs = kwargs
+
+    def do_draw(self, data):
+        return self.definition(data.draw, *self.args, **self.kwargs)
+
+    def calc_label(self):
+        return calc_label_from_cls(self.definition)
+
+
+class DrawFn(Protocol):
+    """This type only exists so that you can write type hints for functions
+    decorated with :func:`@composite <hypothesis.strategies.composite>`.
+
+    .. code-block:: python
+
+        @composite
+        def list_and_index(draw: DrawFn) -> Tupleint, str:
+            i = draw(integers())  # type inferred as 'int'
+            s = draw(text())  # type inferred as 'str'
+            return i, s
+
+    """
+
+    def __init__(self):
+        raise TypeError("Protocols cannot be instantiated")  # pragma: no cover
+
+    # On Python 3.8+, Protocol overrides our signature for __init__,
+    # so we override it right back to make the docs look nice.
+    __signature__: Signature = Signature(parameters=)
+
+    # We define this as a callback protocol because a simple typing.Callable is
+    # insufficient to fully represent the interface, due to the optional `label`
+    # parameter.
+    def __call__(self, strategy: SearchStrategyEx, label: object = None) -> Ex:
+        raise NotImplementedError
+
+
+def _composite(f):
+    # Wrapped below, using ParamSpec if available
+    if isinstance(f, (classmethod, staticmethod)):
+        special_method = type(f)
+        f = f.__func__
+    else:
+        special_method = None
+
+    sig = get_signature(f)
+    params = tuple(sig.parameters.values())
+
+    if not (params and "POSITIONAL" in params0.kind.name):
+        raise InvalidArgument(
+            "Functions wrapped with composite must take at least one "
+            "positional argument."
+        )
+    if params0.default is not sig.empty:
+        raise InvalidArgument("A default value for initial argument will never be used")
+    if not is_first_param_referenced_in_function(f):
+        note_deprecation(
+            "There is no reason to use @st.composite on a function which "
+            "does not call the provided draw() function internally.",
+            since="2022-07-17",
+            has_codemod=False,
+        )
+    if params0.kind.name != "VAR_POSITIONAL":
+        params = params1:
+    newsig = sig.replace(
+        parameters=params,
+        return_annotation=SearchStrategy
+        if sig.return_annotation is sig.empty
+        else SearchStrategysig.return_annotation,
+    )
+
+    @defines_strategy()
+    @define_function_signature(f.__name__, f.__doc__, newsig)
+    def accept(*args, **kwargs):
+        return CompositeStrategy(f, args, kwargs)
+
+    accept.__module__ = f.__module__
+    accept.__signature__ = newsig
+    if special_method is not None:
+        return special_method(accept)
+    return accept
+
+
+if typing.TYPE_CHECKING or ParamSpec is not None:
+    P = ParamSpec("P")
+
+    def composite(
+        f: CallableConcatenateDrawFn, P, Ex
+    ) -> CallableP, SearchStrategyEx:
+        """Defines a strategy that is built out of potentially arbitrarily many
+        other strategies.
+
+        This is intended to be used as a decorator. See
+        :ref:`the full documentation for more details <composite-strategies>`
+        about how to use this function.
+
+        Examples from this strategy shrink by shrinking the output of each draw
+        call.
+        """
+        return _composite(f)
+
+else:  # pragma: no cover
+
+    @cacheable
+    def composite(f: Callable..., Ex) -> Callable..., SearchStrategyEx:
+        """Defines a strategy that is built out of potentially arbitrarily many
+        other strategies.
+
+        This is intended to be used as a decorator. See
+        :ref:`the full documentation for more details <composite-strategies>`
+        about how to use this function.
+
+        Examples from this strategy shrink by shrinking the output of each draw
+        call.
+        """
+        return _composite(f)
+
+
+@defines_strategy(force_reusable_values=True)
+@cacheable
+def complex_numbers(
+    *,
+    min_magnitude: Real = 0,
+    max_magnitude: OptionalReal = None,
+    allow_infinity: Optionalbool = None,
+    allow_nan: Optionalbool = None,
+    allow_subnormal: bool = True,
+    width: int = 128,
+) -> SearchStrategycomplex:
+    """Returns a strategy that generates :class:`~python:complex`
+    numbers.
+
+    This strategy draws complex numbers with constrained magnitudes.
+    The ``min_magnitude`` and ``max_magnitude`` parameters should be
+    non-negative :class:`~python:numbers.Real` numbers; a value
+    of ``None`` corresponds an infinite upper bound.
+
+    If ``min_magnitude`` is nonzero or ``max_magnitude`` is finite, it
+    is an error to enable ``allow_nan``.  If ``max_magnitude`` is finite,
+    it is an error to enable ``allow_infinity``.
+
+    ``allow_infinity``, ``allow_nan``, and ``allow_subnormal`` are
+    applied to each part of the complex number separately, as for
+    :func:`~hypothesis.strategies.floats`.
+
+    The magnitude constraints are respected up to a relative error
+    of (around) floating-point epsilon, due to implementation via
+    the system ``sqrt`` function.
+
+    The ``width`` argument specifies the maximum number of bits of precision
+    required to represent the entire generated complex number.
+    Valid values are 32, 64 or 128, which correspond to the real and imaginary
+    components each having width 16, 32 or 64, respectively.
+    Passing ``width=64`` will still use the builtin 128-bit
+    :class:`~python:complex` class, but always for values which can be
+    exactly represented as two 32-bit floats.
+
+    Examples from this strategy shrink by shrinking their real and
+    imaginary parts, as :func:`~hypothesis.strategies.floats`.
+
+    If you need to generate complex numbers with particular real and
+    imaginary parts or relationships between parts, consider using
+    :func:`builds(complex, ...) <hypothesis.strategies.builds>` or
+    :func:`@composite <hypothesis.strategies.composite>` respectively.
+    """
+    check_valid_magnitude(min_magnitude, "min_magnitude")
+    check_valid_magnitude(max_magnitude, "max_magnitude")
+    check_valid_interval(min_magnitude, max_magnitude, "min_magnitude", "max_magnitude")
+    if max_magnitude == math.inf:
+        max_magnitude = None
+
+    if allow_infinity is None:
+        allow_infinity = bool(max_magnitude is None)
+    elif allow_infinity and max_magnitude is not None:
+        raise InvalidArgument(
+            f"Cannot have allow_infinity={allow_infinity!r} with "
+            f"max_magnitude={max_magnitude!r}"
+        )
+    if allow_nan is None:
+        allow_nan = bool(min_magnitude == 0 and max_magnitude is None)
+    elif allow_nan and not (min_magnitude == 0 and max_magnitude is None):
+        raise InvalidArgument(
+            f"Cannot have allow_nan={allow_nan!r}, min_magnitude={min_magnitude!r} "
+            f"max_magnitude={max_magnitude!r}"
+        )
+    check_type(bool, allow_subnormal, "allow_subnormal")
+    if width not in (32, 64, 128):
+        raise InvalidArgument(
+            f"width={width!r}, but must be 32, 64 or 128 (other complex dtypes "
+            "such as complex192 or complex256 are not supported)"
+            # For numpy, these types would be supported (but not by CPython):
+            # https://numpy.org/doc/stable/reference/arrays.scalars.html#complex-floating-point-types
+        )
+    component_width = width // 2
+    allow_kw = {
+        "allow_nan": allow_nan,
+        "allow_infinity": allow_infinity,
+        # If we have a nonzero normal min_magnitude and draw a zero imaginary part,
+        # then allow_subnormal=True would be an error with the min_value to the floats()
+        # strategy for the real part.  We therefore replace True with None.
+        "allow_subnormal": None if allow_subnormal else allow_subnormal,
+        "width": component_width,
+    }
+
+    if min_magnitude == 0 and max_magnitude is None:
+        # In this simple but common case, there are no constraints on the
+        # magnitude and therefore no relationship between the real and
+        # imaginary parts.
+        return builds(complex, floats(**allow_kw), floats(**allow_kw))  # type: ignore
+
+    @composite
+    def constrained_complex(draw):
+        # We downcast drawn floats to the desired (component) width so we
+        # guarantee the resulting complex values are representable. Note
+        # truncating the mantissa bits with float_of() cannot increase the
+        # magnitude of a float, so we are guaranteed to stay within the allowed
+        # range. See https://github.com/HypothesisWorks/hypothesis/issues/3573
+
+        # Draw the imaginary part, and determine the maximum real part given
+        # this and the max_magnitude
+        if max_magnitude is None:
+            zi = draw(floats(**allow_kw))
+            rmax = None
+        else:
+            zi = draw(
+                floats(
+                    -float_of(max_magnitude, component_width),
+                    float_of(max_magnitude, component_width),
+                    **allow_kw,
+                )
+            )
+            rmax = float_of(cathetus(max_magnitude, zi), component_width)
+        # Draw the real part from the allowed range given the imaginary part
+        if min_magnitude == 0 or math.fabs(zi) >= min_magnitude:
+            zr = draw(floats(None if rmax is None else -rmax, rmax, **allow_kw))
+        else:
+            rmin = float_of(cathetus(min_magnitude, zi), component_width)
+            zr = draw(floats(rmin, rmax, **allow_kw))
+        # Order of conditions carefully tuned so that for a given pair of
+        # magnitude arguments, we always either draw or do not draw the bool
+        # (crucial for good shrinking behaviour) but only invert when needed.
+        if min_magnitude > 0 and draw(booleans()) and math.fabs(zi) <= min_magnitude:
+            zr = -zr
+        return complex(zr, zi)
+
+    return constrained_complex()
+
+
+@defines_strategy(never_lazy=True)
+def shared(
+    base: SearchStrategyEx,
+    *,
+    key: OptionalHashable = None,
+) -> SearchStrategyEx:
+    """Returns a strategy that draws a single shared value per run, drawn from
+    base. Any two shared instances with the same key will share the same value,
+    otherwise the identity of this strategy will be used. That is:
+
+    >>> s = integers()  # or any other strategy
+    >>> x = shared(s)
+    >>> y = shared(s)
+
+    In the above x and y may draw different (or potentially the same) values.
+    In the following they will always draw the same:
+
+    >>> x = shared(s, key="hi")
+    >>> y = shared(s, key="hi")
+
+    Examples from this strategy shrink as per their base strategy.
+    """
+    return SharedStrategy(base, key)
+
+
+@composite
+def _maybe_nil_uuids(draw, uuid):
+    # Equivalent to `random_uuids | just(...)`, with a stronger bias to the former.
+    if draw(data()).conjecture_data.draw_bits(6) == 63:
+        return UUID("00000000-0000-0000-0000-000000000000")
+    return uuid
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def uuids(
+    *, version: Optionalint = None, allow_nil: bool = False
+) -> SearchStrategyUUID:
+    """Returns a strategy that generates :class:`UUIDs <uuid.UUID>`.
+
+    If the optional version argument is given, value is passed through
+    to :class:`~python:uuid.UUID` and only UUIDs of that version will
+    be generated.
+
+    If ``allow_nil`` is True, generate the nil UUID much more often.
+    Otherwise, all returned values from this will be unique, so e.g. if you do
+    ``lists(uuids())`` the resulting list will never contain duplicates.
+
+    Examples from this strategy don't have any meaningful shrink order.
+    """
+    check_type(bool, allow_nil, "allow_nil")
+    if version not in (None, 1, 2, 3, 4, 5):
+        raise InvalidArgument(
+            f"version={version!r}, but version must be in "
+            "(None, 1, 2, 3, 4, 5) to pass to the uuid.UUID constructor."
+        )
+    random_uuids = shared(
+        randoms(use_true_random=True), key="hypothesis.strategies.uuids.generator"
+    ).map(lambda r: UUID(version=version, int=r.getrandbits(128)))
+
+    if allow_nil:
+        if version is not None:
+            raise InvalidArgument("The nil UUID is not of any version")
+        return random_uuids.flatmap(_maybe_nil_uuids)
+    return random_uuids
+
+
+class RunnerStrategy(SearchStrategy):
+    def __init__(self, default):
+        self.default = default
+
+    def do_draw(self, data):
+        runner = getattr(data, "hypothesis_runner", not_set)
+        if runner is not_set:
+            if self.default is not_set:
+                raise InvalidArgument(
+                    "Cannot use runner() strategy with no "
+                    "associated runner or explicit default."
+                )
+            else:
+                return self.default
+        else:
+            return runner
+
+
+@defines_strategy(force_reusable_values=True)
+def runner(*, default: Any = not_set) -> SearchStrategyAny:
+    """A strategy for getting "the current test runner", whatever that may be.
+    The exact meaning depends on the entry point, but it will usually be the
+    associated 'self' value for it.
+
+    If there is no current test runner and a default is provided, return
+    that default. If no default is provided, raises InvalidArgument.
+
+    Examples from this strategy do not shrink (because there is only one).
+    """
+    return RunnerStrategy(default)
+
+
+class DataObject:
+    """This type only exists so that you can write type hints for tests using
+    the :func:`~hypothesis.strategies.data` strategy.  Do not use it directly!
+    """
+
+    # Note that "only exists" here really means "is only exported to users",
+    # but we want to treat it as "semi-stable", not document it as "public API".
+
+    def __init__(self, data):
+        self.count = 0
+        self.conjecture_data = data
+
+    def __repr__(self):
+        return "data(...)"
+
+    def draw(self, strategy: SearchStrategyEx, label: Any = None) -> Ex:
+        check_strategy(strategy, "strategy")
+        result = self.conjecture_data.draw(strategy)
+        self.count += 1
+        printer = RepresentationPrinter(context=current_build_context())
+        printer.text(f"Draw {self.count}")
+        printer.text(": " if label is None else f" ({label}): ")
+        printer.pretty(result)
+        note(printer.getvalue())
+        return result
+
+
+class DataStrategy(SearchStrategy):
+    supports_find = False
+
+    def do_draw(self, data):
+        if not hasattr(data, "hypothesis_shared_data_strategy"):
+            data.hypothesis_shared_data_strategy = DataObject(data)
+        return data.hypothesis_shared_data_strategy
+
+    def __repr__(self):
+        return "data()"
+
+    def map(self, f):
+        self.__not_a_first_class_strategy("map")
+
+    def filter(self, f):
+        self.__not_a_first_class_strategy("filter")
+
+    def flatmap(self, f):
+        self.__not_a_first_class_strategy("flatmap")
+
+    def example(self):
+        self.__not_a_first_class_strategy("example")
+
+    def __not_a_first_class_strategy(self, name):
+        raise InvalidArgument(
+            f"Cannot call {name} on a DataStrategy. You should probably "
+            "be using @composite for whatever it is you're trying to do."
+        )
+
+
+@cacheable
+@defines_strategy(never_lazy=True)
+def data() -> SearchStrategyDataObject:
+    """This isn't really a normal strategy, but instead gives you an object
+    which can be used to draw data interactively from other strategies.
+
+    See :ref:`the rest of the documentation <interactive-draw>` for more
+    complete information.
+
+    Examples from this strategy do not shrink (because there is only one),
+    but the result of calls to each draw() call shrink as they normally would.
+    """
+    return DataStrategy()
+
+
+def register_type_strategy(
+    custom_type: TypeEx,
+    strategy: UnionSearchStrategyEx, CallableTypeEx, SearchStrategyEx,
+) -> None:
+    """Add an entry to the global type-to-strategy lookup.
+
+    This lookup is used in :func:`~hypothesis.strategies.builds` and
+    :func:`@given <hypothesis.given>`.
+
+    :func:`~hypothesis.strategies.builds` will be used automatically for
+    classes with type annotations on ``__init__`` , so you only need to
+    register a strategy if one or more arguments need to be more tightly
+    defined than their type-based default, or if you want to supply a strategy
+    for an argument with a default value.
+
+    ``strategy`` may be a search strategy, or a function that takes a type and
+    returns a strategy (useful for generic types).
+
+    Note that you may not register a parametrised generic type (such as
+    ``MyCollectionint``) directly, because the resolution logic does not
+    handle this case correctly.  Instead, you may register a *function* for
+    ``MyCollection`` and `inspect the type parameters within that function
+    <https://stackoverflow.com/q/48572831>`__.
+    """
+    # TODO: We would like to move this to the top level, but pending some major
+    # refactoring it's hard to do without creating circular imports.
+    from hypothesis.strategies._internal import types
+
+    if not types.is_a_type(custom_type):
+        raise InvalidArgument(f"custom_type={custom_type!r} must be a type")
+    if custom_type in types.NON_RUNTIME_TYPES:
+        raise InvalidArgument(
+            f"custom_type={custom_type!r} is not allowed to be registered, "
+            f"because there is no such thing as a runtime instance of {custom_type!r}"
+        )
+    elif not (isinstance(strategy, SearchStrategy) or callable(strategy)):
+        raise InvalidArgument(
+            "strategy=%r must be a SearchStrategy, or a function that takes "
+            "a generic type and returns a specific SearchStrategy"
+        )
+    elif isinstance(strategy, SearchStrategy) and strategy.is_empty:
+        raise InvalidArgument("strategy=%r must not be empty")
+    elif types.has_type_arguments(custom_type):
+        origin = getattr(custom_type, "__origin__", None)
+        raise InvalidArgument(
+            f"Cannot register generic type {custom_type!r}, because it has type "
+            "arguments which would not be handled.  Instead, register a function "
+            f"for {origin!r} which can inspect specific type objects and return a "
+            "strategy."
+        )
+    if (
+        "pydantic.generics" in sys.modules
+        and issubclass(custom_type, sys.modules"pydantic.generics".GenericModel)
+        and not re.search(r"A-Za-z_+\.+\", repr(custom_type))
+        and callable(strategy)
+    ):  # pragma: no cover
+        # See https://github.com/HypothesisWorks/hypothesis/issues/2940
+        raise InvalidArgument(
+            f"Cannot register a function for {custom_type!r}, because parametrized "
+            "`pydantic.generics.GenericModel` subclasses aren't actually generic "
+            "types at runtime.  In this case, you should register a strategy "
+            "directly for each parametrized form that you anticipate using."
+        )
+
+    types._global_type_lookupcustom_type = strategy
+    from_type.__clear_cache()  # type: ignore
+
+
+@cacheable
+@defines_strategy(never_lazy=True)
+def deferred(definition: Callable, SearchStrategyEx) -> SearchStrategyEx:
+    """A deferred strategy allows you to write a strategy that references other
+    strategies that have not yet been defined. This allows for the easy
+    definition of recursive and mutually recursive strategies.
+
+    The definition argument should be a zero-argument function that returns a
+    strategy. It will be evaluated the first time the strategy is used to
+    produce an example.
+
+    Example usage:
+
+    >>> import hypothesis.strategies as st
+    >>> x = st.deferred(lambda: st.booleans() | st.tuples(x, x))
+    >>> x.example()
+    (((False, (True, True)), (False, True)), (True, True))
+    >>> x.example()
+    True
+
+    Mutual recursion also works fine:
+
+    >>> a = st.deferred(lambda: st.booleans() | b)
+    >>> b = st.deferred(lambda: st.tuples(a, a))
+    >>> a.example()
+    True
+    >>> b.example()
+    (False, (False, ((False, True), False)))
+
+    Examples from this strategy shrink as they normally would from the strategy
+    returned by the definition.
+    """
+    return DeferredStrategy(definition)
+
+
+def domains():
+    import hypothesis.provisional
+
+    return hypothesis.provisional.domains()
+
+
+@defines_strategy(force_reusable_values=True)
+def emails(
+    *, domains: SearchStrategystr = LazyStrategy(domains, (), {})
+) -> SearchStrategystr:
+    """A strategy for generating email addresses as unicode strings. The
+    address format is specified in :rfc:`5322#section-3.4.1`. Values shrink
+    towards shorter local-parts and host domains.
+
+    If ``domains`` is given then it must be a strategy that generates domain
+    names for the emails, defaulting to :func:`~hypothesis.provisional.domains`.
+
+    This strategy is useful for generating "user data" for tests, as
+    mishandling of email addresses is a common source of bugs.
+    """
+    local_chars = string.ascii_letters + string.digits + "!#$%&'*+-/=^_`{|}~"
+    local_part = text(local_chars, min_size=1, max_size=64)
+    # TODO: include dot-atoms, quoted strings, escaped chars, etc in local part
+    return builds("{}@{}".format, local_part, domains).filter(
+        lambda addr: len(addr) <= 254
+    )
+
+
+def _functions(*, like, returns, pure):
+    # Wrapped up to use ParamSpec below
+    check_type(bool, pure, "pure")
+    if not callable(like):
+        raise InvalidArgument(
+            "The first argument to functions() must be a callable to imitate, "
+            f"but got non-callable like={nicerepr(like)!r}"
+        )
+    if returns in (None, ...):
+        # Passing `None` has never been *documented* as working, but it still
+        # did from May 2020 to Jan 2022 so we'll avoid breaking it without cause.
+        hints = get_type_hints(like)
+        returns = from_type(hints.get("return", type(None)))
+    check_strategy(returns, "returns")
+    return FunctionStrategy(like, returns, pure)
+
+
+if typing.TYPE_CHECKING or ParamSpec is not None:
+
+    @overload
+    def functions(
+        *, pure: bool = ...
+    ) -> SearchStrategyCallable, None:  # pragma: no cover
+        ...
+
+    @overload
+    def functions(
+        *,
+        like: CallableP, T,
+        pure: bool = ...,
+    ) -> SearchStrategyCallableP, T:  # pragma: no cover
+        ...
+
+    @overload
+    def functions(
+        *,
+        returns: SearchStrategyT,
+        pure: bool = ...,
+    ) -> SearchStrategyCallable, T:  # pragma: no cover
+        ...
+
+    @overload
+    def functions(
+        *,
+        like: CallableP, Any,
+        returns: SearchStrategyT,
+        pure: bool = ...,
+    ) -> SearchStrategyCallableP, T:  # pragma: no cover
+        ...
+
+    @defines_strategy()
+    def functions(*, like=lambda: None, returns=..., pure=False):
+        # We shouldn't need overloads here, but mypy disallows default args for
+        # generics: https://github.com/python/mypy/issues/3737
+        """functions(*, like=lambda: None, returns=..., pure=False)
+
+        A strategy for functions, which can be used in callbacks.
+
+        The generated functions will mimic the interface of ``like``, which must
+        be a callable (including a class, method, or function).  The return value
+        for the function is drawn from the ``returns`` argument, which must be a
+        strategy.  If ``returns`` is not passed, we attempt to infer a strategy
+        from the return-type annotation if present, falling back to :func:`~none`.
+
+        If ``pure=True``, all arguments passed to the generated function must be
+        hashable, and if passed identical arguments the original return value will
+        be returned again - *not* regenerated, so beware mutable values.
+
+        If ``pure=False``, generated functions do not validate their arguments, and
+        may return a different value if called again with the same arguments.
+
+        Generated functions can only be called within the scope of the ``@given``
+        which created them.  This strategy does not support ``.example()``.
+        """
+        return _functions(like=like, returns=returns, pure=pure)
+
+else:  # pragma: no cover
+
+    @defines_strategy()
+    def functions(
+        *,
+        like: Callable..., Any = lambda: None,
+        returns: UnionSearchStrategyAny, EllipsisType = ...,
+        pure: bool = False,
+    ) -> SearchStrategyCallable..., Any:
+        """functions(*, like=lambda: None, returns=..., pure=False)
+
+        A strategy for functions, which can be used in callbacks.
+
+        The generated functions will mimic the interface of ``like``, which must
+        be a callable (including a class, method, or function).  The return value
+        for the function is drawn from the ``returns`` argument, which must be a
+        strategy.  If ``returns`` is not passed, we attempt to infer a strategy
+        from the return-type annotation if present, falling back to :func:`~none`.
+
+        If ``pure=True``, all arguments passed to the generated function must be
+        hashable, and if passed identical arguments the original return value will
+        be returned again - *not* regenerated, so beware mutable values.
+
+        If ``pure=False``, generated functions do not validate their arguments, and
+        may return a different value if called again with the same arguments.
+
+        Generated functions can only be called within the scope of the ``@given``
+        which created them.  This strategy does not support ``.example()``.
+        """
+        return _functions(like=like, returns=returns, pure=pure)
+
+
+@composite
+def slices(draw: Any, size: int) -> slice:
+    """Generates slices that will select indices up to the supplied size
+
+    Generated slices will have start and stop indices that range from -size to size - 1
+    and will step in the appropriate direction. Slices should only produce an empty selection
+    if the start and end are the same.
+
+    Examples from this strategy shrink toward 0 and smaller values
+    """
+    check_valid_size(size, "size")
+    if size == 0:
+        step = draw(none() | integers().filter(bool))
+        return slice(None, None, step)
+    # For slices start is inclusive and stop is exclusive
+    start = draw(integers(0, size - 1) | none())
+    stop = draw(integers(0, size) | none())
+
+    # Limit step size to be reasonable
+    if start is None and stop is None:
+        max_step = size
+    elif start is None:
+        max_step = stop
+    elif stop is None:
+        max_step = start
+    else:
+        max_step = abs(start - stop)
+
+    step = draw(integers(1, max_step or 1))
+
+    if (draw(booleans()) and start == stop) or (stop or 0) < (start or 0):
+        step *= -1
+
+    if draw(booleans()) and start is not None:
+        start -= size
+    if draw(booleans()) and stop is not None:
+        stop -= size
+    if (not draw(booleans())) and step == 1:
+        step = None
+
+    return slice(start, stop, step)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/datetime.py Added

@@ -0,0 +1,467 @@
+# 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 datetime as dt
+import os.path
+from calendar import monthrange
+from functools import lru_cache
+from importlib import resources
+from typing import Optional
+
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture import utils
+from hypothesis.internal.validation import check_type, check_valid_interval
+from hypothesis.strategies._internal.core import sampled_from
+from hypothesis.strategies._internal.misc import just, none
+from hypothesis.strategies._internal.strategies import SearchStrategy
+from hypothesis.strategies._internal.utils import defines_strategy
+
+# The zoneinfo module, required for the timezones() and timezone_keys()
+# strategies, is new in Python 3.9 and the backport might be missing.
+try:
+    import zoneinfo
+except ImportError:
+    try:
+        from backports import zoneinfo  # type: ignore
+    except ImportError:
+        # We raise an error recommending `pip install hypothesiszoneinfo`
+        # when timezones() or timezone_keys() strategies are actually used.
+        zoneinfo = None  # type: ignore
+
+DATENAMES = ("year", "month", "day")
+TIMENAMES = ("hour", "minute", "second", "microsecond")
+
+
+def is_pytz_timezone(tz):
+    if not isinstance(tz, dt.tzinfo):
+        return False
+    module = type(tz).__module__
+    return module == "pytz" or module.startswith("pytz.")
+
+
+def replace_tzinfo(value, timezone):
+    if is_pytz_timezone(timezone):
+        # Pytz timezones are a little complicated, and using the .replace method
+        # can cause some weird issues, so we use their special "localize" instead.
+        #
+        # We use the fold attribute as a convenient boolean for is_dst, even though
+        # they're semantically distinct.  For ambiguous or imaginary hours, fold says
+        # whether you should use the offset that applies before the gap (fold=0) or
+        # the offset that applies after the gap (fold=1). is_dst says whether you
+        # should choose the side that is "DST" or "STD" (STD->STD or DST->DST
+        # transitions are unclear as you might expect).
+        #
+        # WARNING: this is INCORRECT for timezones with negative DST offsets such as
+        #       "Europe/Dublin", but it's unclear what we could do instead beyond
+        #       documenting the problem and recommending use of `dateutil` instead.
+        return timezone.localize(value, is_dst=not value.fold)
+    return value.replace(tzinfo=timezone)
+
+
+def datetime_does_not_exist(value):
+    """This function tests whether the given datetime can be round-tripped to and
+    from UTC.  It is an exact inverse of (and very similar to) the dateutil method
+    https://dateutil.readthedocs.io/en/stable/tz.html#dateutil.tz.datetime_exists
+    """
+    # Naive datetimes cannot be imaginary, but we need this special case because
+    # chaining .astimezone() ends with *the system local timezone*, not None.
+    # See bug report in https://github.com/HypothesisWorks/hypothesis/issues/2662
+    if value.tzinfo is None:
+        return False
+    try:
+        # Does the naive portion of the datetime change when round-tripped to
+        # UTC?  If so, or if this overflows, we say that it does not exist.
+        roundtrip = value.astimezone(dt.timezone.utc).astimezone(value.tzinfo)
+    except OverflowError:
+        # Overflows at datetime.min or datetime.max boundary condition.
+        # Rejecting these is acceptable, because timezones are close to
+        # meaningless before ~1900 and subject to a lot of change by
+        # 9999, so it should be a very small fraction of possible values.
+        return True
+
+    if (
+        value.tzinfo is not roundtrip.tzinfo
+        and value.utcoffset() != roundtrip.utcoffset()
+    ):
+        # This only ever occurs during imaginary (i.e. nonexistent) datetimes,
+        # and only for pytz timezones which do not follow PEP-495 semantics.
+        # (may exclude a few other edge cases, but you should use zoneinfo anyway)
+        return True
+
+    assert value.tzinfo is roundtrip.tzinfo, "so only the naive portions are compared"
+    return value != roundtrip
+
+
+def draw_capped_multipart(
+    data, min_value, max_value, duration_names=DATENAMES + TIMENAMES
+):
+    assert isinstance(min_value, (dt.date, dt.time, dt.datetime))
+    assert type(min_value) == type(max_value)
+    assert min_value <= max_value
+    result = {}
+    cap_low, cap_high = True, True
+    for name in duration_names:
+        low = getattr(min_value if cap_low else dt.datetime.min, name)
+        high = getattr(max_value if cap_high else dt.datetime.max, name)
+        if name == "day" and not cap_high:
+            _, high = monthrange(**result)
+        if name == "year":
+            val = utils.integer_range(data, low, high, 2000)
+        else:
+            val = utils.integer_range(data, low, high)
+        resultname = val
+        cap_low = cap_low and val == low
+        cap_high = cap_high and val == high
+    if hasattr(min_value, "fold"):
+        # The `fold` attribute is ignored in comparison of naive datetimes.
+        # In tz-aware datetimes it would require *very* invasive changes to
+        # the logic above, and be very sensitive to the specific timezone
+        # (at the cost of efficient shrinking and mutation), so at least for
+        # now we stick with the status quo and generate it independently.
+        result"fold" = utils.integer_range(data, 0, 1)
+    return result
+
+
+class DatetimeStrategy(SearchStrategy):
+    def __init__(self, min_value, max_value, timezones_strat, allow_imaginary):
+        assert isinstance(min_value, dt.datetime)
+        assert isinstance(max_value, dt.datetime)
+        assert min_value.tzinfo is None
+        assert max_value.tzinfo is None
+        assert min_value <= max_value
+        assert isinstance(timezones_strat, SearchStrategy)
+        assert isinstance(allow_imaginary, bool)
+        self.min_value = min_value
+        self.max_value = max_value
+        self.tz_strat = timezones_strat
+        self.allow_imaginary = allow_imaginary
+
+    def do_draw(self, data):
+        # We start by drawing a timezone, and an initial datetime.
+        tz = data.draw(self.tz_strat)
+        result = self.draw_naive_datetime_and_combine(data, tz)
+
+        # TODO: with some probability, systematically search for one of
+        #   - an imaginary time (if allowed),
+        #   - a time within 24hrs of a leap second (if there any are within bounds),
+        #   - other subtle, little-known, or nasty issues as described in
+        #     https://github.com/HypothesisWorks/hypothesis/issues/69
+
+        # If we happened to end up with a disallowed imaginary time, reject it.
+        if (not self.allow_imaginary) and datetime_does_not_exist(result):
+            data.mark_invalid("nonexistent datetime")
+        return result
+
+    def draw_naive_datetime_and_combine(self, data, tz):
+        result = draw_capped_multipart(data, self.min_value, self.max_value)
+        try:
+            return replace_tzinfo(dt.datetime(**result), timezone=tz)
+        except (ValueError, OverflowError):
+            msg = "Failed to draw a datetime between %r and %r with timezone from %r."
+            data.mark_invalid(msg % (self.min_value, self.max_value, self.tz_strat))
+
+
+@defines_strategy(force_reusable_values=True)
+def datetimes(
+    min_value: dt.datetime = dt.datetime.min,
+    max_value: dt.datetime = dt.datetime.max,
+    *,
+    timezones: SearchStrategyOptionaldt.tzinfo = none(),
+    allow_imaginary: bool = True,
+) -> SearchStrategydt.datetime:
+    """datetimes(min_value=datetime.datetime.min, max_value=datetime.datetime.max, *, timezones=none(), allow_imaginary=True)
+
+    A strategy for generating datetimes, which may be timezone-aware.
+
+    This strategy works by drawing a naive datetime between ``min_value``
+    and ``max_value``, which must both be naive (have no timezone).
+
+    ``timezones`` must be a strategy that generates either ``None``, for naive
+    datetimes, or :class:`~python:datetime.tzinfo` objects for 'aware' datetimes.
+    You can construct your own, though we recommend using one of these built-in
+    strategies:
+
+    * with Python 3.9 or newer or :pypi:`backports.zoneinfo`:
+      :func:`hypothesis.strategies.timezones`;
+    * with :pypi:`dateutil <python-dateutil>`:
+      :func:`hypothesis.extra.dateutil.timezones`; or
+    * with :pypi:`pytz`: :func:`hypothesis.extra.pytz.timezones`.
+
+    You may pass ``allow_imaginary=False`` to filter out "imaginary" datetimes
+    which did not (or will not) occur due to daylight savings, leap seconds,
+    timezone and calendar adjustments, etc.  Imaginary datetimes are allowed
+    by default, because malformed timestamps are a common source of bugs.
+
+    Examples from this strategy shrink towards midnight on January 1st 2000,
+    local time.
+    """
+    # Why must bounds be naive?  In principle, we could also write a strategy
+    # that took aware bounds, but the API and validation is much harder.
+    # If you want to generate datetimes between two particular moments in
+    # time I suggest (a) just filtering out-of-bounds values; (b) if bounds
+    # are very close, draw a value and subtract its UTC offset, handling
+    # overflows and nonexistent times; or (c) do something customised to
+    # handle datetimes in e.g. a four-microsecond span which is not
+    # representable in UTC.  Handling (d), all of the above, leads to a much
+    # more complex API for all users and a useful feature for very few.
+    check_type(bool, allow_imaginary, "allow_imaginary")
+    check_type(dt.datetime, min_value, "min_value")
+    check_type(dt.datetime, max_value, "max_value")
+    if min_value.tzinfo is not None:
+        raise InvalidArgument(f"min_value={min_value!r} must not have tzinfo")
+    if max_value.tzinfo is not None:
+        raise InvalidArgument(f"max_value={max_value!r} must not have tzinfo")
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+    if not isinstance(timezones, SearchStrategy):
+        raise InvalidArgument(
+            f"timezones={timezones!r} must be a SearchStrategy that can "
+            "provide tzinfo for datetimes (either None or dt.tzinfo objects)"
+        )
+    return DatetimeStrategy(min_value, max_value, timezones, allow_imaginary)
+
+
+class TimeStrategy(SearchStrategy):
+    def __init__(self, min_value, max_value, timezones_strat):
+        self.min_value = min_value
+        self.max_value = max_value
+        self.tz_strat = timezones_strat
+
+    def do_draw(self, data):
+        result = draw_capped_multipart(data, self.min_value, self.max_value, TIMENAMES)
+        tz = data.draw(self.tz_strat)
+        return dt.time(**result, tzinfo=tz)
+
+
+@defines_strategy(force_reusable_values=True)
+def times(
+    min_value: dt.time = dt.time.min,
+    max_value: dt.time = dt.time.max,
+    *,
+    timezones: SearchStrategyOptionaldt.tzinfo = none(),
+) -> SearchStrategydt.time:
+    """times(min_value=datetime.time.min, max_value=datetime.time.max, *, timezones=none())
+
+    A strategy for times between ``min_value`` and ``max_value``.
+
+    The ``timezones`` argument is handled as for :py:func:`datetimes`.
+
+    Examples from this strategy shrink towards midnight, with the timezone
+    component shrinking as for the strategy that provided it.
+    """
+    check_type(dt.time, min_value, "min_value")
+    check_type(dt.time, max_value, "max_value")
+    if min_value.tzinfo is not None:
+        raise InvalidArgument(f"min_value={min_value!r} must not have tzinfo")
+    if max_value.tzinfo is not None:
+        raise InvalidArgument(f"max_value={max_value!r} must not have tzinfo")
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+    return TimeStrategy(min_value, max_value, timezones)
+
+
+class DateStrategy(SearchStrategy):
+    def __init__(self, min_value, max_value):
+        assert isinstance(min_value, dt.date)
+        assert isinstance(max_value, dt.date)
+        assert min_value < max_value
+        self.min_value = min_value
+        self.max_value = max_value
+
+    def do_draw(self, data):
+        return dt.date(
+            **draw_capped_multipart(data, self.min_value, self.max_value, DATENAMES)
+        )
+
+
+@defines_strategy(force_reusable_values=True)
+def dates(
+    min_value: dt.date = dt.date.min, max_value: dt.date = dt.date.max
+) -> SearchStrategydt.date:
+    """dates(min_value=datetime.date.min, max_value=datetime.date.max)
+
+    A strategy for dates between ``min_value`` and ``max_value``.
+
+    Examples from this strategy shrink towards January 1st 2000.
+    """
+    check_type(dt.date, min_value, "min_value")
+    check_type(dt.date, max_value, "max_value")
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+    if min_value == max_value:
+        return just(min_value)
+    return DateStrategy(min_value, max_value)
+
+
+class TimedeltaStrategy(SearchStrategy):
+    def __init__(self, min_value, max_value):
+        assert isinstance(min_value, dt.timedelta)
+        assert isinstance(max_value, dt.timedelta)
+        assert min_value < max_value
+        self.min_value = min_value
+        self.max_value = max_value
+
+    def do_draw(self, data):
+        result = {}
+        low_bound = True
+        high_bound = True
+        for name in ("days", "seconds", "microseconds"):
+            low = getattr(self.min_value if low_bound else dt.timedelta.min, name)
+            high = getattr(self.max_value if high_bound else dt.timedelta.max, name)
+            val = utils.integer_range(data, low, high, 0)
+            resultname = val
+            low_bound = low_bound and val == low
+            high_bound = high_bound and val == high
+        return dt.timedelta(**result)
+
+
+@defines_strategy(force_reusable_values=True)
+def timedeltas(
+    min_value: dt.timedelta = dt.timedelta.min,
+    max_value: dt.timedelta = dt.timedelta.max,
+) -> SearchStrategydt.timedelta:
+    """timedeltas(min_value=datetime.timedelta.min, max_value=datetime.timedelta.max)
+
+    A strategy for timedeltas between ``min_value`` and ``max_value``.
+
+    Examples from this strategy shrink towards zero.
+    """
+    check_type(dt.timedelta, min_value, "min_value")
+    check_type(dt.timedelta, max_value, "max_value")
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+    if min_value == max_value:
+        return just(min_value)
+    return TimedeltaStrategy(min_value=min_value, max_value=max_value)
+
+
+@lru_cache(maxsize=None)
+def _valid_key_cacheable(tzpath, key):
+    assert isinstance(tzpath, tuple)  # zoneinfo changed, better update this function!
+    for root in tzpath:
+        if os.path.exists(os.path.join(root, key)):  # pragma: no branch
+            # No branch because most systems only have one TZPATH component.
+            return True
+    else:  # pragma: no cover
+        # This branch is only taken for names which are known to zoneinfo
+        # but not present on the filesystem, i.e. on Windows with tzdata,
+        # and so is never executed by our coverage tests.
+        *package_loc, resource_name = key.split("/")
+        package = "tzdata.zoneinfo." + ".".join(package_loc)
+        try:
+            try:
+                traversable = resources.files(package) / resource_name
+                return traversable.exists()
+            except (AttributeError, ValueError):
+                # .files() was added in Python 3.9
+                return resources.is_resource(package, resource_name)
+        except ModuleNotFoundError:
+            return False
+
+
+@defines_strategy(force_reusable_values=True)
+def timezone_keys(
+    *,
+    # allow_alias: bool = True,
+    # allow_deprecated: bool = True,
+    allow_prefix: bool = True,
+) -> SearchStrategystr:
+    """A strategy for :wikipedia:`IANA timezone names <List_of_tz_database_time_zones>`.
+
+    As well as timezone names like ``"UTC"``, ``"Australia/Sydney"``, or
+    ``"America/New_York"``, this strategy can generate:
+
+    - Aliases such as ``"Antarctica/McMurdo"``, which links to ``"Pacific/Auckland"``.
+    - Deprecated names such as ``"Antarctica/South_Pole"``, which *also* links to
+      ``"Pacific/Auckland"``.  Note that most but
+      not all deprecated timezone names are also aliases.
+    - Timezone names with the ``"posix/"`` or ``"right/"`` prefixes, unless
+      ``allow_prefix=False``.
+
+    These strings are provided separately from Tzinfo objects - such as ZoneInfo
+    instances from the timezones() strategy - to facilitate testing of timezone
+    logic without needing workarounds to access non-canonical names.
+
+    .. note::
+
+        The :mod:`python:zoneinfo` module is new in Python 3.9, so you will need
+        to install the :pypi:`backports.zoneinfo` module on earlier versions.
+
+        `On Windows, you will also need to install the tzdata package
+        <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__.
+
+        ``pip install hypothesiszoneinfo`` will install these conditional
+        dependencies if and only if they are needed.
+
+    On Windows, you may need to access IANA timezone data via the :pypi:`tzdata`
+    package.  For non-IANA timezones, such as Windows-native names or GNU TZ
+    strings, we recommend using :func:`~hypothesis.strategies.sampled_from` with
+    the :pypi:`dateutil <python-dateutil>` package, e.g.
+    :meth:`dateutil:dateutil.tz.tzwin.list`.
+    """
+    # check_type(bool, allow_alias, "allow_alias")
+    # check_type(bool, allow_deprecated, "allow_deprecated")
+    check_type(bool, allow_prefix, "allow_prefix")
+    if zoneinfo is None:  # pragma: no cover
+        raise ModuleNotFoundError(
+            "The zoneinfo module is required, but could not be imported.  "
+            "Run `pip install hypothesiszoneinfo` and try again."
+        )
+
+    available_timezones = ("UTC",) + tuple(sorted(zoneinfo.available_timezones()))
+
+    # TODO: filter out alias and deprecated names if disallowed
+
+    # When prefixes are allowed, we first choose a key and then flatmap to get our
+    # choice with one of the available prefixes.  That in turn means that we need
+    # some logic to determine which prefixes are available for a given key:
+
+    def valid_key(key):
+        return key == "UTC" or _valid_key_cacheable(zoneinfo.TZPATH, key)
+
+    # TODO: work out how to place a higher priority on "weird" timezones
+    # For details see https://github.com/HypothesisWorks/hypothesis/issues/2414
+    strategy = sampled_from(key for key in available_timezones if valid_key(key))
+
+    if not allow_prefix:
+        return strategy
+
+    def sample_with_prefixes(zone):
+        keys_with_prefixes = (zone, f"posix/{zone}", f"right/{zone}")
+        return sampled_from(key for key in keys_with_prefixes if valid_key(key))
+
+    return strategy.flatmap(sample_with_prefixes)
+
+
+@defines_strategy(force_reusable_values=True)
+def timezones(*, no_cache: bool = False) -> SearchStrategy"zoneinfo.ZoneInfo":
+    """A strategy for :class:`python:zoneinfo.ZoneInfo` objects.
+
+    If ``no_cache=True``, the generated instances are constructed using
+    :meth:`ZoneInfo.no_cache <python:zoneinfo.ZoneInfo.no_cache>` instead
+    of the usual constructor.  This may change the semantics of your datetimes
+    in surprising ways, so only use it if you know that you need to!
+
+    .. note::
+
+        The :mod:`python:zoneinfo` module is new in Python 3.9, so you will need
+        to install the :pypi:`backports.zoneinfo` module on earlier versions.
+
+        `On Windows, you will also need to install the tzdata package
+        <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__.
+
+        ``pip install hypothesiszoneinfo`` will install these conditional
+        dependencies if and only if they are needed.
+    """
+    check_type(bool, no_cache, "no_cache")
+    if zoneinfo is None:  # pragma: no cover
+        raise ModuleNotFoundError(
+            "The zoneinfo module is required, but could not be imported.  "
+            "Run `pip install hypothesiszoneinfo` and try again."
+        )
+    return timezone_keys().map(
+        zoneinfo.ZoneInfo.no_cache if no_cache else zoneinfo.ZoneInfo
+    )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/deferred.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/featureflags.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/flatmapped.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/functions.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/ipaddress.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/lazy.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/misc.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/numbers.py Added

@@ -0,0 +1,641 @@
+# 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 math
+from decimal import Decimal
+from fractions import Fraction
+from sys import float_info
+from typing import Optional, Union
+
+from hypothesis.control import reject
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture import floats as flt, utils as d
+from hypothesis.internal.conjecture.utils import calc_label_from_name
+from hypothesis.internal.filtering import (
+    get_float_predicate_bounds,
+    get_integer_predicate_bounds,
+)
+from hypothesis.internal.floats import (
+    float_of,
+    float_to_int,
+    int_to_float,
+    is_negative,
+    make_float_clamper,
+    next_down,
+    next_down_normal,
+    next_up,
+    next_up_normal,
+    width_smallest_normals,
+)
+from hypothesis.internal.validation import (
+    check_type,
+    check_valid_bound,
+    check_valid_interval,
+)
+from hypothesis.strategies._internal.misc import nothing
+from hypothesis.strategies._internal.strategies import (
+    SampledFromStrategy,
+    SearchStrategy,
+)
+from hypothesis.strategies._internal.utils import cacheable, defines_strategy
+
+# See https://github.com/python/mypy/issues/3186 - numbers.Real is wrong!
+Real = Unionint, float, Fraction, Decimal
+ONE_BOUND_INTEGERS_LABEL = d.calc_label_from_name("trying a one-bound int allowing 0")
+
+
+class IntegersStrategy(SearchStrategy):
+    def __init__(self, start, end):
+        assert isinstance(start, int) or start is None
+        assert isinstance(end, int) or end is None
+        assert start is None or end is None or start <= end
+        self.start = start
+        self.end = end
+
+    def __repr__(self):
+        if self.start is None and self.end is None:
+            return "integers()"
+        if self.end is None:
+            return f"integers(min_value={self.start})"
+        if self.start is None:
+            return f"integers(max_value={self.end})"
+        return f"integers({self.start}, {self.end})"
+
+    def do_draw(self, data):
+        if self.start is None and self.end is None:
+            return d.unbounded_integers(data)
+
+        if self.start is None:
+            if self.end <= 0:
+                return self.end - abs(d.unbounded_integers(data))
+            else:
+                probe = self.end + 1
+                while self.end < probe:
+                    data.start_example(ONE_BOUND_INTEGERS_LABEL)
+                    probe = d.unbounded_integers(data)
+                    data.stop_example(discard=self.end < probe)
+                return probe
+
+        if self.end is None:
+            if self.start >= 0:
+                return self.start + abs(d.unbounded_integers(data))
+            else:
+                probe = self.start - 1
+                while probe < self.start:
+                    data.start_example(ONE_BOUND_INTEGERS_LABEL)
+                    probe = d.unbounded_integers(data)
+                    data.stop_example(discard=probe < self.start)
+                return probe
+
+        # For bounded integers, make the bounds and near-bounds more likely.
+        forced = None
+        if self.end - self.start > 127:
+            forced = {
+                122: self.start,
+                123: self.start,
+                124: self.end,
+                125: self.end,
+                126: self.start + 1,
+                127: self.end - 1,
+            }.get(data.draw_bits(7))
+
+        return d.integer_range(data, self.start, self.end, center=0, forced=forced)
+
+    def filter(self, condition):
+        if condition is math.isfinite:
+            return self
+        if condition in math.isinf, math.isnan:
+            return nothing()
+        kwargs, pred = get_integer_predicate_bounds(condition)
+
+        start, end = self.start, self.end
+        if "min_value" in kwargs:
+            start = max(kwargs"min_value", -math.inf if start is None else start)
+        if "max_value" in kwargs:
+            end = min(kwargs"max_value", math.inf if end is None else end)
+
+        if start != self.start or end != self.end:
+            if start is not None and end is not None and start > end:
+                return nothing()
+            self = type(self)(start, end)
+        if pred is None:
+            return self
+        return super().filter(pred)
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def integers(
+    min_value: Optionalint = None,
+    max_value: Optionalint = None,
+) -> SearchStrategyint:
+    """Returns a strategy which generates integers.
+
+    If min_value is not None then all values will be >= min_value. If
+    max_value is not None then all values will be <= max_value
+
+    Examples from this strategy will shrink towards zero, and negative values
+    will also shrink towards positive (i.e. -n may be replaced by +n).
+    """
+    check_valid_bound(min_value, "min_value")
+    check_valid_bound(max_value, "max_value")
+    check_valid_interval(min_value, max_value, "min_value", "max_value")
+
+    if min_value is not None:
+        if min_value != int(min_value):
+            raise InvalidArgument(
+                "min_value=%r of type %r cannot be exactly represented as an integer."
+                % (min_value, type(min_value))
+            )
+        min_value = int(min_value)
+    if max_value is not None:
+        if max_value != int(max_value):
+            raise InvalidArgument(
+                "max_value=%r of type %r cannot be exactly represented as an integer."
+                % (max_value, type(max_value))
+            )
+        max_value = int(max_value)
+
+    return IntegersStrategy(min_value, max_value)
+
+
+SMALLEST_SUBNORMAL = next_up(0.0)
+SIGNALING_NAN = int_to_float(0x7FF8_0000_0000_0001)  # nonzero mantissa
+assert math.isnan(SIGNALING_NAN) and math.copysign(1, SIGNALING_NAN) == 1
+
+NASTY_FLOATS = sorted(
+    
+        0.0,
+        0.5,
+        1.1,
+        1.5,
+        1.9,
+        1.0 / 3,
+        10e6,
+        10e-6,
+        1.175494351e-38,
+        next_up(0.0),
+        float_info.min,
+        float_info.max,
+        3.402823466e38,
+        9007199254740992,
+        1 - 10e-6,
+        2 + 10e-6,
+        1.192092896e-07,
+        2.2204460492503131e-016,
+    
+    + 2.0**-n for n in (24, 14, 149, 126)  # minimum (sub)normals for float16,32
+    + float_info.min / n for n in (2, 10, 1000, 100_000)  # subnormal in float64
+    + math.inf, math.nan * 5
+    + SIGNALING_NAN,
+    key=flt.float_to_lex,
+)
+NASTY_FLOATS = list(map(float, NASTY_FLOATS))
+NASTY_FLOATS.extend(-x for x in NASTY_FLOATS)
+
+FLOAT_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
+    "getting another float in FloatStrategy"
+)
+
+
+def _sign_aware_lte(x: float, y: float) -> bool:
+    """Less-than-or-equals, but strictly orders -0.0 and 0.0"""
+    if x == 0.0 == y:
+        return math.copysign(1.0, x) <= math.copysign(1.0, y)
+    else:
+        return x <= y
+
+
+class FloatStrategy(SearchStrategy):
+    """A strategy for floating point numbers."""
+
+    def __init__(
+        self,
+        *,
+        min_value: float,
+        max_value: float,
+        allow_nan: bool,
+        # The smallest nonzero number we can represent is usually a subnormal, but may
+        # be the smallest normal if we're running in unsafe denormals-are-zero mode.
+        # While that's usually an explicit error, we do need to handle the case where
+        # the user passes allow_subnormal=False.
+        smallest_nonzero_magnitude: float = SMALLEST_SUBNORMAL,
+    ):
+        super().__init__()
+        assert isinstance(allow_nan, bool)
+        assert smallest_nonzero_magnitude >= 0.0, "programmer error if this is negative"
+        if smallest_nonzero_magnitude == 0.0:  # pragma: no cover
+            raise FloatingPointError(
+                "Got allow_subnormal=True, but we can't represent subnormal floats "
+                "right now, in violation of the IEEE-754 floating-point "
+                "specification.  This is usually because something was compiled with "
+                "-ffast-math or a similar option, which sets global processor state.  "
+                "See https://simonbyrne.github.io/notes/fastmath/ for a more detailed "
+                "writeup - and good luck!"
+            )
+        self.min_value = min_value
+        self.max_value = max_value
+        self.allow_nan = allow_nan
+        self.smallest_nonzero_magnitude = smallest_nonzero_magnitude
+
+        boundary_values = 
+            min_value,
+            next_up(min_value),
+            min_value + 1,
+            max_value - 1,
+            next_down(max_value),
+            max_value,
+        
+        self.nasty_floats = 
+            f for f in NASTY_FLOATS + boundary_values if self.permitted(f)
+        
+        weights = 0.2 * len(self.nasty_floats) + 0.8 * len(self.nasty_floats)
+        self.sampler = d.Sampler(weights) if self.nasty_floats else None
+
+        self.pos_clamper = self.neg_clamper = None
+        if _sign_aware_lte(0.0, max_value):
+            pos_min = max(min_value, smallest_nonzero_magnitude)
+            allow_zero = _sign_aware_lte(min_value, 0.0)
+            self.pos_clamper = make_float_clamper(pos_min, max_value, allow_zero)
+        if _sign_aware_lte(min_value, -0.0):
+            neg_max = min(max_value, -smallest_nonzero_magnitude)
+            allow_zero = _sign_aware_lte(-0.0, max_value)
+            self.neg_clamper = make_float_clamper(-neg_max, -min_value, allow_zero)
+
+        self.forced_sign_bit: Optionalint = None
+        if (self.pos_clamper is None) != (self.neg_clamper is None):
+            self.forced_sign_bit = 1 if self.neg_clamper else 0
+
+    def __repr__(self):
+        return "{}(min_value={}, max_value={}, allow_nan={}, smallest_nonzero_magnitude={})".format(
+            self.__class__.__name__,
+            self.min_value,
+            self.max_value,
+            self.allow_nan,
+            self.smallest_nonzero_magnitude,
+        )
+
+    def permitted(self, f):
+        assert isinstance(f, float)
+        if math.isnan(f):
+            return self.allow_nan
+        if 0 < abs(f) < self.smallest_nonzero_magnitude:
+            return False
+        return _sign_aware_lte(self.min_value, f) and _sign_aware_lte(f, self.max_value)
+
+    def do_draw(self, data):
+        while True:
+            data.start_example(FLOAT_STRATEGY_DO_DRAW_LABEL)
+            i = self.sampler.sample(data) if self.sampler else 0
+            data.start_example(flt.DRAW_FLOAT_LABEL)
+            if i == 0:
+                result = flt.draw_float(data, forced_sign_bit=self.forced_sign_bit)
+                is_negative = flt.float_to_int(result) >> 63
+                if is_negative:
+                    clamped = -self.neg_clamper(-result)
+                else:
+                    clamped = self.pos_clamper(result)
+                if clamped != result:
+                    data.stop_example(discard=True)
+                    data.start_example(flt.DRAW_FLOAT_LABEL)
+                    flt.write_float(data, clamped)
+                    result = clamped
+            else:
+                result = self.nasty_floatsi - 1
+
+                flt.write_float(data, result)
+
+            data.stop_example()  # (DRAW_FLOAT_LABEL)
+            data.stop_example()  # (FLOAT_STRATEGY_DO_DRAW_LABEL)
+            return result
+
+    def filter(self, condition):
+        # Handle a few specific weird cases.
+        if condition is math.isfinite:
+            return FloatStrategy(
+                min_value=max(self.min_value, next_up(float("-inf"))),
+                max_value=min(self.max_value, next_down(float("inf"))),
+                allow_nan=False,
+                smallest_nonzero_magnitude=self.smallest_nonzero_magnitude,
+            )
+        if condition is math.isinf:
+            permitted_infs = x for x in (-math.inf, math.inf) if self.permitted(x)
+            if not permitted_infs:
+                return nothing()
+            return SampledFromStrategy(permitted_infs)
+        if condition is math.isnan:
+            if not self.allow_nan:
+                return nothing()
+            return NanStrategy()
+
+        kwargs, pred = get_float_predicate_bounds(condition)
+        if not kwargs:
+            return super().filter(pred)
+        min_bound = max(kwargs.get("min_value", -math.inf), self.min_value)
+        max_bound = min(kwargs.get("max_value", math.inf), self.max_value)
+
+        # Adjustments for allow_subnormal=False, if any need to be made
+        if -self.smallest_nonzero_magnitude < min_bound < 0:
+            min_bound = -0.0
+        elif 0 < min_bound < self.smallest_nonzero_magnitude:
+            min_bound = self.smallest_nonzero_magnitude
+        if -self.smallest_nonzero_magnitude < max_bound < 0:
+            max_bound = -self.smallest_nonzero_magnitude
+        elif 0 < max_bound < self.smallest_nonzero_magnitude:
+            max_bound = 0.0
+
+        if min_bound > max_bound:
+            return nothing()
+        if (
+            min_bound > self.min_value
+            or self.max_value > max_bound
+            or (self.allow_nan and (-math.inf < min_bound or max_bound < math.inf))
+        ):
+            self = type(self)(
+                min_value=min_bound,
+                max_value=max_bound,
+                allow_nan=False,
+                smallest_nonzero_magnitude=self.smallest_nonzero_magnitude,
+            )
+        if pred is None:
+            return self
+        return super().filter(pred)
+
+
+@cacheable
+@defines_strategy(force_reusable_values=True)
+def floats(
+    min_value: OptionalReal = None,
+    max_value: OptionalReal = None,
+    *,
+    allow_nan: Optionalbool = None,
+    allow_infinity: Optionalbool = None,
+    allow_subnormal: Optionalbool = None,
+    width: int = 64,
+    exclude_min: bool = False,
+    exclude_max: bool = False,
+) -> SearchStrategyfloat:
+    """Returns a strategy which generates floats.
+
+    - If min_value is not None, all values will be ``>= min_value``
+      (or ``> min_value`` if ``exclude_min``).
+    - If max_value is not None, all values will be ``<= max_value``
+      (or ``< max_value`` if ``exclude_max``).
+    - If min_value or max_value is not None, it is an error to enable
+      allow_nan.
+    - If both min_value and max_value are not None, it is an error to enable
+      allow_infinity.
+    - If inferred values range does not include subnormal values, it is an error
+      to enable allow_subnormal.
+
+    Where not explicitly ruled out by the bounds,
+    :wikipedia:`subnormals <Subnormal_number>`, infinities, and NaNs are possible
+    values generated by this strategy.
+
+    The width argument specifies the maximum number of bits of precision
+    required to represent the generated float. Valid values are 16, 32, or 64.
+    Passing ``width=32`` will still use the builtin 64-bit :class:`~python:float` class,
+    but always for values which can be exactly represented as a 32-bit float.
+
+    The exclude_min and exclude_max argument can be used to generate numbers
+    from open or half-open intervals, by excluding the respective endpoints.
+    Excluding either signed zero will also exclude the other.
+    Attempting to exclude an endpoint which is None will raise an error;
+    use ``allow_infinity=False`` to generate finite floats.  You can however
+    use e.g. ``min_value=-math.inf, exclude_min=True`` to exclude only
+    one infinite endpoint.
+
+    Examples from this strategy have a complicated and hard to explain
+    shrinking behaviour, but it tries to improve "human readability". Finite
+    numbers will be preferred to infinity and infinity will be preferred to
+    NaN.
+    """
+    check_type(bool, exclude_min, "exclude_min")
+    check_type(bool, exclude_max, "exclude_max")
+
+    if allow_nan is None:
+        allow_nan = bool(min_value is None and max_value is None)
+    elif allow_nan and (min_value is not None or max_value is not None):
+        raise InvalidArgument(
+            f"Cannot have allow_nan={allow_nan!r}, with min_value or max_value"
+        )
+
+    if width not in (16, 32, 64):
+        raise InvalidArgument(
+            f"Got width={width!r}, but the only valid values "
+            "are the integers 16, 32, and 64."
+        )
+
+    check_valid_bound(min_value, "min_value")
+    check_valid_bound(max_value, "max_value")
+
+    if math.copysign(1.0, -0.0) == 1.0:  # pragma: no cover
+        raise FloatingPointError(
+            "Your Python install can't represent -0.0, which is required by the "
+            "IEEE-754 floating-point specification.  This is probably because it was "
+            "compiled with an unsafe option like -ffast-math; for a more detailed "
+            "explanation see https://simonbyrne.github.io/notes/fastmath/"
+        )
+    if allow_subnormal and next_up(0.0, width=width) == 0:  # pragma: no cover
+        # Not worth having separate CI envs and dependencies just to cover this branch;
+        # discussion in https://github.com/HypothesisWorks/hypothesis/issues/3092
+        #
+        # Erroring out here ensures that the database contents are interpreted
+        # consistently - which matters for such a foundational strategy, even if it's
+        # not always true for all user-composed strategies further up the stack.
+        from _hypothesis_ftz_detector import identify_ftz_culprits
+
+        try:
+            ftz_pkg = identify_ftz_culprits()
+        except Exception:
+            ftz_pkg = None
+        if ftz_pkg:
+            ftz_msg = (
+                f"This seems to be because the `{ftz_pkg}` package was compiled with "
+                f"-ffast-math or a similar option, which sets global processor state "
+                f"- see https://simonbyrne.github.io/notes/fastmath/ for details.  "
+                f"If you don't know why {ftz_pkg} is installed, `pipdeptree -rp "
+                f"{ftz_pkg}` will show which packages depend on it."
+            )
+        else:
+            ftz_msg = (
+                "This is usually because something was compiled with -ffast-math "
+                "or a similar option, which sets global processor state.  See "
+                "https://simonbyrne.github.io/notes/fastmath/ for a more detailed "
+                "writeup - and good luck!"
+            )
+        raise FloatingPointError(
+            f"Got allow_subnormal={allow_subnormal!r}, but we can't represent "
+            f"subnormal floats right now, in violation of the IEEE-754 floating-point "
+            f"specification.  {ftz_msg}"
+        )
+
+    min_arg, max_arg = min_value, max_value
+    if min_value is not None:
+        min_value = float_of(min_value, width)
+        assert isinstance(min_value, float)
+    if max_value is not None:
+        max_value = float_of(max_value, width)
+        assert isinstance(max_value, float)
+
+    if min_value != min_arg:
+        raise InvalidArgument(
+            f"min_value={min_arg!r} cannot be exactly represented as a float "
+            f"of width {width} - use min_value={min_value!r} instead."
+        )
+    if max_value != max_arg:
+        raise InvalidArgument(
+            f"max_value={max_arg!r} cannot be exactly represented as a float "
+            f"of width {width} - use max_value={max_value!r} instead."
+        )
+
+    if exclude_min and (min_value is None or min_value == math.inf):
+        raise InvalidArgument(f"Cannot exclude min_value={min_value!r}")
+    if exclude_max and (max_value is None or max_value == -math.inf):
+        raise InvalidArgument(f"Cannot exclude max_value={max_value!r}")
+
+    assumed_allow_subnormal = allow_subnormal is None or allow_subnormal
+    if min_value is not None and (
+        exclude_min or (min_arg is not None and min_value < min_arg)
+    ):
+        min_value = next_up_normal(min_value, width, assumed_allow_subnormal)
+        if min_value == min_arg:
+            assert min_value == min_arg == 0
+            assert is_negative(min_arg) and not is_negative(min_value)
+            min_value = next_up_normal(min_value, width, assumed_allow_subnormal)
+        assert min_value > min_arg  # type: ignore
+    if max_value is not None and (
+        exclude_max or (max_arg is not None and max_value > max_arg)
+    ):
+        max_value = next_down_normal(max_value, width, assumed_allow_subnormal)
+        if max_value == max_arg:
+            assert max_value == max_arg == 0
+            assert is_negative(max_value) and not is_negative(max_arg)
+            max_value = next_down_normal(max_value, width, assumed_allow_subnormal)
+        assert max_value < max_arg  # type: ignore
+
+    if min_value == -math.inf:
+        min_value = None
+    if max_value == math.inf:
+        max_value = None
+
+    bad_zero_bounds = (
+        min_value == max_value == 0
+        and is_negative(max_value)
+        and not is_negative(min_value)
+    )
+    if (
+        min_value is not None
+        and max_value is not None
+        and (min_value > max_value or bad_zero_bounds)
+    ):
+        # This is a custom alternative to check_valid_interval, because we want
+        # to include the bit-width and exclusion information in the message.
+        msg = (
+            "There are no %s-bit floating-point values between min_value=%r "
+            "and max_value=%r" % (width, min_arg, max_arg)
+        )
+        if exclude_min or exclude_max:
+            msg += f", exclude_min={exclude_min!r} and exclude_max={exclude_max!r}"
+        raise InvalidArgument(msg)
+
+    if allow_infinity is None:
+        allow_infinity = bool(min_value is None or max_value is None)
+    elif allow_infinity:
+        if min_value is not None and max_value is not None:
+            raise InvalidArgument(
+                f"Cannot have allow_infinity={allow_infinity!r}, "
+                "with both min_value and max_value"
+            )
+    elif min_value == math.inf:
+        if min_arg == math.inf:
+            raise InvalidArgument("allow_infinity=False excludes min_value=inf")
+        raise InvalidArgument(
+            f"exclude_min=True turns min_value={min_arg!r} into inf, "
+            "but allow_infinity=False"
+        )
+    elif max_value == -math.inf:
+        if max_arg == -math.inf:
+            raise InvalidArgument("allow_infinity=False excludes max_value=-inf")
+        raise InvalidArgument(
+            f"exclude_max=True turns max_value={max_arg!r} into -inf, "
+            "but allow_infinity=False"
+        )
+
+    smallest_normal = width_smallest_normalswidth
+    if allow_subnormal is None:
+        if min_value is not None and max_value is not None:
+            if min_value == max_value:
+                allow_subnormal = -smallest_normal < min_value < smallest_normal
+            else:
+                allow_subnormal = (
+                    min_value < smallest_normal and max_value > -smallest_normal
+                )
+        elif min_value is not None:
+            allow_subnormal = min_value < smallest_normal
+        elif max_value is not None:
+            allow_subnormal = max_value > -smallest_normal
+        else:
+            allow_subnormal = True
+    if allow_subnormal:
+        if min_value is not None and min_value >= smallest_normal:
+            raise InvalidArgument(
+                f"allow_subnormal=True, but minimum value {min_value} "
+                f"excludes values below float{width}'s "
+                f"smallest positive normal {smallest_normal}"
+            )
+        if max_value is not None and max_value <= -smallest_normal:
+            raise InvalidArgument(
+                f"allow_subnormal=True, but maximum value {max_value} "
+                f"excludes values above float{width}'s "
+                f"smallest negative normal {-smallest_normal}"
+            )
+
+    if min_value is None:
+        min_value = float("-inf")
+    if max_value is None:
+        max_value = float("inf")
+    if not allow_infinity:
+        min_value = max(min_value, next_up(float("-inf")))
+        max_value = min(max_value, next_down(float("inf")))
+    assert isinstance(min_value, float)
+    assert isinstance(max_value, float)
+    smallest_nonzero_magnitude = (
+        SMALLEST_SUBNORMAL if allow_subnormal else smallest_normal
+    )
+    result: SearchStrategy = FloatStrategy(
+        min_value=min_value,
+        max_value=max_value,
+        allow_nan=allow_nan,
+        smallest_nonzero_magnitude=smallest_nonzero_magnitude,
+    )
+
+    if width < 64:
+
+        def downcast(x):
+            try:
+                return float_of(x, width)
+            except OverflowError:  # pragma: no cover
+                reject()
+
+        result = result.map(downcast)
+    return result
+
+
+class NanStrategy(SearchStrategy):
+    """Strategy for sampling the space of nan float values."""
+
+    def do_draw(self, data):
+        # Nans must have all exponent bits and the first mantissa bit set, so
+        # we generate by taking 64 random bits and setting the required ones.
+        sign_bit = data.draw_bits(1) << 63
+        nan_bits = float_to_int(math.nan)
+        mantissa_bits = data.draw_bits(52)
+        return int_to_float(sign_bit | nan_bits | mantissa_bits)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/random.py Added

@@ -0,0 +1,441 @@
+# 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 inspect
+import math
+from random import Random
+from typing import Dict
+
+import attr
+
+from hypothesis.control import should_note
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.reflection import define_function_signature
+from hypothesis.reporting import report
+from hypothesis.strategies._internal.core import (
+    binary,
+    lists,
+    permutations,
+    sampled_from,
+)
+from hypothesis.strategies._internal.numbers import floats, integers
+from hypothesis.strategies._internal.strategies import SearchStrategy
+
+
+class HypothesisRandom(Random):
+    """A subclass of Random designed to expose the seed it was initially
+    provided with."""
+
+    def __init__(self, note_method_calls):
+        self.__note_method_calls = note_method_calls
+
+    def __deepcopy__(self, table):
+        return self.__copy__()
+
+    def __repr__(self):
+        raise NotImplementedError()
+
+    def seed(self, seed):
+        raise NotImplementedError()
+
+    def getstate(self):
+        raise NotImplementedError()
+
+    def setstate(self, state):
+        raise NotImplementedError()
+
+    def _hypothesis_log_random(self, method, kwargs, result):
+        if not (self.__note_method_calls and should_note()):
+            return
+
+        args, kwargs = convert_kwargs(method, kwargs)
+        argstr = ", ".join(
+            list(map(repr, args)) + f"{k}={v!r}" for k, v in kwargs.items()
+        )
+        report(f"{self!r}.{method}({argstr}) -> {result!r}")
+
+    def _hypothesis_do_random(self, method, kwargs):
+        raise NotImplementedError()
+
+
+RANDOM_METHODS = 
+    name
+    for name in 
+        "_randbelow",
+        "betavariate",
+        "binomialvariate",
+        "choice",
+        "choices",
+        "expovariate",
+        "gammavariate",
+        "gauss",
+        "getrandbits",
+        "lognormvariate",
+        "normalvariate",
+        "paretovariate",
+        "randint",
+        "random",
+        "randrange",
+        "sample",
+        "shuffle",
+        "triangular",
+        "uniform",
+        "vonmisesvariate",
+        "weibullvariate",
+        "randbytes",
+    
+    if hasattr(Random, name)
+
+
+
+# Fake shims to get a good signature
+def getrandbits(self, n: int) -> int:  # type: ignore
+    raise NotImplementedError()
+
+
+def random(self) -> float:  # type: ignore
+    raise NotImplementedError()
+
+
+def _randbelow(self, n: int) -> int:  # type: ignore
+    raise NotImplementedError()
+
+
+STUBS = {f.__name__: f for f in getrandbits, random, _randbelow}
+
+
+SIGNATURES: Dictstr, inspect.Signature = {}
+
+
+def sig_of(name):
+    try:
+        return SIGNATURESname
+    except KeyError:
+        pass
+
+    target = getattr(Random, name)
+    result = inspect.signature(STUBS.get(name, target))
+    SIGNATURESname = result
+    return result
+
+
+def define_copy_method(name):
+    target = getattr(Random, name)
+
+    def implementation(self, **kwargs):
+        result = self._hypothesis_do_random(name, kwargs)
+        self._hypothesis_log_random(name, kwargs, result)
+        return result
+
+    sig = inspect.signature(STUBS.get(name, target))
+
+    result = define_function_signature(target.__name__, target.__doc__, sig)(
+        implementation
+    )
+
+    result.__module__ = __name__
+    result.__qualname__ = "HypothesisRandom." + result.__name__
+
+    setattr(HypothesisRandom, name, result)
+
+
+for r in RANDOM_METHODS:
+    define_copy_method(r)
+
+
+@attr.s(slots=True)
+class RandomState:
+    next_states = attr.ib(default=attr.Factory(dict))
+    state_id = attr.ib(default=None)
+
+
+def state_for_seed(data, seed):
+    try:
+        seeds_to_states = data.seeds_to_states
+    except AttributeError:
+        seeds_to_states = {}
+        data.seeds_to_states = seeds_to_states
+
+    try:
+        state = seeds_to_statesseed
+    except KeyError:
+        state = RandomState()
+        seeds_to_statesseed = state
+
+    return state
+
+
+UNIFORM = floats(0, 1)
+
+
+def normalize_zero(f: float) -> float:
+    if f == 0.0:
+        return 0.0
+    else:
+        return f
+
+
+class ArtificialRandom(HypothesisRandom):
+    VERSION = 10**6
+
+    def __init__(self, note_method_calls, data):
+        super().__init__(note_method_calls=note_method_calls)
+        self.__data = data
+        self.__state = RandomState()
+
+    def __repr__(self):
+        return "HypothesisRandom(generated data)"
+
+    def __copy__(self):
+        result = ArtificialRandom(
+            note_method_calls=self._HypothesisRandom__note_method_calls,
+            data=self.__data,
+        )
+        result.setstate(self.getstate())
+        return result
+
+    def __convert_result(self, method, kwargs, result):
+        if method == "choice":
+            return kwargs.get("seq")result
+        if method in ("choices", "sample"):
+            seq = kwargs"population"
+            return seqi for i in result
+        if method == "shuffle":
+            seq = kwargs"x"
+            original = list(seq)
+            for i, i2 in enumerate(result):
+                seqi = originali2
+            return
+        return result
+
+    def _hypothesis_do_random(self, method, kwargs):
+        if method == "choices":
+            key = (method, len(kwargs"population"), kwargs.get("k"))
+        elif method == "choice":
+            key = (method, len(kwargs"seq"))
+        elif method == "shuffle":
+            key = (method, len(kwargs"x"))
+        else:
+            key = (method,) + tuple(sorted(kwargs))
+
+        try:
+            result, self.__state = self.__state.next_stateskey
+        except KeyError:
+            pass
+        else:
+            return self.__convert_result(method, kwargs, result)
+
+        if method == "_randbelow":
+            result = cu.integer_range(self.__data, 0, kwargs"n" - 1)
+        elif method in ("betavariate", "random"):
+            result = self.__data.draw(UNIFORM)
+        elif method == "uniform":
+            a = normalize_zero(kwargs"a")
+            b = normalize_zero(kwargs"b")
+            result = self.__data.draw(floats(a, b))
+        elif method in ("weibullvariate", "gammavariate"):
+            result = self.__data.draw(floats(min_value=0.0, allow_infinity=False))
+        elif method in ("gauss", "normalvariate"):
+            mu = kwargs"mu"
+            result = mu + self.__data.draw(
+                floats(allow_nan=False, allow_infinity=False)
+            )
+        elif method == "vonmisesvariate":
+            result = self.__data.draw(floats(0, 2 * math.pi))
+        elif method == "randrange":
+            if kwargs"stop" is None:
+                stop = kwargs"start"
+                start = 0
+            else:
+                start = kwargs"start"
+                stop = kwargs"stop"
+
+            step = kwargs"step"
+            if start == stop:
+                raise ValueError(f"empty range for randrange({start}, {stop}, {step})")
+
+            if step != 1:
+                endpoint = (stop - start) // step
+                if (start - stop) % step == 0:
+                    endpoint -= 1
+
+                i = cu.integer_range(self.__data, 0, endpoint)
+                result = start + i * step
+            else:
+                result = cu.integer_range(self.__data, start, stop - 1)
+        elif method == "randint":
+            result = cu.integer_range(self.__data, kwargs"a", kwargs"b")
+        # New in Python 3.12, so not taken by our coverage job
+        elif method == "binomialvariate":  # pragma: no cover
+            result = cu.integer_range(self.__data, 0, kwargs"n")
+        elif method == "choice":
+            seq = kwargs"seq"
+            result = cu.integer_range(self.__data, 0, len(seq) - 1)
+        elif method == "choices":
+            k = kwargs"k"
+            result = self.__data.draw(
+                lists(
+                    integers(0, len(kwargs"population") - 1),
+                    min_size=k,
+                    max_size=k,
+                )
+            )
+        elif method == "sample":
+            k = kwargs"k"
+            seq = kwargs"population"
+
+            if k > len(seq) or k < 0:
+                raise ValueError(
+                    f"Sample size {k} not in expected range 0 <= k <= {len(seq)}"
+                )
+
+            result = self.__data.draw(
+                lists(
+                    sampled_from(range(len(seq))),
+                    min_size=k,
+                    max_size=k,
+                    unique=True,
+                )
+            )
+
+        elif method == "getrandbits":
+            result = self.__data.draw_bits(kwargs"n")
+        elif method == "triangular":
+            low = normalize_zero(kwargs"low")
+            high = normalize_zero(kwargs"high")
+            mode = normalize_zero(kwargs"mode")
+            if mode is None:
+                result = self.__data.draw(floats(low, high))
+            elif self.__data.draw_bits(1):
+                result = self.__data.draw(floats(mode, high))
+            else:
+                result = self.__data.draw(floats(low, mode))
+        elif method in ("paretovariate", "expovariate", "lognormvariate"):
+            result = self.__data.draw(floats(min_value=0.0))
+        elif method == "shuffle":
+            result = self.__data.draw(permutations(range(len(kwargs"x"))))
+        elif method == "randbytes":
+            n = kwargs"n"
+            result = self.__data.draw(binary(min_size=n, max_size=n))
+        else:
+            raise NotImplementedError(method)
+
+        new_state = RandomState()
+        self.__state.next_stateskey = (result, new_state)
+        self.__state = new_state
+
+        return self.__convert_result(method, kwargs, result)
+
+    def seed(self, seed):
+        self.__state = state_for_seed(self.__data, seed)
+
+    def getstate(self):
+        if self.__state.state_id is not None:
+            return self.__state.state_id
+
+        try:
+            states_for_ids = self.__data.states_for_ids
+        except AttributeError:
+            states_for_ids = {}
+            self.__data.states_for_ids = states_for_ids
+
+        self.__state.state_id = len(states_for_ids)
+        states_for_idsself.__state.state_id = self.__state
+
+        return self.__state.state_id
+
+    def setstate(self, state):
+        self.__state = self.__data.states_for_idsstate
+
+
+DUMMY_RANDOM = Random(0)
+
+
+def convert_kwargs(name, kwargs):
+    kwargs = dict(kwargs)
+
+    signature = sig_of(name)
+
+    bound = signature.bind(DUMMY_RANDOM, **kwargs)
+    bound.apply_defaults()
+
+    for k in list(kwargs):
+        if (
+            kwargsk is signature.parametersk.default
+            or signature.parametersk.kind != inspect.Parameter.KEYWORD_ONLY
+        ):
+            kwargs.pop(k)
+
+    arg_names = list(signature.parameters)1:
+
+    args = 
+
+    for a in arg_names:
+        if signature.parametersa.kind == inspect.Parameter.KEYWORD_ONLY:
+            break
+        args.append(bound.argumentsa)
+        kwargs.pop(a, None)
+
+    while args:
+        name = arg_nameslen(args) - 1
+        if args-1 is signature.parametersname.default:
+            args.pop()
+        else:
+            break  # pragma: no cover  # Only on Python < 3.8
+
+    return (args, kwargs)
+
+
+class TrueRandom(HypothesisRandom):
+    def __init__(self, seed, note_method_calls):
+        super().__init__(note_method_calls)
+        self.__seed = seed
+        self.__random = Random(seed)
+
+    def _hypothesis_do_random(self, method, kwargs):
+        args, kwargs = convert_kwargs(method, kwargs)
+
+        return getattr(self.__random, method)(*args, **kwargs)
+
+    def __copy__(self):
+        result = TrueRandom(
+            seed=self.__seed,
+            note_method_calls=self._HypothesisRandom__note_method_calls,
+        )
+        result.setstate(self.getstate())
+        return result
+
+    def __repr__(self):
+        return f"Random({self.__seed!r})"
+
+    def seed(self, seed):
+        self.__random.seed(seed)
+        self.__seed = seed
+
+    def getstate(self):
+        return self.__random.getstate()
+
+    def setstate(self, state):
+        self.__random.setstate(state)
+
+
+class RandomStrategy(SearchStrategy):
+    def __init__(self, note_method_calls, use_true_random):
+        self.__note_method_calls = note_method_calls
+        self.__use_true_random = use_true_random
+
+    def do_draw(self, data):
+        if self.__use_true_random:
+            seed = data.draw_bits(64)
+            return TrueRandom(seed=seed, note_method_calls=self.__note_method_calls)
+        else:
+            return ArtificialRandom(
+                note_method_calls=self.__note_method_calls, data=data
+            )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/recursive.py Added

@@ -0,0 +1,124 @@
+# 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 threading
+from contextlib import contextmanager
+
+from hypothesis.errors import InvalidArgument
+from hypothesis.internal.lazyformat import lazyformat
+from hypothesis.internal.reflection import get_pretty_function_description
+from hypothesis.internal.validation import check_type
+from hypothesis.strategies._internal.strategies import (
+    OneOfStrategy,
+    SearchStrategy,
+    check_strategy,
+)
+
+
+class LimitReached(BaseException):
+    pass
+
+
+class LimitedStrategy(SearchStrategy):
+    def __init__(self, strategy):
+        super().__init__()
+        self.base_strategy = strategy
+        self._threadlocal = threading.local()
+
+    @property
+    def marker(self):
+        return getattr(self._threadlocal, "marker", 0)
+
+    @marker.setter
+    def marker(self, value):
+        self._threadlocal.marker = value
+
+    @property
+    def currently_capped(self):
+        return getattr(self._threadlocal, "currently_capped", False)
+
+    @currently_capped.setter
+    def currently_capped(self, value):
+        self._threadlocal.currently_capped = value
+
+    def __repr__(self):
+        return f"LimitedStrategy({self.base_strategy!r})"
+
+    def do_validate(self):
+        self.base_strategy.validate()
+
+    def do_draw(self, data):
+        assert self.currently_capped
+        if self.marker <= 0:
+            raise LimitReached()
+        self.marker -= 1
+        return data.draw(self.base_strategy)
+
+    @contextmanager
+    def capped(self, max_templates):
+        try:
+            was_capped = self.currently_capped
+            self.currently_capped = True
+            self.marker = max_templates
+            yield
+        finally:
+            self.currently_capped = was_capped
+
+
+class RecursiveStrategy(SearchStrategy):
+    def __init__(self, base, extend, max_leaves):
+        self.max_leaves = max_leaves
+        self.base = base
+        self.limited_base = LimitedStrategy(base)
+        self.extend = extend
+
+        strategies = self.limited_base, self.extend(self.limited_base)
+        while 2 ** (len(strategies) - 1) <= max_leaves:
+            strategies.append(extend(OneOfStrategy(tuple(strategies))))
+        self.strategy = OneOfStrategy(strategies)
+
+    def __repr__(self):
+        if not hasattr(self, "_cached_repr"):
+            self._cached_repr = "recursive(%r, %s, max_leaves=%d)" % (
+                self.base,
+                get_pretty_function_description(self.extend),
+                self.max_leaves,
+            )
+        return self._cached_repr
+
+    def do_validate(self):
+        check_strategy(self.base, "base")
+        extended = self.extend(self.limited_base)
+        check_strategy(extended, f"extend({self.limited_base!r})")
+        self.limited_base.validate()
+        extended.validate()
+        check_type(int, self.max_leaves, "max_leaves")
+        if self.max_leaves <= 0:
+            raise InvalidArgument(
+                f"max_leaves={self.max_leaves!r} must be greater than zero"
+            )
+
+    def do_draw(self, data):
+        count = 0
+        while True:
+            try:
+                with self.limited_base.capped(self.max_leaves):
+                    return data.draw(self.strategy)
+            except LimitReached:
+                # Workaround for possible coverage bug - this branch is definitely
+                # covered but for some reason is showing up as not covered.
+                if count == 0:  # pragma: no branch
+                    data.note_event(
+                        lazyformat(
+                            "Draw for %r exceeded max_leaves and had to be retried",
+                            self,
+                        )
+                    )
+                count += 1

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/regex.py Added

@@ -0,0 +1,501 @@
+# 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 operator
+import re
+
+try:  # pragma: no cover
+    import re._constants as sre
+    import re._parser as sre_parse
+except ImportError:  # Python < 3.11
+    import sre_constants as sre
+    import sre_parse
+
+from hypothesis import reject, strategies as st
+from hypothesis.internal.charmap import as_general_categories, categories
+from hypothesis.internal.compat import int_to_byte
+
+UNICODE_CATEGORIES = set(categories())
+
+
+SPACE_CHARS = set(" \t\n\r\f\v")
+UNICODE_SPACE_CHARS = SPACE_CHARS | set("\x1c\x1d\x1e\x1f\x85")
+UNICODE_DIGIT_CATEGORIES = {"Nd"}
+UNICODE_SPACE_CATEGORIES = set(as_general_categories("Z"))
+UNICODE_LETTER_CATEGORIES = set(as_general_categories("L"))
+UNICODE_WORD_CATEGORIES = set(as_general_categories("L", "N"))
+
+# This is verbose, but correct on all versions of Python
+BYTES_ALL = {int_to_byte(i) for i in range(256)}
+BYTES_DIGIT = {b for b in BYTES_ALL if re.match(b"\\d", b)}
+BYTES_SPACE = {b for b in BYTES_ALL if re.match(b"\\s", b)}
+BYTES_WORD = {b for b in BYTES_ALL if re.match(b"\\w", b)}
+BYTES_LOOKUP = {
+    sre.CATEGORY_DIGIT: BYTES_DIGIT,
+    sre.CATEGORY_SPACE: BYTES_SPACE,
+    sre.CATEGORY_WORD: BYTES_WORD,
+    sre.CATEGORY_NOT_DIGIT: BYTES_ALL - BYTES_DIGIT,
+    sre.CATEGORY_NOT_SPACE: BYTES_ALL - BYTES_SPACE,
+    sre.CATEGORY_NOT_WORD: BYTES_ALL - BYTES_WORD,
+}
+
+
+GROUP_CACHE_STRATEGY = st.shared(st.builds(dict), key="hypothesis.regex.group_cache")
+
+
+@st.composite
+def update_group(draw, group_name, strategy):
+    cache = draw(GROUP_CACHE_STRATEGY)
+    result = draw(strategy)
+    cachegroup_name = result
+    return result
+
+
+@st.composite
+def reuse_group(draw, group_name):
+    cache = draw(GROUP_CACHE_STRATEGY)
+    try:
+        return cachegroup_name
+    except KeyError:
+        reject()
+
+
+@st.composite
+def group_conditional(draw, group_name, if_yes, if_no):
+    cache = draw(GROUP_CACHE_STRATEGY)
+    if group_name in cache:
+        return draw(if_yes)
+    else:
+        return draw(if_no)
+
+
+@st.composite
+def clear_cache_after_draw(draw, base_strategy):
+    cache = draw(GROUP_CACHE_STRATEGY)
+    result = draw(base_strategy)
+    cache.clear()
+    return result
+
+
+class Context:
+    __slots__ = "flags"
+
+    def __init__(self, flags):
+        self.flags = flags
+
+
+class CharactersBuilder:
+    """Helper object that allows to configure `characters` strategy with
+    various unicode categories and characters. Also allows negation of
+    configured set.
+
+    :param negate: If True, configure :func:`hypothesis.strategies.characters`
+        to match anything other than configured character set
+    :param flags: Regex flags. They affect how and which characters are matched
+    """
+
+    def __init__(self, negate=False, flags=0):
+        self._categories = set()
+        self._whitelist_chars = set()
+        self._blacklist_chars = set()
+        self._negate = negate
+        self._ignorecase = flags & re.IGNORECASE
+        self._unicode = not bool(flags & re.ASCII)
+        self.code_to_char = chr
+
+    @property
+    def strategy(self):
+        """Returns resulting strategy that generates configured char set."""
+        max_codepoint = None if self._unicode else 127
+        # Due to the .swapcase() issue described below (and in issue #2657),
+        # self._whitelist_chars may contain strings of len > 1.  We therefore
+        # have some extra logic to filter them out of st.characters() args,
+        # but still generate them if allowed to.
+        if self._negate:
+            black_chars = self._blacklist_chars - self._whitelist_chars
+            return st.characters(
+                blacklist_categories=self._categories | {"Cc", "Cs"},
+                blacklist_characters={c for c in self._whitelist_chars if len(c) == 1},
+                whitelist_characters=black_chars,
+                max_codepoint=max_codepoint,
+            )
+        white_chars = self._whitelist_chars - self._blacklist_chars
+        multi_chars = {c for c in white_chars if len(c) > 1}
+        char_strategy = st.characters(
+            whitelist_categories=self._categories,
+            blacklist_characters=self._blacklist_chars,
+            whitelist_characters=white_chars - multi_chars,
+            max_codepoint=max_codepoint,
+        )
+        if multi_chars:
+            char_strategy |= st.sampled_from(sorted(multi_chars))
+        return char_strategy
+
+    def add_category(self, category):
+        """Update unicode state to match sre_parse object ``category``."""
+        if category == sre.CATEGORY_DIGIT:
+            self._categories |= UNICODE_DIGIT_CATEGORIES
+        elif category == sre.CATEGORY_NOT_DIGIT:
+            self._categories |= UNICODE_CATEGORIES - UNICODE_DIGIT_CATEGORIES
+        elif category == sre.CATEGORY_SPACE:
+            self._categories |= UNICODE_SPACE_CATEGORIES
+            self._whitelist_chars |= (
+                UNICODE_SPACE_CHARS if self._unicode else SPACE_CHARS
+            )
+        elif category == sre.CATEGORY_NOT_SPACE:
+            self._categories |= UNICODE_CATEGORIES - UNICODE_SPACE_CATEGORIES
+            self._blacklist_chars |= (
+                UNICODE_SPACE_CHARS if self._unicode else SPACE_CHARS
+            )
+        elif category == sre.CATEGORY_WORD:
+            self._categories |= UNICODE_WORD_CATEGORIES
+            self._whitelist_chars.add("_")
+        elif category == sre.CATEGORY_NOT_WORD:
+            self._categories |= UNICODE_CATEGORIES - UNICODE_WORD_CATEGORIES
+            self._blacklist_chars.add("_")
+        else:
+            raise NotImplementedError(f"Unknown character category: {category}")
+
+    def add_char(self, char):
+        """Add given char to the whitelist."""
+        c = self.code_to_char(char)
+        self._whitelist_chars.add(c)
+        if (
+            self._ignorecase
+            and re.match(re.escape(c), c.swapcase(), flags=re.IGNORECASE) is not None
+        ):
+            # Note that it is possible that `len(c.swapcase()) > 1`
+            self._whitelist_chars.add(c.swapcase())
+
+
+class BytesBuilder(CharactersBuilder):
+    def __init__(self, negate=False, flags=0):
+        self._whitelist_chars = set()
+        self._blacklist_chars = set()
+        self._negate = negate
+        self._ignorecase = flags & re.IGNORECASE
+        self.code_to_char = int_to_byte
+
+    @property
+    def strategy(self):
+        """Returns resulting strategy that generates configured char set."""
+        allowed = self._whitelist_chars
+        if self._negate:
+            allowed = BYTES_ALL - allowed
+        return st.sampled_from(sorted(allowed))
+
+    def add_category(self, category):
+        """Update characters state to match sre_parse object ``category``."""
+        self._whitelist_chars |= BYTES_LOOKUPcategory
+
+
+@st.composite
+def maybe_pad(draw, regex, strategy, left_pad_strategy, right_pad_strategy):
+    """Attempt to insert padding around the result of a regex draw while
+    preserving the match."""
+    result = draw(strategy)
+    left_pad = draw(left_pad_strategy)
+    if left_pad and regex.search(left_pad + result):
+        result = left_pad + result
+    right_pad = draw(right_pad_strategy)
+    if right_pad and regex.search(result + right_pad):
+        result += right_pad
+    return result
+
+
+def base_regex_strategy(regex, parsed=None):
+    if parsed is None:
+        parsed = sre_parse.parse(regex.pattern, flags=regex.flags)
+    return clear_cache_after_draw(
+        _strategy(parsed, Context(flags=regex.flags), isinstance(regex.pattern, str))
+    )
+
+
+def regex_strategy(regex, fullmatch, *, _temp_jsonschema_hack_no_end_newline=False):
+    if not hasattr(regex, "pattern"):
+        regex = re.compile(regex)
+
+    is_unicode = isinstance(regex.pattern, str)
+
+    parsed = sre_parse.parse(regex.pattern, flags=regex.flags)
+
+    if fullmatch:
+        if not parsed:
+            return st.just("" if is_unicode else b"")
+        return base_regex_strategy(regex, parsed).filter(regex.fullmatch)
+
+    if not parsed:
+        if is_unicode:
+            return st.text()
+        else:
+            return st.binary()
+
+    if is_unicode:
+        base_padding_strategy = st.text()
+        empty = st.just("")
+        newline = st.just("\n")
+    else:
+        base_padding_strategy = st.binary()
+        empty = st.just(b"")
+        newline = st.just(b"\n")
+
+    right_pad = base_padding_strategy
+    left_pad = base_padding_strategy
+
+    if parsed-10 == sre.AT:
+        if parsed-11 == sre.AT_END_STRING:
+            right_pad = empty
+        elif parsed-11 == sre.AT_END:
+            if regex.flags & re.MULTILINE:
+                right_pad = st.one_of(
+                    empty, st.builds(operator.add, newline, right_pad)
+                )
+            else:
+                right_pad = st.one_of(empty, newline)
+
+            # This will be removed when a regex-syntax-translation library exists.
+            # It's a pretty nasty hack, but means that we can match the semantics
+            # of JSONschema's compatible subset of ECMA regex, which is important
+            # for hypothesis-jsonschema and Schemathesis. See e.g.
+            # https://github.com/schemathesis/schemathesis/issues/1241
+            if _temp_jsonschema_hack_no_end_newline:
+                right_pad = empty
+
+    if parsed00 == sre.AT:
+        if parsed01 == sre.AT_BEGINNING_STRING:
+            left_pad = empty
+        elif parsed01 == sre.AT_BEGINNING:
+            if regex.flags & re.MULTILINE:
+                left_pad = st.one_of(empty, st.builds(operator.add, left_pad, newline))
+            else:
+                left_pad = empty
+
+    base = base_regex_strategy(regex, parsed).filter(regex.search)
+
+    return maybe_pad(regex, base, left_pad, right_pad)
+
+
+def _strategy(codes, context, is_unicode):
+    """Convert SRE regex parse tree to strategy that generates strings matching
+    that regex represented by that parse tree.
+
+    `codes` is either a list of SRE regex elements representations or a
+    particular element representation. Each element is a tuple of element code
+    (as string) and parameters. E.g. regex 'ab0-9+' compiles to following
+    elements:
+
+        
+            (LITERAL, 97),
+            (LITERAL, 98),
+            (MAX_REPEAT, (1, 4294967295, 
+                (IN, 
+                    (RANGE, (48, 57))
+                )
+            ))
+        
+
+    The function recursively traverses regex element tree and converts each
+    element to strategy that generates strings that match that element.
+
+    Context stores
+    1. List of groups (for backreferences)
+    2. Active regex flags (e.g. IGNORECASE, DOTALL, UNICODE, they affect
+       behavior of various inner strategies)
+    """
+
+    def recurse(codes):
+        return _strategy(codes, context, is_unicode)
+
+    if is_unicode:
+        empty = ""
+        to_char = chr
+    else:
+        empty = b""
+        to_char = int_to_byte
+        binary_char = st.binary(min_size=1, max_size=1)
+
+    if not isinstance(codes, tuple):
+        # List of codes
+        strategies = 
+
+        i = 0
+        while i < len(codes):
+            if codesi0 == sre.LITERAL and not context.flags & re.IGNORECASE:
+                # Merge subsequent "literals" into one `just()` strategy
+                # that generates corresponding text if no IGNORECASE
+                j = i + 1
+                while j < len(codes) and codesj0 == sre.LITERAL:
+                    j += 1
+
+                if i + 1 < j:
+                    chars = (to_char(charcode) for _, charcode in codesi:j)
+                    strategies.append(st.just(empty.join(chars)))
+                    i = j
+                    continue
+
+            strategies.append(recurse(codesi))
+            i += 1
+
+        # We handle this separately at the top level, but some regex can
+        # contain empty lists internally, so we need to handle this here too.
+        if not strategies:
+            return st.just(empty)
+
+        if len(strategies) == 1:
+            return strategies0
+        return st.tuples(*strategies).map(empty.join)
+    else:
+        # Single code
+        code, value = codes
+        if code == sre.LITERAL:
+            # Regex 'a' (single char)
+            c = to_char(value)
+            if (
+                context.flags & re.IGNORECASE
+                and c != c.swapcase()
+                and re.match(re.escape(c), c.swapcase(), re.IGNORECASE) is not None
+            ):
+                # We do the explicit check for swapped-case matching because
+                # eg 'ß'.upper() == 'SS' and ignorecase doesn't match it.
+                return st.sampled_from(c, c.swapcase())
+            return st.just(c)
+
+        elif code == sre.NOT_LITERAL:
+            # Regex '^a' (negation of a single char)
+            c = to_char(value)
+            blacklist = {c}
+            if (
+                context.flags & re.IGNORECASE
+                and re.match(re.escape(c), c.swapcase(), re.IGNORECASE) is not None
+            ):
+                # There are a few cases where .swapcase() returns two characters,
+                # but is still a case-insensitive match.  In such cases we add *both*
+                # characters to our blacklist, to avoid doing the wrong thing for
+                # patterns such as r"^\u0130+" where "i\u0307" matches.
+                #
+                # (that's respectively 'Latin letter capital I with dot above' and
+                # 'latin latter i' + 'combining dot above'; see issue #2657)
+                #
+                # As a final additional wrinkle, "latin letter capital I" *also*
+                # case-insensitive-matches, with or without combining dot character.
+                # We therefore have to chain .swapcase() calls until a fixpoint.
+                stack = c.swapcase()
+                while stack:
+                    for char in stack.pop():
+                        blacklist.add(char)
+                        stack.extend(set(char.swapcase()) - blacklist)
+
+            if is_unicode:
+                return st.characters(blacklist_characters=blacklist)
+            else:
+                return binary_char.filter(lambda c: c not in blacklist)
+
+        elif code == sre.IN:
+            # Regex 'abc0-9' (set of characters)
+            negate = value00 == sre.NEGATE
+            if is_unicode:
+                builder = CharactersBuilder(negate, context.flags)
+            else:
+                builder = BytesBuilder(negate, context.flags)
+
+            for charset_code, charset_value in value:
+                if charset_code == sre.NEGATE:
+                    # Regex '^...' (negation)
+                    # handled by builder = CharactersBuilder(...) above
+                    pass
+                elif charset_code == sre.LITERAL:
+                    # Regex 'a' (single char)
+                    builder.add_char(charset_value)
+                elif charset_code == sre.RANGE:
+                    # Regex 'a-z' (char range)
+                    low, high = charset_value
+                    for char_code in range(low, high + 1):
+                        builder.add_char(char_code)
+                elif charset_code == sre.CATEGORY:
+                    # Regex '\w' (char category)
+                    builder.add_category(charset_value)
+                else:
+                    # Currently there are no known code points other than
+                    # handled here. This code is just future proofing
+                    raise NotImplementedError(f"Unknown charset code: {charset_code}")
+            return builder.strategy
+
+        elif code == sre.ANY:
+            # Regex '.' (any char)
+            if is_unicode:
+                if context.flags & re.DOTALL:
+                    return st.characters()
+                return st.characters(blacklist_characters="\n")
+            else:
+                if context.flags & re.DOTALL:
+                    return binary_char
+                return binary_char.filter(lambda c: c != b"\n")
+
+        elif code == sre.AT:
+            # Regexes like '^...', '...$', '\bfoo', '\Bfoo'
+            # An empty string (or newline) will match the token itself, but
+            # we don't and can't check the position (eg '%' at the end)
+            return st.just(empty)
+
+        elif code == sre.SUBPATTERN:
+            # Various groups: '(...)', '(:...)' or '(?P<name>...)'
+            old_flags = context.flags
+            context.flags = (context.flags | value1) & ~value2
+
+            strat = _strategy(value-1, context, is_unicode)
+
+            context.flags = old_flags
+
+            if value0:
+                strat = update_group(value0, strat)
+
+            return strat
+
+        elif code == sre.GROUPREF:
+            # Regex '\\1' or '(?P=name)' (group reference)
+            return reuse_group(value)
+
+        elif code == sre.ASSERT:
+            # Regex '(?=...)' or '(?<=...)' (positive lookahead/lookbehind)
+            return recurse(value1)
+
+        elif code == sre.ASSERT_NOT:
+            # Regex '(?!...)' or '(?<!...)' (negative lookahead/lookbehind)
+            return st.just(empty)
+
+        elif code == sre.BRANCH:
+            # Regex 'a|b|c' (branch)
+            return st.one_of(recurse(branch) for branch in value1)
+
+        elif code in sre.MIN_REPEAT, sre.MAX_REPEAT:
+            # Regexes 'a?', 'a*', 'a+' and their non-greedy variants
+            # (repeaters)
+            at_least, at_most, subregex = value
+            if at_most == sre.MAXREPEAT:
+                at_most = None
+            if at_least == 0 and at_most == 1:
+                return st.just(empty) | recurse(subregex)
+            return st.lists(recurse(subregex), min_size=at_least, max_size=at_most).map(
+                empty.join
+            )
+
+        elif code == sre.GROUPREF_EXISTS:
+            # Regex '(?(id/name)yes-pattern|no-pattern)'
+            # (if group exists choice)
+            return group_conditional(
+                value0,
+                recurse(value1),
+                recurse(value2) if value2 else st.just(empty),
+            )
+
+        else:
+            # Currently there are no known code points other than handled here.
+            # This code is just future proofing
+            raise NotImplementedError(f"Unknown code point: {code!r}")

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/shared.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/strategies.py Added

@@ -0,0 +1,991 @@
+# 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 sys
+import warnings
+from collections import abc, defaultdict
+from random import shuffle
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Sequence,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from hypothesis._settings import HealthCheck, Phase, Verbosity, settings
+from hypothesis.control import _current_build_context, assume
+from hypothesis.errors import (
+    HypothesisException,
+    HypothesisWarning,
+    InvalidArgument,
+    NonInteractiveExampleWarning,
+    UnsatisfiedAssumption,
+)
+from hypothesis.internal.conjecture import utils as cu
+from hypothesis.internal.conjecture.data import ConjectureData
+from hypothesis.internal.conjecture.utils import (
+    calc_label_from_cls,
+    calc_label_from_name,
+    combine_labels,
+)
+from hypothesis.internal.coverage import check_function
+from hypothesis.internal.lazyformat import lazyformat
+from hypothesis.internal.reflection import (
+    get_pretty_function_description,
+    is_identity_function,
+)
+from hypothesis.strategies._internal.utils import defines_strategy
+from hypothesis.utils.conventions import UniqueIdentifier
+
+Ex = TypeVar("Ex", covariant=True)
+Ex_Inv = TypeVar("Ex_Inv")
+T = TypeVar("T")
+T3 = TypeVar("T3")
+T4 = TypeVar("T4")
+T5 = TypeVar("T5")
+
+calculating = UniqueIdentifier("calculating")
+
+MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
+    "another attempted draw in MappedSearchStrategy"
+)
+
+FILTERED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
+    "single loop iteration in FilteredStrategy"
+)
+
+
+def recursive_property(name, default):
+    """Handle properties which may be mutually recursive among a set of
+    strategies.
+
+    These are essentially lazily cached properties, with the ability to set
+    an override: If the property has not been explicitly set, we calculate
+    it on first access and memoize the result for later.
+
+    The problem is that for properties that depend on each other, a naive
+    calculation strategy may hit infinite recursion. Consider for example
+    the property is_empty. A strategy defined as x = st.deferred(lambda: x)
+    is certainly empty (in order to draw a value from x we would have to
+    draw a value from x, for which we would have to draw a value from x,
+    ...), but in order to calculate it the naive approach would end up
+    calling x.is_empty in order to calculate x.is_empty in order to etc.
+
+    The solution is one of fixed point calculation. We start with a default
+    value that is the value of the property in the absence of evidence to
+    the contrary, and then update the values of the property for all
+    dependent strategies until we reach a fixed point.
+
+    The approach taken roughly follows that in section 4.2 of Adams,
+    Michael D., Celeste Hollenbeck, and Matthew Might. "On the complexity
+    and performance of parsing with derivatives." ACM SIGPLAN Notices 51.6
+    (2016): 224-236.
+    """
+    cache_key = "cached_" + name
+    calculation = "calc_" + name
+    force_key = "force_" + name
+
+    def forced_value(target):
+        try:
+            return getattr(target, force_key)
+        except AttributeError:
+            return getattr(target, cache_key)
+
+    def accept(self):
+        try:
+            return forced_value(self)
+        except AttributeError:
+            pass
+
+        mapping = {}
+        sentinel = object()
+        hit_recursion = False
+
+        # For a first pass we do a direct recursive calculation of the
+        # property, but we block recursively visiting a value in the
+        # computation of its property: When that happens, we simply
+        # note that it happened and return the default value.
+        def recur(strat):
+            try:
+                return forced_value(strat)
+            except AttributeError:
+                pass
+            result = mapping.get(strat, sentinel)
+            if result is calculating:
+                hit_recursion0 = True
+                return default
+            elif result is sentinel:
+                mappingstrat = calculating
+                mappingstrat = getattr(strat, calculation)(recur)
+                return mappingstrat
+            return result
+
+        recur(self)
+
+        # If we hit self-recursion in the computation of any strategy
+        # value, our mapping at the end is imprecise - it may or may
+        # not have the right values in it. We now need to proceed with
+        # a more careful fixed point calculation to get the exact
+        # values. Hopefully our mapping is still pretty good and it
+        # won't take a large number of updates to reach a fixed point.
+        if hit_recursion0:
+            needs_update = set(mapping)
+
+            # We track which strategies use which in the course of
+            # calculating their property value. If A ever uses B in
+            # the course of calculating its value, then whenever the
+            # value of B changes we might need to update the value of
+            # A.
+            listeners = defaultdict(set)
+        else:
+            needs_update = None
+
+        def recur2(strat):
+            def recur_inner(other):
+                try:
+                    return forced_value(other)
+                except AttributeError:
+                    pass
+                listenersother.add(strat)
+                result = mapping.get(other, sentinel)
+                if result is sentinel:
+                    needs_update.add(other)
+                    mappingother = default
+                    return default
+                return result
+
+            return recur_inner
+
+        count = 0
+        seen = set()
+        while needs_update:
+            count += 1
+            # If we seem to be taking a really long time to stabilize we
+            # start tracking seen values to attempt to detect an infinite
+            # loop. This should be impossible, and most code will never
+            # hit the count, but having an assertion for it means that
+            # testing is easier to debug and we don't just have a hung
+            # test.
+            # Note: This is actually covered, by test_very_deep_deferral
+            # in tests/cover/test_deferred_strategies.py. Unfortunately it
+            # runs into a coverage bug. See
+            # https://github.com/nedbat/coveragepy/issues/605
+            # for details.
+            if count > 50:  # pragma: no cover
+                key = frozenset(mapping.items())
+                assert key not in seen, (key, name)
+                seen.add(key)
+            to_update = needs_update
+            needs_update = set()
+            for strat in to_update:
+                new_value = getattr(strat, calculation)(recur2(strat))
+                if new_value != mappingstrat:
+                    needs_update.update(listenersstrat)
+                    mappingstrat = new_value
+
+        # We now have a complete and accurate calculation of the
+        # property values for everything we have seen in the course of
+        # running this calculation. We simultaneously update all of
+        # them (not just the strategy we started out with).
+        for k, v in mapping.items():
+            setattr(k, cache_key, v)
+        return getattr(self, cache_key)
+
+    accept.__name__ = name
+    return property(accept)
+
+
+class SearchStrategy(GenericEx):
+    """A SearchStrategy is an object that knows how to explore data of a given
+    type.
+
+    Except where noted otherwise, methods on this class are not part of
+    the public API and their behaviour may change significantly between
+    minor version releases. They will generally be stable between patch
+    releases.
+    """
+
+    supports_find = True
+    validate_called = False
+    __label = None
+    __module__ = "hypothesis.strategies"
+
+    def available(self, data):
+        """Returns whether this strategy can *currently* draw any
+        values. This typically useful for stateful testing where ``Bundle``
+        grows over time a list of value to choose from.
+
+        Unlike ``empty`` property, this method's return value may change
+        over time.
+        Note: ``data`` parameter will only be used for introspection and no
+        value drawn from it.
+        """
+        return not self.is_empty
+
+    # Returns True if this strategy can never draw a value and will always
+    # result in the data being marked invalid.
+    # The fact that this returns False does not guarantee that a valid value
+    # can be drawn - this is not intended to be perfect, and is primarily
+    # intended to be an optimisation for some cases.
+    is_empty = recursive_property("is_empty", True)
+
+    # Returns True if values from this strategy can safely be reused without
+    # this causing unexpected behaviour.
+
+    # True if values from this strategy can be implicitly reused (e.g. as
+    # background values in a numpy array) without causing surprising
+    # user-visible behaviour. Should be false for built-in strategies that
+    # produce mutable values, and for strategies that have been mapped/filtered
+    # by arbitrary user-provided functions.
+    has_reusable_values = recursive_property("has_reusable_values", True)
+
+    # Whether this strategy is suitable for holding onto in a cache.
+    is_cacheable = recursive_property("is_cacheable", True)
+
+    def calc_is_cacheable(self, recur):
+        return True
+
+    def calc_is_empty(self, recur):
+        # Note: It is correct and significant that the default return value
+        # from calc_is_empty is False despite the default value for is_empty
+        # being true. The reason for this is that strategies should be treated
+        # as empty absent evidence to the contrary, but most basic strategies
+        # are trivially non-empty and it would be annoying to have to override
+        # this method to show that.
+        return False
+
+    def calc_has_reusable_values(self, recur):
+        return False
+
+    def example(self) -> Ex:
+        """Provide an example of the sort of value that this strategy
+        generates. This is biased to be slightly simpler than is typical for
+        values from this strategy, for clarity purposes.
+
+        This method shouldn't be taken too seriously. It's here for interactive
+        exploration of the API, not for any sort of real testing.
+
+        This method is part of the public API.
+        """
+        if getattr(sys, "ps1", None) is None:  # pragma: no branch
+            # The other branch *is* covered in cover/test_examples.py; but as that
+            # uses `pexpect` for an interactive session `coverage` doesn't see it.
+            warnings.warn(
+                "The `.example()` method is good for exploring strategies, but should "
+                "only be used interactively.  We recommend using `@given` for tests - "
+                "it performs better, saves and replays failures to avoid flakiness, "
+                "and reports minimal examples. (strategy: %r)" % (self,),
+                NonInteractiveExampleWarning,
+                stacklevel=2,
+            )
+
+        context = _current_build_context.value
+        if context is not None:
+            if context.data is not None and context.data.depth > 0:
+                raise HypothesisException(
+                    "Using example() inside a strategy definition is a bad "
+                    "idea. Instead consider using hypothesis.strategies.builds() "
+                    "or @hypothesis.strategies.composite to define your strategy."
+                    " See https://hypothesis.readthedocs.io/en/latest/data.html"
+                    "#hypothesis.strategies.builds or "
+                    "https://hypothesis.readthedocs.io/en/latest/data.html"
+                    "#composite-strategies for more details."
+                )
+            else:
+                raise HypothesisException(
+                    "Using example() inside a test function is a bad "
+                    "idea. Instead consider using hypothesis.strategies.data() "
+                    "to draw more examples during testing. See "
+                    "https://hypothesis.readthedocs.io/en/latest/data.html"
+                    "#drawing-interactively-in-tests for more details."
+                )
+
+        try:
+            return self.__examples.pop()
+        except (AttributeError, IndexError):
+            self.__examples: ListEx = 
+
+        from hypothesis.core import given
+
+        # Note: this function has a weird name because it might appear in
+        # tracebacks, and we want users to know that they can ignore it.
+        @given(self)
+        @settings(
+            database=None,
+            max_examples=100,
+            deadline=None,
+            verbosity=Verbosity.quiet,
+            phases=(Phase.generate,),
+            suppress_health_check=list(HealthCheck),
+        )
+        def example_generating_inner_function(ex):
+            self.__examples.append(ex)
+
+        example_generating_inner_function()
+        shuffle(self.__examples)
+        return self.__examples.pop()
+
+    def map(self, pack: CallableEx, T) -> "SearchStrategyT":
+        """Returns a new strategy that generates values by generating a value
+        from this strategy and then calling pack() on the result, giving that.
+
+        This method is part of the public API.
+        """
+        if is_identity_function(pack):
+            return self  # type: ignore  # Mypy has no way to know that `Ex == T`
+        return MappedSearchStrategy(pack=pack, strategy=self)
+
+    def flatmap(
+        self, expand: CallableEx, "SearchStrategyT"
+    ) -> "SearchStrategyT":
+        """Returns a new strategy that generates values by generating a value
+        from this strategy, say x, then generating a value from
+        strategy(expand(x))
+
+        This method is part of the public API.
+        """
+        from hypothesis.strategies._internal.flatmapped import FlatMapStrategy
+
+        return FlatMapStrategy(expand=expand, strategy=self)
+
+    def filter(self, condition: CallableEx, Any) -> "SearchStrategyEx":
+        """Returns a new strategy that generates values from this strategy
+        which satisfy the provided condition. Note that if the condition is too
+        hard to satisfy this might result in your tests failing with
+        Unsatisfiable.
+
+        This method is part of the public API.
+        """
+        return FilteredStrategy(conditions=(condition,), strategy=self)
+
+    def _filter_for_filtered_draw(self, condition):
+        # Hook for parent strategies that want to perform fallible filtering
+        # on one of their internal strategies (e.g. UniqueListStrategy).
+        # The returned object must have a `.do_filtered_draw(data)` method
+        # that behaves like `do_draw`, but returns the sentinel object
+        # `filter_not_satisfied` if the condition could not be satisfied.
+
+        # This is separate from the main `filter` method so that strategies
+        # can override `filter` without having to also guarantee a
+        # `do_filtered_draw` method.
+        return FilteredStrategy(conditions=(condition,), strategy=self)
+
+    @property
+    def branches(self) -> List"SearchStrategyEx":
+        return self
+
+    def __or__(self, other: "SearchStrategyT") -> "SearchStrategyUnionEx, T":
+        """Return a strategy which produces values by randomly drawing from one
+        of this strategy or the other strategy.
+
+        This method is part of the public API.
+        """
+        if not isinstance(other, SearchStrategy):
+            raise ValueError(f"Cannot | a SearchStrategy with {other!r}")
+        return OneOfStrategy((self, other))
+
+    def __bool__(self) -> bool:
+        warnings.warn(
+            f"bool({self!r}) is always True, did you mean to draw a value?",
+            HypothesisWarning,
+            stacklevel=2,
+        )
+        return True
+
+    def validate(self) -> None:
+        """Throw an exception if the strategy is not valid.
+
+        This can happen due to lazy construction
+        """
+        if self.validate_called:
+            return
+        try:
+            self.validate_called = True
+            self.do_validate()
+            self.is_empty
+            self.has_reusable_values
+        except Exception:
+            self.validate_called = False
+            raise
+
+    LABELS: Dicttype, int = {}
+
+    @property
+    def class_label(self):
+        cls = self.__class__
+        try:
+            return cls.LABELScls
+        except KeyError:
+            pass
+        result = calc_label_from_cls(cls)
+        cls.LABELScls = result
+        return result
+
+    @property
+    def label(self) -> int:
+        if self.__label is calculating:
+            return 0
+        if self.__label is None:
+            self.__label = calculating
+            self.__label = self.calc_label()
+        return cast(int, self.__label)
+
+    def calc_label(self):
+        return self.class_label
+
+    def do_validate(self):
+        pass
+
+    def do_draw(self, data: ConjectureData) -> Ex:
+        raise NotImplementedError(f"{type(self).__name__}.do_draw")
+
+    def __init__(self):
+        pass
+
+
+def is_simple_data(value):
+    try:
+        hash(value)
+        return True
+    except TypeError:
+        return False
+
+
+class SampledFromStrategy(SearchStrategy):
+    """A strategy which samples from a set of elements. This is essentially
+    equivalent to using a OneOfStrategy over Just strategies but may be more
+    efficient and convenient.
+
+    The conditional distribution chooses uniformly at random from some
+    non-empty subset of the elements.
+    """
+
+    def __init__(self, elements, repr_=None, transformations=()):
+        super().__init__()
+        self.elements = cu.check_sample(elements, "sampled_from")
+        assert self.elements
+        self.repr_ = repr_
+        self._transformations = transformations
+
+    def map(self, pack):
+        return type(self)(
+            self.elements,
+            repr_=self.repr_,
+            transformations=self._transformations + (("map", pack),),
+        )
+
+    def filter(self, condition):
+        return type(self)(
+            self.elements,
+            repr_=self.repr_,
+            transformations=self._transformations + (("filter", condition),),
+        )
+
+    def __repr__(self):
+        return (
+            self.repr_
+            or "sampled_from("
+            + ", ".join(map(get_pretty_function_description, self.elements))
+            + ")"
+        ) + "".join(
+            f".{name}({get_pretty_function_description(f)})"
+            for name, f in self._transformations
+        )
+
+    def calc_has_reusable_values(self, recur):
+        # Because our custom .map/.filter implementations skip the normal
+        # wrapper strategies (which would automatically return False for us),
+        # we need to manually return False here if any transformations have
+        # been applied.
+        return not self._transformations
+
+    def calc_is_cacheable(self, recur):
+        return is_simple_data(self.elements)
+
+    def _transform(self, element):
+        # Used in UniqueSampledListStrategy
+        for name, f in self._transformations:
+            if name == "map":
+                element = f(element)
+            else:
+                assert name == "filter"
+                if not f(element):
+                    return filter_not_satisfied
+        return element
+
+    def do_draw(self, data):
+        result = self.do_filtered_draw(data)
+        if result is filter_not_satisfied:
+            data.mark_invalid(f"Aborted test because unable to satisfy {self!r}")
+        return result
+
+    def get_element(self, i):
+        return self._transform(self.elementsi)
+
+    def do_filtered_draw(self, data):
+        # Set of indices that have been tried so far, so that we never test
+        # the same element twice during a draw.
+        known_bad_indices = set()
+
+        # Start with ordinary rejection sampling. It's fast if it works, and
+        # if it doesn't work then it was only a small amount of overhead.
+        for _ in range(3):
+            i = cu.integer_range(data, 0, len(self.elements) - 1)
+            if i not in known_bad_indices:
+                element = self.get_element(i)
+                if element is not filter_not_satisfied:
+                    return element
+                if not known_bad_indices:
+                    FilteredStrategy.note_retried(self, data)
+                known_bad_indices.add(i)
+
+        # If we've tried all the possible elements, give up now.
+        max_good_indices = len(self.elements) - len(known_bad_indices)
+        if not max_good_indices:
+            return filter_not_satisfied
+
+        # Figure out the bit-length of the index that we will write back after
+        # choosing an allowed element.
+        write_length = len(self.elements).bit_length()
+
+        # Impose an arbitrary cutoff to prevent us from wasting too much time
+        # on very large element lists.
+        cutoff = 10000
+        max_good_indices = min(max_good_indices, cutoff)
+
+        # Before building the list of allowed indices, speculatively choose
+        # one of them. We don't yet know how many allowed indices there will be,
+        # so this choice might be out-of-bounds, but that's OK.
+        speculative_index = cu.integer_range(data, 0, max_good_indices - 1)
+
+        # Calculate the indices of allowed values, so that we can choose one
+        # of them at random. But if we encounter the speculatively-chosen one,
+        # just use that and return immediately.  Note that we also track the
+        # allowed elements, in case of .map(some_stateful_function)
+        allowed = 
+        for i in range(min(len(self.elements), cutoff)):
+            if i not in known_bad_indices:
+                element = self.get_element(i)
+                if element is not filter_not_satisfied:
+                    allowed.append((i, element))
+                    if len(allowed) > speculative_index:
+                        # Early-exit case: We reached the speculative index, so
+                        # we just return the corresponding element.
+                        data.draw_bits(write_length, forced=i)
+                        return element
+
+        # The speculative index didn't work out, but at this point we've built
+        # and can choose from the complete list of allowed indices and elements.
+        if allowed:
+            i, element = cu.choice(data, allowed)
+            data.draw_bits(write_length, forced=i)
+            return element
+        # If there are no allowed indices, the filter couldn't be satisfied.
+        return filter_not_satisfied
+
+
+class OneOfStrategy(SearchStrategyEx):
+    """Implements a union of strategies. Given a number of strategies this
+    generates values which could have come from any of them.
+
+    The conditional distribution draws uniformly at random from some
+    non-empty subset of these strategies and then draws from the
+    conditional distribution of that strategy.
+    """
+
+    def __init__(self, strategies):
+        super().__init__()
+        strategies = tuple(strategies)
+        self.original_strategies = list(strategies)
+        self.__element_strategies = None
+        self.__in_branches = False
+
+    def calc_is_empty(self, recur):
+        return all(recur(e) for e in self.original_strategies)
+
+    def calc_has_reusable_values(self, recur):
+        return all(recur(e) for e in self.original_strategies)
+
+    def calc_is_cacheable(self, recur):
+        return all(recur(e) for e in self.original_strategies)
+
+    @property
+    def element_strategies(self):
+        if self.__element_strategies is None:
+            # While strategies are hashable, they use object.__hash__ and are
+            # therefore distinguished only by identity.
+            #
+            # In principle we could "just" define a __hash__ method
+            # (and __eq__, but that's easy in terms of type() and hash())
+            # to make this more powerful, but this is harder than it sounds:
+            #
+            # 1. Strategies are often distinguished by non-hashable attributes,
+            #    or by attributes that have the same hash value ("^.+" / b"^.+").
+            # 2. LazyStrategy: can't reify the wrapped strategy without breaking
+            #    laziness, so there's a hash each for the lazy and the nonlazy.
+            #
+            # Having made several attempts, the minor benefits of making strategies
+            # hashable are simply not worth the engineering effort it would take.
+            # See also issues #2291 and #2327.
+            seen = {self}
+            strategies = 
+            for arg in self.original_strategies:
+                check_strategy(arg)
+                if not arg.is_empty:
+                    for s in arg.branches:
+                        if s not in seen and not s.is_empty:
+                            seen.add(s)
+                            strategies.append(s)
+            self.__element_strategies = strategies
+        return self.__element_strategies
+
+    def calc_label(self):
+        return combine_labels(
+            self.class_label, *(p.label for p in self.original_strategies)
+        )
+
+    def do_draw(self, data: ConjectureData) -> Ex:
+        strategy = data.draw(
+            SampledFromStrategy(self.element_strategies).filter(
+                lambda s: s.available(data)
+            )
+        )
+        return data.draw(strategy)
+
+    def __repr__(self):
+        return "one_of(%s)" % ", ".join(map(repr, self.original_strategies))
+
+    def do_validate(self):
+        for e in self.element_strategies:
+            e.validate()
+
+    @property
+    def branches(self):
+        if not self.__in_branches:
+            try:
+                self.__in_branches = True
+                return self.element_strategies
+            finally:
+                self.__in_branches = False
+        else:
+            return self
+
+    def filter(self, condition):
+        return FilteredStrategy(
+            OneOfStrategy(s.filter(condition) for s in self.original_strategies),
+            conditions=(),
+        )
+
+
+@overload
+def one_of(
+    __args: SequenceSearchStrategyAny,
+) -> SearchStrategyAny:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def one_of(__a1: SearchStrategyEx) -> SearchStrategyEx:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def one_of(
+    __a1: SearchStrategyEx, __a2: SearchStrategyT
+) -> SearchStrategyUnionEx, T:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def one_of(
+    __a1: SearchStrategyEx, __a2: SearchStrategyT, __a3: SearchStrategyT3
+) -> SearchStrategyUnionEx, T, T3:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def one_of(
+    __a1: SearchStrategyEx,
+    __a2: SearchStrategyT,
+    __a3: SearchStrategyT3,
+    __a4: SearchStrategyT4,
+) -> SearchStrategyUnionEx, T, T3, T4:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def one_of(
+    __a1: SearchStrategyEx,
+    __a2: SearchStrategyT,
+    __a3: SearchStrategyT3,
+    __a4: SearchStrategyT4,
+    __a5: SearchStrategyT5,
+) -> SearchStrategyUnionEx, T, T3, T4, T5:  # pragma: no cover
+    ...
+
+
+@overload  # noqa: F811
+def one_of(*args: SearchStrategyAny) -> SearchStrategyAny:  # pragma: no cover
+    ...
+
+
+@defines_strategy(never_lazy=True)
+def one_of(
+    *args: UnionSequenceSearchStrategyAny, SearchStrategyAny
+) -> SearchStrategyAny:  # noqa: F811
+    # Mypy workaround alert:  Any is too loose above; the return parameter
+    # should be the union of the input parameters.  Unfortunately, Mypy <=0.600
+    # raises errors due to incompatible inputs instead.  See #1270 for links.
+    # v0.610 doesn't error; it gets inference wrong for 2+ arguments instead.
+    """Return a strategy which generates values from any of the argument
+    strategies.
+
+    This may be called with one iterable argument instead of multiple
+    strategy arguments, in which case ``one_of(x)`` and ``one_of(*x)`` are
+    equivalent.
+
+    Examples from this strategy will generally shrink to ones that come from
+    strategies earlier in the list, then shrink according to behaviour of the
+    strategy that produced them. In order to get good shrinking behaviour,
+    try to put simpler strategies first. e.g. ``one_of(none(), text())`` is
+    better than ``one_of(text(), none())``.
+
+    This is especially important when using recursive strategies. e.g.
+    ``x = st.deferred(lambda: st.none() | st.tuples(x, x))`` will shrink well,
+    but ``x = st.deferred(lambda: st.tuples(x, x) | st.none())`` will shrink
+    very badly indeed.
+    """
+    if len(args) == 1 and not isinstance(args0, SearchStrategy):
+        try:
+            args = tuple(args0)
+        except TypeError:
+            pass
+    if len(args) == 1 and isinstance(args0, SearchStrategy):
+        # This special-case means that we can one_of over lists of any size
+        # without incurring any performance overhead when there is only one
+        # strategy, and keeps our reprs simple.
+        return args0
+    if args and not any(isinstance(a, SearchStrategy) for a in args):
+        # And this special case is to give a more-specific error message if it
+        # seems that the user has confused `one_of()` for  `sampled_from()`;
+        # the remaining validation is left to OneOfStrategy.  See PR #2627.
+        raise InvalidArgument(
+            f"Did you mean st.sampled_from({list(args)!r})?  st.one_of() is used "
+            "to combine strategies, but all of the arguments were of other types."
+        )
+    return OneOfStrategy(args)
+
+
+class MappedSearchStrategy(SearchStrategyEx):
+    """A strategy which is defined purely by conversion to and from another
+    strategy.
+
+    Its parameter and distribution come from that other strategy.
+    """
+
+    def __init__(self, strategy, pack=None):
+        super().__init__()
+        self.mapped_strategy = strategy
+        if pack is not None:
+            self.pack = pack
+
+    def calc_is_empty(self, recur):
+        return recur(self.mapped_strategy)
+
+    def calc_is_cacheable(self, recur):
+        return recur(self.mapped_strategy)
+
+    def __repr__(self):
+        if not hasattr(self, "_cached_repr"):
+            self._cached_repr = "{!r}.map({})".format(
+                self.mapped_strategy,
+                get_pretty_function_description(self.pack),
+            )
+        return self._cached_repr
+
+    def do_validate(self):
+        self.mapped_strategy.validate()
+
+    def pack(self, x):
+        """Take a value produced by the underlying mapped_strategy and turn it
+        into a value suitable for outputting from this strategy."""
+        raise NotImplementedError(f"{self.__class__.__name__}.pack()")
+
+    def do_draw(self, data: ConjectureData) -> Any:
+        with warnings.catch_warnings():
+            if isinstance(self.pack, type) and issubclass(
+                self.pack, (abc.Mapping, abc.Set)
+            ):
+                warnings.simplefilter("ignore", BytesWarning)
+            for _ in range(3):
+                try:
+                    data.start_example(MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL)
+                    x = data.draw(self.mapped_strategy)
+                    result = self.pack(x)  # type: ignore
+                    data.stop_example()
+                    _current_build_context.value.record_call(result, self.pack, x, {})
+                    return result
+                except UnsatisfiedAssumption:
+                    data.stop_example(discard=True)
+        raise UnsatisfiedAssumption()
+
+    @property
+    def branches(self) -> ListSearchStrategyEx:
+        return 
+            MappedSearchStrategy(pack=self.pack, strategy=strategy)
+            for strategy in self.mapped_strategy.branches
+        
+
+
+filter_not_satisfied = UniqueIdentifier("filter not satisfied")
+
+
+class FilteredStrategy(SearchStrategyEx):
+    def __init__(self, strategy, conditions):
+        super().__init__()
+        if isinstance(strategy, FilteredStrategy):
+            # Flatten chained filters into a single filter with multiple conditions.
+            self.flat_conditions = strategy.flat_conditions + conditions
+            self.filtered_strategy = strategy.filtered_strategy
+        else:
+            self.flat_conditions = conditions
+            self.filtered_strategy = strategy
+
+        assert isinstance(self.flat_conditions, tuple)
+        assert not isinstance(self.filtered_strategy, FilteredStrategy)
+
+        self.__condition = None
+
+    def calc_is_empty(self, recur):
+        return recur(self.filtered_strategy)
+
+    def calc_is_cacheable(self, recur):
+        return recur(self.filtered_strategy)
+
+    def __repr__(self):
+        if not hasattr(self, "_cached_repr"):
+            self._cached_repr = "{!r}{}".format(
+                self.filtered_strategy,
+                "".join(
+                    f".filter({get_pretty_function_description(cond)})"
+                    for cond in self.flat_conditions
+                ),
+            )
+        return self._cached_repr
+
+    def do_validate(self):
+        # Start by validating our inner filtered_strategy.  If this was a LazyStrategy,
+        # validation also reifies it so that subsequent calls to e.g. `.filter()` will
+        # be passed through.
+        self.filtered_strategy.validate()
+        # So now we have a reified inner strategy, we'll replay all our saved
+        # predicates in case some or all of them can be rewritten.  Note that this
+        # replaces the `fresh` strategy too!
+        fresh = self.filtered_strategy
+        for cond in self.flat_conditions:
+            fresh = fresh.filter(cond)
+        if isinstance(fresh, FilteredStrategy):
+            # In this case we have at least some non-rewritten filter predicates,
+            # so we just re-initialize the strategy.
+            FilteredStrategy.__init__(
+                self, fresh.filtered_strategy, fresh.flat_conditions
+            )
+        else:
+            # But if *all* the predicates were rewritten... well, do_validate() is
+            # an in-place method so we still just re-initialize the strategy!
+            FilteredStrategy.__init__(self, fresh, ())
+
+    def filter(self, condition):
+        # If we can, it's more efficient to rewrite our strategy to satisfy the
+        # condition.  We therefore exploit the fact that the order of predicates
+        # doesn't matter (`f(x) and g(x) == g(x) and f(x)`) by attempting to apply
+        # condition directly to our filtered strategy as the inner-most filter.
+        out = self.filtered_strategy.filter(condition)
+        # If it couldn't be rewritten, we'll get a new FilteredStrategy - and then
+        # combine the conditions of each in our expected newest=last order.
+        if isinstance(out, FilteredStrategy):
+            return FilteredStrategy(
+                out.filtered_strategy, self.flat_conditions + out.flat_conditions
+            )
+        # But if it *could* be rewritten, we can return the more efficient form!
+        return FilteredStrategy(out, self.flat_conditions)
+
+    @property
+    def condition(self):
+        if self.__condition is None:
+            if len(self.flat_conditions) == 1:
+                # Avoid an extra indirection in the common case of only one condition.
+                self.__condition = self.flat_conditions0
+            elif len(self.flat_conditions) == 0:
+                # Possible, if unlikely, due to filter predicate rewriting
+                self.__condition = lambda _: True
+            else:
+                self.__condition = lambda x: all(
+                    cond(x) for cond in self.flat_conditions
+                )
+        return self.__condition
+
+    def do_draw(self, data: ConjectureData) -> Ex:
+        result = self.do_filtered_draw(data)
+        if result is not filter_not_satisfied:
+            return result
+
+        data.mark_invalid(f"Aborted test because unable to satisfy {self!r}")
+        raise NotImplementedError("Unreachable, for Mypy")
+
+    def note_retried(self, data):
+        data.note_event(lazyformat("Retried draw from %r to satisfy filter", self))
+
+    def do_filtered_draw(self, data):
+        for i in range(3):
+            start_index = data.index
+            data.start_example(FILTERED_SEARCH_STRATEGY_DO_DRAW_LABEL)
+            value = data.draw(self.filtered_strategy)
+            if self.condition(value):
+                data.stop_example()
+                return value
+            else:
+                data.stop_example(discard=True)
+                if i == 0:
+                    self.note_retried(data)
+                # This is to guard against the case where we consume no data.
+                # As long as we consume data, we'll eventually pass or raise.
+                # But if we don't this could be an infinite loop.
+                assume(data.index > start_index)
+
+        return filter_not_satisfied
+
+    @property
+    def branches(self) -> ListSearchStrategyEx:
+        return 
+            FilteredStrategy(strategy=strategy, conditions=self.flat_conditions)
+            for strategy in self.filtered_strategy.branches
+        
+
+
+@check_function
+def check_strategy(arg, name=""):
+    assert isinstance(name, str)
+    if not isinstance(arg, SearchStrategy):
+        hint = ""
+        if isinstance(arg, (list, tuple)):
+            hint = ", such as st.sampled_from({}),".format(name or "...")
+        if name:
+            name += "="
+        raise InvalidArgument(
+            "Expected a SearchStrategy%s but got %s%r (type=%s)"
+            % (hint, name, arg, type(arg).__name__)
+        )

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/strings.py Added

@@ -0,0 +1,179 @@
+# 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 copy
+import warnings
+
+from hypothesis.errors import HypothesisWarning, InvalidArgument
+from hypothesis.internal import charmap
+from hypothesis.internal.conjecture.utils import biased_coin, integer_range
+from hypothesis.internal.intervalsets import IntervalSet
+from hypothesis.strategies._internal.collections import ListStrategy
+from hypothesis.strategies._internal.strategies import SearchStrategy
+
+
+class OneCharStringStrategy(SearchStrategy):
+    """A strategy which generates single character strings of text type."""
+
+    def __init__(
+        self,
+        whitelist_categories=None,
+        blacklist_categories=None,
+        blacklist_characters=None,
+        min_codepoint=None,
+        max_codepoint=None,
+        whitelist_characters=None,
+    ):
+        assert set(whitelist_categories or ()).issubset(charmap.categories())
+        assert set(blacklist_categories or ()).issubset(charmap.categories())
+        intervals = charmap.query(
+            include_categories=whitelist_categories,
+            exclude_categories=blacklist_categories,
+            min_codepoint=min_codepoint,
+            max_codepoint=max_codepoint,
+            include_characters=whitelist_characters,
+            exclude_characters=blacklist_characters,
+        )
+        self._arg_repr = ", ".join(
+            f"{k}={v!r}"
+            for k, v in 
+                ("whitelist_categories", whitelist_categories),
+                ("blacklist_categories", blacklist_categories),
+                ("whitelist_characters", whitelist_characters),
+                ("blacklist_characters", blacklist_characters),
+                ("min_codepoint", min_codepoint),
+                ("max_codepoint", max_codepoint),
+            
+            if not (v in (None, "") or (k == "blacklist_categories" and v == ("Cs",)))
+        )
+        if not intervals:
+            raise InvalidArgument(
+                "No characters are allowed to be generated by this "
+                f"combination of arguments: {self._arg_repr}"
+            )
+        self.intervals = IntervalSet(intervals)
+        self.zero_point = self.intervals.index_above(ord("0"))
+        self.Z_point = min(
+            self.intervals.index_above(ord("Z")), len(self.intervals) - 1
+        )
+
+    def __repr__(self):
+        return f"characters({self._arg_repr})"
+
+    def do_draw(self, data):
+        if len(self.intervals) > 256:
+            if biased_coin(data, 0.2):
+                i = integer_range(data, 256, len(self.intervals) - 1)
+            else:
+                i = integer_range(data, 0, 255)
+        else:
+            i = integer_range(data, 0, len(self.intervals) - 1)
+
+        i = self.rewrite_integer(i)
+
+        return chr(self.intervalsi)
+
+    def rewrite_integer(self, i):
+        # We would like it so that, where possible, shrinking replaces
+        # characters with simple ascii characters, so we rejig this
+        # bit so that the smallest values are 0, 1, 2, ..., Z.
+        #
+        # Imagine that numbers are laid out as abc0yyyZ...
+        # this rearranges them so that they are laid out as
+        # 0yyyZcba..., which gives a better shrinking order.
+        if i <= self.Z_point:
+            # We want to rewrite the integers 0, n inclusive
+            # to zero_point, Z_point.
+            n = self.Z_point - self.zero_point
+            if i <= n:
+                i += self.zero_point
+            else:
+                # We want to rewrite the integers n + 1, Z_point to
+                # zero_point, 0 (reversing the order so that codepoints below
+                # zero_point shrink upwards).
+                i = self.zero_point - (i - n)
+                assert i < self.zero_point
+            assert 0 <= i <= self.Z_point
+        return i
+
+
+class TextStrategy(ListStrategy):
+    def do_draw(self, data):
+        return "".join(super().do_draw(data))
+
+    def __repr__(self):
+        args = 
+        if repr(self.element_strategy) != "characters()":
+            args.append(repr(self.element_strategy))
+        if self.min_size:
+            args.append(f"min_size={self.min_size}")
+        if self.max_size < float("inf"):
+            args.append(f"max_size={self.max_size}")
+        return f"text({', '.join(args)})"
+
+    # See https://docs.python.org/3/library/stdtypes.html#string-methods
+    # These methods always return Truthy values for any nonempty string.
+    _nonempty_filters = ListStrategy._nonempty_filters + (
+        str,
+        str.capitalize,
+        str.casefold,
+        str.encode,
+        str.expandtabs,
+        str.join,
+        str.lower,
+        str.rsplit,
+        str.split,
+        str.splitlines,
+        str.swapcase,
+        str.title,
+        str.upper,
+    )
+    _nonempty_and_content_filters = (
+        str.isidentifier,
+        str.islower,
+        str.isupper,
+        str.isalnum,
+        str.isalpha,
+        str.isascii,
+        str.isdecimal,
+        str.isdigit,
+        str.isnumeric,
+        str.isspace,
+        str.istitle,
+        str.lstrip,
+        str.rstrip,
+        str.strip,
+    )
+
+    def filter(self, condition):
+        if condition in (str.lower, str.title, str.upper):
+            warnings.warn(
+                f"You applied str.{condition.__name__} as a filter, but this allows "
+                f"all nonempty strings!  Did you mean str.is{condition.__name__}?",
+                HypothesisWarning,
+            )
+        # We use ListStrategy filter logic for the conditions that *only* imply
+        # the string is nonempty.  Here, we increment the min_size but still apply
+        # the filter for conditions that imply nonempty *and specific contents*.
+        if condition in self._nonempty_and_content_filters:
+            assert self.max_size >= 1, "Always-empty is special cased in st.text()"
+            self = copy.copy(self)
+            self.min_size = max(1, self.min_size)
+            return ListStrategy.filter(self, condition)
+
+        return super().filter(condition)
+
+
+class FixedSizeBytes(SearchStrategy):
+    def __init__(self, size):
+        self.size = size
+
+    def do_draw(self, data):
+        return bytes(data.draw_bytes(self.size))

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/types.py Added

@@ -0,0 +1,968 @@
+# 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 builtins
+import collections
+import collections.abc
+import datetime
+import decimal
+import fractions
+import functools
+import inspect
+import io
+import ipaddress
+import numbers
+import os
+import re
+import sys
+import typing
+import uuid
+from pathlib import PurePath
+from types import FunctionType
+
+from hypothesis import strategies as st
+from hypothesis.errors import InvalidArgument, ResolutionFailed
+from hypothesis.internal.compat import (
+    PYPY,
+    BaseExceptionGroup,
+    ExceptionGroup,
+    get_origin,
+)
+from hypothesis.internal.conjecture.utils import many as conjecture_utils_many
+from hypothesis.strategies._internal.datetime import zoneinfo  # type: ignore
+from hypothesis.strategies._internal.ipaddress import (
+    SPECIAL_IPv4_RANGES,
+    SPECIAL_IPv6_RANGES,
+    ip_addresses,
+)
+from hypothesis.strategies._internal.lazy import unwrap_strategies
+from hypothesis.strategies._internal.strategies import OneOfStrategy
+
+GenericAlias: typing.Any
+UnionType: typing.Any
+try:
+    # The type of PEP-604 unions (`int | str`), added in Python 3.10
+    from types import GenericAlias, UnionType
+except ImportError:
+    GenericAlias = ()
+    UnionType = ()
+
+try:
+    import typing_extensions
+except ImportError:
+    typing_extensions = None  # type: ignore
+
+try:
+    from typing import _AnnotatedAlias  # type: ignore
+except ImportError:
+    try:
+        from typing_extensions import _AnnotatedAlias
+    except ImportError:
+        _AnnotatedAlias = ()
+
+TypeAliasTypes: tuple = ()
+try:
+    TypeAliasTypes += (typing.TypeAlias,)
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.10`
+try:
+    TypeAliasTypes += (typing_extensions.TypeAlias,)
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `typing_extensions<3.10`
+
+ClassVarTypes: tuple = (typing.ClassVar,)
+try:
+    ClassVarTypes += (typing_extensions.ClassVar,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+FinalTypes: tuple = ()
+try:
+    FinalTypes += (typing.Final,)
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.8`
+try:
+    FinalTypes += (typing_extensions.Final,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+ConcatenateTypes: tuple = ()
+try:
+    ConcatenateTypes += (typing.Concatenate,)
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.8`
+try:
+    ConcatenateTypes += (typing_extensions.Concatenate,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+ParamSpecTypes: tuple = ()
+try:
+    ParamSpecTypes += (typing.ParamSpec,)
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.8`
+try:
+    ParamSpecTypes += (typing_extensions.ParamSpec,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+TypeGuardTypes: tuple = ()
+try:
+    TypeGuardTypes += (typing.TypeGuard,)
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.8`
+try:
+    TypeGuardTypes += (typing_extensions.TypeGuard,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+
+RequiredTypes: tuple = ()
+try:
+    RequiredTypes += (typing.Required,)  # type: ignore
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.11`
+try:
+    RequiredTypes += (typing_extensions.Required,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+
+NotRequiredTypes: tuple = ()
+try:
+    NotRequiredTypes += (typing.NotRequired,)  # type: ignore
+except AttributeError:  # pragma: no cover
+    pass  # Is missing for `python<3.11`
+try:
+    NotRequiredTypes += (typing_extensions.NotRequired,)
+except AttributeError:  # pragma: no cover
+    pass  # `typing_extensions` might not be installed
+
+
+# We use this variable to be sure that we are working with a type from `typing`:
+typing_root_type = (typing._Final, typing._GenericAlias)  # type: ignore
+
+# We use this to disallow all non-runtime types from being registered and resolved.
+# By "non-runtime" we mean: types that do not really exist in python's
+# and are just added for more fancy type annotations.
+# `Final` is a great example: it just indicates
+# that this value can't be reassigned.
+NON_RUNTIME_TYPES = (
+    typing.Any,
+    *ClassVarTypes,
+    *TypeAliasTypes,
+    *FinalTypes,
+    *ConcatenateTypes,
+    *ParamSpecTypes,
+    *TypeGuardTypes,
+)
+for name in (
+    "Annotated",
+    "NoReturn",
+    "Self",
+    "Required",
+    "NotRequired",
+    "Never",
+    "TypeVarTuple",
+    "Unpack",
+    "LiteralString",
+):
+    try:
+        NON_RUNTIME_TYPES += (getattr(typing, name),)
+    except AttributeError:
+        pass
+    try:
+        NON_RUNTIME_TYPES += (getattr(typing_extensions, name),)
+    except AttributeError:  # pragma: no cover
+        pass  # typing_extensions might not be installed
+
+
+def type_sorting_key(t):
+    """Minimise to None, then non-container types, then container types."""
+    if not (is_a_type(t) or is_typing_literal(t)):  # This branch is for Python < 3.8
+        raise InvalidArgument(f"thing={t} must be a type")  # pragma: no cover
+    if t is None or t is type(None):  # noqa: E721
+        return (-1, repr(t))
+    t = getattr(t, "__origin__", t)
+    if not isinstance(t, type):  # pragma: no cover
+        # Some generics in the typing module are not actually types in 3.7
+        return (2, repr(t))
+    return (int(issubclass(t, collections.abc.Container)), repr(t))
+
+
+def _compatible_args(args, superclass_args):
+    """Check that the args of two generic types are compatible for try_issubclass."""
+    assert superclass_args is not None
+    if args is None:
+        return True
+    return len(args) == len(superclass_args) and all(
+        # "a==b or either is a typevar" is a hacky approximation, but it's
+        # good enough for all the cases that I've seen so far and has the
+        # substantial virtue of (relative) simplicity.
+        a == b or isinstance(a, typing.TypeVar) or isinstance(b, typing.TypeVar)
+        for a, b in zip(args, superclass_args)
+    )
+
+
+def try_issubclass(thing, superclass):
+    try:
+        # In this case we're looking at two distinct classes - which might be generics.
+        # That brings in some complications:
+        if issubclass(
+            getattr(thing, "__origin__", None) or thing,
+            getattr(superclass, "__origin__", None) or superclass,
+        ):
+            superclass_args = getattr(superclass, "__args__", None)
+            if not superclass_args:
+                # The superclass is not generic, so we're definitely a subclass.
+                return True
+            # Sadly this is just some really fiddly logic to handle all the cases
+            # of user-defined generic types, types inheriting from parametrised
+            # generics, and so on.  If you need to change this code, read PEP-560
+            # and Hypothesis issue #2951 closely first, and good luck.  The tests
+            # will help you, I hope - good luck.
+            if getattr(thing, "__args__", None) is not None:
+                return True  # pragma: no cover  # only possible on Python <= 3.9
+            for orig_base in getattr(thing, "__orig_bases__", None) or None:
+                args = getattr(orig_base, "__args__", None)
+                if _compatible_args(args, superclass_args):
+                    return True
+        return False
+    except (AttributeError, TypeError):
+        # Some types can't be the subject or object of an instance or subclass check
+        return False
+
+
+def is_a_new_type(thing):
+    if not isinstance(typing.NewType, type):
+        # At runtime, `typing.NewType` returns an identity function rather
+        # than an actual type, but we can check whether that thing matches.
+        return (  # pragma: no cover  # Python <= 3.9 only
+            hasattr(thing, "__supertype__")
+            and getattr(thing, "__module__", None) in ("typing", "typing_extensions")
+            and inspect.isfunction(thing)
+        )
+    # In 3.10 and later, NewType is actually a class - which simplifies things.
+    # See https://bugs.python.org/issue44353 for links to the various patches.
+    return isinstance(thing, typing.NewType)
+
+
+def is_a_union(thing):
+    """Return True if thing is a typing.Union or types.UnionType (in py310)."""
+    return (
+        isinstance(thing, UnionType)
+        or getattr(thing, "__origin__", None) is typing.Union
+    )
+
+
+def is_a_type(thing):
+    """Return True if thing is a type or a generic type like thing."""
+    return isinstance(thing, type) or is_generic_type(thing) or is_a_new_type(thing)
+
+
+def is_typing_literal(thing):
+    return (
+        hasattr(typing, "Literal")
+        and getattr(thing, "__origin__", None) == typing.Literal
+        or hasattr(typing_extensions, "Literal")
+        and getattr(thing, "__origin__", None) == typing_extensions.Literal
+    )
+
+
+def is_annotated_type(thing):
+    return (
+        isinstance(thing, _AnnotatedAlias)
+        and getattr(thing, "__args__", None) is not None
+    )
+
+
+def find_annotated_strategy(annotated_type):  # pragma: no cover
+    flattened_meta = 
+
+    all_args = (
+        *getattr(annotated_type, "__args__", ()),
+        *getattr(annotated_type, "__metadata__", ()),
+    )
+    for arg in all_args:
+        if is_annotated_type(arg):
+            flattened_meta.append(find_annotated_strategy(arg))
+        if isinstance(arg, st.SearchStrategy):
+            flattened_meta.append(arg)
+    return flattened_meta-1 if flattened_meta else None
+
+
+def has_type_arguments(type_):
+    """Decides whethere or not this type has applied type arguments."""
+    args = getattr(type_, "__args__", None)
+    if args and isinstance(type_, (typing._GenericAlias, GenericAlias)):
+        # There are some cases when declared types do already have type arguments
+        # Like `Sequence`, that is `_GenericAlias(abc.SequenceT)T`
+        parameters = getattr(type_, "__parameters__", None)
+        if parameters:  # So, we need to know if type args are just "aliases"
+            return args != parameters
+    return bool(args)
+
+
+def is_generic_type(type_):
+    """Decides whether a given type is generic or not."""
+    # The ugly truth is that `MyClass`, `MyClassT`, and `MyClassint` are very different.
+    # We check for `MyClassT` and `MyClassint` with the first condition,
+    # while the second condition is for `MyClass`.
+    return isinstance(type_, typing_root_type + (GenericAlias,)) or (
+        isinstance(type_, type)
+        and (typing.Generic in type_.__mro__ or hasattr(type_, "__class_getitem__"))
+    )
+
+
+def _try_import_forward_ref(thing, bound):  # pragma: no cover
+    """
+    Tries to import a real bound type from ``TypeVar`` bound to a ``ForwardRef``.
+
+    This function is very "magical" to say the least, please don't use it.
+    This function fully covered, but is excluded from coverage
+    because we can only cover each path in a separate python version.
+    """
+    try:
+        return typing._eval_type(bound, vars(sys.modulesthing.__module__), None)
+    except (KeyError, AttributeError, NameError):
+        # We fallback to `ForwardRef` instance, you can register it as a type as well:
+        # >>> from typing import ForwardRef
+        # >>> from hypothesis import strategies as st
+        # >>> st.register_type_strategy(ForwardRef('YourType'), your_strategy)
+        return bound
+
+
+def from_typing_type(thing):
+    # We start with special-case support for Tuple, which isn't actually a generic
+    # type; then Final, Literal, and Annotated since they don't support `isinstance`.
+    #
+    # We then explicitly error on non-Generic types, which don't carry enough
+    # information to sensibly resolve to strategies at runtime.
+    # Finally, we run a variation of the subclass lookup in `st.from_type`
+    # among generic types in the lookup.
+    if getattr(thing, "__origin__", None) == tuple or isinstance(
+        thing, getattr(typing, "TupleMeta", ())
+    ):
+        elem_types = getattr(thing, "__tuple_params__", None) or ()
+        elem_types += getattr(thing, "__args__", None) or ()
+        if (
+            getattr(thing, "__tuple_use_ellipsis__", False)
+            or len(elem_types) == 2
+            and elem_types-1 is Ellipsis
+        ):
+            return st.lists(st.from_type(elem_types0)).map(tuple)
+        elif len(elem_types) == 1 and elem_types0 == ():
+            return st.tuples()  # Empty tuple; see issue #1583
+        return st.tuples(*map(st.from_type, elem_types))
+    if hasattr(typing, "Final") and getattr(thing, "__origin__", None) == typing.Final:
+        return st.one_of(st.from_type(t) for t in thing.__args__)
+    if is_typing_literal(thing):
+        args_dfs_stack = list(thing.__args__)
+        literals = 
+        while args_dfs_stack:
+            arg = args_dfs_stack.pop()
+            if is_typing_literal(arg):  # pragma: no cover
+                # Python 3.10+ flattens for us when constructing Literal objects
+                args_dfs_stack.extend(reversed(arg.__args__))
+            else:
+                literals.append(arg)
+        return st.sampled_from(literals)
+    if is_annotated_type(thing):  # pragma: no cover
+        # This requires Python 3.9+ or the typing_extensions package
+        annotated_strategy = find_annotated_strategy(thing)
+        if annotated_strategy is not None:
+            return annotated_strategy
+        args = thing.__args__
+        assert args, "it's impossible to make an annotated type with no args"
+        annotated_type = args0
+        return st.from_type(annotated_type)
+    # Now, confirm that we're dealing with a generic type as we expected
+    if sys.version_info:2 < (3, 9) and not isinstance(
+        thing, typing_root_type
+    ):  # pragma: no cover
+        raise ResolutionFailed(f"Cannot resolve {thing} to a strategy")
+
+    # Some "generic" classes are not generic *in* anything - for example both
+    # Hashable and Sized have `__args__ == ()` on Python 3.7 or later.
+    origin = getattr(thing, "__origin__", thing)
+    if (
+        origin in vars(collections.abc).values()
+        and len(getattr(thing, "__args__", None) or ) == 0
+    ):
+        return st.from_type(origin)
+
+    # Parametrised generic types have their __origin__ attribute set to the
+    # un-parametrised version, which we need to use in the subclass checks.
+    # e.g.:     typing.Listint.__origin__ == typing.List
+    mapping = {
+        k: v
+        for k, v in _global_type_lookup.items()
+        if is_generic_type(k) and try_issubclass(k, thing)
+    }
+    # Drop some unusual cases for simplicity
+    for weird in (tuple, getattr(os, "_Environ", None)):
+        if len(mapping) > 1:
+            mapping.pop(weird, None)
+    # After we drop Python 3.8 and can rely on having generic builtin types, we'll
+    # be able to simplify this logic by dropping the typing-module handling.
+    if {dict, set, typing.Dict, typing.Set}.intersection(mapping):
+        # ItemsView can cause test_lookup.py::test_specialised_collection_types
+        # to fail, due to weird isinstance behaviour around the elements.
+        mapping.pop(collections.abc.ItemsView, None)
+        mapping.pop(typing.ItemsView, None)
+    if {collections.deque, typing.Deque}.intersection(mapping) and len(mapping) > 1:
+        # Resolving generic sequences to include a deque is more trouble for e.g.
+        # the ghostwriter than it's worth, via undefined names in the repr.
+        mapping.pop(collections.deque, None)
+        mapping.pop(typing.Deque, None)
+    if len(mapping) > 1:
+        # issubclass treats bytestring as a kind of sequence, which it is,
+        # but treating it as such breaks everything else when it is presumed
+        # to be a generic sequence or container that could hold any item.
+        # Except for sequences of integers, or unions which include integer!
+        # See https://github.com/HypothesisWorks/hypothesis/issues/2257
+        #
+        # This block drops ByteString from the types that can be generated
+        # if there is more than one allowed type, and the element type is
+        # not either `int` or a Union with `int` as one of its elements.
+        elem_type = (getattr(thing, "__args__", None) or "not int")0
+        if is_a_union(elem_type):
+            union_elems = elem_type.__args__
+        else:
+            union_elems = ()
+        if not any(
+            isinstance(T, type) and issubclass(int, get_origin(T) or T)
+            for T in list(union_elems) + elem_type
+        ):
+            mapping.pop(bytes, None)
+            mapping.pop(collections.abc.ByteString, None)
+            mapping.pop(typing.ByteString, None)
+    elif (
+        (not mapping)
+        and isinstance(thing, typing.ForwardRef)
+        and thing.__forward_arg__ in vars(builtins)
+    ):
+        return st.from_type(getattr(builtins, thing.__forward_arg__))
+    # Before Python 3.9, we sometimes have e.g. ByteString from both the typing
+    # module, and collections.abc module.  Discard any type which is not it's own
+    # origin, where the origin is also in the mapping.
+    for t in sorted(mapping, key=type_sorting_key):
+        origin = get_origin(t)
+        if origin is not t and origin in mapping:
+            mapping.pop(t)
+    # Sort strategies according to our type-sorting heuristic for stable output
+    strategies = 
+        v if isinstance(v, st.SearchStrategy) else v(thing)
+        for k, v in sorted(mapping.items(), key=lambda kv: type_sorting_key(kv0))
+        if sum(try_issubclass(k, T) for T in mapping) == 1
+    
+    empty = ", ".join(repr(s) for s in strategies if s.is_empty)
+    if empty or not strategies:
+        raise ResolutionFailed(
+            f"Could not resolve {empty or thing} to a strategy; "
+            "consider using register_type_strategy"
+        )
+    return st.one_of(strategies)
+
+
+def can_cast(type, value):
+    """Determine if value can be cast to type."""
+    try:
+        type(value)
+        return True
+    except Exception:
+        return False
+
+
+def _networks(bits):
+    return st.tuples(st.integers(0, 2**bits - 1), st.integers(-bits, 0).map(abs))
+
+
+utc_offsets = st.builds(
+    datetime.timedelta, minutes=st.integers(0, 59), hours=st.integers(-23, 23)
+)
+
+# These builtin and standard-library types have Hypothesis strategies,
+# seem likely to appear in type annotations, or are otherwise notable.
+#
+# The strategies below must cover all possible values from the type, because
+# many users treat them as comprehensive and one of Hypothesis' design goals
+# is to avoid testing less than expected.
+#
+# As a general rule, we try to limit this to scalars because from_type()
+# would have to decide on arbitrary collection elements, and we'd rather
+# not (with typing module generic types and some builtins as exceptions).
+_global_type_lookup: typing.Dict
+    type, typing.Unionst.SearchStrategy, typing.Callabletype, st.SearchStrategy
+ = {
+    type(None): st.none(),
+    bool: st.booleans(),
+    int: st.integers(),
+    float: st.floats(),
+    complex: st.complex_numbers(),
+    fractions.Fraction: st.fractions(),
+    decimal.Decimal: st.decimals(),
+    str: st.text(),
+    bytes: st.binary(),
+    datetime.datetime: st.datetimes(),
+    datetime.date: st.dates(),
+    datetime.time: st.times(),
+    datetime.timedelta: st.timedeltas(),
+    datetime.timezone: st.builds(datetime.timezone, offset=utc_offsets)
+    | st.builds(datetime.timezone, offset=utc_offsets, name=st.text(st.characters())),
+    uuid.UUID: st.uuids(),
+    tuple: st.builds(tuple),
+    list: st.builds(list),
+    set: st.builds(set),
+    collections.abc.MutableSet: st.builds(set),
+    frozenset: st.builds(frozenset),
+    dict: st.builds(dict),
+    FunctionType: st.functions(),
+    type(Ellipsis): st.just(Ellipsis),
+    type(NotImplemented): st.just(NotImplemented),
+    bytearray: st.binary().map(bytearray),
+    memoryview: st.binary().map(memoryview),
+    numbers.Real: st.floats(),
+    numbers.Rational: st.fractions(),
+    numbers.Number: st.complex_numbers(),
+    numbers.Integral: st.integers(),
+    numbers.Complex: st.complex_numbers(),
+    slice: st.builds(
+        slice,
+        st.none() | st.integers(),
+        st.none() | st.integers(),
+        st.none() | st.integers(),
+    ),
+    range: st.one_of(
+        st.builds(range, st.integers(min_value=0)),
+        st.builds(range, st.integers(), st.integers()),
+        st.builds(range, st.integers(), st.integers(), st.integers().filter(bool)),
+    ),
+    ipaddress.IPv4Address: ip_addresses(v=4),
+    ipaddress.IPv6Address: ip_addresses(v=6),
+    ipaddress.IPv4Interface: _networks(32).map(ipaddress.IPv4Interface),
+    ipaddress.IPv6Interface: _networks(128).map(ipaddress.IPv6Interface),
+    ipaddress.IPv4Network: st.one_of(
+        _networks(32).map(lambda x: ipaddress.IPv4Network(x, strict=False)),
+        st.sampled_from(SPECIAL_IPv4_RANGES).map(ipaddress.IPv4Network),
+    ),
+    ipaddress.IPv6Network: st.one_of(
+        _networks(128).map(lambda x: ipaddress.IPv6Network(x, strict=False)),
+        st.sampled_from(SPECIAL_IPv6_RANGES).map(ipaddress.IPv6Network),
+    ),
+    os.PathLike: st.builds(PurePath, st.text()),
+    UnicodeDecodeError: st.builds(
+        UnicodeDecodeError,
+        st.just("unknown encoding"),
+        st.just(b""),
+        st.just(0),
+        st.just(0),
+        st.just("reason"),
+    ),
+    UnicodeEncodeError: st.builds(
+        UnicodeEncodeError,
+        st.just("unknown encoding"),
+        st.text(),
+        st.just(0),
+        st.just(0),
+        st.just("reason"),
+    ),
+    UnicodeTranslateError: st.builds(
+        UnicodeTranslateError, st.text(), st.just(0), st.just(0), st.just("reason")
+    ),
+    BaseExceptionGroup: st.builds(
+        BaseExceptionGroup,
+        st.text(),
+        st.lists(st.from_type(BaseException), min_size=1),
+    ),
+    ExceptionGroup: st.builds(
+        ExceptionGroup,
+        st.text(),
+        st.lists(st.from_type(Exception), min_size=1),
+    ),
+    enumerate: st.builds(enumerate, st.just(())),
+    filter: st.builds(filter, st.just(lambda _: None), st.just(())),
+    map: st.builds(map, st.just(lambda _: None), st.just(())),
+    reversed: st.builds(reversed, st.just(())),
+    property: st.builds(property, st.just(lambda _: None)),
+    classmethod: st.builds(classmethod, st.just(lambda self: self)),
+    staticmethod: st.builds(staticmethod, st.just(lambda self: self)),
+    super: st.builds(super, st.from_type(type)),
+    re.Match: st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool),
+    re.Pattern: st.builds(re.compile, st.sampled_from("", b"")),
+    # Pull requests with more types welcome!
+}
+if zoneinfo is not None:  # pragma: no branch
+    _global_type_lookupzoneinfo.ZoneInfo = st.timezones()
+if PYPY:
+    _global_type_lookupbuiltins.sequenceiterator = st.builds(iter, st.tuples())  # type: ignore
+
+
+_global_type_lookuptype = st.sampled_from(
+    type(None) + sorted(_global_type_lookup, key=str)
+)
+if sys.version_info:2 >= (3, 9):
+    # subclass of MutableMapping, and in Python 3.9 we resolve to a union
+    # which includes this... but we don't actually ever want to build one.
+    _global_type_lookupos._Environ = st.just(os.environ)
+
+
+_global_type_lookup.update(
+    {
+        # Note: while ByteString notionally also represents the bytearray and
+        # memoryview types, it is a subclass of Hashable and those types are not.
+        # We therefore only generate the bytes type.
+        typing.ByteString: st.binary(),
+        collections.abc.ByteString: st.binary(),
+        # TODO: SupportsAbs and SupportsRound should be covariant, ie have functions.
+        typing.SupportsAbs: st.one_of(
+            st.booleans(),
+            st.integers(),
+            st.floats(),
+            st.complex_numbers(),
+            st.fractions(),
+            st.decimals(),
+            st.timedeltas(),
+        ),
+        typing.SupportsRound: st.one_of(
+            st.booleans(), st.integers(), st.floats(), st.decimals(), st.fractions()
+        ),
+        typing.SupportsComplex: st.one_of(
+            st.booleans(),
+            st.integers(),
+            st.floats(),
+            st.complex_numbers(),
+            st.decimals(),
+            st.fractions(),
+        ),
+        typing.SupportsFloat: st.one_of(
+            st.booleans(),
+            st.integers(),
+            st.floats(),
+            st.decimals(),
+            st.fractions(),
+            # with floats its far more annoying to capture all
+            # the magic in a regex. so we just stringify some floats
+            st.floats().map(str),
+        ),
+        typing.SupportsInt: st.one_of(
+            st.booleans(),
+            st.integers(),
+            st.floats(),
+            st.uuids(),
+            st.decimals(),
+            # this generates strings that should able to be parsed into integers
+            st.from_regex(r"\A-?\d+\Z").filter(functools.partial(can_cast, int)),
+        ),
+        typing.SupportsBytes: st.one_of(
+            st.booleans(),
+            st.binary(),
+            st.integers(0, 255),
+            # As with Reversible, we tuplize this for compatibility with Hashable.
+            st.lists(st.integers(0, 255)).map(tuple),  # type: ignore
+        ),
+        typing.BinaryIO: st.builds(io.BytesIO, st.binary()),
+        typing.TextIO: st.builds(io.StringIO, st.text()),
+    }
+)
+if hasattr(typing, "SupportsIndex"):  # pragma: no branch  # new in Python 3.8
+    _global_type_lookuptyping.SupportsIndex = st.integers() | st.booleans()
+
+
+# The "extra" lookups define a callable that either resolves to a strategy for
+# this narrowly extra-specific type, or returns None to proceed with normal
+# type resolution. The callable will only be called if the module is
+# installed. To avoid the performance hit of importing anything here, we defer
+# it until the method is called the first time, at which point we replace the
+# entry in the lookup table with the direct call.
+def _from_numpy_type(thing: typing.Type) -> typing.Optionalst.SearchStrategy:
+    from hypothesis.extra.numpy import _from_type
+
+    _global_extra_lookup"numpy" = _from_type
+    return _from_type(thing)
+
+
+_global_extra_lookup: typing.Dict
+    str, typing.Callabletyping.Type, typing.Optionalst.SearchStrategy
+ = {
+    "numpy": _from_numpy_type,
+}
+
+
+def register(type_, fallback=None, *, module=typing):
+    if isinstance(type_, str):
+        # Use the name of generic types which are not available on all
+        # versions, and the function just won't be added to the registry
+        type_ = getattr(module, type_, None)
+        if type_ is None:  # pragma: no cover
+            return lambda f: f
+
+    def inner(func):
+        nonlocal type_
+        if fallback is None:
+            _global_type_lookuptype_ = func
+            return func
+
+        @functools.wraps(func)
+        def really_inner(thing):
+            # This branch is for Python < 3.8, when __args__ was not always tracked
+            if getattr(thing, "__args__", None) is None:
+                return fallback  # pragma: no cover
+            return func(thing)
+
+        if sys.version_info:2 >= (3, 9):
+            try:
+                type_ = get_origin(type_)
+            except Exception:
+                pass
+        _global_type_lookuptype_ = really_inner
+        return really_inner
+
+    return inner
+
+
+@register(typing.Type)
+@register("Type", module=typing_extensions)
+def resolve_Type(thing):
+    if getattr(thing, "__args__", None) is None:
+        # This branch is for Python < 3.8, when __args__ was not always tracked
+        return st.just(type)  # pragma: no cover
+    args = (thing.__args__0,)
+    if is_a_union(args0):
+        args = args0.__args__
+    # Duplicate check from from_type here - only paying when needed.
+    args = list(args)
+    for i, a in enumerate(args):
+        if type(a) == typing.ForwardRef:
+            try:
+                argsi = getattr(builtins, a.__forward_arg__)
+            except AttributeError:
+                raise ResolutionFailed(
+                    f"Cannot find the type referenced by {thing} - try using "
+                    f"st.register_type_strategy({thing}, st.from_type(...))"
+                ) from None
+    return st.sampled_from(sorted(args, key=type_sorting_key))
+
+
+@register(typing.List, st.builds(list))
+def resolve_List(thing):
+    return st.lists(st.from_type(thing.__args__0))
+
+
+def _can_hash(val):
+    try:
+        hash(val)
+        return True
+    except Exception:
+        return False
+
+
+# Some types are subclasses of typing.Hashable, because they define a __hash__
+# method, but have non-hashable instances such as `Decimal("snan")` or may contain
+# such instances (e.g. `FrozenSetDecimal`).  We therefore keep this whitelist of
+# types which are always hashable, and apply the `_can_hash` filter to all others.
+# Our goal is not completeness, it's to get a small performance boost for the most
+# common cases, and a short whitelist is basically free to maintain.
+ALWAYS_HASHABLE_TYPES = {type(None), bool, int, float, complex, str, bytes}
+
+
+def _from_hashable_type(type_):
+    if type_ in ALWAYS_HASHABLE_TYPES:
+        return st.from_type(type_)
+    else:
+        return st.from_type(type_).filter(_can_hash)
+
+
+@register(typing.Set, st.builds(set))
+@register(typing.MutableSet, st.builds(set))
+def resolve_Set(thing):
+    return st.sets(_from_hashable_type(thing.__args__0))
+
+
+@register(typing.FrozenSet, st.builds(frozenset))
+def resolve_FrozenSet(thing):
+    return st.frozensets(_from_hashable_type(thing.__args__0))
+
+
+@register(typing.Dict, st.builds(dict))
+def resolve_Dict(thing):
+    # If thing is a Collection instance, we need to fill in the values
+    keys_vals = thing.__args__ * 2
+    return st.dictionaries(
+        _from_hashable_type(keys_vals0), st.from_type(keys_vals1)
+    )
+
+
+@register(typing.DefaultDict, st.builds(collections.defaultdict))
+@register("DefaultDict", st.builds(collections.defaultdict), module=typing_extensions)
+def resolve_DefaultDict(thing):
+    return resolve_Dict(thing).map(lambda d: collections.defaultdict(None, d))
+
+
+@register(typing.ItemsView, st.builds(dict).map(dict.items))
+def resolve_ItemsView(thing):
+    return resolve_Dict(thing).map(dict.items)
+
+
+@register(typing.KeysView, st.builds(dict).map(dict.keys))
+def resolve_KeysView(thing):
+    return st.dictionaries(_from_hashable_type(thing.__args__0), st.none()).map(
+        dict.keys
+    )
+
+
+@register(typing.ValuesView, st.builds(dict).map(dict.values))
+def resolve_ValuesView(thing):
+    return st.dictionaries(st.integers(), st.from_type(thing.__args__0)).map(
+        dict.values
+    )
+
+
+@register(typing.Iterator, st.iterables(st.nothing()))
+def resolve_Iterator(thing):
+    return st.iterables(st.from_type(thing.__args__0))
+
+
+@register(typing.Counter, st.builds(collections.Counter))
+def resolve_Counter(thing):
+    return st.dictionaries(
+        keys=st.from_type(thing.__args__0),
+        values=st.integers(),
+    ).map(collections.Counter)
+
+
+@register(typing.Deque, st.builds(collections.deque))
+def resolve_deque(thing):
+    return st.lists(st.from_type(thing.__args__0)).map(collections.deque)
+
+
+@register(typing.ChainMap, st.builds(dict).map(collections.ChainMap))
+def resolve_ChainMap(thing):
+    return resolve_Dict(thing).map(collections.ChainMap)
+
+
+@register("OrderedDict", st.builds(dict).map(collections.OrderedDict))
+def resolve_OrderedDict(thing):
+    # typing.OrderedDict is new in Python 3.7.2
+    return resolve_Dict(thing).map(collections.OrderedDict)
+
+
+@register(typing.Pattern, st.builds(re.compile, st.sampled_from("", b"")))
+def resolve_Pattern(thing):
+    if isinstance(thing.__args__0, typing.TypeVar):  # pragma: no cover
+        # TODO: this was covered on Python 3.8, but isn't on 3.10 - we should
+        # work out why not and write some extra tests to help avoid regressions.
+        return st.builds(re.compile, st.sampled_from("", b""))
+    return st.just(re.compile(thing.__args__0()))
+
+
+@register(  # pragma: no branch  # coverage does not see lambda->exit branch
+    typing.Match,
+    st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool),
+)
+def resolve_Match(thing):
+    if thing.__args__0 == bytes:
+        return (
+            st.binary(min_size=1)
+            .map(lambda c: re.match(b".", c, flags=re.DOTALL))
+            .filter(bool)
+        )
+    return st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool)
+
+
+class GeneratorStrategy(st.SearchStrategy):
+    def __init__(self, yields, returns):
+        assert isinstance(yields, st.SearchStrategy)
+        assert isinstance(returns, st.SearchStrategy)
+        self.yields = yields
+        self.returns = returns
+
+    def __repr__(self):
+        return f"<generators yields={self.yields!r} returns={self.returns!r}>"
+
+    def do_draw(self, data):
+        elements = conjecture_utils_many(data, min_size=0, max_size=100, average_size=5)
+        while elements.more():
+            yield data.draw(self.yields)
+        return data.draw(self.returns)
+
+
+@register(typing.Generator, GeneratorStrategy(st.none(), st.none()))
+def resolve_Generator(thing):
+    yields, _, returns = thing.__args__
+    return GeneratorStrategy(st.from_type(yields), st.from_type(returns))
+
+
+@register(typing.Callable, st.functions())
+def resolve_Callable(thing):
+    # Generated functions either accept no arguments, or arbitrary arguments.
+    # This is looser than ideal, but anything tighter would generally break
+    # use of keyword arguments and we'd rather not force positional-only.
+    if not thing.__args__:  # pragma: no cover  # varies by minor version
+        return st.functions()
+
+    *args_types, return_type = thing.__args__
+
+    # Note that a list can only appear in __args__ under Python 3.9 with the
+    # collections.abc version; see https://bugs.python.org/issue42195
+    if len(args_types) == 1 and isinstance(args_types0, list):
+        args_types = tuple(args_types0)  # pragma: no cover
+
+    pep612 = ConcatenateTypes + ParamSpecTypes
+    for arg in args_types:
+        # awkward dance because you can't use Concatenate in isistance or issubclass
+        if getattr(arg, "__origin__", arg) in pep612 or type(arg) in pep612:
+            raise InvalidArgument(
+                "Hypothesis can't yet construct a strategy for instances of a "
+                f"Callable type parametrized by {arg!r}.  Consider using an "
+                "explicit strategy, or opening an issue."
+            )
+    if getattr(return_type, "__origin__", None) in TypeGuardTypes:
+        raise InvalidArgument(
+            "Hypothesis cannot yet construct a strategy for callables which "
+            f"are PEP-647 TypeGuards (got {return_type!r}).  "
+            "Consider using an explicit strategy, or opening an issue."
+        )
+
+    return st.functions(
+        like=(lambda *a, **k: None) if args_types else (lambda: None),
+        returns=st.from_type(return_type),
+    )
+
+
+@register(typing.TypeVar)
+def resolve_TypeVar(thing):
+    type_var_key = f"typevar={thing!r}"
+
+    if getattr(thing, "__bound__", None) is not None:
+        bound = thing.__bound__
+        if isinstance(bound, typing.ForwardRef):
+            bound = _try_import_forward_ref(thing, bound)
+        strat = unwrap_strategies(st.from_type(bound))
+        if not isinstance(strat, OneOfStrategy):
+            return strat
+        # The bound was a union, or we resolved it as a union of subtypes,
+        # so we need to unpack the strategy to ensure consistency across uses.
+        # This incantation runs a sampled_from over the strategies inferred for
+        # each part of the union, wraps that in shared so that we only generate
+        # from one type per testcase, and flatmaps that back to instances.
+        return st.shared(
+            st.sampled_from(strat.original_strategies), key=type_var_key
+        ).flatmap(lambda s: s)
+
+    builtin_scalar_types = type(None), bool, int, float, str, bytes
+    return st.shared(
+        st.sampled_from(
+            # Constraints may be None or () on various Python versions.
+            getattr(thing, "__constraints__", None)
+            or builtin_scalar_types,
+        ),
+        key=type_var_key,
+    ).flatmap(st.from_type)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/strategies/_internal/utils.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/utils Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/utils/__init__.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/utils/conventions.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/utils/dynamicvariables.py Changed

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/utils/terminal.py Added

@@ -0,0 +1,37 @@
+# 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 os
+
+
+def guess_background_color():
+    """Returns one of "dark", "light", or "unknown".
+
+    This is basically just guessing, but better than always guessing "dark"!
+    See also https://stackoverflow.com/questions/2507337/ and
+    https://unix.stackexchange.com/questions/245378/
+    """
+    django_colors = os.getenv("DJANGO_COLORS", "")
+    for theme in ("light", "dark"):
+        if theme in django_colors.split(";"):
+            return theme
+    # Guessing based on the $COLORFGBG environment variable
+    try:
+        fg, *_, bg = os.getenv("COLORFGBG").split(";")
+    except Exception:
+        pass
+    else:
+        # 0=black, 7=light-grey, 15=white ; we don't interpret other colors
+        if fg in ("7", "15") and bg == "0":
+            return "dark"
+        elif fg == "0" and bg in ("7", "15"):
+            return "light"
+    # TODO: Guessing based on the xterm control sequence
+    return "unknown"

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/vendor Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/vendor/__init__.py Added

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/vendor/pretty.py Added

@@ -0,0 +1,813 @@
+# 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/.
+
+"""
+Python advanced pretty printer.  This pretty printer is intended to
+replace the old `pprint` python module which does not allow developers
+to provide their own pretty print callbacks.
+This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
+Example Usage
+-------------
+To get a string of the output use `pretty`::
+    from pretty import pretty
+    string = pretty(complex_object)
+Extending
+---------
+The pretty library allows developers to add pretty printing rules for their
+own objects.  This process is straightforward.  All you have to do is to
+add a `_repr_pretty_` method to your object and call the methods on the
+pretty printer passed::
+    class MyObject(object):
+        def _repr_pretty_(self, p, cycle):
+            ...
+Here is an example implementation of a `_repr_pretty_` method for a list
+subclass::
+    class MyList(list):
+        def _repr_pretty_(self, p, cycle):
+            if cycle:
+                p.text('MyList(...)')
+            else:
+                with p.group(8, 'MyList(', ')'):
+                    for idx, item in enumerate(self):
+                        if idx:
+                            p.text(',')
+                            p.breakable()
+                        p.pretty(item)
+The `cycle` parameter is `True` if pretty detected a cycle.  You *have* to
+react to that or the result is an infinite loop.  `p.text()` just adds
+non breaking text to the output, `p.breakable()` either adds a whitespace
+or breaks here.  If you pass it an argument it's used instead of the
+default space.  `p.pretty` prettyprints another object using the pretty print
+method.
+The first parameter to the `group` function specifies the extra indentation
+of the next line.  In this example the next item will either be on the same
+line (if the items are short enough) or aligned with the right edge of the
+opening bracket of `MyList`.
+If you just want to indent something you can use the group function
+without open / close parameters.  You can also use this code::
+    with p.indent(2):
+        ...
+Inheritance diagram:
+.. inheritance-diagram:: IPython.lib.pretty
+   :parts: 3
+:copyright: 2007 by Armin Ronacher.
+            Portions (c) 2009 by Robert Kern.
+:license: BSD License.
+"""
+
+import datetime
+import re
+import struct
+import types
+import warnings
+from collections import defaultdict, deque
+from contextlib import contextmanager
+from io import StringIO
+from math import copysign, isnan
+
+__all__ = 
+    "pretty",
+    "IDKey",
+    "RepresentationPrinter",
+
+
+
+_re_pattern_type = type(re.compile(""))
+
+
+def _safe_getattr(obj, attr, default=None):
+    """Safe version of getattr.
+
+    Same as getattr, but will return ``default`` on any Exception,
+    rather than raising.
+
+    """
+    try:
+        return getattr(obj, attr, default)
+    except Exception:
+        return default
+
+
+def pretty(obj):
+    """Pretty print the object's representation."""
+    printer = RepresentationPrinter()
+    printer.pretty(obj)
+    return printer.getvalue()
+
+
+class IDKey:
+    def __init__(self, value):
+        self.value = value
+
+    def __hash__(self) -> int:
+        return hash((type(self), id(self.value)))
+
+    def __eq__(self, __o: object) -> bool:
+        return isinstance(__o, type(self)) and id(self.value) == id(__o.value)
+
+
+class RepresentationPrinter:
+    """Special pretty printer that has a `pretty` method that calls the pretty
+    printer for a python object.
+
+    This class stores processing data on `self` so you must *never* use
+    this class in a threaded environment.  Always lock it or
+    reinstantiate it.
+
+    """
+
+    def __init__(self, output=None, *, context=None):
+        """Pass the output stream, and optionally the current build context.
+
+        We use the context to represent objects constructed by strategies by showing
+        *how* they were constructed, and add annotations showing which parts of the
+        minimal failing example can vary without changing the test result.
+        """
+        self.broken = False
+        self.output = StringIO() if output is None else output
+        self.max_width = 79
+        self.max_seq_length = 1000
+        self.output_width = 0
+        self.buffer_width = 0
+        self.buffer = deque()
+
+        root_group = Group(0)
+        self.group_stack = root_group
+        self.group_queue = GroupQueue(root_group)
+        self.indentation = 0
+
+        self.snans = 0
+
+        self.stack = 
+        self.singleton_pprinters = _singleton_pprinters.copy()
+        self.type_pprinters = _type_pprinters.copy()
+        self.deferred_pprinters = _deferred_type_pprinters.copy()
+
+        # for which-parts-matter, we track a mapping from the (start_idx, end_idx)
+        # of slices into the minimal failing example; this is per-interesting_origin
+        # but we report each separately so that's someone else's problem here.
+        # Invocations of self.repr_call() can report the slice for each argument,
+        # which will then be used to look up the relevant comment if any.
+        if context is None:
+            self.known_object_printers = defaultdict(list)
+            self.slice_comments = {}
+        else:
+            self.known_object_printers = context.known_object_printers
+            self.slice_comments = context.data.slice_comments
+        assert all(isinstance(k, IDKey) for k in self.known_object_printers)
+
+    def pretty(self, obj):
+        """Pretty print the given object."""
+        obj_id = id(obj)
+        cycle = obj_id in self.stack
+        self.stack.append(obj_id)
+        try:
+            with self.group():
+                obj_class = _safe_getattr(obj, "__class__", None) or type(obj)
+                # First try to find registered singleton printers for the type.
+                try:
+                    printer = self.singleton_pprintersobj_id
+                except (TypeError, KeyError):
+                    pass
+                else:
+                    return printer(obj, self, cycle)
+                # Next walk the mro and check for either:
+                #   1) a registered printer
+                #   2) a _repr_pretty_ method
+                for cls in obj_class.__mro__:
+                    if cls in self.type_pprinters:
+                        # printer registered in self.type_pprinters
+                        return self.type_pprinterscls(obj, self, cycle)
+                    else:
+                        # Check if the given class is specified in the deferred type
+                        # registry; move it to the regular type registry if so.
+                        key = (
+                            _safe_getattr(cls, "__module__", None),
+                            _safe_getattr(cls, "__name__", None),
+                        )
+                        if key in self.deferred_pprinters:
+                            # Move the printer over to the regular registry.
+                            printer = self.deferred_pprinters.pop(key)
+                            self.type_pprinterscls = printer
+                            return printer(obj, self, cycle)
+                        else:
+                            # Finally look for special method names.
+                            # Some objects automatically create any requested
+                            # attribute. Try to ignore most of them by checking for
+                            # callability.
+                            if "_repr_pretty_" in cls.__dict__:
+                                meth = cls._repr_pretty_
+                                if callable(meth):
+                                    return meth(obj, self, cycle)
+                # Now check for object-specific printers which show how this
+                # object was constructed (a Hypothesis special feature).
+                printers = self.known_object_printersIDKey(obj)
+                if len(printers) == 1:
+                    return printers0(obj, self, cycle)
+                elif printers:
+                    # We've ended up with multiple registered functions for the same
+                    # object, which must have been returned from multiple calls due to
+                    # e.g. memoization.  If they all return the same string, we'll use
+                    # the first; otherwise we'll pretend that *none* were registered.
+                    #
+                    # It's annoying, but still seems to be the best option for which-
+                    # parts-matter too, as unreportable results aren't very useful.
+                    strs = set()
+                    for f in printers:
+                        p = RepresentationPrinter()
+                        f(obj, p, cycle)
+                        strs.add(p.getvalue())
+                    if len(strs) == 1:
+                        return printers0(obj, self, cycle)
+
+                # A user-provided repr. Find newlines and replace them with p.break_()
+                return _repr_pprint(obj, self, cycle)
+        finally:
+            self.stack.pop()
+
+    def _break_outer_groups(self):
+        while self.max_width < self.output_width + self.buffer_width:
+            group = self.group_queue.deq()
+            if not group:
+                return
+            while group.breakables:
+                x = self.buffer.popleft()
+                self.output_width = x.output(self.output, self.output_width)
+                self.buffer_width -= x.width
+            while self.buffer and isinstance(self.buffer0, Text):
+                x = self.buffer.popleft()
+                self.output_width = x.output(self.output, self.output_width)
+                self.buffer_width -= x.width
+
+    def text(self, obj):
+        """Add literal text to the output."""
+        width = len(obj)
+        if self.buffer:
+            text = self.buffer-1
+            if not isinstance(text, Text):
+                text = Text()
+                self.buffer.append(text)
+            text.add(obj, width)
+            self.buffer_width += width
+            self._break_outer_groups()
+        else:
+            self.output.write(obj)
+            self.output_width += width
+
+    def breakable(self, sep=" "):
+        """Add a breakable separator to the output.
+
+        This does not mean that it will automatically break here.  If no
+        breaking on this position takes place the `sep` is inserted
+        which default to one space.
+
+        """
+        width = len(sep)
+        group = self.group_stack-1
+        if group.want_break:
+            self.flush()
+            self.output.write("\n" + " " * self.indentation)
+            self.output_width = self.indentation
+            self.buffer_width = 0
+        else:
+            self.buffer.append(Breakable(sep, width, self))
+            self.buffer_width += width
+            self._break_outer_groups()
+
+    def break_(self):
+        """Explicitly insert a newline into the output, maintaining correct
+        indentation."""
+        self.flush()
+        self.output.write("\n" + " " * self.indentation)
+        self.output_width = self.indentation
+        self.buffer_width = 0
+
+    @contextmanager
+    def indent(self, indent):
+        """`with`-statement support for indenting/dedenting."""
+        self.indentation += indent
+        try:
+            yield
+        finally:
+            self.indentation -= indent
+
+    @contextmanager
+    def group(self, indent=0, open="", close=""):
+        """Context manager for an indented group.
+
+            with p.group(1, '{', '}'):
+
+        The first parameter specifies the indentation for the next line
+        (usually the width of the opening text), the second and third the
+        opening and closing delimiters.
+        """
+        if open:
+            self.text(open)
+        group = Group(self.group_stack-1.depth + 1)
+        self.group_stack.append(group)
+        self.group_queue.enq(group)
+        self.indentation += indent
+        try:
+            yield
+        finally:
+            self.indentation -= indent
+            group = self.group_stack.pop()
+            if not group.breakables:
+                self.group_queue.remove(group)
+            if close:
+                self.text(close)
+
+    def _enumerate(self, seq):
+        """Like enumerate, but with an upper limit on the number of items."""
+        for idx, x in enumerate(seq):
+            if self.max_seq_length and idx >= self.max_seq_length:
+                self.text(",")
+                self.breakable()
+                self.text("...")
+                return
+            yield idx, x
+
+    def flush(self):
+        """Flush data that is left in the buffer."""
+        if self.snans:
+            # Reset self.snans *before* calling breakable(), which might flush()
+            snans = self.snans
+            self.snans = 0
+            self.breakable("  ")
+            self.text(f"# Saw {snans} signaling NaN" + "s" * (snans > 1))
+        for data in self.buffer:
+            self.output_width += data.output(self.output, self.output_width)
+        self.buffer.clear()
+        self.buffer_width = 0
+
+    def getvalue(self):
+        assert isinstance(self.output, StringIO)
+        self.flush()
+        return self.output.getvalue()
+
+    def repr_call(
+        self,
+        func_name,
+        args,
+        kwargs,
+        *,
+        force_split=None,
+        arg_slices=None,
+        leading_comment=None,
+    ):
+        """Helper function to represent a function call.
+
+        - func_name, args, and kwargs should all be pretty obvious.
+        - If split_lines, we'll force one-argument-per-line; otherwise we'll place
+          calls that fit on a single line (and split otherwise).
+        - arg_slices is a mapping from pos-idx or keyword to (start_idx, end_idx)
+          of the Conjecture buffer, by which we can look up comments to add.
+        """
+        assert isinstance(func_name, str)
+        if func_name.startswith(("lambda:", "lambda ")):
+            func_name = f"({func_name})"
+        self.text(func_name)
+        all_args = (None, v) for v in args + list(kwargs.items())
+        comments = {
+            k: self.slice_commentsv
+            for k, v in (arg_slices or {}).items()
+            if v in self.slice_comments
+        }
+
+        if leading_comment or any(k in comments for k, _ in all_args):
+            # We have to split one arg per line in order to leave comments on them.
+            force_split = True
+        if force_split is None:
+            # We're OK with printing this call on a single line, but will it fit?
+            # If not, we'd rather fall back to one-argument-per-line instead.
+            p = RepresentationPrinter()
+            p.stack = self.stack.copy()
+            p.known_object_printers = self.known_object_printers
+            p.repr_call("_" * self.output_width, args, kwargs, force_split=False)
+            s = p.getvalue()
+            force_split = "\n" in s
+
+        with self.group(indent=4, open="(", close=""):
+            for i, (k, v) in enumerate(all_args):
+                if force_split:
+                    if i == 0 and leading_comment:
+                        self.break_()
+                        self.text(leading_comment)
+                    self.break_()
+                else:
+                    self.breakable(" " if i else "")
+                if k:
+                    self.text(f"{k}=")
+                self.pretty(v)
+                if force_split or i + 1 < len(all_args):
+                    self.text(",")
+                # Optional comments are used to annotate which-parts-matter
+                comment = comments.get(i) or comments.get(k)
+                if comment:
+                    self.text(f"  # {comment}")
+        if all_args and force_split:
+            self.break_()
+        self.text(")")  # after dedent
+
+
+class Printable:
+    def output(self, stream, output_width):  # pragma: no cover
+        raise NotImplementedError()
+
+
+class Text(Printable):
+    def __init__(self):
+        self.objs = 
+        self.width = 0
+
+    def output(self, stream, output_width):
+        for obj in self.objs:
+            stream.write(obj)
+        return output_width + self.width
+
+    def add(self, obj, width):
+        self.objs.append(obj)
+        self.width += width
+
+
+class Breakable(Printable):
+    def __init__(self, seq, width, pretty):
+        self.obj = seq
+        self.width = width
+        self.pretty = pretty
+        self.indentation = pretty.indentation
+        self.group = pretty.group_stack-1
+        self.group.breakables.append(self)
+
+    def output(self, stream, output_width):
+        self.group.breakables.popleft()
+        if self.group.want_break:
+            stream.write("\n" + " " * self.indentation)
+            return self.indentation
+        if not self.group.breakables:
+            self.pretty.group_queue.remove(self.group)
+        stream.write(self.obj)
+        return output_width + self.width
+
+
+class Group(Printable):
+    def __init__(self, depth):
+        self.depth = depth
+        self.breakables = deque()
+        self.want_break = False
+
+
+class GroupQueue:
+    def __init__(self, *groups):
+        self.queue = 
+        for group in groups:
+            self.enq(group)
+
+    def enq(self, group):
+        depth = group.depth
+        while depth > len(self.queue) - 1:
+            self.queue.append()
+        self.queuedepth.append(group)
+
+    def deq(self):
+        for stack in self.queue:
+            for idx, group in enumerate(reversed(stack)):
+                if group.breakables:
+                    del stackidx
+                    group.want_break = True
+                    return group
+            for group in stack:
+                group.want_break = True
+            del stack:
+
+    def remove(self, group):
+        try:
+            self.queuegroup.depth.remove(group)
+        except ValueError:
+            pass
+
+
+def _seq_pprinter_factory(start, end, basetype):
+    """Factory that returns a pprint function useful for sequences.
+
+    Used by the default pprint for tuples, dicts, and lists.
+    """
+
+    def inner(obj, p, cycle):
+        typ = type(obj)
+        if (
+            basetype is not None
+            and typ is not basetype
+            and typ.__repr__ != basetype.__repr__
+        ):
+            # If the subclass provides its own repr, use it instead.
+            return p.text(typ.__repr__(obj))
+
+        if cycle:
+            return p.text(start + "..." + end)
+        step = len(start)
+        with p.group(step, start, end):
+            for idx, x in p._enumerate(obj):
+                if idx:
+                    p.text(",")
+                    p.breakable()
+                p.pretty(x)
+            if len(obj) == 1 and type(obj) is tuple:
+                # Special case for 1-item tuples.
+                p.text(",")
+
+    return inner
+
+
+def _set_pprinter_factory(start, end, basetype):
+    """Factory that returns a pprint function useful for sets and
+    frozensets."""
+
+    def inner(obj, p, cycle):
+        typ = type(obj)
+        if (
+            basetype is not None
+            and typ is not basetype
+            and typ.__repr__ != basetype.__repr__
+        ):
+            # If the subclass provides its own repr, use it instead.
+            return p.text(typ.__repr__(obj))
+
+        if cycle:
+            return p.text(start + "..." + end)
+        if not obj:
+            # Special case.
+            p.text(basetype.__name__ + "()")
+        else:
+            step = len(start)
+            with p.group(step, start, end):
+                # Like dictionary keys, try to sort the items if there aren't too many
+                items = obj
+                if not (p.max_seq_length and len(obj) >= p.max_seq_length):
+                    try:
+                        items = sorted(obj)
+                    except Exception:
+                        # Sometimes the items don't sort.
+                        pass
+                for idx, x in p._enumerate(items):
+                    if idx:
+                        p.text(",")
+                        p.breakable()
+                    p.pretty(x)
+
+    return inner
+
+
+def _dict_pprinter_factory(start, end, basetype=None):
+    """Factory that returns a pprint function used by the default pprint of
+    dicts and dict proxies."""
+
+    def inner(obj, p, cycle):
+        typ = type(obj)
+        if (
+            basetype is not None
+            and typ is not basetype
+            and typ.__repr__ != basetype.__repr__
+        ):
+            # If the subclass provides its own repr, use it instead.
+            return p.text(typ.__repr__(obj))
+
+        if cycle:
+            return p.text("{...}")
+        with p.group(1, start, end):
+            # If the dict contains both "" and b"" (empty string and empty bytes), we
+            # ignore the BytesWarning raised by `python -bb` mode.  We can't use
+            # `.items()` because it might be a non-`dict` type of mapping.
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", BytesWarning)
+                for idx, key in p._enumerate(obj):
+                    if idx:
+                        p.text(",")
+                        p.breakable()
+                    p.pretty(key)
+                    p.text(": ")
+                    p.pretty(objkey)
+
+    inner.__name__ = f"_dict_pprinter_factory({start!r}, {end!r}, {basetype!r})"
+    return inner
+
+
+def _super_pprint(obj, p, cycle):
+    """The pprint for the super type."""
+    with p.group(8, "<super: ", ">"):
+        p.pretty(obj.__thisclass__)
+        p.text(",")
+        p.breakable()
+        p.pretty(obj.__self__)
+
+
+def _re_pattern_pprint(obj, p, cycle):
+    """The pprint function for regular expression patterns."""
+    p.text("re.compile(")
+    pattern = repr(obj.pattern)
+    if pattern:1 in "uU":  # pragma: no cover
+        pattern = pattern1:
+        prefix = "ur"
+    else:
+        prefix = "r"
+    pattern = prefix + pattern.replace("\\\\", "\\")
+    p.text(pattern)
+    if obj.flags:
+        p.text(",")
+        p.breakable()
+        done_one = False
+        for flag in (
+            "TEMPLATE",
+            "IGNORECASE",
+            "LOCALE",
+            "MULTILINE",
+            "DOTALL",
+            "UNICODE",
+            "VERBOSE",
+            "DEBUG",
+        ):
+            if obj.flags & getattr(re, flag, 0):
+                if done_one:
+                    p.text("|")
+                p.text("re." + flag)
+                done_one = True
+    p.text(")")
+
+
+def _type_pprint(obj, p, cycle):
+    """The pprint for classes and types."""
+    # Heap allocated types might not have the module attribute,
+    # and others may set it to None.
+
+    # Checks for a __repr__ override in the metaclass
+    # != rather than is not because pypy compatibility
+    if type(obj).__repr__ != type.__repr__:
+        _repr_pprint(obj, p, cycle)
+        return
+
+    mod = _safe_getattr(obj, "__module__", None)
+    try:
+        name = obj.__qualname__
+        if not isinstance(name, str):  # pragma: no cover
+            # This can happen if the type implements __qualname__ as a property
+            # or other descriptor in Python 2.
+            raise Exception("Try __name__")
+    except Exception:  # pragma: no cover
+        name = obj.__name__
+        if not isinstance(name, str):
+            name = "<unknown type>"
+
+    if mod in (None, "__builtin__", "builtins", "exceptions"):
+        p.text(name)
+    else:
+        p.text(mod + "." + name)
+
+
+def _repr_pprint(obj, p, cycle):
+    """A pprint that just redirects to the normal repr function."""
+    # Find newlines and replace them with p.break_()
+    output = repr(obj)
+    for idx, output_line in enumerate(output.splitlines()):
+        if idx:
+            p.break_()
+        p.text(output_line)
+
+
+def _function_pprint(obj, p, cycle):
+    """Base pprint for all functions and builtin functions."""
+    from hypothesis.internal.reflection import get_pretty_function_description
+
+    p.text(get_pretty_function_description(obj))
+
+
+def _exception_pprint(obj, p, cycle):
+    """Base pprint for all exceptions."""
+    name = getattr(obj.__class__, "__qualname__", obj.__class__.__name__)
+    if obj.__class__.__module__ not in ("exceptions", "builtins"):
+        name = f"{obj.__class__.__module__}.{name}"
+    step = len(name) + 1
+    with p.group(step, name + "(", ")"):
+        for idx, arg in enumerate(getattr(obj, "args", ())):
+            if idx:
+                p.text(",")
+                p.breakable()
+            p.pretty(arg)
+
+
+def _repr_float_counting_nans(obj, p, cycle):
+    if isnan(obj) and hasattr(p, "snans"):
+        if struct.pack("!d", abs(obj)) != struct.pack("!d", float("nan")):
+            p.snans += 1
+        if copysign(1.0, obj) == -1.0:
+            p.text("-nan")
+            return
+    p.text(repr(obj))
+
+
+#: printers for builtin types
+_type_pprinters = {
+    int: _repr_pprint,
+    float: _repr_float_counting_nans,
+    str: _repr_pprint,
+    tuple: _seq_pprinter_factory("(", ")", tuple),
+    list: _seq_pprinter_factory("", "", list),
+    dict: _dict_pprinter_factory("{", "}", dict),
+    set: _set_pprinter_factory("{", "}", set),
+    frozenset: _set_pprinter_factory("frozenset({", "})", frozenset),
+    super: _super_pprint,
+    _re_pattern_type: _re_pattern_pprint,
+    type: _type_pprint,
+    types.FunctionType: _function_pprint,
+    types.BuiltinFunctionType: _function_pprint,
+    types.MethodType: _repr_pprint,
+    datetime.datetime: _repr_pprint,
+    datetime.timedelta: _repr_pprint,
+    BaseException: _exception_pprint,
+    slice: _repr_pprint,
+    range: _repr_pprint,
+    bytes: _repr_pprint,
+}
+
+#: printers for types specified by name
+_deferred_type_pprinters = {}  # type: ignore
+
+
+def for_type_by_name(type_module, type_name, func):
+    """Add a pretty printer for a type specified by the module and name of a
+    type rather than the type object itself."""
+    key = (type_module, type_name)
+    oldfunc = _deferred_type_pprinters.get(key, None)
+    _deferred_type_pprinterskey = func
+    return oldfunc
+
+
+#: printers for the default singletons
+_singleton_pprinters = dict.fromkeys(
+    map(id, None, True, False, Ellipsis, NotImplemented), _repr_pprint
+)
+
+
+def _defaultdict_pprint(obj, p, cycle):
+    name = obj.__class__.__name__
+    with p.group(len(name) + 1, name + "(", ")"):
+        if cycle:
+            p.text("...")
+        else:
+            p.pretty(obj.default_factory)
+            p.text(",")
+            p.breakable()
+            p.pretty(dict(obj))
+
+
+def _ordereddict_pprint(obj, p, cycle):
+    name = obj.__class__.__name__
+    with p.group(len(name) + 1, name + "(", ")"):
+        if cycle:
+            p.text("...")
+        elif obj:
+            p.pretty(list(obj.items()))
+
+
+def _deque_pprint(obj, p, cycle):
+    name = obj.__class__.__name__
+    with p.group(len(name) + 1, name + "(", ")"):
+        if cycle:
+            p.text("...")
+        else:
+            p.pretty(list(obj))
+
+
+def _counter_pprint(obj, p, cycle):
+    name = obj.__class__.__name__
+    with p.group(len(name) + 1, name + "(", ")"):
+        if cycle:
+            p.text("...")
+        elif obj:
+            p.pretty(dict(obj))
+
+
+def _repr_dataframe(obj, p, cycle):  # pragma: no cover
+    with p.indent(4):
+        p.break_()
+        _repr_pprint(obj, p, cycle)
+    p.break_()
+
+
+def _repr_enum(obj, p, cycle):
+    p.text(type(obj).__name__ + "." + obj.name)
+
+
+for_type_by_name("collections", "defaultdict", _defaultdict_pprint)
+for_type_by_name("collections", "OrderedDict", _ordereddict_pprint)
+for_type_by_name("ordereddict", "OrderedDict", _ordereddict_pprint)
+for_type_by_name("collections", "deque", _deque_pprint)
+for_type_by_name("collections", "Counter", _counter_pprint)
+for_type_by_name("pandas.core.frame", "DataFrame", _repr_dataframe)
+for_type_by_name("enum", "Enum", _repr_enum)

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/vendor/tlds-alpha-by-domain.txt Added

@@ -0,0 +1,1475 @@
+# Version 2023061100, Last Updated Sun Jun 11 07:07:01 2023 UTC
+AAA
+AARP
+ABB
+ABBOTT
+ABBVIE
+ABC
+ABLE
+ABOGADO
+ABUDHABI
+AC
+ACADEMY
+ACCENTURE
+ACCOUNTANT
+ACCOUNTANTS
+ACO
+ACTOR
+AD
+ADS
+ADULT
+AE
+AEG
+AERO
+AETNA
+AF
+AFL
+AFRICA
+AG
+AGAKHAN
+AGENCY
+AI
+AIG
+AIRBUS
+AIRFORCE
+AIRTEL
+AKDN
+AL
+ALIBABA
+ALIPAY
+ALLFINANZ
+ALLSTATE
+ALLY
+ALSACE
+ALSTOM
+AM
+AMAZON
+AMERICANEXPRESS
+AMERICANFAMILY
+AMEX
+AMFAM
+AMICA
+AMSTERDAM
+ANALYTICS
+ANDROID
+ANQUAN
+ANZ
+AO
+AOL
+APARTMENTS
+APP
+APPLE
+AQ
+AQUARELLE
+AR
+ARAB
+ARAMCO
+ARCHI
+ARMY
+ARPA
+ART
+ARTE
+AS
+ASDA
+ASIA
+ASSOCIATES
+AT
+ATHLETA
+ATTORNEY
+AU
+AUCTION
+AUDI
+AUDIBLE
+AUDIO
+AUSPOST
+AUTHOR
+AUTO
+AUTOS
+AVIANCA
+AW
+AWS
+AX
+AXA
+AZ
+AZURE
+BA
+BABY
+BAIDU
+BANAMEX
+BANANAREPUBLIC
+BAND
+BANK
+BAR
+BARCELONA
+BARCLAYCARD
+BARCLAYS
+BAREFOOT
+BARGAINS
+BASEBALL
+BASKETBALL
+BAUHAUS
+BAYERN
+BB
+BBC
+BBT
+BBVA
+BCG
+BCN
+BD
+BE
+BEATS
+BEAUTY
+BEER
+BENTLEY
+BERLIN
+BEST
+BESTBUY
+BET
+BF
+BG
+BH
+BHARTI
+BI
+BIBLE
+BID
+BIKE
+BING
+BINGO
+BIO
+BIZ
+BJ
+BLACK
+BLACKFRIDAY
+BLOCKBUSTER
+BLOG
+BLOOMBERG
+BLUE
+BM
+BMS
+BMW
+BN
+BNPPARIBAS
+BO
+BOATS
+BOEHRINGER
+BOFA
+BOM
+BOND
+BOO
+BOOK
+BOOKING
+BOSCH
+BOSTIK
+BOSTON
+BOT
+BOUTIQUE
+BOX
+BR
+BRADESCO
+BRIDGESTONE
+BROADWAY
+BROKER
+BROTHER
+BRUSSELS
+BS
+BT
+BUILD
+BUILDERS
+BUSINESS
+BUY
+BUZZ
+BV
+BW
+BY
+BZ
+BZH
+CA
+CAB
+CAFE
+CAL
+CALL
+CALVINKLEIN
+CAM
+CAMERA
+CAMP
+CANON
+CAPETOWN
+CAPITAL
+CAPITALONE
+CAR
+CARAVAN
+CARDS
+CARE
+CAREER
+CAREERS
+CARS
+CASA
+CASE
+CASH
+CASINO
+CAT
+CATERING
+CATHOLIC
+CBA
+CBN
+CBRE
+CBS
+CC
+CD
+CENTER
+CEO
+CERN
+CF
+CFA
+CFD
+CG
+CH
+CHANEL
+CHANNEL
+CHARITY
+CHASE
+CHAT
+CHEAP
+CHINTAI
+CHRISTMAS
+CHROME
+CHURCH
+CI
+CIPRIANI
+CIRCLE
+CISCO
+CITADEL
+CITI
+CITIC
+CITY
+CITYEATS
+CK
+CL
+CLAIMS
+CLEANING
+CLICK
+CLINIC
+CLINIQUE
+CLOTHING
+CLOUD
+CLUB
+CLUBMED
+CM
+CN
+CO
+COACH
+CODES
+COFFEE
+COLLEGE
+COLOGNE
+COM
+COMCAST
+COMMBANK
+COMMUNITY
+COMPANY
+COMPARE
+COMPUTER
+COMSEC
+CONDOS
+CONSTRUCTION
+CONSULTING
+CONTACT
+CONTRACTORS
+COOKING
+COOKINGCHANNEL
+COOL
+COOP
+CORSICA
+COUNTRY
+COUPON
+COUPONS
+COURSES
+CPA
+CR
+CREDIT
+CREDITCARD
+CREDITUNION
+CRICKET
+CROWN
+CRS
+CRUISE
+CRUISES
+CU
+CUISINELLA
+CV
+CW
+CX
+CY
+CYMRU
+CYOU
+CZ
+DABUR
+DAD
+DANCE
+DATA
+DATE
+DATING
+DATSUN
+DAY
+DCLK
+DDS
+DE
+DEAL
+DEALER
+DEALS
+DEGREE
+DELIVERY
+DELL
+DELOITTE
+DELTA
+DEMOCRAT
+DENTAL
+DENTIST
+DESI
+DESIGN
+DEV
+DHL
+DIAMONDS
+DIET
+DIGITAL
+DIRECT
+DIRECTORY
+DISCOUNT
+DISCOVER
+DISH
+DIY
+DJ
+DK
+DM
+DNP
+DO
+DOCS
+DOCTOR
+DOG
+DOMAINS
+DOT
+DOWNLOAD
+DRIVE
+DTV
+DUBAI
+DUNLOP
+DUPONT
+DURBAN
+DVAG
+DVR
+DZ
+EARTH
+EAT
+EC
+ECO
+EDEKA
+EDU
+EDUCATION
+EE
+EG
+EMAIL
+EMERCK
+ENERGY
+ENGINEER
+ENGINEERING
+ENTERPRISES
+EPSON
+EQUIPMENT
+ER
+ERICSSON
+ERNI
+ES
+ESQ
+ESTATE
+ET
+ETISALAT
+EU
+EUROVISION
+EUS
+EVENTS
+EXCHANGE
+EXPERT
+EXPOSED
+EXPRESS
+EXTRASPACE
+FAGE
+FAIL
+FAIRWINDS
+FAITH
+FAMILY
+FAN
+FANS
+FARM
+FARMERS
+FASHION
+FAST
+FEDEX
+FEEDBACK
+FERRARI
+FERRERO
+FI
+FIDELITY
+FIDO
+FILM
+FINAL
+FINANCE
+FINANCIAL
+FIRE
+FIRESTONE
+FIRMDALE
+FISH
+FISHING
+FIT
+FITNESS
+FJ
+FK
+FLICKR
+FLIGHTS
+FLIR
+FLORIST
+FLOWERS
+FLY
+FM
+FO
+FOO
+FOOD
+FOODNETWORK
+FOOTBALL
+FORD
+FOREX
+FORSALE
+FORUM
+FOUNDATION
+FOX
+FR
+FREE
+FRESENIUS
+FRL
+FROGANS
+FRONTDOOR
+FRONTIER
+FTR
+FUJITSU
+FUN
+FUND
+FURNITURE
+FUTBOL
+FYI
+GA
+GAL
+GALLERY
+GALLO
+GALLUP
+GAME
+GAMES
+GAP
+GARDEN
+GAY
+GB
+GBIZ
+GD
+GDN
+GE
+GEA
+GENT
+GENTING
+GEORGE
+GF
+GG
+GGEE
+GH
+GI
+GIFT
+GIFTS
+GIVES
+GIVING
+GL
+GLASS
+GLE
+GLOBAL
+GLOBO
+GM
+GMAIL
+GMBH
+GMO
+GMX
+GN
+GODADDY
+GOLD
+GOLDPOINT
+GOLF
+GOO
+GOODYEAR
+GOOG
+GOOGLE
+GOP
+GOT
+GOV
+GP
+GQ
+GR
+GRAINGER
+GRAPHICS
+GRATIS
+GREEN
+GRIPE
+GROCERY
+GROUP
+GS
+GT
+GU
+GUARDIAN
+GUCCI
+GUGE
+GUIDE
+GUITARS
+GURU
+GW
+GY
+HAIR
+HAMBURG
+HANGOUT
+HAUS
+HBO
+HDFC
+HDFCBANK
+HEALTH
+HEALTHCARE
+HELP
+HELSINKI
+HERE
+HERMES
+HGTV
+HIPHOP
+HISAMITSU
+HITACHI
+HIV
+HK
+HKT
+HM
+HN
+HOCKEY
+HOLDINGS
+HOLIDAY
+HOMEDEPOT
+HOMEGOODS
+HOMES
+HOMESENSE
+HONDA
+HORSE
+HOSPITAL
+HOST
+HOSTING
+HOT
+HOTELES
+HOTELS
+HOTMAIL
+HOUSE
+HOW
+HR
+HSBC
+HT
+HU
+HUGHES
+HYATT
+HYUNDAI
+IBM
+ICBC
+ICE
+ICU
+ID
+IE
+IEEE
+IFM
+IKANO
+IL
+IM
+IMAMAT
+IMDB
+IMMO
+IMMOBILIEN
+IN
+INC
+INDUSTRIES
+INFINITI
+INFO
+ING
+INK
+INSTITUTE
+INSURANCE
+INSURE
+INT
+INTERNATIONAL
+INTUIT
+INVESTMENTS
+IO
+IPIRANGA
+IQ
+IR
+IRISH
+IS
+ISMAILI
+IST
+ISTANBUL
+IT
+ITAU
+ITV
+JAGUAR
+JAVA
+JCB
+JE
+JEEP
+JETZT
+JEWELRY
+JIO
+JLL
+JM
+JMP
+JNJ
+JO
+JOBS
+JOBURG
+JOT
+JOY
+JP
+JPMORGAN
+JPRS
+JUEGOS
+JUNIPER
+KAUFEN
+KDDI
+KE
+KERRYHOTELS
+KERRYLOGISTICS
+KERRYPROPERTIES
+KFH
+KG
+KH
+KI
+KIA
+KIDS
+KIM
+KINDER
+KINDLE
+KITCHEN
+KIWI
+KM
+KN
+KOELN
+KOMATSU
+KOSHER
+KP
+KPMG
+KPN
+KR
+KRD
+KRED
+KUOKGROUP
+KW
+KY
+KYOTO
+KZ
+LA
+LACAIXA
+LAMBORGHINI
+LAMER
+LANCASTER
+LAND
+LANDROVER
+LANXESS
+LASALLE
+LAT
+LATINO
+LATROBE
+LAW
+LAWYER
+LB
+LC
+LDS
+LEASE
+LECLERC
+LEFRAK
+LEGAL
+LEGO
+LEXUS
+LGBT
+LI
+LIDL
+LIFE
+LIFEINSURANCE
+LIFESTYLE
+LIGHTING
+LIKE
+LILLY
+LIMITED
+LIMO
+LINCOLN
+LINK
+LIPSY
+LIVE
+LIVING
+LK
+LLC
+LLP
+LOAN
+LOANS
+LOCKER
+LOCUS
+LOL
+LONDON
+LOTTE
+LOTTO
+LOVE
+LPL
+LPLFINANCIAL
+LR
+LS
+LT
+LTD
+LTDA
+LU
+LUNDBECK
+LUXE
+LUXURY
+LV
+LY
+MA
+MADRID
+MAIF
+MAISON
+MAKEUP
+MAN
+MANAGEMENT
+MANGO
+MAP
+MARKET
+MARKETING
+MARKETS
+MARRIOTT
+MARSHALLS
+MATTEL
+MBA
+MC
+MCKINSEY
+MD
+ME
+MED
+MEDIA
+MEET
+MELBOURNE
+MEME
+MEMORIAL
+MEN
+MENU
+MERCKMSD
+MG
+MH
+MIAMI
+MICROSOFT
+MIL
+MINI
+MINT
+MIT
+MITSUBISHI
+MK
+ML
+MLB
+MLS
+MM
+MMA
+MN
+MO
+MOBI
+MOBILE
+MODA
+MOE
+MOI
+MOM
+MONASH
+MONEY
+MONSTER
+MORMON
+MORTGAGE
+MOSCOW
+MOTO
+MOTORCYCLES
+MOV
+MOVIE
+MP
+MQ
+MR
+MS
+MSD
+MT
+MTN
+MTR
+MU
+MUSEUM
+MUSIC
+MUTUAL
+MV
+MW
+MX
+MY
+MZ
+NA
+NAB
+NAGOYA
+NAME
+NATURA
+NAVY
+NBA
+NC
+NE
+NEC
+NET
+NETBANK
+NETFLIX
+NETWORK
+NEUSTAR
+NEW
+NEWS
+NEXT
+NEXTDIRECT
+NEXUS
+NF
+NFL
+NG
+NGO
+NHK
+NI
+NICO
+NIKE
+NIKON
+NINJA
+NISSAN
+NISSAY
+NL
+NO
+NOKIA
+NORTHWESTERNMUTUAL
+NORTON
+NOW
+NOWRUZ
+NOWTV
+NP
+NR
+NRA
+NRW
+NTT
+NU
+NYC
+NZ
+OBI
+OBSERVER
+OFFICE
+OKINAWA
+OLAYAN
+OLAYANGROUP
+OLDNAVY
+OLLO
+OM
+OMEGA
+ONE
+ONG
+ONL
+ONLINE
+OOO
+OPEN
+ORACLE
+ORANGE
+ORG
+ORGANIC
+ORIGINS
+OSAKA
+OTSUKA
+OTT
+OVH
+PA
+PAGE
+PANASONIC
+PARIS
+PARS
+PARTNERS
+PARTS
+PARTY
+PASSAGENS
+PAY
+PCCW
+PE
+PET
+PF
+PFIZER
+PG
+PH
+PHARMACY
+PHD
+PHILIPS
+PHONE
+PHOTO
+PHOTOGRAPHY
+PHOTOS
+PHYSIO
+PICS
+PICTET
+PICTURES
+PID
+PIN
+PING
+PINK
+PIONEER
+PIZZA
+PK
+PL
+PLACE
+PLAY
+PLAYSTATION
+PLUMBING
+PLUS
+PM
+PN
+PNC
+POHL
+POKER
+POLITIE
+PORN
+POST
+PR
+PRAMERICA
+PRAXI
+PRESS
+PRIME
+PRO
+PROD
+PRODUCTIONS
+PROF
+PROGRESSIVE
+PROMO
+PROPERTIES
+PROPERTY
+PROTECTION
+PRU
+PRUDENTIAL
+PS
+PT
+PUB
+PW
+PWC
+PY
+QA
+QPON
+QUEBEC
+QUEST
+RACING
+RADIO
+RE
+READ
+REALESTATE
+REALTOR
+REALTY
+RECIPES
+RED
+REDSTONE
+REDUMBRELLA
+REHAB
+REISE
+REISEN
+REIT
+RELIANCE
+REN
+RENT
+RENTALS
+REPAIR
+REPORT
+REPUBLICAN
+REST
+RESTAURANT
+REVIEW
+REVIEWS
+REXROTH
+RICH
+RICHARDLI
+RICOH
+RIL
+RIO
+RIP
+RO
+ROCHER
+ROCKS
+RODEO
+ROGERS
+ROOM
+RS
+RSVP
+RU
+RUGBY
+RUHR
+RUN
+RW
+RWE
+RYUKYU
+SA
+SAARLAND
+SAFE
+SAFETY
+SAKURA
+SALE
+SALON
+SAMSCLUB
+SAMSUNG
+SANDVIK
+SANDVIKCOROMANT
+SANOFI
+SAP
+SARL
+SAS
+SAVE
+SAXO
+SB
+SBI
+SBS
+SC
+SCA
+SCB
+SCHAEFFLER
+SCHMIDT
+SCHOLARSHIPS
+SCHOOL
+SCHULE
+SCHWARZ
+SCIENCE
+SCOT
+SD
+SE
+SEARCH
+SEAT
+SECURE
+SECURITY
+SEEK
+SELECT
+SENER
+SERVICES
+SEVEN
+SEW
+SEX
+SEXY
+SFR
+SG
+SH
+SHANGRILA
+SHARP
+SHAW
+SHELL
+SHIA
+SHIKSHA
+SHOES
+SHOP
+SHOPPING
+SHOUJI
+SHOW
+SHOWTIME
+SI
+SILK
+SINA
+SINGLES
+SITE
+SJ
+SK
+SKI
+SKIN
+SKY
+SKYPE
+SL
+SLING
+SM
+SMART
+SMILE
+SN
+SNCF
+SO
+SOCCER
+SOCIAL
+SOFTBANK
+SOFTWARE
+SOHU
+SOLAR
+SOLUTIONS
+SONG
+SONY
+SOY
+SPA
+SPACE
+SPORT
+SPOT
+SR
+SRL
+SS
+ST
+STADA
+STAPLES
+STAR
+STATEBANK
+STATEFARM
+STC
+STCGROUP
+STOCKHOLM
+STORAGE
+STORE
+STREAM
+STUDIO
+STUDY
+STYLE
+SU
+SUCKS
+SUPPLIES
+SUPPLY
+SUPPORT
+SURF
+SURGERY
+SUZUKI
+SV
+SWATCH
+SWISS
+SX
+SY
+SYDNEY
+SYSTEMS
+SZ
+TAB
+TAIPEI
+TALK
+TAOBAO
+TARGET
+TATAMOTORS
+TATAR
+TATTOO
+TAX
+TAXI
+TC
+TCI
+TD
+TDK
+TEAM
+TECH
+TECHNOLOGY
+TEL
+TEMASEK
+TENNIS
+TEVA
+TF
+TG
+TH
+THD
+THEATER
+THEATRE
+TIAA
+TICKETS
+TIENDA
+TIFFANY
+TIPS
+TIRES
+TIROL
+TJ
+TJMAXX
+TJX
+TK
+TKMAXX
+TL
+TM
+TMALL
+TN
+TO
+TODAY
+TOKYO
+TOOLS
+TOP
+TORAY
+TOSHIBA
+TOTAL
+TOURS
+TOWN
+TOYOTA
+TOYS
+TR
+TRADE
+TRADING
+TRAINING
+TRAVEL
+TRAVELCHANNEL
+TRAVELERS
+TRAVELERSINSURANCE
+TRUST
+TRV
+TT
+TUBE
+TUI
+TUNES
+TUSHU
+TV
+TVS
+TW
+TZ
+UA
+UBANK
+UBS
+UG
+UK
+UNICOM
+UNIVERSITY
+UNO
+UOL
+UPS
+US
+UY
+UZ
+VA
+VACATIONS
+VANA
+VANGUARD
+VC
+VE
+VEGAS
+VENTURES
+VERISIGN
+VERSICHERUNG
+VET
+VG
+VI
+VIAJES
+VIDEO
+VIG
+VIKING
+VILLAS
+VIN
+VIP
+VIRGIN
+VISA
+VISION
+VIVA
+VIVO
+VLAANDEREN
+VN
+VODKA
+VOLKSWAGEN
+VOLVO
+VOTE
+VOTING
+VOTO
+VOYAGE
+VU
+VUELOS
+WALES
+WALMART
+WALTER
+WANG
+WANGGOU
+WATCH
+WATCHES
+WEATHER
+WEATHERCHANNEL
+WEBCAM
+WEBER
+WEBSITE
+WED
+WEDDING
+WEIBO
+WEIR
+WF
+WHOSWHO
+WIEN
+WIKI
+WILLIAMHILL
+WIN
+WINDOWS
+WINE
+WINNERS
+WME
+WOLTERSKLUWER
+WOODSIDE
+WORK
+WORKS
+WORLD
+WOW
+WS
+WTC
+WTF
+XBOX
+XEROX
+XFINITY
+XIHUAN
+XIN
+XN--11B4C3D
+XN--1CK2E1B
+XN--1QQW23A
+XN--2SCRJ9C
+XN--30RR7Y
+XN--3BST00M
+XN--3DS443G
+XN--3E0B707E
+XN--3HCRJ9C
+XN--3PXU8K
+XN--42C2D9A
+XN--45BR5CYL
+XN--45BRJ9C
+XN--45Q11C
+XN--4DBRK0CE
+XN--4GBRIM
+XN--54B7FTA0CC
+XN--55QW42G
+XN--55QX5D
+XN--5SU34J936BGSG
+XN--5TZM5G
+XN--6FRZ82G
+XN--6QQ986B3XL
+XN--80ADXHKS
+XN--80AO21A
+XN--80AQECDR1A
+XN--80ASEHDB
+XN--80ASWG
+XN--8Y0A063A
+XN--90A3AC
+XN--90AE
+XN--90AIS
+XN--9DBQ2A
+XN--9ET52U
+XN--9KRT00A
+XN--B4W605FERD
+XN--BCK1B9A5DRE4C
+XN--C1AVG
+XN--C2BR7G
+XN--CCK2B3B
+XN--CCKWCXETD
+XN--CG4BKI
+XN--CLCHC0EA0B2G2A9GCD
+XN--CZR694B
+XN--CZRS0T
+XN--CZRU2D
+XN--D1ACJ3B
+XN--D1ALF
+XN--E1A4C
+XN--ECKVDTC9D
+XN--EFVY88H
+XN--FCT429K
+XN--FHBEI
+XN--FIQ228C5HS
+XN--FIQ64B
+XN--FIQS8S
+XN--FIQZ9S
+XN--FJQ720A
+XN--FLW351E
+XN--FPCRJ9C3D
+XN--FZC2C9E2C
+XN--FZYS8D69UVGM
+XN--G2XX48C
+XN--GCKR3F0F
+XN--GECRJ9C
+XN--GK3AT1E
+XN--H2BREG3EVE
+XN--H2BRJ9C
+XN--H2BRJ9C8C
+XN--HXT814E
+XN--I1B6B1A6A2E
+XN--IMR513N
+XN--IO0A7I
+XN--J1AEF
+XN--J1AMH
+XN--J6W193G
+XN--JLQ480N2RG
+XN--JVR189M
+XN--KCRX77D1X4A
+XN--KPRW13D
+XN--KPRY57D
+XN--KPUT3I
+XN--L1ACC
+XN--LGBBAT1AD8J
+XN--MGB9AWBF
+XN--MGBA3A3EJT
+XN--MGBA3A4F16A
+XN--MGBA7C0BBN0A
+XN--MGBAAKC7DVF
+XN--MGBAAM7A8H
+XN--MGBAB2BD
+XN--MGBAH1A3HJKRD
+XN--MGBAI9AZGQP6J
+XN--MGBAYH7GPA
+XN--MGBBH1A
+XN--MGBBH1A71E
+XN--MGBC0A9AZCG
+XN--MGBCA7DZDO
+XN--MGBCPQ6GPA1A
+XN--MGBERP4A5D4AR
+XN--MGBGU82A
+XN--MGBI4ECEXP
+XN--MGBPL2FH
+XN--MGBT3DHD
+XN--MGBTX2B
+XN--MGBX4CD0AB
+XN--MIX891F
+XN--MK1BU44C
+XN--MXTQ1M
+XN--NGBC5AZD
+XN--NGBE9E0A
+XN--NGBRX
+XN--NODE
+XN--NQV7F
+XN--NQV7FS00EMA
+XN--NYQY26A
+XN--O3CW4H
+XN--OGBPF8FL
+XN--OTU796D
+XN--P1ACF
+XN--P1AI
+XN--PGBS0DH
+XN--PSSY2U
+XN--Q7CE6A
+XN--Q9JYB4C
+XN--QCKA1PMC
+XN--QXA6A
+XN--QXAM
+XN--RHQV96G
+XN--ROVU88B
+XN--RVC1E0AM3E
+XN--S9BRJ9C
+XN--SES554G
+XN--T60B56A
+XN--TCKWE
+XN--TIQ49XQYJ
+XN--UNUP4Y
+XN--VERMGENSBERATER-CTB
+XN--VERMGENSBERATUNG-PWB
+XN--VHQUV
+XN--VUQ861B
+XN--W4R85EL8FHU5DNRA
+XN--W4RS40L
+XN--WGBH1C
+XN--WGBL6A
+XN--XHQ521B
+XN--XKC2AL3HYE2A
+XN--XKC2DL3A5EE0H
+XN--Y9A3AQ
+XN--YFRO4I67O
+XN--YGBI2AMMX
+XN--ZFR164B
+XXX
+XYZ
+YACHTS
+YAHOO
+YAMAXUN
+YANDEX
+YE
+YODOBASHI
+YOGA
+YOKOHAMA
+YOU
+YOUTUBE
+YT
+YUN
+ZA
+ZAPPOS
+ZARA
+ZERO
+ZIP
+ZM
+ZONE
+ZUERICH
+ZW

_service:tar_scm:hypothesis-6.79.0.tar.gz/src/hypothesis/version.py Added

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.flake8 Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.gitattributes Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.github Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.github/workflows Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.github/workflows/main.yml Deleted

@@ -1,200 +0,0 @@
-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:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        task:
-          - check-whole-repo-tests
-          - lint
-          - check-format
-          - check-coverage
-          - check-conjecture-coverage
-          - check-py37
-          - check-pypy37
-          - check-py38
-          - check-pypy38
-          - check-py39
-          - check-pypy39
-          - check-py310
-          # - check-py310-pyjion  # see notes in tox.ini
-          - check-py311
-          # - check-py312  # enable when alpha1 is released, ~Nov 2022
-          - check-quality
-          - lint-ruby
-          - check-ruby-tests
-          - check-rust-in-ruby-format
-          - lint-rust-in-ruby
-          - audit-rust-in-ruby
-          - check-conjecture-rust-format
-          - check-rust-tests
-          - audit-conjecture-rust
-          - lint-conjecture-rust
-          - check-nose
-          - check-pytest46
-          - check-pytest54
-          - check-pytest62
-          - check-django40
-          - check-django32
-          - check-django22
-          - check-pandas13
-          - check-pandas12
-          - check-pandas11
-          - check-pandas10
-          - check-pandas25
-      fail-fast: false
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: Set up Python 3.8
-      uses: actions/setup-python@v2
-      with:
-        python-version: "3.8"
-    - name: Restore cache
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.cache
-          ~/wheelhouse
-          ~/.local
-          vendor/bundle
-        key: deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}-${{ matrix.task }}
-        restore-keys: |
-          deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}
-          deps-${{ runner.os }}
-    - name: Install dotnet6 for Pyjion
-      if: ${{ endsWith(matrix.task, '-pyjion') }}
-      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: Run tests
-      run: TASK=${{ matrix.task }} ./build.sh
-    - name: Upload coverage data
-      uses: actions/upload-artifact@v2
-      # Invoke the magic `always` function to run on both success and failure.
-      if: ${{ always() && endsWith(matrix.task, '-coverage') }}
-      with:
-        name: ${{ matrix.task }}-data
-        path: |
-          hypothesis-python/.coverage*
-          !hypothesis-python/.coveragerc
-          hypothesis-python/branch-check
-
-  test-win:
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        include:
-          - task: check-py38-x64
-            python.architecture: "x64"
-          - task: check-py38-x86
-            python.architecture: "x86"
-      fail-fast: false
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: Set up Python 3.8
-      uses: actions/setup-python@v2
-      with:
-        python-version: "3.8"
-        architecture: ${{ matrix.python-architecture }}
-    - name: Restore cache
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~\appdata\local\pip\cache
-          vendor\bundle
-        key: deps-${{ runner.os }}-${{ matrix.python-architecture }}-${{ hashFiles('requirements/*.txt') }}-${{ matrix.task }}
-        restore-keys: |
-          deps-${{ runner.os }}-${{ matrix.python-architecture }}-${{ hashFiles('requirements/*.txt') }}
-          deps-${{ runner.os }}-${{ matrix.python-architecture }}
-    - name: Install dependencies
-      run: |
-        pip install --upgrade setuptools pip wheel
-        pip install -r requirements/coverage.txt
-        pip install hypothesis-python/all
-    - name: Run tests
-      run: python -m pytest --numprocesses auto hypothesis-python/tests/ --ignore=hypothesis-python/tests/quality/ --ignore=hypothesis-python/tests/ghostwriter/
-
-  test-osx:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        task:
-          - check-py38
-      fail-fast: false
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: Set up Python 3.8
-      uses: actions/setup-python@v2
-      with:
-        python-version: "3.8"
-    - name: Restore cache
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.cache
-          ~/Library/Caches/pip
-        key: deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}-${{ matrix.task }}
-    - name: Run tests
-      run: TASK=${{ matrix.task }} ./build.sh
-
-  deploy:
-    if: "github.event_name == 'push' && github.repository == 'HypothesisWorks/hypothesis'"
-    runs-on: ubuntu-latest
-    needs: test, test-win, test-osx
-    strategy:
-      matrix:
-        task:
-          - deploy
-      fail-fast: false
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-        token: ${{ secrets.GH_TOKEN }}
-    - name: Set up Python 3.8
-      uses: actions/setup-python@v2
-      with:
-        python-version: "3.8"
-    - name: Restore cache
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.cache
-          ~/wheelhouse
-          ~/.local
-          vendor/bundle
-        key: deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}-${{ matrix.task }}
-        restore-keys: |
-          deps-${{ runner.os }}-${{ hashFiles('requirements/*.txt') }}
-          deps-${{ runner.os }}
-    - name: Deploy package
-      env:
-        GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-        GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_TOKEN }}
-        CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-      run: TASK=${{ matrix.task }} ./build.sh

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.github/workflows/update-deps.yml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.gitignore Deleted

@@ -1,104 +0,0 @@
-# misc (editors, file systems, etc)
-
-*.swo
-*.swp
-.idea
-.vagrant
-.DS_Store
-.hypothesis
-.vscode/
-
-# generic build components
-
-.runtimes
-/hypothesis-python/branch-check
-/pythonpython3.*
-
-# python
-
-*.pyc
-*.pyo
-venv*
-.cache
-.pytest_cache
-.mypy_cache
-docs/_build
-*.egg-info
-_build
-.tox
-.coverage
-.pypirc
-htmlcov
-build
-dist
-.doctrees/
-.venv/
-
-# encrypted files
-secrets.tar
-secrets
-
-# Rust build targets
-target
-
-_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

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/.readthedocs.yml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/AUTHORS.rst Deleted

@@ -1,163 +0,0 @@
---------------------
-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).
-
-* `Aaron Meurer <https://github.com/asmeurer>`_
-* `Adam Johnson <https://github.com/adamchainz>`_
-* `Adam Sven Johnson <https://www.github.com/pkqk>`_
-* `Afrida Tabassum <https://github.com/oxfordhalfblood>`_ (afrida@gmail.com)
-* `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>`_
-* `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>`_
-* `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>`_
-* `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>`_
-* `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>`_
-* `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>`_
-* `Gary Donovan <https://www.github.com/garyd203>`_
-* `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>`_
-* `Grigorios Giannakopoulos <https://github.com/grigoriosgiann>`_
-* `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>`_
-* `Jack Massey <https://github.com/massey101>`_
-* `Jakub Nabaglo <https://github.com/nbgl>`_ (j@nab.gl)
-* `Jenny Rouleau <https://github.com/jennyrou>`_
-* `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)
-* `jmhsi <https://www.github.com/jmhsi>`_
-* `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>`_
-* `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 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)
-* `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>`_
-* `Nicholas Chammas <https://www.github.com/nchammas>`_
-* `Nick Anyos <https://www.github.com/NickAnyos>`_
-* `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>`_
-* `Richard Boulton <https://www.github.com/rboulton>`_ (richard@tartarus.org)
-* `Robert Howlett <https://github.com/jebob>`_
-* `Robert Knight <https://github.com/robertknight>`_ (robertknight@gmail.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 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)
-* `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 Grainge <https://www.github.com/tgrainge>`_
-* `Tim Martin <https://www.github.com/timmartin>`_ (tim@asymptotic.co.uk)
-* `Thomas Kluyver <https://www.github.com/takluyver>`_ (thomas@kluyver.me.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)
-* `Vincent Michel <https://www.github.com/vxgmichel>`_ (vxgmichel@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>`_
-* `Zac Hatfield-Dodds <https://www.github.com/Zac-HD>`_ (zac.hatfield.dodds@gmail.com)
-* `Zebulun Arendsee <https://www.github.com/arendsee>`_ (zbwrnz@gmail.com)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/CITATION.cff Deleted

@@ -1,65 +0,0 @@
-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"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/CODEOWNERS Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/CODE_OF_CONDUCT.rst Deleted

@@ -1,46 +0,0 @@
----------------
-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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/CONTRIBUTING.rst Deleted

@@ -1,243 +0,0 @@
-=============
-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 you 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 recent PRs for examples.
-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://virtualenv.pypa.io/en/latest/>`_. For example:
-
-.. code:: bash
-
-  virtualenv 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 OS X. 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-py37`` (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-py37``). 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 py37-custom 3.7.13 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.8:
-
-.. code-block::
-
-    ./build.sh tox py38-custom 3.8.13 -- 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>`__.
-
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/.ruby-version Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/CNAME Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/Dockerfile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/Gemfile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/Gemfile.lock Deleted

@@ -1,240 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (4.2.9)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    addressable (2.5.2)
-      public_suffix (>= 2.0.2, < 4.0)
-    coffee-script (2.4.1)
-      coffee-script-source
-      execjs
-    coffee-script-source (1.11.1)
-    colorator (1.1.0)
-    commonmarker (0.17.7.1)
-      ruby-enum (~> 0.5)
-    concurrent-ruby (1.0.5)
-    ethon (0.11.0)
-      ffi (>= 1.3.0)
-    execjs (2.7.0)
-    faraday (0.14.0)
-      multipart-post (>= 1.2, < 3)
-    ffi (1.9.21)
-    forwardable-extended (2.6.0)
-    gemoji (3.0.0)
-    github-pages (177)
-      activesupport (= 4.2.9)
-      github-pages-health-check (= 1.3.5)
-      jekyll (= 3.6.2)
-      jekyll-avatar (= 0.5.0)
-      jekyll-coffeescript (= 1.0.2)
-      jekyll-commonmark-ghpages (= 0.1.5)
-      jekyll-default-layout (= 0.1.4)
-      jekyll-feed (= 0.9.2)
-      jekyll-gist (= 1.4.1)
-      jekyll-github-metadata (= 2.9.3)
-      jekyll-mentions (= 1.2.0)
-      jekyll-optional-front-matter (= 0.3.0)
-      jekyll-paginate (= 1.1.0)
-      jekyll-readme-index (= 0.2.0)
-      jekyll-redirect-from (= 0.12.1)
-      jekyll-relative-links (= 0.5.2)
-      jekyll-remote-theme (= 0.2.3)
-      jekyll-sass-converter (= 1.5.0)
-      jekyll-seo-tag (= 2.3.0)
-      jekyll-sitemap (= 1.1.1)
-      jekyll-swiss (= 0.4.0)
-      jekyll-theme-architect (= 0.1.0)
-      jekyll-theme-cayman (= 0.1.0)
-      jekyll-theme-dinky (= 0.1.0)
-      jekyll-theme-hacker (= 0.1.0)
-      jekyll-theme-leap-day (= 0.1.0)
-      jekyll-theme-merlot (= 0.1.0)
-      jekyll-theme-midnight (= 0.1.0)
-      jekyll-theme-minimal (= 0.1.0)
-      jekyll-theme-modernist (= 0.1.0)
-      jekyll-theme-primer (= 0.5.2)
-      jekyll-theme-slate (= 0.1.0)
-      jekyll-theme-tactile (= 0.1.0)
-      jekyll-theme-time-machine (= 0.1.0)
-      jekyll-titles-from-headings (= 0.5.0)
-      jemoji (= 0.8.1)
-      kramdown (= 1.16.2)
-      liquid (= 4.0.0)
-      listen (= 3.0.6)
-      mercenary (~> 0.3)
-      minima (= 2.1.1)
-      nokogiri (>= 1.8.1, < 2.0)
-      rouge (= 2.2.1)
-      terminal-table (~> 1.4)
-    github-pages-health-check (1.3.5)
-      addressable (~> 2.3)
-      net-dns (~> 0.8)
-      octokit (~> 4.0)
-      public_suffix (~> 2.0)
-      typhoeus (~> 0.7)
-    html-pipeline (2.7.1)
-      activesupport (>= 2)
-      nokogiri (>= 1.4)
-    i18n (0.9.4)
-      concurrent-ruby (~> 1.0)
-    jekyll (3.6.2)
-      addressable (~> 2.4)
-      colorator (~> 1.0)
-      jekyll-sass-converter (~> 1.0)
-      jekyll-watch (~> 1.1)
-      kramdown (~> 1.14)
-      liquid (~> 4.0)
-      mercenary (~> 0.3.3)
-      pathutil (~> 0.9)
-      rouge (>= 1.7, < 3)
-      safe_yaml (~> 1.0)
-    jekyll-avatar (0.5.0)
-      jekyll (~> 3.0)
-    jekyll-coffeescript (1.0.2)
-      coffee-script (~> 2.2)
-      coffee-script-source (~> 1.11.1)
-    jekyll-commonmark (1.1.0)
-      commonmarker (~> 0.14)
-      jekyll (>= 3.0, < 4.0)
-    jekyll-commonmark-ghpages (0.1.5)
-      commonmarker (~> 0.17.6)
-      jekyll-commonmark (~> 1)
-      rouge (~> 2)
-    jekyll-default-layout (0.1.4)
-      jekyll (~> 3.0)
-    jekyll-feed (0.9.2)
-      jekyll (~> 3.3)
-    jekyll-gist (1.4.1)
-      octokit (~> 4.2)
-    jekyll-github-metadata (2.9.3)
-      jekyll (~> 3.1)
-      octokit (~> 4.0, != 4.4.0)
-    jekyll-mentions (1.2.0)
-      activesupport (~> 4.0)
-      html-pipeline (~> 2.3)
-      jekyll (~> 3.0)
-    jekyll-optional-front-matter (0.3.0)
-      jekyll (~> 3.0)
-    jekyll-paginate (1.1.0)
-    jekyll-readme-index (0.2.0)
-      jekyll (~> 3.0)
-    jekyll-redirect-from (0.12.1)
-      jekyll (~> 3.3)
-    jekyll-relative-links (0.5.2)
-      jekyll (~> 3.3)
-    jekyll-remote-theme (0.2.3)
-      jekyll (~> 3.5)
-      rubyzip (>= 1.2.1, < 3.0)
-      typhoeus (>= 0.7, < 2.0)
-    jekyll-sass-converter (1.5.0)
-      sass (~> 3.4)
-    jekyll-seo-tag (2.3.0)
-      jekyll (~> 3.3)
-    jekyll-sitemap (1.1.1)
-      jekyll (~> 3.3)
-    jekyll-swiss (0.4.0)
-    jekyll-theme-architect (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-cayman (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-dinky (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-hacker (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-leap-day (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-merlot (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-midnight (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-minimal (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-modernist (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-primer (0.5.2)
-      jekyll (~> 3.5)
-      jekyll-github-metadata (~> 2.9)
-      jekyll-seo-tag (~> 2.2)
-    jekyll-theme-slate (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-tactile (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-time-machine (0.1.0)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-titles-from-headings (0.5.0)
-      jekyll (~> 3.3)
-    jekyll-watch (1.5.1)
-      listen (~> 3.0)
-    jemoji (0.8.1)
-      activesupport (~> 4.0, >= 4.2.9)
-      gemoji (~> 3.0)
-      html-pipeline (~> 2.2)
-      jekyll (>= 3.0)
-    kramdown (1.16.2)
-    liquid (4.0.0)
-    listen (3.0.6)
-      rb-fsevent (>= 0.9.3)
-      rb-inotify (>= 0.9.7)
-    mercenary (0.3.6)
-    mini_portile2 (2.3.0)
-    minima (2.1.1)
-      jekyll (~> 3.3)
-    minitest (5.11.3)
-    multipart-post (2.0.0)
-    net-dns (0.8.0)
-    nokogiri (1.8.2)
-      mini_portile2 (~> 2.3.0)
-    octokit (4.8.0)
-      sawyer (~> 0.8.0, >= 0.5.3)
-    pathutil (0.16.1)
-      forwardable-extended (~> 2.6)
-    public_suffix (2.0.5)
-    rb-fsevent (0.10.2)
-    rb-inotify (0.9.10)
-      ffi (>= 0.5.0, < 2)
-    rouge (2.2.1)
-    ruby-enum (0.7.1)
-      i18n
-    rubyzip (1.2.1)
-    safe_yaml (1.0.4)
-    sass (3.5.5)
-      sass-listen (~> 4.0.0)
-    sass-listen (4.0.0)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
-    sawyer (0.8.1)
-      addressable (>= 2.3.5, < 2.6)
-      faraday (~> 0.8, < 1.0)
-    terminal-table (1.8.0)
-      unicode-display_width (~> 1.1, >= 1.1.1)
-    thread_safe (0.3.6)
-    typhoeus (0.8.0)
-      ethon (>= 0.8.0)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-    unicode-display_width (1.3.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  github-pages
-  jekyll-redirect-from
-
-BUNDLED WITH
-   1.16.0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/LICENSE.md Deleted

@@ -1,25 +0,0 @@
-Parts of this site are based on rifyll by Moinul Hossain. These parts (and
-only these parts) arereleased under the following license:
-
-
-The MIT License (MIT)
-
-Copyright (c) 2015 Moinul Hossain
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/Makefile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/README.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/Vagrantfile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_config.yml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_data Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_data/authors.yml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_data/menu.yml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_includes Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_includes/blog_header.html Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_includes/footer.html Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_includes/head.html Deleted

@@ -1,21 +0,0 @@
-<head>
-  <meta charset="utf-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="description"
-    content="{{page.title}} {{page.excerpt | strip_html}} {{ site.description }}">
-  <title>{% if page.title %} {{ page.title }} - {{ site.title }} {% else %} {{ site.title }} {% endif %}</title>
-
-  
-  <link media="all" href="https://netdna.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css" rel="stylesheet">
-  <link media="all" href="https://netdna.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">
-  <link media="all" rel="stylesheet" href="{{ "/assets/css/site.css" | prepend: site.baseurl }}">
-  <link media="all" rel="stylesheet" href="{{ "/assets/css/jekyll-github.css" | prepend: site.baseurl }}">
-
-  <link rel="canonical" href="https://hypothesis.works{{page.url}}">
-
-  {% if page.has_feed %}
-    <link href="{{page.url}}feed/" type="application/atom+xml" rel="alternate" title="Atom feed" />
-  {% endif %}
-
-</head>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_includes/header.html Deleted

@@ -1,30 +0,0 @@
-<header>
-  <nav class="navbar navbar-default navbar-fixed-top" role="navigation">
-    <div class="container-fluid">
-      <div class="navbar-header">
-        <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
-          <span class="sr-only">Toggle navigation</span>
-          <span class="icon-bar"></span>
-          <span class="icon-bar"></span>
-          <span class="icon-bar"></span>
-        </button>
-      </div>
-
-      <div class="collapse navbar-collapse" id="navbar">
-
-        <ul id="main-menu" class="nav navbar-nav navbar-right">
-
-          {% for menuItem in site.data.menu.mainmenu %}
-            <li><a href="{{ menuItem1.url | prepend: site.baseurl }}">
-              <i class="fa {{menuItem1.icon_class}}"></i> {{menuItem1.text}}</a>
-            </li>
-          {% endfor %}
-
-        </ul>
-      </div>
-      
-    </div>
-    
-  </nav>
-
-</header>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_layouts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_layouts/blog_feed.xml Deleted

@@ -1,53 +0,0 @@
----
-layout: null
----
-<?xml version="1.0" encoding="UTF-8"?>
-
-{% if page.tag %}
-
-{% assign posts = site.tagspage.tag %}
-
-{% else %}
-
-{% assign posts = site.posts %}
-
-{% endif %}
-
-
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
-  <channel>
-    {% if page.tag %}
-      <title>{{ site.title | xml_escape }} articles tagged "{{page.tag}}"</title>
-      <link>{{ site.url }}/articles/{{page.tag}}/</link>
-    {% else %}
-      <title>{{ site.title | xml_escape }} articles</title>
-      <link>{{ site.url }}/articles/</link>
-    {% endif %}
-    <description>{{ site.description | xml_escape }}</description>
-
-    {% if page.tag %}
-      <atom:link href="http://hypothesis.works/articles/{{page.tag}}/feed/" rel="self" type="application/rss+xml" />
-    {% else %}
-      <atom:link href="http://hypothesis.works/articles/feed/" rel="self" type="application/rss+xml" />
-    {% endif %}
-    <pubDate>{{ site.time | date_to_rfc822 }}</pubDate>
-    <lastBuildDate>{{ site.time | date_to_rfc822 }}</lastBuildDate>
-    {% for post in posts limit:10 %}
-      <item>
-        <title>{{ post.title | xml_escape }}</title>
-        <description>{{ post.excerpt | xml_escape }}
-          &lt;a href="{{ post.url | prepend: site.baseurl | prepend: site.url }}"&gt;Read more...&lt;/a&gt;
-        </description>
-        <pubDate>{{ post.date | date_to_rfc822 }}</pubDate>
-        <link>{{ post.url | prepend: site.baseurl | prepend: site.url }}</link>
-        <guid isPermaLink="true">{{ post.url | prepend: site.baseurl | prepend: site.url }}</guid>
-        {% for tag in post.tags %}
-        <category>{{ tag | xml_escape }}</category>
-        {% endfor %}
-        {% for cat in post.categories %}
-        <category>{{ cat | xml_escape }}</category>
-        {% endfor %}
-      </item>
-    {% endfor %}
-  </channel>
-</rss>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_layouts/blog_listing.html Deleted

@@ -1,75 +0,0 @@
----
-layout: default
-has_feed: true
----
-
-{% if page.tag %}
-
-{% assign posts = site.tagspage.tag %}
-
-{% else %}
-
-{% assign posts = site.posts %}
-
-{% endif %}
-
-<div class="container article-listing">
-  <div class="row">
-    <div class="col-xs-12 col-sm-12 col-md-12 col-lg-12">
-    <div class="panel panel-default">
-      <div class="panel-heading">
-        {% if page.tag %}
-          <span class="label label-tag">{{page.tag}}</span>
-        {% else %}
-          All our articles
-        {% endif %}
-      </div>
-      <div class="panel-body">
-          {{content}}
-      </div>
-      <div class="panel-footer rss-plug">
-        <a href="{{page.url}}feed/">
-        {% if page.tag %}
-          Subscribe to articles tagged &ldquo;{{page.tag}}&rdquo; via RSS
-        {% else %}
-          Subscribe to all articles from us via RSS
-        {% endif %}
-
-        <i class="fa fa-rss" aria-hidden="true"></i>
-        </a>
-      </div>
-    </div>
-
-      {% for post in posts %}
-        <div class="blog-short">
-          <h3><a href="{{post.url | prepend: site.baseurl}}">{{post.title}}</a></h3>
-  		<div>
-  		  <small>
-  			<i class="fa fa-calendar"></i>
-  			<time>
-          {{ post.date | date:'%A, %B %d, %Y'}}
-  			</time>
-  		  </small>
-           </div>
-  		    <div class="margin10">
-            <small>
-              <i class="fa fa-tag"></i>
-              {% assign sorted_tags = post.tags |  sort %}
-              {% for tag in sorted_tags %}
-                <span class="label label-tag"><a href="/articles/{{tag}}/">{{tag}}</a></span>
-              {% endfor %}
-            </small>
-          </div>
-          {% if post.thumbnail %}
-            <div class="imgcontainer col-xs-12 col-sm-4 col-md-3 col-lg-3">
-              <img src="{{post.thumbnail}}"
-              alt="{{post.title}}"  class="pull-left img-responsive thumb img-thumbnail" />
-            </div>
-          {% endif %}
-          <article class="excerpt">{{post.excerpt}}</article>
-          <a class="pull-right marginBottom10" href="{{post.url | prepend: site.baseurl }}">Read More</a>
-        </div>
-      {% endfor %}
-    </div>
-  </div>
-</div>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_layouts/default.html Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_layouts/page.html Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_layouts/post.html Deleted

@@ -1,41 +0,0 @@
----
-layout: default
----
-<div class="container">
-  <div class="row">
-    <div class="col-xs-12 col-sm-12 col-md-12 col-lg-12">
-      <div class="page">
-
-        <header class="page-header">
-          <h3 class="page-title"><a href="{{page.url|prepend: site.baseurl}}">{{ page.title }}</a></h3>
-          <div class="post-metadata">
-
-            {% assign author = site.data.authorspage.author %}
-
-            <div class="author">
-              <a href="{{author.url}}">{{ author.name }}</a>
-            </div>
-
-            <div> <i class="fa fa-calendar"></i>
-              <time>
-                {{ page.date | date:'%A, %B %d, %Y'}}
-              </time>
-            </div>
-
-            <div> <i class="fa fa-tag"></i>
-              {% assign sorted_tags = page.tags |  sort %}
-              {% for tag in sorted_tags %}
-                <span class="label label-tag"><a href=/articles/{{tag}}/>{{tag}}</a></span>
-              {% endfor %}
-            </div>
-          </div>
-
-        </header>
-
-        <article class="page-content">
-          {{ content }}
-        </article>
-      </div>
-    </div>
-  </div>
-</div>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-15-economics-of-software-correctness.md Deleted

@@ -1,70 +0,0 @@
----
-layout: post
-tags: writing-good-software non-technical
-date: 2016-04-15 15:00
-title: The Economics of Software Correctness
-published: true
-author: drmaciver
----
-
-You have probably never written a significant piece of correct software.
-
-That's not a value judgement. It's certainly not a criticism of your competence. I can say with almost complete confidence that every non-trivial piece of software I have written contains at least one bug. You *might* have written small libraries that are essentially bug free, but the chance that you have written a non-trivial bug free program is tantamount to zero.
-
-I don't even mean this in some pedantic academic sense. I'm talking about behaviour where if someone spotted it and pointed it out to you you would probably admit that it's a bug. It might even be a bug that you cared about.
-
-Why is this?
-
-
-
-Well, lets start with why it's not: It's not because we don't know how to write correct software. We've known how to write software that is more or less correct (or at least vastly closer to correct than the norm) for a while now. If you <a href="http://www.fastcompany.com/28121/they-write-right-stuff">look at the NASA development process</a> they're pretty much doing it.
-
-Also, if you look at the NASA development process you will probably conclude that we can't do that. It's orders of magnitude more work than we ever put into software development. It's process heavy, laborious, and does not adapt well to changing requirements or tight deadlines.
-
-The problem is not that we don't know how to write correct software. The problem is that correct software is too expensive.
-
-And "too expensive" doesn't mean "It will knock 10% off our profit margins, we couldn't possibly do that". It means "if our software cost this much to make, nobody would be willing to pay a price we could afford to sell it at". It may also mean "If our software took this long to make then someone else will release a competing product two years earlier than us, everyone will use that, and when ours comes along nobody will be interested in using it".
-
-("sell" and "release" here can mean a variety of things. It can mean that terribly unfashionable behaviour where people give you money and you give them a license to your software. It can mean subscriptions. It can mean ad space. It can even mean paid work. I'm just going to keep saying sell and release).
-
-NASA can do it because when they introduce a software bug they potentially lose some combination of billions of dollars, years of work and many lives. When that's the cost of a bug, spending that much time and money on correctness seems like a great deal. Safety critical industries like medical technology and aviation can do it for similar reasons
-(buggy medical technology kills people(https://en.wikipedia.org/wiki/Therac-25) and you don't want your engines power cycling themselves midflight(http://www.engadget.com/2015/05/01/boeing-787-dreamliner-software-bug/)).
-
-The rest of us aren't writing safety critical software, and as a result people aren't willing to pay for that level of correctness.
-
-So the result is that we write software with bugs in it, and we adopt a much cheaper software testing methodology: We ship it and see what happens. Inevitably some user will find a bug in our software. Probably many users will find many bugs in our software.
-
-And this means that we're turning our users into our QA department.
-
-Which, to be clear, is fine. Users have stated the price that they're willing to pay, and that price does not include correctness, so they're getting software that is not correct. I think we all feel bad about shipping buggy software, so let me emphasise this here: Buggy software is not a moral failing. The option to ship correct software is simply not on the table, so why on earth should we feel bad about not taking it?
-
-But in another sense, turning our users into a QA department is a terrible idea.
-
-Why? Because users are not actually good at QA. QA is a complicated professional skill which very few people can do well. Even skilled developers often don't know <a href="http://www.drmaciver.com/2013/09/how-to-submit-a-decent-bug-report/">how to write a good bug report</a>. How can we possibly expect our users to?
-
-The result is long and frustrating conversations with users in which you try to determine whether what they're seeing is actually a bug or a misunderstanding (although treating misunderstandings as bugs is a good idea too), trying to figure out what the actual bug is, etc. It's a time consuming process which ends up annoying the user and taking up a lot of expensive time from developers and customer support.
-
-And that's of course if the users tell you at all. Some users will just try your software, decide it doesn't work, and go away without ever saying anything to you. This is particularly bad for software where you can't easily tell who is using it.
-
-Also, some of our users are actually adversaries. They're not only not going to tell you about bugs they find, they're going to actively try to keep you from finding out because they're using it to steal money and/or data from you.
-
-So <em>this</em> is the problem with shipping buggy software: Bugs found by users are more expensive than bugs found before a user sees them. Bugs found by users may result in lost users, lost time and theft. These all hurt the bottom line.
-
-At the same time, your users are a lot more effective at finding bugs than you are due to sheer numbers if nothing else, and as we've established it's basically impossible to ship fully correct software, so we end up choosing some level of acceptable defect rate in the middle. This is generally determined by the point at which it is more expensive to find the next bug yourself than it is to let your users find it. Any higher or lower defect rate and you could just adjust your development process and make more money, and companies like making money so if they're competently run will generally do the things that cause them to do so.
-
-You can, and should, cheaper to find bugs is to reduce the cost of when your users do find them(http://itamarst.org/softwaretesting/book/realworld.html), but it's always going to be expensive.
-
-This means that there are only two viable ways to improve software quality:
-
-* Make users angrier about bugs
-* Make it cheaper to find bugs
-
-I think making users angrier about bugs is a good idea and I wish people cared more about software quality, but as a business plan it's a bit of a rubbish one. It creates higher quality software by making it more expensive to write software.
-
-Making it cheaper to find bugs though... that's a good one, because it increases the quality of the software by increasing your profit margins. Literally everyone wins: The developers win, the users win, the business's owners win.
-
-And so this is the lever we get to pull to change the world: If you want better software, make or find tools that reduce the effort of finding bugs.
-
-Obviously I think Hypothesis is an example of this, but it's neither the only one nor the only one you need. Better monitoring is another. Code review processes. Static analysis. Improved communication. There are many more.
-
-But one thing that *won't* improve your ability to find bugs is feeling bad about yourself and trying really hard to write correct software then feeling guilty when you fail. This seems to be the current standard, and it's deeply counter-productive. You can't fix systemic issues with individual action, and the only way to ship better software is to change the economics to make it viable to do so.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-15-getting-started-with-hypothesis.md Deleted

@@ -1,100 +0,0 @@
----
-layout: post
-tags: intro python technical properties
-date: 2016-04-15 13:00
-title: Getting started with Hypothesis
-published: true
-author: drmaciver
----
-
-Hypothesis will speed up your testing process and improve your software quality,
-but when first starting out people often struggle to figure out exactly how to use it.
-
-Until you're used to thinking in this style of testing, it's not always obvious what the invariants of your
-code actually *are*, and people get stuck trying to come up with interesting ones to test.
-
-Fortunately, there's a simple invariant which every piece of software should satisfy, and which can be
-remarkably powerful as a way to uncover surprisingly deep bugs in your software.
-
-
-
-That invariant is simple: The software shouldn't crash. Or sometimes, it should only crash in defined
-ways.
-
-There is then a standard test you can write for most of your code that asserts this
-invariant.
-
-It consists of two steps:
-
-1. Pick a function in your code base that you want to be better tested.
-2. Call it with random data.
-
-This style of testing is usually called *fuzzing*.
-
-This will possibly require you to figure out how to generate your domain objects. Hypothesis
-has a pretty extensive library({{site.url}}{% post_url 2016-05-11-generating-the-right-data %})
-of tools (called 'strategies' in Hypothesis terminology) for generating
-custom types but if you can, try to start somewhere where the types you
-need aren’t *too* complicated to generate.
-
-Chances are actually pretty good that you’ll find something wrong this way if you pick a
-sufficiently interesting entry point. For example, there’s a long track record of people trying to
-test interesting properties with their text handling and getting unicode errors when text()
-gives them something that their code didn’t know how to handle.
-
-You’ll probably get exceptions here you don’t care about. e.g. some arguments to functions may not be valid.
-Set up your test to ignore those.
-
-So at this point you’ll have something like this:
-
-```python
-from hypothesis import given, reject
-from hypothesis.strategies import integers, text
-
-
-@given(integers(), text())
-def test_some_stuff(x, y):
-    try:
-        my_function(x, y)
-    except SomeExpectedException:
-        reject()
-```
-
-In this example we generate two values - one integer, one text - and
-pass them to your test function. Hypothesis will repeatedly call the
-test function with values drawn from these strategies, trying to find
-one that produces an unexpected exception.
-
-When an exception we know is possible happens (e.g. a ValueError because
-some argument was out of range) we call reject. This discards the
-example, and Hypothesis won't count it towards the 'budget' of examples
-it is allowed to run.
-
-This is already a pretty good starting point and does have a decent
-tendency to flush out bugs. You’ll often find cases where you forgot some
-boundary condition and your code misbehaves as a result. But there’s
-still plenty of room to improve.
-
-There are now two directions you can go in from here:
-
-1. Try to assert some things about the function’s result. Anything at all. What type is it?
-   Can it be None? Does it have any relation at all to the input values that you can check?
-   It doesn’t have to be clever - even very trivial properties are useful here.
-2. Start making your code more defensive.
-
-The second part is probably the most productive one.
-
-The goal is to turn faulty assumptions in your code into crashes instead of silent corruption of your application state. You can do this in a couple ways:
-
-1. Add argument checking to your functions (Hypothesis uses a dedicated InvalidArgumentException for this case, but you can raise whatever errors you find appropriate).
-2. Add a whole bunch of assertions into your code itself.
-Even when it’s hard to reason about formal properties of your code, it’s usually relatively easy to add local properties, and assertions are a great way to encode them. John Regehr has a good post on this subject(http://blog.regehr.org/archives/1091) if you want to know more about it.
-
-This approach will make your code more robust even if you don’t find any bugs in it during testing (and you’ll probably find bugs in it during testing), and it gives you a nice easy route into property based testing by letting you focus on only one half of the problem at a time.
-
-Once you think you've got the hang of this, a good next step is to start looking for 
-places with complex optimizations({{site.url}}{% post_url 2016-04-29-testing-performance-optimizations %}) or
-Encode/Decode pairs({{site.url}}{% post_url 2016-04-16-encode-decode-invariant %}) in
-your code, as they're a fairly easy properties to test and are both rich sources of bugs.
-
-And, of course, if you’re still having trouble getting started with Hypothesis, the other easy way is to persuade your company to hire us for a training course(/training/). Drop us an email at training@hypothesis.works(mailto:training@hypothesis.works)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-16-anatomy-of-a-test.md Deleted

@@ -1,203 +0,0 @@
----
-layout: post
-tags: python details technical
-date: 2016-04-16 06:00
-title: Anatomy of a Hypothesis Based Test
-published: true
-author: drmaciver
----
-
-What happens when you run a test using Hypothesis? This article will help you understand.
-
-
-
-The Python version of Hypothesis uses *decorators* to transform a test function that
-doesn't use Hypothesis into one that does.
-
-Consider the following example using py.test(http://pytest.org/latest/) style testing:
-
-```python
-from hypothesis import given
-from hypothesis.strategies import floats
-
-
-@given(floats(), floats())
-def test_floats_are_commutative(x, y):
-    assert x + y == y + x
-```
-
-The inner function takes two arguments, but the wrapping function defined by the @given
-decorator takes none and may be invoked as a normal test:
-
-```bash
-python -m pytest test_floats.py
-```
-
-And we see the following output from py.test:
-
-```
-    @given(floats(), floats())
-    def test_floats_are_commutative(x, y):
->       assert x + y == y + x
-E       assert (0.0 + nan) == (nan + 0.0)
-
-test_floats.py:7: AssertionError
-
-Falsifying example: test_floats_are_commutative(x=0.0, y=nan)
-```
-
-The test fails, because nan(https://en.wikipedia.org/wiki/NaN) is a valid floating
-point number which is not equal to itself, and adding anything to nan yields nan.
-
-When we ran this, Hypothesis invoked our test function with a number of randomly chosen
-values for the arguments until it found one that failed. It then attempted to *shrink*
-those values to produce a simpler one that would also fail.
-
-If we wanted to see what it actually called our function with we can set the *verbosity
-level*. This can either be done in code with settings, or by specifying an environment
-variable:
-
-
-```python
-from hypothesis import Verbosity, given, settings
-from hypothesis.strategies import floats
-
-
-@settings(verbosity=Verbosity.verbose)
-@given(floats(), floats())
-def test_floats_are_commutative(x, y):
-    assert x + y == y + x
-```
-
-```bash
-HYPOTHESIS_VERBOSITY_LEVEL=verbose python -m pytest test_floats.py
-```
-
-Any verbosity values explicitly passed in settings will override whatever is set at
-the environment level - the latter just provides a default.
-
-Whichever one we choose, running it we'll see output something like the following:
-
-```
-
-Trying example: test_floats_are_commutative(x=-0.05851890381391768, y=-6.060045836901702e+300)
-Trying example: test_floats_are_commutative(x=-0.06323690311413645, y=2.0324087421708266e-308)
-Trying example: test_floats_are_commutative(x=-0.05738038380011458, y=-1.5993500302384265e-308)
-Trying example: test_floats_are_commutative(x=-0.06598754758697359, y=-1.1412902232349034e-308)
-Trying example: test_floats_are_commutative(x=-0.06472919559855002, y=1.7429441378277974e+35)
-Trying example: test_floats_are_commutative(x=-0.06537123121982172, y=-8.136220566134233e-156)
-Trying example: test_floats_are_commutative(x=-0.06016703321602157, y=1.9718842567475311e-215)
-Trying example: test_floats_are_commutative(x=-0.055257588875432875, y=1.578407827448836e-308)
-Trying example: test_floats_are_commutative(x=-0.06313031758042666, y=1.6749023021600297e-175)
-Trying example: test_floats_are_commutative(x=-0.05886897920547916, y=1.213699633272585e+292)
-Trying example: test_floats_are_commutative(x=-12.0, y=-0.0)
-Trying example: test_floats_are_commutative(x=4.0, y=1.7976931348623157e+308)
-Trying example: test_floats_are_commutative(x=-9.0, y=0.0)
-Trying example: test_floats_are_commutative(x=-38.0, y=1.7976931348623157e+308)
-Trying example: test_floats_are_commutative(x=-24.0, y=1.5686642754811104e+289)
-Trying example: test_floats_are_commutative(x=-10.0, y=nan)
-Traceback (most recent call last):
-  ...
-AssertionError: assert (-10.0 + nan) == (nan + -10.0)
-
-Trying example: test_floats_are_commutative(x=10.0, y=nan)
-Traceback (most recent call last):
-  ...
-AssertionError: assert (10.0 + nan) == (nan + 10.0)
-
-Trying example: test_floats_are_commutative(x=0.0, y=nan)
-Traceback (most recent call last):
-  ...
-AssertionError: assert (0.0 + nan) == (nan + 0.0)
-
-Trying example: test_floats_are_commutative(x=0.0, y=0.0)
-Trying example: test_floats_are_commutative(x=0.0, y=inf)
-Trying example: test_floats_are_commutative(x=0.0, y=-inf)
-Falsifying example: test_floats_are_commutative(x=0.0, y=nan)
-```
-
-Notice how the first failing example we got was -10.0, nan but Hypothesis was able
-to turn that into 0.0, nan. That's the shrinking at work. For a simple case like this it
-doesn't matter so much, but as your examples get complicated it's essential for making
-Hypothesis's output easy to understand.
-
-
-```
-Trying example: test_floats_are_commutative(x=nan, y=0.0)
-Traceback (most recent call last):
-  ...
-AssertionError: assert (nan + 0.0) == (0.0 + nan)
-
-Trying example: test_floats_are_commutative(x=0.0, y=0.0)
-Trying example: test_floats_are_commutative(x=inf, y=0.0)
-Trying example: test_floats_are_commutative(x=-inf, y=0.0)
-Falsifying example: test_floats_are_commutative(x=nan, y=0.0)
-```
-
-Now lets see what happens when we rerun the test:
-
-
-```
-Trying example: test_floats_are_commutative(x=0.0, y=nan)
-Traceback (most recent call last):
-  ...
-AssertionError: assert (0.0 + nan) == (nan + 0.0)
-
-Trying example: test_floats_are_commutative(x=0.0, y=0.0)
-Trying example: test_floats_are_commutative(x=0.0, y=inf)
-Trying example: test_floats_are_commutative(x=0.0, y=-inf)
-Falsifying example: test_floats_are_commutative(x=0.0, y=nan)
-```
-
-Notice how the first example it tried was the failing example we had last time? That's
-not an accident. Hypothesis has an example database where it saves failing examples.
-When it starts up it looks for any examples it has seen failing previously and tries
-them first before any random generation occurs. If any of them fail, we take that
-failure as our starting point and move straight to the shrinking phase without any
-generation.
-
-The database format is safe to check in to version control if you like and will merge
-changes correctly out of the box, but it's often clearer to specify the examples you
-want to run every time in the source code as follows:
-
-
-```python
-from hypothesis import example, given
-from hypothesis.strategies import floats
-
-
-@example(0.0, float("nan"))
-@given(floats(), floats())
-def test_floats_are_commutative(x, y):
-    assert x + y == y + x
-```
-
-```
-Falsifying example: test_floats_are_commutative(x=0.0, y=nan)
-```
-
-If you run this in verbose mode it will print out
-Falsifying example: test\_floats\_are\_commutative(x=0.0, y=nan) immediately and
-not try to do any shrinks. Values you pass in via example will not be shrunk.
-This is partly a technical limitation but it can often be useful as well.
-
-Explicitly provided examples are run before any generated examples.
-
-So, to recap and elaborate, when you use a test written using Hypothesis:
-
-1. Your test runner sees the decorated test as if it were a perfectly normal test function
-   and invokes it.
-2. Hypothesis calls your test function with each explicitly provided @example. If one
-   of these fails it stops immediately and bubbles up the exception for the test runner to handle.
-3. Hypothesis reads examples out of its database of previously failing examples. If any of them
-   fail, it stops there and proceeds to the shrinking step with that example. Otherwise it continues
-   to the generation step.
-4. Hypothesis tries generating a number of examples. If any of these raises an exception, it stops
-   there and proceeds to the shrinking step. If none of them raise an exception, it silently returns
-   and the test passes.
-5. Hypothesis takes the previously failing example it's seen and tries to produce a "Simpler" version
-   of it. Once it has found the simplest it possibly can, it saves that in the example database (in
-   actual fact it saves every failing example in the example database as it shrinks, but the reasons
-   why aren't important right now).
-6. Hypothesis takes the simplest failing example and replays it, finally letting the test bubble up to
-   the test runner.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-16-encode-decode-invariant.md Deleted

@@ -1,156 +0,0 @@
----
-layout: post
-tags: python intro technical properties
-date: 2016-04-16 06:00
-title: The Encode/Decode invariant
-published: true
-author: drmaciver
----
-
-One of the simplest types of invariant to find once you move past
-just fuzzing your code({{site.url}}{% post_url 2016-04-15-getting-started-with-hypothesis %}) is asserting that two
-different operations should produce the same result, and one of the simplest instances of
-*that* is looking for encode/decode pairs. That is, you have some function that takes a
-value and encodes it as another value, and another that is supposed to reverse the process.
-
-This is ripe for testing with Hypothesis because it has a natural completely defined
-specification: Encoding and then decoding should be exactly the same as doing nothing.
-
-Lets look at a concrete example.
-
-
-
-The following code is a lightly reformatted version of
-an implementation of Run Length Encoding(https://en.wikipedia.org/wiki/Run-length_encoding)
-taken from Rosetta Code(http://rosettacode.org/wiki/Run-length_encoding).
-
-```python
-def encode(input_string):
-    count = 1
-    prev = ""
-    lst = 
-    for character in input_string:
-        if character != prev:
-            if prev:
-                entry = (prev, count)
-                lst.append(entry)
-            count = 1
-            prev = character
-        else:
-            count += 1
-    else:
-        entry = (character, count)
-        lst.append(entry)
-    return lst
-
-
-def decode(lst):
-    q = ""
-    for character, count in lst:
-        q += character * count
-    return q
-```
-
-We can test this using Hypothesis and py.test as follows:
-
-
-```python
-from hypothesis import given
-from hypothesis.strategies import text
-
-
-@given(text())
-def test_decode_inverts_encode(s):
-    assert decode(encode(s)) == s
-```
-
-This asserts what we described above: If we encode a string as run length encoded and then
-decode it, we get back to where we started.
-
-This test finds a bug, not through the actual invariant. Instead it finds one through pure
-fuzzing: The code does not correctly handle the empty string.
-
-
-```
-Falsifying example: test_decode_inverts_encode(s='')
-
-UnboundLocalError: local variable 'character' referenced before assignment
-```
-
-One of the nice features of testing invariants is that they incorporate the fuzzing you
-could be doing anyway, more or less for free, so even trivial invariants can often
-find interesting problems.
-
-We can fix this bug by adding a guard to the encode function:
-
-```python
-if not input_string:
-    return 
-```
-
-The test now passes, which isn't very interesting, so lets break the code. We'll delete
-a line from our implementation of encode which resets the count when the character changes:
-
-
-```python
-def encode(input_string):
-    if not input_string:
-        return 
-    count = 1
-    prev = ""
-    lst = 
-    for character in input_string:
-        if character != prev:
-            if prev:
-                entry = (prev, count)
-                lst.append(entry)
-            # count = 1  # Missing reset operation
-            prev = character
-        else:
-            count += 1
-    else:
-        entry = (character, count)
-        lst.append(entry)
-    return lst
-```
-
-Now the test fails:
-
-```
-    @given(text())
-    def test_decode_inverts_encode(s):
->       assert decode(encode(s)) == s
-E       assert '1100' == '110'
-E         - 1100
-E         ?    -
-E         + 110
-
-test_encoding.py:35: AssertionError
------------------------------------- Hypothesis ------------------------------------ 
-Falsifying example: test_decode_inverts_encode(s='110')
-
-```
-
-Not resetting the count did indeed produce unintended data that doesn't translate back
-to the original thing. Hypothesis has given us the shortest example that could trigger
-it - two identical characters followed by one different one. It's not *quite* the
-simplest example according to Hypothesis's preferred ordering - that would be '001' -
-but it's still simple enough to be quite legible, which helps to rapidly diagnose
-the problem when you see it in real code.
-
-Encode/decode loops like this are *very* common, because you will frequently want to
-serialize your domain objects to other representations - into forms, into APIs, into
-the database, and these are things that are so integral to your applications that it's
-worth getting all the edge cases right.
-
-Other examples of this:
-
-* This talk by Matt Bacchman(https://speakerdeck.com/bachmann1234/property-based-testing-hypothesis)
-  in which he discovers an eccentricity of formats for dates.
-* Mercurial bugs 4927(https://bz.mercurial-scm.org/show_bug.cgi?id=4927) and 5031(https://bz.mercurial-scm.org/show_bug.cgi?id=5031)
-  were found by applying this sort of testing to their internal UTF8b encoding functions.
-* This test(https://github.com/The-Compiler/qutebrowser/blob/24a71e5c2ebbffd9021694f32fa9ec51d0046d5a/tests/unit/browser/test_webelem.py#L652).
-  Has caught three bugs in Qutebrowser's JavaScript escaping (1(https://github.com/The-Compiler/qutebrowser/commit/73e9fd11188ce4dddd7626e39d691e0df649e87c),
-  2(https://github.com/The-Compiler/qutebrowser/commit/93d27cbb5f49085dd5a7f5e05f2cc45cc84f94a4),
-  3(https://github.com/The-Compiler/qutebrowser/commit/24a71e5c2ebbffd9021694f32fa9ec51d0046d5a)), which could have caused data loss if a user had run
-  into them.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-16-quickcheck-in-every-language.html Deleted

@@ -1,212 +0,0 @@
----
-layout: post
-tags: alternatives technical
-date: 2016-04-16 15:00
-title: QuickCheck in Every Language
-published: true
-author: drmaciver
----
-
-<p>
-There are a lot of ports of <a href="https://en.wikipedia.org/wiki/QuickCheck">QuickCheck</a>,
-the original property based testing library, to a variety of different languages.
-</p>
-
-<p>
-Some of them are good. Some of them are <em>very</em> good. Some of them are OK. Many are not.
-</p>
-
-<p>
-I thought it would be worth keeping track of which are which, so I've put together a list.
-</p>
-
-
-
-<p>In order to make it onto this list, an implementation has to meet the following criteria:</p>
-
-<ol>
-	<li>Must support random generation of data to a test function. e.g. testing systems based on
-      <a href="https://hackage.haskell.org/package/smallcheck">smallcheck</a> while interesting and related
-      don't fit on this list.
-  </li>
-	<li>It must be fairly straightforward to generate your own custom types.</li>
-	<li>It must support shrinking of falsifying examples.</li>
-	<li>It must be under active development, in the sense that bugs in it will get fixed.</li>
-	<li>Must be under an OSI approved license.</li>
-</ol>
-<p>
-In this I've tried to to collect a list of what I think the best ones are for any given language.
-I haven't used all of these, but I've used some and read and talked to people about the others.
-</p>
-
-<h2>Uncontested Winners by Language</h2>
-
-<p>For many languages there is a clear winner that you should just use. Here are the ones I've
-found and what I think of them.</p>
-
-
-<table class="table">
-
-<thead>
-<tr>
-<th>Language</th>
-<th>Library</th>
-<th>Our rating</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>C</td>
-<td><a href="https://github.com/silentbicycle/theft">theft</a></td>
-<td>Good but does not come with a library of data generators.</td>
-</tr>
-<tr>
-<td>C++</td>
-<td><a href="https://github.com/grogers0/CppQuickCheck">CppQuickCheck</a></td>
-<td>Unsure</td>
-</tr>
-<tr>
-<td>Clojure</td>
-<td><a href="https://github.com/clojure/test.check">test.check</a></td>
-<td>Very good</td>
-</tr>
-<tr>
-<td>Coq</td>
-<td><a href=https://github.com/QuickChick/QuickChick>QuickChick</a></td>
-<td>Unsure</td>
-</tr>
-<tr>
-<td>F#</td>
-<td><a href="https://github.com/fscheck/FsCheck">FsCheck</a></td>
-<td>Very Good</td>
-</tr>
-<tr>
-<td>Go</td>
-<td><a href="https://github.com/leanovate/gopter">gopter</a></td>
-<td>Unsure but looks promising.</td>
-</tr>
-<tr>
-<td>Haskell</td>
-<td><a href="https://hackage.haskell.org/package/hedgehog">Hedgehog</a></td>
-<td>Comparatively new, but looks solid. See below.</td>
-</tr>
-<tr>
-<td>Java</td>
-<td><a href="https://github.com/NCR-CoDE/QuickTheories">QuickTheories</a></td>
-<td>Unsure. Extremely new but looks promising.</td>
-</tr>
-<tr>
-<td>JavaScript</td>
-<td><a href="https://github.com/jsverify/jsverify">jsverify</a></td>
-<td>Good</td>
-</tr>
-<tr>
-<td>PHP</td>
-<td><a href="https://github.com/giorgiosironi/eris">Eris</a></td>
-<td>Unsure. Looks promising.</td>
-</tr>
-<tr>
-<td>Python</td>
-<td><a href="http://hypothesis.works">Hypothesis</a></td>
-<td>I may be a bit biased on this one, but it's also unambiguously true.</td>
-</tr>
-<tr>
-<td>Ruby</td>
-<td><a href="https://github.com/abargnesi/rantly">Rantly</a></td>
-<td>Unsure. We're not convinced, but the alternatives are definitely worse.</td>
-</tr>
-<tr>
-<td>Rust</td>
-<td><a href="https://github.com/BurntSushi/quickcheck">Quickcheck</a></td>
-<td>Unsure, but probably very good based on initial appearance and usage level.</td>
-</tr>
-<tr>
-<td>Scala</td>
-<td><a href="https://www.scalacheck.org/">ScalaCheck</a></td>
-<td>Very Good</td>
-</tr>
-<tr>
-<td>Swift</td>
-<td><a href="https://github.com/typelift/SwiftCheck">Swiftcheck</a></td>
-<td>Unsure</td>
-</tr>
-</tbody>
-</table>
-
-<p>Where when I've said "Unsure" I really just mean that I think it looks good but
-I haven't put in the depth of in time to be sure, not that I have doubts.</p>
-
-<h2>Special case: Haskell</h2>
-
-<p>
-  <a href="https://hackage.haskell.org/package/QuickCheck">The original QuickCheck</a>
-  was of course written in Haskell, so it may seem odd that it's not the property based testing
-  library I recommend for Haskell!
-</p>
-
-<p>
-  The reason is that I feel that the design of classic QuickCheck is fundamentally limiting,
-  and that Hedgehog takes it in the direction that the rest of the property-based testing
-  world is moving (and where most of the implementations for dynamic languages, Hypothesis
-  included, already are). In particular its approach starts from generators rather than
-  type classes, and it has <a href="{{site.url}}{% post_url 2016-12-05-integrated-shrinking %}">integrated shrinking</a>,
-  and a fairly comprehensive library of generators.
-</p>
-
-<h2>Special case: Erlang</h2>
-
-<p>
-  Erlang is a special case because they have <a href="http://www.quviq.com/">QuviQ's QuickCheck</a>.
-  Their QuickCheck implementation is by all accounts <em>extremely</em> good, but it is also proprietary
-  and fairly expensive. Nevertheless, if you find yourselves in the right language, circumstance and
-  financial situation to use it, I would strongly recommend doing so.
-</p>
-
-<p>
-  In particular, QuviQ's QuickCheck is really the only implementation in this article I think is
-  simply better than Hypothesis. Hypothesis is significantly more user friendly, especially if the
-  users in question are less than familiar with Erlang, but there are things QuviQ can do that
-  Hypothesis can't, and the data generation has had a great deal more engineering effort put into it.
-</p>
-
-<p>
-  If you're using Erlang but <em>not</em> able to pay for QuickCheck, apparently the one to use is
-  <a href="https://github.com/manopapad/proper">PropEr</a>. If you're also unable to use GPLed software
-  there's <a href=https://github.com/krestenkrab/triq>triq</a>. I know very little about either.
-</p>
-
-<h2>Special case: OCaml</h2>
-
-<p>
-  OCaml seems to be suffering from a problem of being close enough to Haskell that people try to do a
-  straight port of Quickcheck but far enough from Haskell that this doesn't work. The result is that
-  there is <a href="https://github.com/alanfalloon/ocaml-quickcheck">a "mechanical port" of Quickcheck
-  which is completely abandoned</a> and <a href="https://github.com/camlunity/ocaml-quickcheck">a fork
-  of it that uses more idiomatic OCaml</a>. I'm insufficiently familiar with OCaml or its community
-  to know if either is used or whether there is another one that is.
-</p>
-
-<h2>What does this have to do with Hypothesis?</h2>
-
-<p>
-  In some sense these are all "competitors" to Hypothesis, but we're perfectly happy not to compete.
-</p>
-
-<p>
-  In the case of Erlang, I wouldn't even try. In the case of Scala, F#, or Clojure, I might at some
-  point work with them to try to bring the best parts of Hypothesis to their existing implementation,
-  but I don't consider them a priority - they're well served by what they have right now, and there 
-  are many languages that are not.
-</p>
-
-<p>
-  For the rest though? I'm glad they exist! I care about testing about about high quality software,
-  and they're doing their part to make it possible.
-</p>
-
-<p>
-  But I feel they're being badly served by their underlying model, and that they feel quite unnatural
-  to use in the context of a more conventional test setting. I think Hypothesis is the way forward,
-  and I'll be doing my best <a href="/services/#ports-of-hypothesis-to-new-languages">to make it
-  possible for everyone to use it in their language of choice</a>.
-</p>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-16-the-purpose-of-hypothesis.md Deleted

@@ -1,60 +0,0 @@
----
-layout: post
-tags: writing-good-software principles non-technical
-date: 2016-04-16 12:00
-title: The Purpose of Hypothesis
-published: true
-author: drmaciver
----
-
-What is Hypothesis for?
-
-From the perspective of a user, the purpose of Hypothesis is to make it easier for you
-to write better tests.
-
-From my perspective as the primary author, that is of course also *a* purpose of Hypothesis.
-I write a lot of code, it needs testing, and the idea of trying to do that without Hypothesis
-has become nearly unthinkable.
-
-But, on a large scale, the true purpose of Hypothesis is to drag the world kicking and screaming
-into a new and terrifying age of high quality software.
-
-
-
-Software is everywhere. We have built a civilization on it, and it's only getting more prevalent
-as more services move online and embedded and "internet of things" devices become cheaper and
-more common.
-
-Software is also terrible. It’s buggy, it's insecure, and it's rarely well thought out.
-
-This combination is clearly a recipe for disaster.
-
-The state of software testing is even worse. It’s uncontroversial at this point that you *should*
-be testing your code, but it's a rare codebase whose authors could honestly claim that they feel
-its testing is sufficient.
-
-Much of the problem here is that it’s too hard to write good tests. Tests take up a vast quantity
-of development time, but they mostly just laboriously encode exactly the same assumptions and
-fallacies that the authors had when they wrote the code, so they miss exactly the same bugs that
-you missed when they wrote the code.
-
-Meanwhile, there are all sorts of tools for making testing better that are basically unused, or
-used in only specialised contexts. The original Quickcheck is from 1999 and the majority of
-developers have not even heard of it, let alone used it. There are a bunch of half-baked
-implementations for most languages, but very few of them are worth using. More recently, there
-are many good tools applied to specialized problems, but very little that even attempts, let
-alone succeeds, to help general purpose testing.
-
-The goal of Hypothesis is to fix this, by taking research level ideas and applying solid
-engineering to them to produce testing tools that are both powerful *and* practical, and
-are accessible to everyone..
-
-Many of the ideas that Hypothesis is built on are new. Many of them are not. It doesn't matter.
-The purpose of Hypothesis is not to produce research level ideas. The purpose of Hypothesis is
-to produce high quality software by any means necessary. Where the ideas we need exist, we
-will use them. Where they do not, we will invent them.
-
-If people aren't using advanced testing tools, that's a bug. We should find it and fix it.
-
-Fortunately, we have this tool called Hypothesis. It's very good at finding bugs. But this
-one it can also fix.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-19-rule-based-stateful-testing.md Deleted

@@ -1,350 +0,0 @@
----
-layout: post
-tags: python technical intro
-date: 2016-04-19 07:00
-title: Rule Based Stateful Testing
-published: true
-author: drmaciver
----
-
-Hypothesis's standard testing mechanisms are very good for testing things that can be
-considered direct functions of data. But supposed you have some complex stateful
-system or object that you want to test. How can you do that?
-
-In this article we'll see how to use Hypothesis's *rule based state machines* to define
-tests that generate not just simple data, but entire programs using some stateful
-object. These will give the same level of boost to testing the behaviour of the
-object as you get to testing the data it accepts.
-
-
-
-The model of a stateful system we'll be using is a priority queue(https://en.wikipedia.org/wiki/Priority_queue)
-implemented as a binary heap.
-
-We have the following operations:
-
-* newheap() - returns a new heap
-* heappush(heap, value) - place a new value into the heap
-* heappop(heap) - remove and return the smallest value currently on the heap. Error if heap is empty.
-* heapempty(heap) - return True if the heap has no elements, else False.
-
-We'll use the following implementation of these:
-
-```python
-def heapnew():
-    return 
-
-
-def heapempty(heap):
-    return not heap
-
-
-def heappush(heap, value):
-    heap.append(value)
-    index = len(heap) - 1
-    while index > 0:
-        parent = (index - 1) // 2
-        if heapparent > heapindex:
-            heapparent, heapindex = heapindex, heapparent
-            index = parent
-        else:
-            break
-
-
-def heappop(heap):
-    return heap.pop(0)
-```
-
-(Note that this implementation is *wrong*. heappop as implemented will return the smallest element
-if the heap currently satisfies the heap property, but it will not rebalance the heap afterwards
-so it may leave the heap in an invalid state)
-
-We could test this readily enough using @given with something like the following:
-
-
-```python
-from hypothesis import given
-from hypothesis.strategies import integers, lists
-
-
-@given(lists(integers()))
-def test_pop_in_sorted_order(ls):
-    h = heapnew()
-    for l in ls:
-        heappush(h, l)
-    r = 
-    while not heapempty(h):
-        r.append(heappop(h))
-    assert r == sorted(ls)
-```
-
-And this indeed finds the bug:
-
-```
->       assert r == sorted(ls)
-E       assert 0, 1, 0 == 0, 0, 1
-E         At index 1 diff: 1 != 0
-E         Use -v to get the full diff
-
-binheap.py:74: AssertionError
------ Hypothesis -----
-Falsifying example: test_pop_in_sorted_order(ls=0, 1, 0)
-```
-
-So we replace heappop with a correct implementation which rebalances the heap:
-
-```python
-def heappop(heap):
-    if len(heap) == 0:
-        raise ValueError("Empty heap")
-    if len(heap) == 1:
-        return heap.pop()
-    result = heap0
-    heap0 = heap.pop()
-    index = 0
-    while index * 2 + 1 < len(heap):
-        children = index * 2 + 1, index * 2 + 2
-        children = i for i in children if i < len(heap)
-        assert children
-        children.sort(key=lambda x: heapx)
-        for c in children:
-            if heapindex > heapc:
-                heapindex, heapc = heapc, heapindex
-                index = c
-                break
-        else:
-            break
-    return result
-```
-
-But how do we know this is enough? Might some combination of mixing pushes and pops break the
-invariants of the heap in a way that this simple pattern of pushing everything then popping
-everything cannot witness?
-
-This is where the rule based state machines come in. Instead of just letting Hypothesis give
-us data which we feed into a fixed structure of test, we let Hypothesis choose which operations
-to perform on our data structure:
-
-```python
-from hypothesis.stateful import RuleBasedStateMachine, precondition, rule
-
-
-class HeapMachine(RuleBasedStateMachine):
-    def __init__(self):
-        super().__init__()
-        self.heap = 
-
-    @rule(value=integers())
-    def push(self, value):
-        heappush(self.heap, value)
-
-    @rule()
-    @precondition(lambda self: self.heap)
-    def pop(self):
-        correct = min(self.heap)
-        result = heappop(self.heap)
-        assert correct == result
-```
-
-@rule is a slightly restricted version of @given that only works for methods on a RuleBasedStateMachine.
-
-However it has one *major* difference from @given, which is that multiple rules can be chained together:
-A test using this state machine doesn't just run each rule in isolation, it instantiates an instance of
-the machine and then runs multiple rules in succession.
-
-The @precondition decorator constrains when a rule is allowed to fire: We are not allowed to pop from
-an empty heap, so the pop rule may only fire when there is data to be popped.
-
-We can run this by getting a standard unit test TestCase object out of it to be picked up by unittest
-or py.test as normal:
-
-```python
-TestHeaps = HeapMachine.TestCase
-```
-
-With our original broken heappop we find the same bug as before:
-
-```
-E       AssertionError: assert 0 == 1
-
-binheap.py:90: AssertionError
------ Captured stdout call -----
-Step #1: push(value=1)
-Step #2: push(value=0)
-Step #3: push(value=0)
-Step #4: pop()
-Step #5: pop()
-```
-
-With the fixed implementation the test passes.
-
-As it currently stands, this is already very useful. It's particularly good for testing single standalone
-objects or services like storage systems.
-
-But one limitation of it as we have written it is that it only concerns ourselves with a single heap. What
-if we wanted to combine two heaps? For example, suppose we wanted a heap merging operation that takes two
-heaps and returns a new heap containing the values in either of the original two.
-
-As before, we'll start with a broken implementation:
-
-```python
-def heapmerge(x, y):
-    x, y = sorted((x, y))
-    return x + y
-```
-
-We can't just write a strategy for heaps, because each heap would be a fresh object and thus it would not
-preserve the stateful aspect.
-
-What we instead do is use the other big feature of Hypothesis's rule bases state machines: Bundles.
-
-Bundles allow rules to return as well as accept values. A bundle is a strategy which generates anything
-a rule has previously provided to it. Using them is as follows:
-
-
-```python
-class HeapMachine(RuleBasedStateMachine):
-    Heaps = Bundle("heaps")
-
-    @rule(target=Heaps)
-    def newheap(self):
-        return 
-
-    @rule(heap=Heaps, value=integers())
-    def push(self, heap, value):
-        heappush(heap, value)
-
-    @rule(heap=Heaps.filter(bool))
-    def pop(self, heap):
-        correct = min(heap)
-        result = heappop(heap)
-        assert correct == result
-
-    @rule(target=Heaps, heap1=Heaps, heap2=Heaps)
-    def merge(self, heap1, heap2):
-        return heapmerge(heap1, heap2)
-```
-
-So now instead of a single heap we manage a collection of heaps. All of our previous operations become
-constrained by an instance of a heap.
-
-Note the use of filter: A bundle is a strategy you can use like any other. In this case the filter replaces
-our use of a precondition because we now only care about whether this *specific* heap is empty.
-
-This is sufficient to find the fact that our implementation is wrong:
-
-```
-    @rule(heap=Heaps.filter(bool))
-    def pop(self, heap):
-        correct = min(heap)
-        result = heappop(heap)
->       assert correct == result
-E       AssertionError: assert 0 == 1
-
-binheap.py:105: AssertionError
-
------ Captured stdout call -----
-
-Step #1: v1 = newheap()
-Step #2: push(heap=v1, value=0)
-Step #3: push(heap=v1, value=1)
-Step #4: push(heap=v1, value=1)
-Step #5: v2 = merge(heap2=v1, heap1=v1)
-Step #6: pop(heap=v2)
-Step #7: pop(heap=v2)
-```
-
-We create a small heap, merge it with itself, and rapidly discover that it has become unbalanced.
-
-We can fix this by fixing our heapmerge to be correct:
-
-```python
-def heapmerge(x, y):
-    result = list(x)
-    for v in y:
-        heappush(result, v)
-    return result
-```
-
-But that's boring. Lets introduce a more *interestingly* broken implementation instead:
-
-```python
-def heapmerge(x, y):
-    result = 
-    i = 0
-    j = 0
-    while i < len(x) and j < len(y):
-        if xi <= yj:
-            result.append(xi)
-            i += 1
-        else:
-            result.append(yj)
-            j += 1
-    result.extend(xi:)
-    result.extend(yj:)
-    return result
-```
-
-This merge operation selectively splices two heaps together as if we were merging two
-sorted lists (heaps aren't actually sorted, but the code still works regardless it
-just doesn't do anything very meaningful).
-
-This is wrong, but it turns out to work surprisingly well for small heaps and it's
-not completely straightforward to find an example showing that it's wrong.
-
-Here's what Hypothesis comes up with:
-
-```
-Step #1: v1 = newheap()
-Step #2: push(heap=v1, value=0)
-Step #3: v2 = merge(heap1=v1, heap2=v1)
-Step #4: v3 = merge(heap1=v2, heap2=v2)
-Step #5: push(heap=v3, value=-1)
-Step #6: v4 = merge(heap1=v1, heap2=v2)
-Step #7: pop(heap=v4)
-Step #8: push(heap=v3, value=-1)
-Step #9: v5 = merge(heap1=v1, heap2=v2)
-Step #10: v6 = merge(heap1=v5, heap2=v4)
-Step #11: v7 = merge(heap1=v6, heap2=v3)
-Step #12: pop(heap=v7)
-Step #13: pop(heap=v7)
-```
-
-Through a careful set of heap creation and merging, Hypothesis manages to find a series
-of merges that produce an unbalanced heap. Every heap prior to v7 is balanced, but v7 looks
-like this:
-
-```
->>> v7
--1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0
-```
-
-Which doesn't satisfy the heap property because of that -1 far down in the list.
-
-I don't know about you, but I would never have come up with that example. There's probably
-a simpler one given a different set of operations - e.g. one thing that would probably improve
-the quality of this test is to let Hypothesis instantiate a new heap with a list of elements
-which it pops onto it.
-
-But the nice thing about rule based stateful testing is that I don't *have* to come up with
-the example. Instead Hypothesis is able to guarantee that every combination of operations
-on my objects works, and can flush out some remarkably subtle bugs in the process.
-
-Because after all, if it takes this complicated an example to demonstrate that a completely
-wrong implementation is wrong, how hard can it sometimes be to demonstrate subtle bugs?
-
-### Real world usage
-
-This feature is currently somewhat under-documented so hasn't seen as widespread adoption as
-it could. However, there are at least two interesting real world examples:
-
-1. Hypothesis uses it to test itself. Hypothesis has tests of its example database(
-   https://github.com/HypothesisWorks/hypothesis-python/blob/master/tests/cover/test_database_agreement.py)
-   which work very much like the above, and a small model of its test API(
-   https://github.com/HypothesisWorks/hypothesis-python/blob/master/tests/nocover/test_strategy_state.py)
-   which generates random strategies and runs tests using them.
-2. It's being used to test Mercurial(https://www.mercurial-scm.org/pipermail/mercurial-devel/2016-February/080037.html)
-   generating random. So far it's found bug 5112(https://bz.mercurial-scm.org/show_bug.cgi?id=5112) and
-   bug 5113(https://bz.mercurial-scm.org/show_bug.cgi?id=5113). The usage pattern on Mercurial is one
-   such that the stateful testing probably needs more resources, more rules and more work on deployment
-   before it's going to find much more than that though.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-04-29-testing-performance-optimizations.md Deleted

@@ -1,129 +0,0 @@
----
-layout: post
-tags: technical intro python properties
-date: 2016-04-29 11:00
-title: Testing performance optimizations
-published: true
-author: drmaciver
----
-
-Once you've 
-flushed out the basic crashing bugs({{site.url}}{% post_url 2016-04-15-getting-started-with-hypothesis %})
-in your code, you're going to want to look for more interesting things to test.
-
-The next easiest thing to test is code where you know what the right answer is for every input.
-
-Obviously in theory you think you know what the right answer is - you can just run the code. That's not very
-helpful though, as that's the answer you're trying to verify.
-
-But sometimes there is more than one way to get the right answer, and you choose the one you run in production
-not because it gives a different answer but because it gives the same answer *faster*.
-
-
-
-For example:
-
-* There might be a fancy but fast version of an algorithm and a simple but slow version of an algorithm.
-* You might have a caching layer and be able to run the code with and without caching turned on, or with a
-  different cache timeout.
-* You might be moving to a new database backend to improve your scalability, but you still have the code for
-  the old backend until you've completed your migration.
-
-There are plenty of other ways this can crop up, but those are the ones that seem the most common.
-
-Anyway, this creates an *excellent* use case for property based testing, because if two functions are supposed
-to always return the same answer, you can test that: Just call both functions with the same data and assert
-that their answer is the same.
-
-Lets look at this in the fancy algorithm case. Suppose we implemented merge sort(
-https://en.wikipedia.org/wiki/Merge_sort):
-
-```python
-def merge_sort(ls):
-    if len(ls) <= 1:
-        return ls
-    else:
-        k = len(ls) // 2
-        return merge_sorted_lists(merge_sort(ls:k), merge_sort(lsk:))
-
-
-def merge_sorted_lists(x, y):
-    result = 
-    i = 0
-    j = 0
-    while i < len(x) and j < len(y):
-        if xi <= yj:
-            result.append(xi)
-            i += 1
-        else:
-            result.append(yj)
-            j += 1
-    return result
-```
-
-We want a reference implementation to test it against, so lets also implement bubble sort(
-https://en.wikipedia.org/wiki/Bubble_sort):
-
-```python
-def bubble_sort(ls):
-    ls = list(ls)
-    needs_sorting = True
-    while needs_sorting:
-        needs_sorting = False
-        for i in range(1, len(ls)):
-            if lsi - 1 > lsi:
-                needs_sorting = True
-                lsi - 1, lsi = lsi, lsi - 1
-    return ls
-```
-
-These *should* always give the same answer,  so lets test that:
-
-```python
-@given(lists(integers()))
-def test_bubble_sorting_is_same_as_merge_sorting(ls):
-    assert bubble_sort(ls) == merge_sort(ls)
-```
-
-This gives us an error:
-
-```
-    @given(lists(integers()))
-    def test_bubble_sorting_is_same_as_merge_sorting(ls):
->       assert bubble_sort(ls) == merge_sort(ls)
-E       assert 0, 0 == 0
-E         Left contains more items, first extra item: 0
-E         Use -v to get the full diff
-
-foo.py:43: AssertionError
------ Hypothesis -----
-Falsifying example: test_bubble_sorting_is_same_as_merge_sorting(ls=0, 0)
-```
-
-What's happened is that we messed up our implementation of merge\_sorted\_lists, because we forgot
-to include the elements left over in the other list once we've reached the end of one of them. As a
-result we ended up losing elements from the list, a problem that our simpler implementation lacks.
-We can fix this as follows and then the test passes:
-
-```python
-def merge_sorted_lists(x, y):
-    result = 
-    i = 0
-    j = 0
-    while i < len(x) and j < len(y):
-        if xi <= yj:
-            result.append(xi)
-            i += 1
-        else:
-            result.append(yj)
-            j += 1
-    result.extend(xi:)
-    result.extend(yj:)
-    return result
-```
-
-This technique combines especially well with 
-Hypothesis's stateful testing({{site.url}}{% post_url 2016-04-19-rule-based-stateful-testing %}), because
-you can use it to then test different implementations of complex APIs. For example, Hypothesis uses this
-property together with stateful testing to verify that the different implementations of its example database
-behave identically(https://github.com/HypothesisWorks/hypothesis/blob/master/hypothesis-python/tests/nocover/test_database_agreement.py).

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-02-referential-transparency.md Deleted

@@ -1,25 +0,0 @@
----
-layout: post
-tags: non-technical
-date: 2016-05-02 08:00
-title: You Don't Need Referential Transparency
-published: true
-author: drmaciver
----
-
-It's a common belief that in order for property based testing to be useful, your code must be referentially transparent(https://en.wikipedia.org/wiki/Referential_transparency). That is, it must be a pure function with no side effects that just takes input data and produces output data and is solely defined by what input data produces what output data.
-
-This is, bluntly, complete and utter nonsense with no basis in reality.
-
-
-
-
-The idea comes from the fact that it was true of very early versions of the original Haskell QuickCheck(https://hackage.haskell.org/package/QuickCheck) - it was designed to look more like formal methods than unit testing, and it was designed for a language where referential transparency was the norm.
-
-But that was the *original* version of Haskell QuickCheck. It's not even true for the latest version of it, let alone for ports to other languages! The Haskell version has full support for testing properties in IO (if you don't know Haskell, this means "tests which may have side effects"). It works really well. Hypothesis doesn't even consider this a question - testing code with side effects works the same way as testing code without side effects.
-
-The *only* requirement that property based testing has on the side effects your tests may perform is that if your test has *global* side effects then it must be able to roll them back at the end.
-
-If that sounds familiar, it's because it's *exactly the same requirement every other test has*. Tests that have global side effects are not repeatable and may interfere with other tests, so they must keep their side effects to themselves by rolling them back at the end of the test.
-
-Property based testing is just normal testing, run multiple times, with a source of data to fill in some of the blanks. There is no special requirement on it beyond that, and the myth that there is causes great harm and keeps many people from adopting more powerful testing tools.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-11-generating-the-right-data.md Deleted

@@ -1,372 +0,0 @@
----
-layout: post
-tags: technical python intro
-date: 2016-05-11 10:00
-title: Generating the right data
-published: true
-author: drmaciver
----
-
-One thing that often causes people problems is figuring out how to generate
-the right data to fit their data
-model. You can start with just generating strings and integers, but eventually you want
-to be able to generate
-objects from your domain model. Hypothesis provides a lot of tools to help you build the
-data you want, but sometimes the choice can be a bit overwhelming.
-
-Here's a worked example to walk you through some of the details and help you get to grips with how to use
-them.
-
-
-
-Suppose we have the following class:
-
-```python
-class Project:
-    def __init__(self, name, start, end):
-        self.name = name
-        self.start = start
-        self.end = end
-
-    def __repr__(self):
-        return "Project {} from {} to {}".format(
-            self.name, self.start.isoformat(), self.end.isoformat()
-        )
-```
-
-A project has a name, a start date, and an end date.
-
-How do we generate such a thing?
-
-The idea is to break the problem down into parts, and then use the tools
-Hypothesis provides to assemble those parts into a strategy for generating
-our projects.
-
-We'll start by generating the data we need for each field, and then at the end
-we'll see how to put it all together to generate a Project.
-
-### Names
-
-First we need to generate a name. We'll use Hypothesis's standard text
-strategy for that:
-
-```pycon
->>> from hypothesis.strategies import text
->>> text().example()
-''
->>> text().example()
-'\nŁ昘迥'
-```
-
-Lets customize this a bit: First off, lets say project names have to be
-non-empty.
-
-```pycon
->>> text(min_size=1).example()
-'w\nC'
->>> text(min_size=1).example()
-'ሚಃJ»'
-```
-
-Now, lets avoid the high end unicode for now (of course, your system *should*
-handle the full range of unicode, but this is just an example, right?).
-
-To do this we need to pass an alphabet to the text strategy. This can either be
-a range of characters or another strategy. We're going to use the *characters*
-strategy, which gives you a flexible way of describing a strategy for single-character
-text strings, to do that.
-
-```pycon
-i>>> characters(min_codepoint=1, max_codepoint=1000, blacklist_categories=('Cc', 'Cs')).example()
-'²'
->>> characters(min_codepoint=1, max_codepoint=1000, blacklist_categories=('Cc', 'Cs')).example()
-'E'
->>> characters(min_codepoint=1, max_codepoint=1000, blacklist_categories=('Cc', 'Cs')).example()
-'̺'
-
-```
-
-The max and min codepoint parameters do what you'd expect: They limit the range of
-permissible codepoints. We've blocked off the 0 codepoint (it's not really useful and
-tends to just cause trouble with C libraries) and anything with a codepoint above
-1000 - so we're considering non-ASCII characters but nothing really high end.
-
-The blacklist\_categories parameter uses the notion of unicode category(https://en.wikipedia.org/wiki/Unicode_character_property#General_Category)
-to limit the range of acceptable characters. If you want to see what category a
-character has you can use Python's unicodedata module to find out:
-
-```pycon
->>> from unicodedata import category
->>> category('\n')
-'Cc'
->>> category('\t')
-'Cc'
->>> category(' ')
-'Zs'
->>> category('a')
-'Ll'
-```
-
-The categories we've excluded are *control characters* and *surrogates*. Surrogates
-are excluded by default but when you explicitly pass in blacklist categories you
-need to exclude them yourself.
-
-So we can put that together with text() to get a name matching our requirements:
-
-```pycon
->>> names = text(characters(max_codepoint=1000, blacklist_categories=('Cc', 'Cs')), min_size=1)
-```
-
-But this is still not quite right: We've allowed spaces in names, but we don't really want
-a name to start with or end with a space. You can see that this is currently allowed by
-asking Hypothesis for a more specific example:
-
-```pycon
->>> find(names, lambda x: x0 == ' ')
-' '
-```
-
-So lets fix it so that they can't by stripping the spaces off it.
-
-To do this we're going to use the strategy's *map* method which lets you compose it with
-an arbitrary function to post-process the results into the for you want:
-
-```pycon
->>> names = text(characters(max_codepoint=1000, blacklist_categories=('Cc', 'Cs')), min_size=1).map(
-...     lambda x: x.strip())
-```
-
-Now lets check that we can no longer have the above problem:
-
-```pycon
->>> find(names, lambda x: x0 == ' ')
-Traceback (most recent call last):
-  File "<stdin>", line 1, in <module>
-  File "/usr/lib/python3.5/site-packages/hypothesis/core.py", line 648, in find
-    runner.run()
-  File "/usr/lib/python3.5/site-packages/hypothesis/internal/conjecture/engine.py", line 168, in run
-    self._run()
-  File "/usr/lib/python3.5/site-packages/hypothesis/internal/conjecture/engine.py", line 262, in _run
-    self.test_function(data)
-  File "/usr/lib/python3.5/site-packages/hypothesis/internal/conjecture/engine.py", line 68, in test_function
-    self._test_function(data)
-  File "/usr/lib/python3.5/site-packages/hypothesis/core.py", line 616, in template_condition
-    success = condition(result)
-  File "<stdin>", line 1, in <lambda>
-IndexError: string index out of range
-```
-
-Whoops!
-
-The problem is that our initial test worked because the strings we were generating were always
-non-empty because of the min\_size parameter. We're still only generating non-empty strings,
-but if we generate a string which is all spaces then strip it, the result will be empty
-*after* our map.
-
-We can fix this using the strategy's *filter* function, which restricts to only generating
-things which satisfy some condition:
-
-```pycon
->>> names = text(characters(max_codepoint=1000, blacklist_categories=('Cc', 'Cs')), min_size=1).map(
-...     lambda s: s.strip()).filter(lambda s: len(s) > 0)
-```
-
-And repeating the check:
-
-```pycon
->>> find(names, lambda x: x0 == ' ')
-Traceback (most recent call last):
-  File "<stdin>", line 1, in <module>
-  File "/usr/lib/python3.5/site-packages/hypothesis/core.py", line 670, in find
-    raise NoSuchExample(get_pretty_function_description(condition))
-hypothesis.errors.NoSuchExample: No examples found of condition lambda x: <unknown>
-```
-
-Hypothesis raises NoSuchExample to indicate that... well, that there's no such example.
-
-In general you should be a little bit careful with filter and only use it to filter
-to conditions that are relatively hard to happen by accident. In this case it's fine
-because the filter condition only fails if our initial draw was a string consisting
-entirely of spaces, but if we'd e.g. tried the opposite and tried to filter to strings
-that *only* had spaces, we'd have had a bad time of it and got a very slow and not
-very useful test.
-
-Anyway, we now really do have a strategy that produces decent names for our projects.
-Lets put this all together into a test that demonstrates that our names now have the
-desired properties:
-
-```python
-from unicodedata import category
-
-from hypothesis import given
-from hypothesis.strategies import characters, text
-
-names = (
-    text(characters(max_codepoint=1000, blacklist_categories=("Cc", "Cs")), min_size=1)
-    .map(lambda s: s.strip())
-    .filter(lambda s: len(s) > 0)
-)
-
-
-@given(names)
-def test_names_match_our_requirements(name):
-    assert len(name) > 0
-    assert name == name.strip()
-    for c in name:
-        assert 1 <= ord(c) <= 1000
-        assert category(c) not in ("Cc", "Cs")
-```
-
-It's not common practice to write tests for your strategies, but it can be helpful
-when trying to figure things out.
-
-### Dates and times
-
-Hypothesis has date and time generation in a hypothesis.extra subpackage because it
-relies on pytz to generate them, but other than that it works in exactly the same
-way as before:
-
-```pycon
->>> from hypothesis.extra.datetime import datetimes
->>> datetimes().example()
-datetime.datetime(1642, 1, 23, 2, 34, 28, 148985, tzinfo=<DstTzInfo 'Antarctica/Mawson' zzz0:00:00 STD>)
-```
-
-Lets constrain our dates to be UTC, because the sensible thing to do is to use UTC
-internally and convert on display to the user:
-
-```pycon
->>> datetimes(timezones=('UTC',)).example()
-datetime.datetime(6820, 2, 4, 19, 16, 27, 322062, tzinfo=<UTC>)
-```
-
-We can also constrain our projects to start in a reasonable range of years,
-as by default Hypothesis will cover the whole of representable history:
-
-```pycon
->>> datetimes(timezones=('UTC',), min_year=2000, max_year=2100).example()
-datetime.datetime(2084, 6, 9, 11, 48, 14, 213208, tzinfo=<UTC>)
-```
-
-Again we can put together a test that checks this behaviour (though we have
-less code here so it's less useful):
-
-```python
-from hypothesis import given
-from hypothesis.extra.datetime import datetimes
-
-project_date = datetimes(timezones=("UTC",), min_year=2000, max_year=2100)
-
-
-@given(project_date)
-def test_dates_are_in_the_right_range(date):
-    assert 2000 <= date.year <= 2100
-    assert date.tzinfo._tzname == "UTC"
-```
-
-### Putting it all together
-
-We can now generate all the parts for our project definitions, but how do we
-generate a project?
-
-The first thing to reach for is the *builds* function.
-
-```pycon
-
->>> from hypothesis.strategies import builds
->>> projects = builds(Project, name=names, start=project_date, end=project_date)
->>> projects.example()
-Project 'd!#ñcJν' from 2091-06-22T06:57:39.050162+00:00 to 2057-06-11T02:41:43.889510+00:00
-```
-
-builds lets you take a set of strategies and feed their results as arguments to a
-function (or, in this case, class. Anything callable really) to create a new
-strategy that works by drawing those arguments then passing them to the function
-to give you that example.
-
-Unfortunately, this isn't quite right:
-
-```pycon
->>> find(projects, lambda x: x.start > x.end)
-Project '0' from 2000-01-01T00:00:00.000001+00:00 to 2000-01-01T00:00:00+00:00
-```
-
-Projects can start after they end when we use builds this way. One way to fix this would be
-to use filter():
-
-```pycon
->>> projects = builds(Project, name=names, start=project_date, end=project_date).filter(
-...     lambda p: p.start < p.end)
->>> find(projects, lambda x: x.start > x.end)
-Traceback (most recent call last):
-  File "<stdin>", line 1, in <module>
-  File "/usr/lib/python3.5/site-packages/hypothesis/core.py", line 670, in find
-    raise NoSuchExample(get_pretty_function_description(condition))
-hypothesis.errors.NoSuchExample: No examples found of condition lambda x: <unknown>
-```
-
-This will work, but it starts to edge into the territory of where filter should be
-avoided - about half of the initially generated examples will fail the filter.
-
-What we'll do instead is draw two dates and use whichever one is smallest as the
-start, and whatever is largest at the end. This is hard to do with builds because
-of the dependence between the arguments, so instead we'll use builds' more advanced
-cousin, *composite*:
-
-```python
-from hypothesis import assume
-from hypothesis.strategies import composite
-
-
-@composite
-def projects(draw):
-    name = draw(names)
-    date1 = draw(project_date)
-    date2 = draw(project_date)
-    assume(date1 != date2)
-    start = min(date1, date2)
-    end = max(date1, date2)
-    return Project(name, start, end)
-```
-
-The idea of composite is you get passed a magic first argument 'draw' that you can
-use to get examples out of a strategy. You then make as many draws as you want and
-use these to return the desired data.
-
-You can also use the *assume* function to discard the current call if you get yourself
-into a state where you can't proceed or where it's easier to start again. In this case
-we do that when we draw the same data twice.
-
-```pycon
->>> projects().example()
-Project 'rĂ5ĠǓ#' from 2000-05-14T07:21:12.282521+00:00 to 2026-05-12T13:20:43.225796+00:00
->>> find(projects(), lambda x: x.start > x.end)
-Traceback (most recent call last):
-  File "<stdin>", line 1, in <module>
-  File "/usr/lib/python3.5/site-packages/hypothesis/core.py", line 670, in find
-    raise NoSuchExample(get_pretty_function_description(condition))
-hypothesis.errors.NoSuchExample: No examples found of condition lambda x: <unknown>
-```
-
-Note that in all of our examples we're now writing projects() instead of projects. That's
-because composite returns a function rather than a strategy. Any arguments to your
-defining function other than the first are also arguments to the one produced by composite.
-
-We can now put together one final test that we got this bit right too:
-
-```python
-@given(projects())
-def test_projects_end_after_they_started(project):
-    assert project.start < project.end
-```
-
-### Wrapping up
-
-There's a lot more to Hypothesis's data generation than this, but hopefully it gives you
-a flavour of the sort of things to try and the sort of things that are possible.
-
-It's worth having a read of the documentation(https://hypothesis.readthedocs.io/en/latest/data.html)
-for this, and if you're still stuck then try asking the community(https://hypothesis.readthedocs.io/en/latest/community.html)
-for some help. We're pretty friendly.
-
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-13-what-is-property-based-testing.md Deleted

@@ -1,136 +0,0 @@
----
-layout: post
-tags: non-technical philosophy
-date: 2016-05-14 09:00
-title: What is Property Based Testing?
-published: true
-author: drmaciver
----
-
-I get asked this a lot, and I write property based testing tools for a living, so you'd think
-I have a good answer to this, but historically I haven't. This is my attempt to fix that.
-
-Historically the definition of property based testing has been "The thing that
-QuickCheck({{site.url}}{% post_url 2016-04-16-quickcheck-in-every-language %}) does". As
-a working definition this has served pretty well, but the problem is that it makes us unable
-to distinguish what the essential features of property-based testing are and what are just
-accidental features that appeared in the implementations that we're used to(
- {{site.url}}{% post_url  2016-05-02-referential-transparency %}).
-
-As the author of a property based testing system which diverges quite a lot from QuickCheck,
-this troubles me more than it would most people, so I thought I'd set out some of my thoughts on
-what property based testing is and isn't.
-
-This isn't intended to be definitive, and it will evolve over time as my thoughts do, but
-it should provide a useful grounding for further discussion.
-
-
-
-There are essentially two ways we can draw a boundary for something like this: We can go
-narrow or we can go wide. i.e. we can restrict our definitions to things that look exactly
-like QuickCheck, or things that are in the same general family of behaviour. My inclination
-is always to go wide, but I'm going to try to rein that in for the purpose of this piece.
-
-But I'm still going to start by planting a flag. The following are *not* essential features
-of property based testing:
-
-1. Referential Transparency({{site.url}}{% post_url  2016-05-02-referential-transparency %}).
-2. Types
-3. Randomization
-4. The use of any particular tool or library
-
-As evidence I present the following:
-
-1. Almost every property based testing library, including but not limited to Hypothesis and
-   QuickCheck (both Erlang and Haskell).
-2. The many successful property based testing systems for dynamic languages. e.g. Erlang
-   QuickCheck, test.check, Hypothesis.
-3. SmallCheck(https://hackage.haskell.org/package/smallcheck). I have mixed feelings about
-   its effectiveness, but it's unambiguously property-based testing.
-4. It's very easy to hand-roll your own testing protocols for property-based testing of a
-   particular result. For example, I've previously done this for testing a code formatter(
-   http://www.drmaciver.com/2015/03/27-bugs-in-24-hours/): Run it over a corpus (more on
-   whether running over a corpus "really" counts in a second) of Python files, check whether
-   the resulting formatted code satisfies PEP8. It's classic property-based testing with an
-   oracle.
-
-So that provides us with a useful starting point of things that are definitely property based
-testing. But you're never going to find a good definition by looking at only positive examples,
-so lets look at some cases where it's more arguable.
-
-First off, lets revisit that parenthetical question: Does just testing against a large corpus count?
-
-I'm going to go with "probably". I think if we're counting SmallCheck we need to count testing
-against a large corpus: If you take the first 20k outputs that would be generated by SmallCheck
-and just replay the test using those the first N of those each time, you're doing exactly the
-same sort of testing. Similarly if you draw 20k outputs using Hypothesis and then just randomly
-sample from them each time.
-
-I think drawing from a small, fixed, corpus probably *doesn't* count. If you could feasibly
-write a property based test as 10 example based tests in line in your source code, it's
-probably really just example based testing. This boundary is a bit, um, fuzzy though.
-
-On which note, what about fuzzing?
-
-I have previously argued that fuzzing is just a form of property-based testing - you're testing
-the property "it doesn't crash". I think I've reversed my opinion on this. In particular, I think
-the style of testing I advocate for getting started with Hypothesis(
- {{site.url}}{% post_url  2016-04-15-getting-started-with-hypothesis %}), *probably* doesn't
-count as property based testing.
-
-I'm unsure about this boundary. The main reason I'm drawing it here is that they do feel like
-they have a different character - property based testing requires you to reason about how your
-program should behave, while fuzzing can just be applied to arbitrary programs with minimal
-understanding of their behaviour - and also that fuzzing feels somehow more fundamental.
-
-But you can certainly do property based testing using fuzzing tools, in the same way that you
-can do it with hand-rolled property based testing systems - I could have taken my Python formatting
-test above, added python-afl(http://jwilk.net/software/python-afl) to the mix, and
-that would still be property based testing.
-
-Conversely, you can do fuzzing with property-based testing tools: If fuzzing is not property
-based testing then not all tests using Hypothesis, QuickCheck, etc. are property based tests.
-I'm actually OK with that. There's a long tradition of testing tools being used outside their
-domain - e.g. most test frameworks originally designed as unit testing tools end up getting
-being used for the whole gamut of testing.
-
-So with that in mind, lets provide a definition of fuzzing that I'd like to use:
-
-> Fuzzing is feeding a piece of code (function, program, etc.) data from a large corpus, possibly
-> dynamically generated, possibly dependent on the results of execution on previous data, in
-> order to see whether it fails.
-
-The definitions of "data" and "whether it fails" will vary from fuzzer to fuzzer - some fuzzers
-will generate only binary data, some fuzzers will generate more structured data. Some fuzzers
-will look for a process crash, some might just look for a function returning false.
-
-(Often definitions of fuzzing focus on "malformed" data. I think this is misguided and fails
-to consider a lot of things that people would obviously consider fuzzers. e.g. CSmith(https://embed.cs.utah.edu/csmith/)
-is certainly a type of fuzzer but deliberately only generates well formed C programs).
-
-And given that definition, I think I can now provide a definition of property-based testing:
-
-> Property based testing is the construction of tests such that, when these tests are fuzzed,
-> failures in the test reveal problems with the system under test that could not have been
-> revealed by direct fuzzing of that system.
-
-(If you feel strongly that fuzzing *should* count as property-based testing you can just drop
-the 'that could not have been etc.' part. I'm on the fence about it myself.)
-
-These extra modes of failure then constitute the properties that we're testing.
-
-I think this works pretty well at capturing what we're doing with property based testing. It's
-not perfect, but I'm pretty happy with it. One of the things I particularly like is that it makes
-it clear that property-based testing is what *you* do, not what the computer does. The part
-that the computer does is "just fuzzing".
-
-Under this point of view, a property-based testing library is really two parts:
-
-1. A fuzzer.
-2. A library of tools for making it easy to construct property-based tests using that fuzzer.
-
-Hypothesis is very explicitly designed along these lines - the core of it is a structured
-fuzzing library called Conjecture - which suggests that I may have a bit of bias here, but
-I still feel that it captures the behaviour of most other property based testing systems
-quite well, and provides quite a nice middle ground between the wider definition that I
-wanted and the more tightly focused definition that QuickCheck orients people around.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-19-announcing-hypothesis-legacy-support.md Deleted

@@ -1,24 +0,0 @@
----
-layout: post
-tags: news python
-date: 2016-05-19 12:00
-title: Announcing Hypothesis Legacy Support
-published: true
-author: drmaciver
----
-
-For a brief period, Python 2.6 was supported in Hypothesis for Python(
- {{site.url}}/products/#hypothesis-for-python
-). Because Python 2.6 has been end of lifed for some time, I decided this wasn't
-a priority and support was dropped in Hypothesis 2.0.
-
-I've now added it back, but under a more restrictive license.
-
-If you want to use Hypothesis on Python 2.6, you can now do so by installing
-the hypothesislegacysupport({{site.url}}/products/#hypothesis-legacy-support)
-package. This will allow you to run Hypothesis on Python 2.6.
-
-Note that by default this is licensed under the GNU Affero General Public License 3.0(
-https://www.gnu.org/licenses/agpl-3.0.en.html). If you want to use it in commercial
-software you will likely want to buy a commercial license. Email us at  licensing@hypothesis.works(mailto:licensing@hypothesis.works)
-to discuss details.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-26-exploring-voting-with-hypothesis.md Deleted

@@ -1,180 +0,0 @@
----
-layout: post
-tags: python technical example
-date: 2016-05-26 11:00
-title: Exploring Voting Systems with Hypothesis
-published: true
-author: drmaciver
----
-
-Hypothesis is, of course, a library for writing tests.
-
-But from an *implementation* point of view this is hardly noticeable.
-Really it's a library for constructing and exploring data and using it
-to prove or disprove hypotheses about it. It then has a small testing
-library built on top of it.
-
-It's far more widely used as a testing library, and that's really where
-the focus of its development lies, but with the *find* function you can
-use it just as well to explore your data interactively.
-
-In this article we'll go through an example of doing this, by using it
-to take a brief look at one of my other favourite subjects: Voting
-systems.
-
-
-
-We're going to focus entirely on single winner preferential voting
-systems: You have a set of candidates, and every voter gives a complete
-ordering of the candidates from their favourite to their least
-favourite. The voting system then tries to select a single candidate and
-declare them the winner.
-
-The general Python interface for a voting system we'll use is things
-that look like the following:
-
-```python
-def plurality_winner(election):
-    counts = Counter(vote0 for vote in election)
-    alternatives = candidates_for_election(election)
-    winning_score = max(counts.values())
-    winners = c for c, v in counts.items() if v == winning_score
-    if len(winners) > 1:
-        return None
-    else:
-        return winners0
-```
-
-That is, they take a list of individual votes, each expressed
-as a list putting the candidates in order, and return a candidate that
-is an unambiguous winner or None in the event of a tie.
-
-The above implements plurality voting, what most people might think of
-as "normal voting": The candidate with the most first preference votes
-wins.
-
-The other main voting system we'll consider is Instant Runoff Voting (
-which you might know under the name "Alternative Vote" if you follow
-British politics):
- 
-```python
-def irv_winner(election):
-    candidates = candidates_for_election(election)
-    while len(candidates) > 1:
-        scores = Counter()
-        for vote in election:
-            for c in vote:
-                if c in candidates:
-                    scoresc += 1
-                    break
-        losing_score = min(scoresc for c in candidates)
-        candidates = c for c in candidates if scoresc > losing_score
-    if not candidates:
-        return None
-    else:
-        return candidates0
-```
-
-In IRV, we run the vote in multiple rounds until we've eliminated all
-but one candidate. In each round, we give each candidate a score which
-is the number of voters who have ranked that candidate highest amongst
-all the ones remaining. The candidates with the joint lowest score
-drop out.
-
-At the end, we'll either have either zero or one candidates remaining (
-we can have zero if all candidates are tied for joint lowest score at
-some point). If we have zero, that's a draw. If we have one, that's a
-victory.
-
-It seems pretty plausible that these would not produce the same answer
-all the time (it would be surpising if they did!), but it's maybe not
-obvious how you would go about constructing an example that shows it.
-
-Fortunately, we don't have to because Hypothesis can do it for us!
-
-We first create a strategy which generates elections, using Hypothesis's
-composite decorator:
-
-```python
-import hypothesis.strategies as st
-
-
-@st.composite
-def election(draw):
-    candidates = list(range(draw(st.integers(2, 10))))
-    return draw(st.lists(st.permutations(candidates), min_size=1))
-```
-
-This first draws the set of candidates as a list of integers of size
-between 2 and 10 (it doesn't really matter what our candidates are as
-long as they're distinct, so we use integers for simplicity). It then
-draws an election as lists of permutations of those candidates, as we
-defined it above.
-
-We now write a condition to look for:
-
-```python
-def differing_without_ties(election):
-    irv = irv_winner(election)
-    if irv is None:
-        return False
-    plurality = plurality_winner(election)
-    if plurality is None:
-        return False
-    return irv != plurality
-```
-
-That is, we're interested in elections where neither plurality nor IRV
-resulted in a tie, but they resulted in distinct candidates winning.
-
-We can now run this in the console:
-
-```
->>> from hypothesis import find
->>> import voting as v
->>> distinct = find(v.election(), v.differing_without_ties)
->>> distinct
-0, 1, 2,
- 0, 1, 2,
- 1, 0, 2,
- 2, 1, 0,
- 0, 1, 2,
- 0, 1, 2,
- 1, 0, 2,
- 1, 0, 2,
- 2, 1, 0
-```
-
-The example is a bit large, mostly because we insisted on there being
-no ties: If we'd broken ties arbitrarily (e.g. preferring the lower
-numbered candidates) we could have found a smaller one. Also, in some
-runs Hypothesis ends up finding a slightly smaller election but with
-four candidates instead of three.
-
-We can check to make sure that these really do give different results:
-
-```
->>> v.irv_winner(distinct)
-1
-
->>> v.plurality_winner(distinct)
-0
-```
-
-There are a lot of other interesting properties of voting systems to
-explore, but this is an article about Hypothesis rather than one about
-voting, so I'll stop here. However the interested reader might want to
-try to build on this to:
-
-1. Find an election which has a Condorcet Cycle(https://en.wikipedia.org/wiki/Voting_paradox)
-2. Find elections in which the majority prefers the plurality winner to
-   the IRV winner and vice versa.
-3. Use @given rather than find and write some tests verifying some of
-   the classic properties of election systems(https://en.wikipedia.org/wiki/Voting_system#Evaluating_voting_systems_using_criteria).
-
-And the reader who isn't that interested in voting systems might still
-want to think about how this could be useful in other areas: Development
-is often a constant series of small experiments and, while testing is
-often a good way to perform them, sometimes you just have a more
-exploratory "I wonder if...?" question to answer, and it can be
-extremely helpful to be able to bring Hypothesis to bear there too.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-29-testing-optimizers-with-hypothesis.md Deleted

@@ -1,160 +0,0 @@
----
-layout: post
-tags: technical python example properties
-date: 2016-05-29 21:00
-title: Testing Optimizers
-published: true
-author: drmaciver
-redirect_from: /articles/testing-optimizers
----
-
-We've previously looked into testing performance optimizations({{site.url}}{% post_url 2016-04-29-testing-performance-optimizations %})
-using Hypothesis, but this
-article is about something quite different: It's about testing code
-that is designed to optimize a value. That is, you have some function
-and you want to find arguments to it that maximize (or minimize) its
-value.
-
-As well as being an interesting subject in its own right, this will also
-nicely illustrate the use of Hypothesis's data() functionality, which
-allows you to draw more data after the test has started, and will
-introduce a useful general property that can improve your testing in
-a much wider variety of settings.
-
-
-
-We'll use the Knapsack Packing Problem(https://en.wikipedia.org/wiki/Knapsack_problem)
-as our example optimizer. We'll use the greedy approximation algorithm
-described in the link, and see if Hypothesis can show us that it's
-merely an approximation and not in fact optimal.
-
-```python
-def pack_knapsack(items, capacity):
-    """Given items as a list (value, weight), with value and weight
-    strictly positive integers, try to find a maximum value subset of
-    items with total weight <= capacity"""
-    remaining_capacity = capacity
-    result = 
-
-    # Sort in order of decreasing value per unit weight, breaking
-    # ties by taking the lowest weighted items first.
-    items = sorted(items, key=lambda x: (x1 / x0, x1))
-    for value, weight in items:
-        if weight <= remaining_capacity:
-            result.append((value, weight))
-            remaining_capacity -= weight
-    return result
-```
-
-So how are we going to test this?
-
-If we had another optimizer we could test by comparing the two results,
-but we don't, so we need to figure out properties it should satisfy in
-the absence of that.
-
-The trick we will used to test this is to look for responses to change.
-
-That is, we will run the function, we will make a change to the data
-that should cause the function's output to change in a predictable way,
-and then we will run the function again and see if it did.
-
-But how do we figure out what changes to make?
-
-The key idea is that we will look at the output of running the optimizer
-and use that to guide what changes we make. In particular we will test
-the following two properties:
-
-1. If we remove an item that was previously chosen as part of the
-   optimal solution, this should not improve the score.
-2. If we add an extra copy of an item that was previously chosen as part
-   of the optimal solution, this should not make the score worse.
-
-In the first case, any solution that is found when running with one
-fewer item would also be a possible solution when running with the full
-set, so if the optimizer is working correctly then it should have found
-that one if it were an improvement.
-
-In the second case, the opposite is true: Any solution that was
-previously available is still available, so if the optimizer is working
-correctly it can't find a worse one than it previously found.
-
-The two tests look very similar:
-
-```python
-from hypothesis import Verbosity, assume, given, settings, strategies as st
-
-
-def score_items(items):
-    return sum(value for value, _ in items)
-
-
-PositiveIntegers = st.integers(min_value=1, max_value=10)
-Items = st.lists(st.tuples(PositiveIntegers, PositiveIntegers), min_size=1)
-Capacities = PositiveIntegers
-
-
-@given(Items, Capacities, st.data())
-def test_cloning_an_item(items, capacity, data):
-    original_solution = pack_knapsack(items, capacity)
-    assume(original_solution)
-    items.append(data.draw(st.sampled_from(original_solution)))
-    new_solution = pack_knapsack(items, capacity)
-    assert score_items(new_solution) >= score_items(original_solution)
-
-
-@given(Items, Capacities, st.data())
-def test_removing_an_item(items, capacity, data):
-    original_solution = pack_knapsack(items, capacity)
-    assume(original_solution)
-    item = data.draw(st.sampled_from(original_solution))
-    items.remove(item)
-    new_solution = pack_knapsack(items, capacity)
-    assert score_items(new_solution) <= score_items(original_solution)
-```
-
-(The max_value parameter for integers is inessential but results in
-nicer example quality).
-
-The *data* strategy simply provides an object you can use for drawing
-more data interactively during the test. This allows us to make our
-choices dependent on the output of the function when we run it. The
-draws made will be printed as additional information in the case of a
-failing example.
-
-In fact, both of these tests fail:
-
-```
-
-Falsifying example: test_cloning_an_item(items=(1, 1), (1, 1), (2, 5), capacity=7, data=data(...))
-Draw 1: (1, 1)
-
-```
-
-In this case what happens is that when Hypothesis clones an item of
-weight and value 1, the algorithm stuffs its knapsack with all three
-(1, 1) items, at which point it has spare capacity but no remaining
-items that are small enough to fit in it.
-
-```
-
-Falsifying example: test_removing_a_chosen_item(items=(1, 1), (2, 4), (1, 2), capacity=6, data=data(...))
-Draw 1: (1, 1)
-
-```
-
-In this case what happens is the opposite: Previously the greedy
-algorithm was reaching for the (1, 1) item as the most appealing because
-it had the highest value to weight ratio, but by including it it only
-had space for one of the remaining two. When Hypothesis removed that
-option, it could fit the remaining two items into its knapsack and thus
-scored a higher point.
-
-In this case these failures were more or less expected: As described in
-the Wikipedia link, for the relatively small knapsacks we're exploring
-here the greedy approximation algorithm turns out to in fact be quite
-bad, and Hypothesis can easily expose that.
-
-This technique however can be more widely applied: e.g. You can try
-changing permissions and settings on a user and asserting that they
-always have more options, or increasing the capacity of a subsystem and
-seeing that it is always allocated more tasks.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-05-31-looking-for-guest-posts.md Deleted

@@ -1,36 +0,0 @@
----
-layout: post
-tags: non-technical news
-date: 2016-05-29 21:00
-title: Guest Posts Welcome
-published: true
-author: drmaciver
----
-
-I would like to see more posters on the hypothesis.works blog. I'm
-particularly interested in experience reports from people who use
-Hypothesis in the wild. Could that be you?
-
-
-
-Details of how to guest post on here:
-
-1. This site is a Jekyll site on GitHub(https://github.com/HypothesisWorks/HypothesisWorks.github.io).
-   To add a post, create a markdown file in the _posts directory with the
-   appropriate structure and send a pull request.
-2. You will want to add an entry for yourself to the authors data file(https://github.com/HypothesisWorks/HypothesisWorks.github.io/blob/master/_data/authors.yml)
-3. You of course retain all copyright to your work. All you're granting is the right to publish it on this site.
-
-I'd particularly like to hear from:
-
-* People who work in QA
-* People using the Django support
-* People using Hypothesis for heavily numerical work
-* People whose first experience of property based testing was via Hypothesis
-* People who would like to write about another property based testing system (
-  and ideally to compare it to Hypothesis)
-
-But I'd also like to hear from anyone else who would like to write
-something about Hypothesis, or property based testing in general: Whether
-it's an experience report, a cool trick you figured out, an introductory
-article to Hypothesis, etc.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-06-05-incremental-property-based-testing.md Deleted

@@ -1,281 +0,0 @@
----
-layout: post
-tags: intro python technical properties
-date: 2016-06-05 16:00
-title: Evolving toward property-based testing with Hypothesis
-published: true
-author: jml
----
-
-Many people are quite comfortable writing ordinary unit tests, but feel a bit
-confused when they start with property-based testing. This post shows how two
-ordinary programmers started with normal Python unit tests and nudged them
-incrementally toward property-based tests, gaining many advantages on the way.
-
-
-
-Background
-----------
-
-I used to work on a command-line tool with an interface much like git's. It
-had a repository, and within that repository you could create branches and
-switch between them. Let's call the tool `tlr`.
-
-It was supposed to behave something like this:
-
-List branches:
-
-    $ tlr branch
-    foo
-    * master
-
-Switch to an existing branch:
-
-    $ tlr checkout foo
-    * foo
-    master
-
-Create a branch and switch to it:
-
-    $ tlr checkout -b new-branch
-    $ tlr branch
-    foo
-    master
-    * new-branch
-
-Early on, my colleague and I found a bug: when you created a new branch with
-`checkout -b` it wouldn't switch to it. The behavior looked something like
-this:
-
-    $ tlr checkout -b new-branch
-    $ tlr branch
-    foo
-    * master
-    new-branch
-
-The previously active branch (in this case, `master`) stayed active, rather
-than switching to the newly-created branch (`new-branch`).
-
-Before we fixed the bug, we decided to write a test. I thought this would be a
-good chance to start using Hypothesis.
-
-Writing a simple test
----------------------
-
-My colleague was less familiar with Hypothesis than I was, so we started with
-a plain old Python unit test:
-
-```python
-def test_checkout_new_branch(self):
-    """Checking out a new branch makes it the current active branch."""
-    tmpdir = FilePath(self.mktemp())
-    tmpdir.makedirs()
-    repo = Repository.initialize(tmpdir.path)
-    repo.checkout("new-branch", create=True)
-    self.assertEqual("new-branch", repo.get_active_branch())
-```
-
-The first thing to notice here is that the string `"new-branch"` is not
-actually relevant to the test. It's just a value we picked to exercise the
-buggy code. The test should be able to pass with *any valid branch name*.
-
-Even before we started to use Hypothesis, we made this more explicit by making
-the branch name a parameter to the test:
-
-```python
-def test_checkout_new_branch(self, branch_name="new-branch"):
-    tmpdir = FilePath(self.mktemp())
-    tmpdir.makedirs()
-    repo = Repository.initialize(tmpdir.path)
-    repo.checkout(branch_name, create=True)
-    self.assertEqual(branch_name, repo.get_active_branch())
-```
-
-(For brevity, I'll elide the docstring from the rest of the code examples)
-
-We never manually provided the `branch_name` parameter, but this change made
-it more clear that the test ought to pass regardless of the branch name.
-
-Introducing Hypothesis
-----------------------
-
-Once we had a parameter, the next thing was to use Hypothesis to provide the
-parameter for us. First, we imported Hypothesis:
-
-```python
-from hypothesis import given, strategies as st
-```
-
-And then made the simplest change to our test to actually use it:
-
-```python
-@given(branch_name=st.just("new-branch"))
-def test_checkout_new_branch(self, branch_name):
-    tmpdir = FilePath(self.mktemp())
-    tmpdir.makedirs()
-    repo = Repository.initialize(tmpdir.path)
-    repo.checkout(branch_name, create=True)
-    self.assertEqual(branch_name, repo.get_active_branch())
-```
-
-Here, rather than providing the branch name as a default argument value, we
-are telling Hypothesis to come up with a branch name for us using the
-`just("new-branch")`
-strategy(https://hypothesis.readthedocs.io/en/latest/data.html). This
-strategy will always come up with `"new-branch"`, so it's actually no
-different from what we had before.
-
-What we actually wanted to test is that any valid branch name worked. We
-didn't yet know how to generate any valid branch name, but using a
-time-honored tradition we pretended that we did:
-
-```python
-def valid_branch_names():
-    """Hypothesis strategy to generate arbitrary valid branch names."""
-    # TODO: Improve this strategy.
-    return st.just("new-branch")
-
-
-@given(branch_name=valid_branch_names())
-def test_checkout_new_branch(self, branch_name):
-    tmpdir = FilePath(self.mktemp())
-    tmpdir.makedirs()
-    repo = Repository.initialize(tmpdir.path)
-    repo.checkout(branch_name, create=True)
-    self.assertEqual(branch_name, repo.get_active_branch())
-```
-
-Even if we had stopped here, this would have been an improvement. Although the
-Hypothesis version of the test doesn't have any extra power over the vanilla
-version, it is more explicit about what it's testing, and the
-`valid_branch_names()` strategy can be re-used by future tests, giving us a
-single point for improving the coverage of many tests at once.
-
-Expanding the strategy
-----------------------
-
-It's only when we get Hypothesis to start generating our data for us that we
-really get to take advantage of its bug finding power.
-
-The first thing my colleague and I tried was:
-
-```python
-def valid_branch_names():
-    return st.text()
-```
-
-But that failed pretty hard-core.
-
-Turns out branch names were implemented as symlinks on disk, so valid branch
-name has to be a valid file name on whatever filesystem the tests are running
-on. This at least rules out empty names, `"."`, `".."`, very long names, names
-with slashes in them, and probably others (it's actually
-really complicated(https://en.wikipedia.org/wiki/Filename#Comparison_of_filename_limitations)).
-
-Hypothesis had made something very clear to us: neither my colleague nor I
-actually knew what a valid branch name should be. None of our interfaces
-documented it, we had no validators, no clear ideas for rendering & display,
-nothing. We had just been assuming that people would pick good, normal,
-sensible names.
-
-It was as if we had suddenly gained the benefit of extensive real-world
-end-user testing, just by calling the right function. This was:
-
- 1. Awesome. We've found bugs that our users won't.
- 2. Annoying. We really didn't want to fix this bug right now.
-
-In the end, we compromised and implemented a relatively conservative strategy
-to simulate the good, normal, sensible branch names that we expected:
-
-```python
-from string import ascii_lowercase
-
-VALID_BRANCH_CHARS = ascii_lowercase + "_-."
-
-
-def valid_branch_names():
-    # TODO: Handle unicode / weird branch names by rejecting them early, raising nice errors
-    # TODO: How do we handle case-insensitive file systems?
-    return st.text(alphabet=VALID_BRANCH_CHARS, min_size=1, max_size=112)
-```
-
-Not ideal, but *much* more extensive than just hard-coding `"new-branch"`, and
-much clearer communication of intent.
-
-Adding edge cases
------------------
-
-There's one valid branch name that this strategy *could* generate, but
-probably won't: `master`. If we left the test just as it is, then one time in
-a hojillion the strategy would generate `"master"` and the test would fail.
-
-Rather than waiting on chance, we encoded this in the `valid_branch_names`
-strategy, to make it more likely:
-
-```python
-def valid_branch_names():
-    return st.text(alphabet=letters, min_size=1, max_size=112).map(
-        lambda t: t.lower()
-    ) | st.just("master")
-```
-
-When we ran the tests now, they failed with an exception due to the branch
-`master` already existing. To fix this, we used `assume`:
-
-```python
-from hypothesis import assume
-
-
-@given(branch_name=valid_branch_names())
-def test_checkout_new_branch(self, branch_name):
-    assume(branch_name != "master")
-    tmpdir = FilePath(self.mktemp())
-    tmpdir.makedirs()
-    repo = Repository.initialize(tmpdir.path)
-    repo.checkout(branch_name, create=True)
-    self.assertEqual(branch_name, repo.get_active_branch())
-```
-
-Why did we add `master` to the valid branch names if we were just going to
-exclude it anyway? Because when other tests say "give me a valid branch name",
-we want *them* to make the decision about whether `master` is appropriate or
-not. Any future test author will be compelled to actually think about whether
-handling `master` is a thing that they want to do. That's one of the great
-benefits of Hypothesis: it's like having a rigorous design critic in your
-team.
-
-Going forward
--------------
-
-We stopped there, but we need not have. Just as the test should have held for
-any branch, it should also hold for any repository. We were just creating an
-empty repository because it was convenient for us.
-
-If we were to continue, the next step would be to write a `repositories()`
-function to generate repositories({% post_url 2016-05-11-generating-the-right-data %})
-with more varied contents, commit histories, and existing branches.
-The test might then look something like this:
-
-```python
-@given(repo=repositories(), branch_name=valid_branch_names())
-def test_checkout_new_branch(self, repo, branch_name):
-    """
-    Checking out a new branch results in it being the current active
-    branch.
-    """
-    assume(branch_name not in repo.get_branches())
-    repo.checkout(branch_name, create=True)
-    self.assertEqual(branch_name, repo.get_active_branch())
-```
-
-This is about as close to a bona fide "property" as you're likely to get in
-code that isn't a straight-up computer science problem: if you create and
-switch to a branch that doesn't already exist, the new active branch is the
-newly created branch.
-
-We got there not by sitting down and thinking about the properties of our
-software in the abstract, nor by necessarily knowing much about property-based
-testing, but rather by incrementally taking advantage of features of Python
-and Hypothesis. On the way, we discovered and, umm, contained a whole class of
-bugs, and we made sure that all future tests would be heaps more powerful.
-Win.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-06-13-testing-configuration-parameters.md Deleted

@@ -1,151 +0,0 @@
----
-layout: post
-tags: technical python properties
-date: 2016-06-13 00:00
-title: Testing Configuration Parameters
-published: true
-author: drmaciver
----
-
-A lot of applications end up growing a complex configuration system,
-with a large number of different knobs and dials you can turn to change
-behaviour. Some of these are just for performance tuning, some change
-operational concerns, some have other functions.
-
-Testing these is tricky. As the number of parameters goes up, the number
-of possible configuration goes up exponentially. Manual testing of the
-different combinations quickly becomes completely unmanageable, not
-to mention extremely tedious.
-
-Fortunately, this is somewhere where property-based testing in general
-and Hypothesis in particular can help a lot.
-
-
-
-Configuration parameters almost all have one thing in common: For the
-vast majority of things, they shouldn't change the behaviour. A
-configuration parameter is rarely going to be a complete reskin of your
-application.
-
-This means that they are relatively easy to test with property-based
-testing. You take an existing test - either one that is already using
-Hypothesis or a normal example based test test - and you vary some
-configuration parameters and make sure the test still passes.
-
-This turns out to be remarkably effective. Here's an example where I
-used this technique and found some bugs in the Argon2(
-https://github.com/P-H-C/phc-winner-argon2) password hashing library,
-using Hynek(https://hynek.me/)'s
-CFFI based bindings(https://github.com/hynek/argon2_cffi).
-
-The idea of password hashing is straightforward: Given a password, you
-can create a hash against which the password can be verified without
-ever storing the password (after all, you're not storing passwords in
-plain text on your servers, right?). Although straightforward to
-describe, there's a lot of difficulty in making a good implementation
-of this. Argon2 is a fairly recent one which won the Password Hashing
-Competition(https://password-hashing.net/) so should be fairly good.
-
-We can verify that hashing works correctly fairly immediately using
-Hypothesis:
-
-```python
-from argon2 import PasswordHasher
-
-from hypothesis import given, strategies as st
-
-
-class TestPasswordHasherWithHypothesis:
-    @given(password=st.text())
-    def test_a_password_verifies(self, password):
-        ph = PasswordHasher()
-        hash = ph.hash(password)
-        assert ph.verify(hash, password)
-```
-
-This takes an arbitrary text password, hashes it and verifies it against
-the generated hash.
-
-This passes. So far, so good.
-
-But as you probably expected from its context here, argon2 has quite
-a lot of different parameters to it. We can expand the test to vary
-them and see what happens:
-
-```python
-from argon2 import PasswordHasher
-
-from hypothesis import assume, given, strategies as st
-
-
-class TestPasswordHasherWithHypothesis:
-    @given(
-        password=st.text(),
-        time_cost=st.integers(1, 10),
-        parallelism=st.integers(1, 10),
-        memory_cost=st.integers(8, 2048),
-        hash_len=st.integers(12, 1000),
-        salt_len=st.integers(8, 1000),
-    )
-    def test_a_password_verifies(
-        self,
-        password,
-        time_cost,
-        parallelism,
-        memory_cost,
-        hash_len,
-        salt_len,
-    ):
-        assume(parallelism * 8 <= memory_cost)
-        ph = PasswordHasher(
-            time_cost=time_cost,
-            parallelism=parallelism,
-            memory_cost=memory_cost,
-            hash_len=hash_len,
-            salt_len=salt_len,
-        )
-        hash = ph.hash(password)
-        assert ph.verify(hash, password)
-```
-
-
-These parameters are mostly intended to vary the difficulty of
-calculating the hash. Honestly I'm not entirely sure what all of them
-do. Fortunately for the purposes of writing this test, understanding is
-optional.
-
-In terms of how I chose the specific strategies to get there, I just
-picked some plausible looking parameters ranges and adjusted them until
-I wasn't getting validation errors (I did look for documentation, I
-promise). The assume() call comes from reading the argon2 source to try
-to find out what the valid range of parallelism was.
-
-This ended up finding
-two bugs(https://github.com/hynek/argon2_cffi/issues/4), which I duly
-reported to Hynek, but they actually turned out to be upstream bugs!
-
-In both cases, a password would no longer validate against itself:
-
-
-```
-Falsifying example: test_a_password_verifies(
-    password='', time_cost=1, parallelism=1, memory_cost=8, hash_len=4,
-    salt_len=8,
-)
-```
-
-```
-Falsifying example: test_a_password_verifies(
-    password='', time_cost=1, parallelism=1, memory_cost=8,
-    hash_len=513, salt_len=8
-)
-```
-
-(I found the second one by manually determining that the first bug
-happened whenever salt_len < 12 and manually ruling that case out).
-
-One interesting thing about both of these bugs is that they're actually
-not bugs in the Python library but are both downstream bugs. I hadn't
-set out to do that when I wrote these tests, but it nicely validates
-that Hypothesis is rather useful for testing C libraries as well as
-Python, given how easy they are to bind to with CFFI.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-06-30-tests-as-complete-specifications.md Deleted

@@ -1,167 +0,0 @@
----
-layout: post
-tags: technical python properties into
-date: 2016-06-30 00:00
-title: Testing as a Complete Specification
-published: true
-author: drmaciver
----
-
-Sometimes you're lucky enough to have problems where the result is
-completely specified by a few simple properties.
-
-This doesn't necessarily correspond to them being easy! Many such
-problems are actually extremely fiddly to implement.
-
-It does mean that they're easy to *test* though. Lets see how.
-
-
-
-Lets look at the problem of doing a binary search. Specifically we'll
-look at a left biased binary search: Given a sorted list and some value,
-we want to find the smallest index that we can insert that value at and
-still have the result be sorted.
-
-So we've got the following properties:
-
-1. binary_search must always return a valid index to insert the value
-   at.
-2. If we insert the value at that index the result must be sorted.
-3. If we insert the value at any *smaller* index, the result must *not*
-   be sorted.
-
-Using Hypothesis we can write down tests for all these properties:
-
-```python
-from hypothesis import given, strategies as st
-
-
-@given(lists(integers()).map(sorted), integers())
-def test_binary_search_gives_valid_index(ls, v):
-    i = binary_search(ls, v)
-    assert 0 <= i <= len(ls)
-
-
-@given(lists(integers()).map(sorted), integers())
-def test_inserting_at_binary_search_remains_sorted(ls, v):
-    i = binary_search(ls, v)
-    ls.insert(i, v)
-    assert sorted(ls) == ls
-
-
-@given(lists(integers()).map(sorted), integers())
-def test_inserting_at_smaller_index_gives_unsorted(ls, v):
-    for i in range(binary_search(ls, v)):
-        ls2 = list(ls)
-        ls2.insert(i, v)
-        assert sorted(ls2) != ls
-```
-
-If these tests pass, our implementation must be perfectly correct,
-right? They capture the specification of the binary_search function
-exactly, so they should be enough.
-
-And they mostly are, but they suffer from one problem that will
-sometimes crop up with property-based testing: They don't hit all bugs
-with quite high enough probability.
-
-This is the difference between testing and mathematical proof: A proof
-will guarantee that these properties *always* hold, while a test can
-only guarantee that they hold in the areas that it's checked. A test
-using Hypothesis will check a much wider area than most hand-written
-tests, but it's still limited to a finite set of examples.
-
-Lets see how this can cause us problems. Consider the following
-implementation of binary search:
-
-```python
-def binary_search(list, value):
-    if not list:
-        return 0
-    if value > list-1:
-        return len(list)
-    if value <= list0:
-        return 0
-    lo = 0
-    hi = len(list) - 1
-    while lo + 1 < hi:
-        mid = (lo + hi) // 2
-        pivot = listmid
-        if value < pivot:
-            hi = mid
-        elif value == pivot:
-            return mid
-        else:
-            lo = mid
-    return hi
-```
-
-This implements the common check that if our pivot index ever has
-exactly the right value we return early there. Unfortunately in this
-case that check is wrong: It violates the property that we should
-always find the *smallest* property, so the third test should fail.
-
-And sure enough, if you run the test enough times it eventually *does*
-fail:
-
-```
-Falsifying example: test_inserting_at_smaller_index_gives_unsorted(
-    ls=0, 1, 1, 1, 1, v=1
- )
-```
-
-(you may also get (ls=-1, 0, 0, 0, 0, v=0))
-
-However when I run it it usually *doesn't* fail the first time. It
-usually takes somewhere between two and five runs before it fails. This
-is because in order to trigger this behaviour being wrong you need
-quite specific behaviour: value needs to appear in ls at least
-twice, and it needs to do so in such a way that one of the indices where
-it appears that is *not* the first one gets chosen as mid at some
-point in the process. Hypothesis does some things that boost the
-chances of this happening, but they don't boost it *that* much.
-
-Of course, once it starts failing Hypothesis's test database kicks in,
-and the test keeps failing until the bug is fixed, but low probability
-failures are still annoying because they move the point at which you
-discover the problem further away from when you introduced it. This is
-especially true when you're using stateful testing
-({{site.url}}{% post_url 2016-04-19-rule-based-stateful-testing %}),
-because the search space is so large that there are a lot of low
-probability bugs.
-
-Fortunately there's an easy fix for this case: You can write additional
-tests that are more likely to discover bugs because they are less
-sensitively dependent on the example chosen by Hypothesis to exhibit
-interesting behaviours.
-
-Consider the following test:
-
-```python
-@given(lists(integers()).map(sorted), integers())
-def test_inserting_at_result_point_and_searching_again(ls, v):
-    i = binary_search(ls, v)
-    ls.insert(i, v)
-    assert binary_search(ls, v) == i
-```
-
-The idea here is that by doing a search, inserting the value at that
-index, and searching again we cannot have moved the insert point:
-Inserting there again would still result in a sorted list, and inserting
-any earlier would still have resulted in an unsorted list, so this must
-still be the same insert point (this should remind you a bit of 
-the approach for testing optimizers we used before(
-{{site.url}}{% post_url 2016-05-29-testing-optimizers-with-hypothesis %})
-).
-
-This test fails pretty consistently because it doesn't rely nearly so
-much on finding duplicates: Instead it deliberately creates them in a
-place where they are likely to be problematic.
-
-So, in conclusion:
-
-1. When the problem is fully specified, this gives you a natural source
-   of tests that you can easily write using Hypothesis.
-2. However this is where your tests should *start* rather than finish,
-   and you still need to think about other interesting ways to test your
-   software.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-07-04-calculating-the-mean.md Deleted

@@ -1,192 +0,0 @@
----
-layout: post
-tags: technical python properties intro
-date: 2016-07-04 00:00
-title: Calculating the mean of a list of numbers
-published: true
-author: drmaciver
----
-
-Consider the following problem:
-
-You have a list of floating point numbers. No nasty tricks - these
-aren't NaN or Infinity, just normal "simple" floating point numbers.
-
-Now: Calculate the mean (average). Can you do it?
-
-It turns out this is a hard problem. It's hard to get it even *close* to
-right. Lets see why.
-
-
-
-Consider the following test case using Hypothesis:
-
-```python
-from hypothesis import given
-from hypothesis.strategies import floats, lists
-
-
-@given(lists(floats(allow_nan=False, allow_infinity=False), min_size=1))
-def test_mean_is_within_reasonable_bounds(ls):
-    assert min(ls) <= mean(ls) <= max(ls)
-```
-
-This isn't testing much about correctness, only that the value of the
-mean is within reasonable bounds for the list: There are a lot of
-functions that would satisfy this without being the mean. min and max
-both satisfy this, as does the median, etc.
-
-However, almost nobody's implementation of the mean satisfies this.
-
-To see why, lets write our own mean:
-
-```python
-def mean(ls):
-    return sum(ls) / len(ls)
-```
-
-This seems reasonable enough - it's just the definition of the mean -
-but it's wrong:
-
-```
-assert inf <= 8.98846567431158e+307
- +  where inf = mean(8.988465674311579e+307, 8.98846567431158e+307)
- +  and   8.98846567431158e+307 = max(8.988465674311579e+307, 8.98846567431158e+307)
-
-Falsifying example: test_mean_is_within_reasonable_bounds(
-    ls=8.988465674311579e+307, 8.98846567431158e+307
-)
-```
-
-The problem is that finite floating point numbers may be large enough
-that their sum overflows to infinity. When you then divide infinity by a
-finite number you still get infinity, which is out of the range.
-
-So to prevent that overflow, lets try to bound the size of our numbers
-by the length *first*:
-
-```python
-def mean(ls):
-    return sum(l / len(ls) for l in ls)
-```
-
-```
-assert min(ls) <= mean(ls) <= max(ls)
-assert 1.390671161567e-309 <= 1.390671161566996e-309
-where 1.390671161567e-309 = min(1.390671161567e-309, 1.390671161567e-309, 1.390671161567e-309)
-and   1.390671161566996e-309 = mean(1.390671161567e-309, 1.390671161567e-309, 1.390671161567e-309)
-
-Falsifying example: test_mean_is_within_reasonable_bounds(
-    ls=1.390671161567e-309, 1.390671161567e-309, 1.390671161567e-309
-)
-```
-
-In this case the problem you run into is not overflow, but the lack of
-precision of floating point numbers: Floating point numbers are only
-exact up to powers of two times an integer, so dividing by three will
-cause rounding errors. In this case we have the problem that (x / 3) * 3
-may not be equal to x in general.
-
-So now we've got a sense of why this might be hard. Lets see how
-existing implementations do at satisfying this test.
-
-First let's try numpy:
-
-```python
-import numpy as np
-
-
-def mean(ls):
-    return np.array(ls).mean()
-```
-
-This runs into the problem we had in our first implementation:
-
-```
-assert min(ls) <= mean(ls) <= max(ls)
-assert inf <= 8.98846567431158e+307
-
-where inf = mean(8.988465674311579e+307, 8.98846567431158e+307)
-and   8.98846567431158e+307 = max(8.988465674311579e+307, 8.98846567431158e+307)
-
-Falsifying example: test_mean_is_within_reasonable_bounds(
-    ls=8.988465674311579e+307, 8.98846567431158e+307
-)
-```
-
-There's also the new statistics module from Python 3.4. Unfortunately,
-this is broken too
-(this is fixed in 3.5.2(https://bugs.python.org/issue25177)):
-
-```
-OverflowError: integer division result too large for a float
-
-Falsifying example: test_mean_is_within_reasonable_bounds(
-    ls=8.988465674311579e+307, 8.98846567431158e+307
-)
-```
-
-In the case where we previously overflowed to infinity this instead
-raises an error. The reason for this is that internally the statistics
-module is converting everything to the Fraction type, which is an
-arbitrary precision rational type. Because of the details of where and
-when they were converting back to floats, this produced a rational that
-couldn't be readily converted back to a float.
-
-It's relatively easy to write an implementation which passes this test
-by simply cheating and not actually calculating the mean:
-
-```python
-def clamp(lo, v, hi):
-    return min(hi, max(lo, v))
-
-
-def mean(ls):
-    return clamp(min(ls), sum(ls) / len(ls), max(ls))
-```
-
-i.e. just restricting the value to lie in the desired range.
-
-However getting an actually correct implementation of the mean (which
-*would* pass this test) is quite hard:
-
-To see just how hard, here's a 30 page
-paper on calculating the mean of two numbers(https://hal.archives-ouvertes.fr/file/index/docid/576641/filename/computing-midpoint.pdf).
-
-I wouldn't feel obliged to read that paper if I were you. I *have* read
-it and I don't remember many of the details.
-
-This test is a nice instance of a general one: Once you've got the
-this code doesn't crash({{site.url}}{% post_url 2016-04-15-getting-started-with-hypothesis %}),
-tests working, you can start to layer on additional constraints on the
-result value. As this example shows, even when the constraints you
-impose are *very* lax it can often catch interesting bugs.
-
-It also demonstrates a problem: Floating point mathematics is *very*
-hard, and this makes it somewhat unsuitable for testing with Hypothesis.
-
-This isn't because Hypothesis is *bad* at testing floating point code,
-it's because it's good at showing you how hard programming actually is,
-and floating point code is much harder than people like to admit.
-
-As a result, you probably don't care about the bugs it will find:
-Generally speaking most peoples' attitude to floating point errors is
-"Eh, those are weird numbers, we don't really care about that. It's
-probably good enough". Very few people are actually prepared to do the
-required work of a numerical sensitivity analysis that is needed if you
-want your floating point code to be correct.
-
-I used to use this example a lot for demonstrating Hypothesis to people,
-but because of these problems I tend not to any more: Telling people
-about bugs they're not going to want to fix will get you neither bug
-fixes nor friends.
-
-But it's worth knowing that this is a problem: Programming *is* really
-hard, and ignoring the problems won't make it less hard. You can ignore
-the correctness issues until they actually bite you, but it's best not
-to be surprised when they do.
-
-And it's also worth remembering the general technique here, because this
-isn't just useful for floating point numbers: Most code can benefit from
-this, and most of the time the bugs it tells you won't be nearly this
-unpleasant.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-07-09-hypothesis-3.4.1-release.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-07-13-hypothesis-3.4.2-release.md Deleted

@@ -1,43 +0,0 @@
----
-layout: post
-tags: news python non-technical
-date: 2016-07-13 00:00
-title: 3.4.2 Release of Hypothesis for Python
-published: true
-author: drmaciver
----
-
-This is a bug fix release, fixing a number of problems with the settings
-system:
-
-* Test functions defined using @given can now be called from other
-  threads (Issue #337)
-* Attempting to delete a settings property would previously have
-  silently done the wrong thing. Now it raises an AttributeError.
-* Creating a settings object with a custom database_file parameter
-  was silently getting ignored and the default was being used instead.
-  Now it’s not.
-
-## Notes
-
-For historic reasons, _settings.py had been excluded from the
-requirement to have 100% branch coverage. Issue #337 would have been
-caught by a coverage requirement: the code in question simply couldn't
-have worked, but it was not covered by any tests, so it slipped through.
-
-As part of the general principle that bugs shouldn't just be fixed
-without addressing the reason why the bug slipped through in the first
-place, I decided to impose the coverage requirements on _settings.py
-as well, which is how the other two bugs were found. Both of these had
-code that was never run during tests - in the case of the deletion bug
-there was a \_\_delete\_\_ descriptor method that was never being run,
-and in the case of the database\_file one there was a check later that
-could never fire because the internal \_database field was always being
-set in \_\_init\_\_.
-
-I feel like this experiment thoroughly validated that 100% coverage is a
-useful thing to aim for. Unfortunately it also pointed out that the
-settings system is *much* more complicated than it needs to be. I'm
-unsure what to do about that - some of its functionality is a bit too
-baked into the public API to lightly change, and I'm don't think it's
-worth breaking that just to simplify the code.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-07-23-what-is-hypothesis.md Deleted

@@ -1,161 +0,0 @@
----
-layout: post
-tags: python intro
-date: 2016-07-24 00:00
-title: What is Hypothesis?
-published: true
-author: drmaciver
----
-
-Hypothesis is a library designed to help you write what are called
-*property-based tests*.
-
-The key idea of property based testing is that rather than writing a test
-that tests just a single scenario, you write tests that describe a range
-of scenarios and then let the computer explore the possibilities for you
-rather than having to hand-write every one yourself.
-
-In order to contrast this with the sort of tests you might be used to, when
-talking about property-based testing we tend to describe the normal sort of
-testing as *example-based testing*.
-
-Property-based testing can be significantly more powerful than example based
-testing, because it automates the most time consuming part of writing tests
-- coming up with the specific examples - and will usually perform it better
-than a human would. This allows you to focus on the parts that humans are
-better at - understanding the system, its range of acceptable behaviours,
-and how they might break.
-
-You don't *need* a library to do property-based testing. If you've ever
-written a test which generates some random data and uses it for testing,
-that's a property-based test. But having a library can help you a lot,
-making your tests easier to write, more robust, and better at finding
-bugs. In the rest of this article we'll see how.
-
-
-
-### How to use it
-
-The key object of Hypothesis is a *strategy*. A strategy is a recipe for
-describing the sort of data you want to generate. The existence of a rich
-and comprehensive strategy library is the first big advantage of Hypothesis
-over a more manual process: Rather than having to hand-write generators
-for the data you want, you can just compose the ones that Hypothesis
-provides you with to get the data you want. e.g. if you want a lists of
-floats, you just use the strategy lists(floats()). As well as being
-easier to write, the resulting data will usually have a distribution
-that is much better at finding edge cases than all but the most heavily
-tuned manual implementations.
-
-As well as the basic out of the box strategy implementations, Hypothesis
-has a number of tools for composing strategies with user defined functions
-and constraints, making it fairly easy to generate the data you want.
-
-Note: For the remainder of this article I'll focus on the Hypothesis for
-Python implementation. The Java implementation is similar, but has a number
-of small differences that I'll discuss in a later article.
-
-Once you know how to generate your data, the main entry point to Hypothesis
-is the @given decorator. This takes a function that accepts some arguments
-and turns it into a normal test function.
-
-An important consequence of that is that Hypothesis is not itself a test
-runner. It works inside your normal testing framework - it will work fine
-with nose, py.test, unittest, etc. because all it does is expose a function
-of the right name that the test runner can then pick up.
-
-Using it with a py.test or nose style test looks like this:
-
-```python
-from mercurial.encoding import fromutf8b, toutf8b
-
-from hypothesis import given
-from hypothesis.strategies import binary
-
-
-@given(binary())
-def test_decode_inverts_encode(s):
-    assert fromutf8b(toutf8b(s)) == s
-```
-
-(This is an example from testing Mercurial which found two bugs:
-4927(https://bz.mercurial-scm.org/show_bug.cgi?id=4927) and 
-5031(https://bz.mercurial-scm.org/show_bug.cgi?id=5031)).
-
-In this test we are asserting that for any binary string, converting
-it to its utf8b representation and back again should result in the
-same string we started with. The @given decorator then handles
-executing this test over a range of different binary strings without
-us having to explicitly specify any of the examples ourself.
-
-When this is first run, you will see an error that looks something
-like this:
-
-```
-Falsifying example: test_decode_inverts_encode(s='\xc2\xc2\x80')
-
-Traceback (most recent call last):
-  File "/home/david/.pyenv/versions/2.7/lib/python2.7/site-packages/hypothesis/core.py", line 443, in evaluate_test_data
-    search_strategy, test,
-  File "/home/david/.pyenv/versions/2.7/lib/python2.7/site-packages/hypothesis/executors.py", line 58, in default_new_style_executor
-    return function(data)
-  File "/home/david/.pyenv/versions/2.7/lib/python2.7/site-packages/hypothesis/core.py", line 110, in run
-    return test(*args, **kwargs)
-  File "/home/david/hg/test_enc.py", line 8, in test_decode_inverts_encode
-    assert fromutf8b(toutf8b(s)) == s
-  File "/home/david/hg/mercurial/encoding.py", line 485, in fromutf8b
-    u = s.decode("utf-8")
-  File "/home/david/.pyenv/versions/2.7/lib/python2.7/encodings/utf_8.py", line 16, in decode
-    return codecs.utf_8_decode(input, errors, True)
-UnicodeDecodeError: 'utf8' codec can't decode byte 0xc2 in position 1: invalid continuation byte
-```
-
-Note that the falsifying example is quite small. Hypothesis has a
-"simplification" process which runs behind the scenes and generally
-tries to give the impression that the test simply failed with one
-example that happened to be a really nice one.
-
-Another important thing to note is that because of the random nature
-of Hypothesis and because this bug is relatively hard to find, this
-test may run successfully a couple of times before finding it.
-
-However, once that happens, when we rerun the test it will keep failing
-with the same example. This is because Hypothesis has a local test
-database that it saves failing examples in. When you rerun the test,
-it will first try the previous failure.
-
-This is pretty important: It means that although Hypothesis is at its
-heart random testing, it is *repeatable* random testing: A bug will
-never go away by chance, because a test will only start passing if
-the example that previously failed no longer failed.
-
-(This isn't entirely true because a bug could be caused by random
-factors such as timing or hash randomization. However in these cases
-it's true for example-based testing as well. If anything Hypothesis
-is *more* robust here because it will tend to find these cases with
-higher probability).
-
-Ultimately that's "all" Hypothesis does: It provides repeatability,
-reporting and simplification for randomized tests, and it provides
-a large library of generators to make it easier to write them.
-
-Because of these features, the workflow is a huge improvement on
-writing your own property-based tests by hand, and thanks to the
-library of generators it's often even easier than writing your
-own example based tests by hand.
-
-### What now?
-
-If you want to read more on the subject, there are a couple places
-you could go:
-
-* If you want to know more of the details of the process I described
-  when a test executes, you can check out the
-  Anatomy of a test({{site.url}}{% post_url 2016-04-16-anatomy-of-a-test %})
-  article which will walk you through the steps in more detail.
-* If you'd like more examples of how to use it, check out the rest of the
-  intro section({{site.url}}/articles/intro/).
-
-But really the best way to learn more is to try to use it!
-As you've hopefully seen in this article, it's quite approachable to
-get started with. Try writing some tests and see what happens.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-08-09-hypothesis-pytest-fixtures.md Deleted

@@ -1,151 +0,0 @@
----
-layout: post
-tags: technical faq python
-date: 2016-08-09 10:00
-title: How do I use pytest fixtures with Hypothesis?
-published: true
-author: drmaciver
----
-
-pytest(http://doc.pytest.org/en/latest/) is a great test runner, and is the one
-Hypothesis itself uses for testing (though Hypothesis works fine with other test
-runners too).
-
-It has a fairly elaborate fixture system(http://doc.pytest.org/en/latest/fixture.html),
-and people are often unsure how that interacts with Hypothesis. In this article we'll
-go over the details of how to use the two together.
-
-
-
-Mostly, Hypothesis and py.test fixtures don't interact: Each just ignores the other's
-presence.
-
-When using a @given decorator, any arguments that are not provided in the @given
-will be left visible in the final function:
-
-```python
-from inspect import getargspec
-
-from hypothesis import given, strategies as st
-
-
-@given(a=st.none(), c=st.none())
-def test_stuff(a, b, c, d):
-    pass
-
-
-print(getargspec(test_stuff))
-```
-
-This then outputs the following:
-
-```
-ArgSpec(args='b', 'd', varargs=None, keywords=None, defaults=None)
-```
-
-We've hidden the arguments 'a' and 'c', but the unspecified arguments 'b' and 'd'
-are still left to be passed in. In particular, they can be provided as py.test
-fixtures:
-
-```python
-from pytest import fixture
-
-from hypothesis import given, strategies as st
-
-
-@fixture
-def stuff():
-    return "kittens"
-
-
-@given(a=st.none())
-def test_stuff(a, stuff):
-    assert a is None
-    assert stuff == "kittens"
-```
-
-This also works if we want to use @given with positional arguments: 
-
-```python
-from pytest import fixture
-
-from hypothesis import given, strategies as st
-
-
-@fixture
-def stuff():
-    return "kittens"
-
-
-@given(t.none())
-def test_stuff(stuff, a):
-    assert a is None
-    assert stuff == "kittens"
-```
-
-The positional argument fills in from the right, replacing the 'a'
-argument and leaving us with 'stuff' to be provided by the fixture.
-
-Personally I don't usually do this because I find it gets a bit
-confusing - if I'm going to use fixtures then I always use the named
-variant of given. There's no reason you *can't* do it this way if
-you prefer though.
-
-@given also works fine in combination with parametrized tests:
-
-```python
-import pytest
-
-from hypothesis import given, strategies as st
-
-
-@pytest.mark.parametrize("stuff", 1, 2, 3)
-@given(a=st.none())
-def test_stuff(a, stuff):
-    assert a is None
-    assert 1 <= stuff <= 3
-```
-
-This will run 3 tests, one for each value for 'stuff'.
-
-There is one unfortunate feature of how this interaction works though: In pytest
-you can declare fixtures which do set up and tear down per function. These will
-"work" with Hypothesis, but they will run once for the entire test function
-rather than once for each time given calls your test function. So the following
-will fail:
-
-```python
-from pytest import fixture
-
-from hypothesis import given, strategies as st
-
-counter = 0
-
-
-@fixture(scope="function")
-def stuff():
-    global counter
-    counter = 0
-
-
-@given(a=st.none())
-def test_stuff(a, stuff):
-    global counter
-    counter += 1
-    assert counter == 1
-```
-
-The counter will not get reset at the beginning of each call to the test function,
-so it will be incremented each time and the test will start failing after the
-first call.
-
-There currently aren't any great ways around this unfortunately. The best you can
-really do is do manual setup and teardown yourself in your tests using
-Hypothesis (e.g. by implementing a version of your fixture as a context manager).
-
-Long-term, I'd like to resolve this by providing a mechanism for allowing fixtures
-to be run for each example (it's probably not correct to have *every* function scoped
-fixture run for each example), but for now it's stalled because it requires changes
-on the py.test side as well as the Hypothesis side(https://github.com/pytest-dev/pytest/issues/916)
-and we haven't quite managed to find the time and place to collaborate on figuring
-out how to fix this yet.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-08-19-recursive-data.md Deleted

@@ -1,164 +0,0 @@
----
-layout: post
-tags: technical python intro
-date: 2016-08-19 10:00
-title: Generating recursive data
-published: true
-author: drmaciver
----
-
-Sometimes you want to generate data which is *recursive*.
-That is, in order to draw some data you may need to draw
-some more data from the same strategy. For example we might
-want to generate a tree structure, or arbitrary JSON.
-
-Hypothesis has the *recursive* function in the hypothesis.strategies
-module to make this easier to do. This is an article about how to
-use it.
-
-
-
-Lets start with a simple example of drawing tree shaped data:
-In our example a tree is either a single boolean value (a leaf
-node), or a tuple of two child trees. So a tree might be e.g. True,
-or (False, True), or ((True, True), False), etc.
-
-First off, it might not be obvious that you *need* the recursive
-strategy. In principle you could just do this with composite:
-
-
-```python
-import hypothesis.strategies as st
-
-
-@st.composite
-def composite_tree(draw):
-    return draw(
-        st.one_of(
-            st.booleans(),
-            st.tuples(composite_tree(), composite_tree()),
-        )
-    )
-```
-
-If you try drawing examples from this you'll probably see one of
-three scenarios:
-
-1. You'll get a single boolean value
-2. You'll get a very large tree
-3. You'll get a RecursionError from a stack overflow
-
-It's unlikely that you'll see any non-trivial small examples.
-
-The reason for this is that this sort of recursion tends to
-explode in size: If this were implemneted as a naive random
-generation process then the expected size of the tree would
-be infinite. Hypothesis has some built in limiters to stop
-it ever trying to actually generate infinitely large amounts
-of data, but it will still tend to draw trees that are very
-large if they're not trivial, and it can't do anything about
-the recursion problem.
-
-So instead of using this sort of unstructured recursion,
-Hypothesis exposes a way of doing recursion in a slightly more
-structured way that lets it control the size of the
-generated data much more effectively. This is the recursive
-strategy.
-
-In order to use the recursive strategy you need two parts:
-
-1. A base strategy for generating "simple" instances of the
-   data that you want.
-2. A function that takes a child strategy that generates data
-   of the type you want and returns a new strategy generating
-   "larger" instances.
-
-So for example for our trees of booleans and tuples we could
-use booleans() for the first and something for returning tuples
-of children for the second:
-
-```python
-recursive_tree = st.recursive(
-    st.booleans(), lambda children: st.tuples(children, children)
-)
-```
-
-The way to think about the recursive strategy is that you're
-repeatedly building up a series of strategies as follows:
-
-```python
-s1 = base
-s2 = one_of(s1, extend(s1))
-s3 = one_of(s2, extend(s2))
-...
-```
-
-So at each level you augment the things from the previous
-level with your extend function. Drawing from the resulting
-recursive strategy then picks one of this infinite sequence
-of strategies and draws from it (this isn't quite what happens
-in practice, but it's pretty close).
-
-The resulting strategy does a much better job of drawing small
-and medium sized trees than our original composite based one
-does, and should never raise a RecursionError:
-
-```
->>> recursive_tree.example()
-((False, True), ((True, True), False))
-
->>> recursive_tree.example()
-((((False, False), True), False), False)
-
->>> recursive_tree.example()
-(False, True)
-
->>> recursive_tree.example()
-True
-
-```
-
-You can also control the size of the trees it draws with the
-third parameter to recursive:
-
-```
->>> st.recursive(st.booleans(), lambda children: st.tuples(children, children), max_leaves=2).example()
-True
-
->>> st.recursive(st.booleans(), lambda children: st.tuples(children, children), max_leaves=2).example()
-(True, False)
-```
-
-The max_leaves parameter controls the number of values drawn from
-the 'base' strategy. It defaults to 50, which will tend to give you
-moderately sized values. This helps keep example sizes under control,
-as otherwise it can be easy to create extend functions which cause the
-size to grow very rapidly.
-
-In this particular example, Hypothesis will typically not hit the default,
-but consider something like the following:
-
-```
->>> st.recursive(st.booleans(), lambda children: st.lists(children, min_size=3)).example()
-False,
-  True,
-  False,
-  False,
-  False,
-  True,
-  True,
-  True,
-  False,
-  False,
-  False,
-  True,
-  True,
-  False,
- False,
- False, True, False, True, False,
- True, False, True, False, False, False
-```
-
-In this case the size of the example will tend to push up against the max_leaves value
-because extend() grows the strategy in size quite rapidly, so if you want larger
-examples you will need to turn up max_leaves.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-08-31-how-many-tests.md Deleted

@@ -1,145 +0,0 @@
----
-layout: post
-tags: technical details faq python
-date: 2016-08-31 00:00
-title: How many times will Hypothesis run my test?
-published: true
-author: drmaciver
----
-
-This is one of the most common first questions about Hypothesis.
-
-People generally assume that the number of tests run will depend on
-the specific strategies used, but that's generally not the case.
-Instead Hypothesis has a fairly fixed set of heuristics to determine
-how many times to run, which are mostly independent of the data
-being generated.
-
-But how many runs is *that*?
-
-The short answer is 200. Assuming you have a default configuration
-and everything is running smoothly, Hypothesis will run your test
-200 times.
-
-The longer answer is "It's complicated". It will depend on the exact
-behaviour of your tests and the value of some settings. In this article
-I'll try to clear up some of the specifics of which
-settings(http://hypothesis.readthedocs.io/en/latest/settings.html)
-affect the answer and how.
-
-
-
-Advance warning: This is a set of heuristics built up over time. It's
-probably not the best choice of heuristics, but it mostly seems
-to work well in practice. It will hopefully be replaced with a
-simpler set of rules at some point.
-
-The first setting that affects how many times the test function will
-be called is the timeout setting. This specifies a maximum amount of
-time for Hypothesis to run your tests for. Once that has exceeded it
-will stop and not run any more (note: This is a soft limit, so it
-won't interrupt a test midway through).
-
-The result of this is that slow tests may get run fewer times. By
-default the timeout is one minute, which is high enough that most
-tests shouldn't hit it, if your tests take somewhere in the region
-of 300-400ms on average they will start to hit the timeout.
-
-The timeout is respected regardless of whether the test passes or
-fails, but other than that the behaviour for a passing test is
-very different from a failing one.
-
-### Passing tests
-
-For the passing case there are two other settings that affect the
-answer: max\_examples and max\_iterations.
-
-In the normal case, max\_examples is what you can think of as the
-number of test runs. The difference comes when you start using
-assume or filter (and a few other cases).
-
-Hypothesis distinguishes between a *valid* test run and an invalid one
-- if assume has been called with a falsey value or at some point in
-the generation process it got stuck (e.g. because filter couldn't
-find any satisfying examples) it aborts the example and starts
-again from the beginning. max\_examples counts only valid examples
-while max\_iterations counts all examples, valid or otherwise. Some
-duplicate tests will also be considered invalid (though Hypothesis
-can't distinguish all duplicates. e.g. if you did
-integers().map(lambda x: 1) it would think you had many distinct values
-when you only had one). The default value for max_iterations
-is currently 1000.
-
-To see why it's important to have the max\_iterations limit,
-consider something like:
-
-```python
-from hypothesis import assume, given, strategies as st
-
-
-@given(st.integers())
-def test_stuff(i):
-    assume(False)
-```
-
-Then without a limit on invalid examples this would run forever.
-
-Conversely however, treating valid examples specially is useful because
-otherwise even casual use of assume would reduce the number of tests
-you run, reducing the quality of your testing.
-
-Another thing to note here is that the test with assume(False) will
-actually fail, raising:
-
-```
-hypothesis.errors.Unsatisfiable: Unable to satisfy assumptions of hypothesis test_stuff. Only 0 examples considered satisfied assumptions
-```
-
-This is because of the min\_satisfying\_examples setting: If
-Hypothesis couldn't find enough valid test cases then it will
-fail the test rather than silently doing the wrong thing.
-
-min\_satisfying\_examples will never increase the number of tests
-run, only fail the test if that number of valid examples haven't
-been run. If you're hitting this failure you can either turn it
-down or turn the timeout or max\_iterations up. Better, you can
-figure out *why* you're hitting that and fix it, because it's
-probably a sign you're not getting much benefit out of Hypothesis.
-
-
-### Failing tests
-
-If in the course of normal execution Hypothesis finds an example
-which causes your test to fail, it switches into shrinking mode.
-
-Shrinking mode tries to take your example and produce a smaller
-one. It ignores max\_examples and max\_iterations but respects
-timeout. It also respects one additional setting: max\_shrinks.
-
-max\_shrinks is the maximum number of *failing* tests that Hypothesis
-will see before it stops. It may try any number of valid or invalid
-examples in the course of shrinking. This is because failing
-examples tend to be a lot rarer than passing or invalid examples,
-so it makes more sense to limit based on that if we want to get
-good examples out at the end.
-
-Once Hypothesis has finished shrinking it will run your test once
-more to replay it for display: In the final run only it will print
-out the example and any notes, and will let the exception bubble
-up to the test runner to be handled as normal.
-
-
-### In Conclusion
-
-"It's complicated".
-
-These heuristics are probably not the best. They've evolved
-over time, and are definitely not the ones that you or I would
-obviously come up with if you sat down and designed the system
-from scratch.
-
-Fortunately, you're not expected to know these heuristics by heart
-and mostly shouldn't have to. I'm working on a new feature that
-will help show how many examples Hypothesis has tried and help
-debug why it's stopped at that point. Hopefully it will be coming
-in a release in the near future.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-09-04-hypothesis-vs-eris.md Deleted

@@ -1,224 +0,0 @@
----
-layout: post
-tags: technical python intro
-date: 2016-09-04 15:00
-title: Hypothesis vs. Eris
-published: true
-author: giorgiosironi
----
-
-Eris(https://github.com/giorgiosironi/eris/) is a library for property-based testing of PHP code, inspired by the mature frameworks that other languages provide like QuickCheck(https://hackage.haskell.org/package/QuickCheck), Clojure's test.check(https://github.com/clojure/test.check) and of course Hypothesis.
-
-Here is a side-by-side comparison of some basic and advanced features that have been implemented in both Hypothesis and Eris, which may help developers coming from either Python or PHP and looking at the other side.
-
-
-
-## Hello, world
-
-The first example can be considered an `Hello, world` of randomized testing: given two random numbers, their sum should be constant no matter the order in which they are summed. The test case has two input parameters, so that it can be run dozens or hundreds of times, each run with different and increasingly complex input values.
-
-Hypothesis provides an idiomatic Python solution, the `@given` decorator, that can be used to compose the strategies objects instantiated from `hypothesis.strategies`. The test case is very similar to an example-based one, except for the addition of arguments:
-
-```python
-import unittest
-
-from hypothesis import given, strategies as st
-
-
-class TestEris(unittest.TestCase):
-    "Comparing the syntax and implementation of features with Eris"
-
-    @given(st.integers(), st.integers())
-    def test_sum_is_commutative(self, first, second):
-        x = first + second
-        y = second + first
-        self.assertEqual(
-            x, y, "Sum between %d and %d should be commutative" % (first, second)
-        )
-```
-
-In this example, I am using the unittest syntax for maximum test portability, but this does not affect Hypothesis, which works across testing frameworks.
-
-Eris provides functionality with a trait instead, that can be composed into the test cases that need access to randomized input. The test method is not augmented with additional parameters, but its code is moved inside an anonymous function for the `then()` primitive. Input distributions are defined in a mathematically-named `forAll()` primitive:
-
-```php
-<?php
-use Eris\Generator;
-use Eris\TestTrait;
-
-class IntegerTest extends PHPUnit_Framework_TestCase
-{
-    use TestTrait;
-
-    public function testSumIsCommutative()
-    {
-        $this
-            ->forAll(
-                Generator\int(),
-                Generator\int()
-            )
-            ->then(function ($first, $second) {
-                $x = $first + $second;
-                $y = $second + $first;
-                $this->assertEquals(
-                    $x,
-                    $y,
-                    "Sum between {$first} and {$second} should be commutative"
-                );
-            });
-    }
-```
-
-Both these tests will be run hundreds of times, each computing two sums and comparing them for equality with the assertion library of the underlying testing framework (unittest and PHPUnit).
-
-## Composing strategies
-
-A very simple composition problem consists of generating a collection data structured whose elements are drawn from a known distribution, for example a list of integers. Hypothesis provides *strategies* that can compose other strategies, in this case to build a list of random integers of arbitrary length:
-
-```python
-@given(st.lists(st.integers()))
-def test_sorting_a_list_twice_is_the_same_as_sorting_it_once(self, xs):
-    xs.sort()
-    ys = list(xs)
-    xs.sort()
-    self.assertEqual(xs, ys)
-```
-
-Eris calls *generators* the objects representing statistical distributions, but uses the same compositional pattern for higher-order values like lists and all collections:
-
-```php
-    public function testArraySortingIsIdempotent()
-    {
-        $this
-            ->forAll(
-                Generator\seq(Generator\nat())
-            )
-            ->then(function ($array) {
-                sort($array);
-                $expected = $array;
-                sort($array);
-                $this->assertEquals($expected, $array);
-            });
-    }
-```
-
-In both these test cases, we generate a random list and check that the sorting operation is idempotent: operating it twice on the input data gives the same result as operating it once.
-
-## Filtering generated values
-
-Not all problems are abstract enough to accept all values in input, so it may be necessary to exclude part of the generated values when they do not fit our needs.
-
-Hypothesis provides a `filter()` method to apply a lambda to values, expressing a condition for them to be included in the test:
-
-```python
-@given(st.integers().filter(lambda x: x > 42))
-def test_filtering(self, x):
-    self.assertGreater(x, 42)
-```
-
-Eris allows to filter values with a predicate in the same way, but prefers to allocate the filter to the generic `ForAll` object rather than decorate it on each Generator:
-
-```php
-    public function testWhenWithAnAnonymousFunctionWithGherkinSyntax()
-    {
-        $this
-            ->forAll(
-                Generator\choose(0, 1000)
-            )
-            ->when(function ($n) {
-                return $n > 42;
-            })
-            ->then(function ($number) {
-                $this->assertTrue(
-                    $number > 42,
-                    "\$number was filtered to be more than 42, but it's $number"
-                );
-            });
-    }
-```
-
-Filtering and the constructs that follow are integrated with shrinking in both Hypothesis and Eris: once a test fails and shrinking starts, constraints and transformations will continue to be applied to the generated values so that the simpler inputs are still going to belong to the same distribution; in this scenario, shrinking would only be able to propose numbers greater than 42.
-
-## Transforming generated values
-
-Another common need consists of transforming the generated value to a different space, for example the set of all even numbers rather than the (larger) set of integers. Hypothesis allows to do this by passing a lambda to the `map()` method of a strategy:
-
-```python
-@given(st.integers().map(lambda x: x * 2))
-def test_mapping(self, x):
-    self.assertEqual(x % 2, 0)
-```
-
-Eris instead provides a `Map` higher-order generator, which applies the lambda during generation:
-
-```php
-    public function testApplyingAFunctionToGeneratedValues()
-    {
-        $this
-            ->forAll(
-                Generator\map(
-                    function ($n) { return $n * 2; },
-                    Generator\nat()
-                )
-            )
-            ->then(function ($number) {
-                $this->assertTrue(
-                    $number % 2 == 0,
-                    "$number is not even"
-                );
-            });
-    }
-```
-
-In both cases, the advantage of using the `map` support from the library (rather than writing our own multiplying code in the tests) is that the resulting object can be further composed to build larger data structures like a list or set of even numbers.
-
-## Generators with random parameters
-
-It's possible to build even stricter values, that have internal constraints that must be satisfied but can't easily be generated by applying a pure function to a previously generated value.
-
-Hypothesis provides the `flatmap()` method to pass the output of an inner strategy to a lambda that creates an outer strategy to use in the test. Here a list of 4 integers is passed to the lambda, to generate a tuple consisting of the list and a random element chosen from it:
-
-```python
-@given(
-    st.lists(st.integers(), min_size=4, max_size=4).flatmap(
-        lambda xs: st.tuples(st.just(xs), st.sampled_from(xs))
-    )
-)
-def test_list_and_element_from_it(self, pair):
-    (generated_list, element) = pair
-    self.assertIn(element, generated_list)
-```
-
-Eris does the same with a slightly different naming, calling this primitive `bind`:
-
-```php
-    public function testCreatingABrandNewGeneratorFromAGeneratedValue()
-    {
-        $this
-            ->forAll(
-                Generator\bind(
-                    Generator\vector(4, Generator\nat()),
-                    function ($vector) {
-                        return Generator\tuple(
-                            Generator\elements($vector),
-                            Generator\constant($vector)
-                        );
-                    }
-                )
-            )
-            ->then(function ($tuple) {
-                list($element, $vector) = $tuple;
-                $this->assertContains($element, $vector);
-            });
-    }
-```
-
-## What the future brings
-
-Hypothesis is a much more mature project than Eris, especially when it comes to keeping state between test runs or acting as a generic random data provider rather than as an extension to a testing framework. It will be interesting to continue porting Hypothesis features to the PHP world, given the original features and patterns that Hypothesis shows with respect to the rest of the `*Check` world.
-
-## References
-
-The Hypothesis examples shown in this post can be found in this example repository(https://github.com/giorgiosironi/hypothesis-exploration/blob/master/test_eris.py).
-
-The Eris examples can instead be found in the example/ folder of the(https://github.com/giorgiosironi/eris/blob/master/examples/IntegerTest.php#L9) Eris(https://github.com/giorgiosironi/eris/blob/master/examples/SequenceTest.php#L31) repository(https://github.com/giorgiosironi/eris/blob/master/examples/WhenTest.php#L8) on(https://github.com/giorgiosironi/eris/blob/master/examples/MapTest.php#L8) GitHub(https://github.com/giorgiosironi/eris/blob/master/examples/BindTest.php#L8).

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-09-23-hypothesis-3.5.0-release.md Deleted

@@ -1,66 +0,0 @@
----
-layout: post
-tags: news python non-technical
-date: 2016-09-23 00:00
-title: 3.5.0 and 3.5.1 Releases of Hypothesis for Python
-published: true
-author: drmaciver
----
-
-This is a combined release announcement for two releases. 3.5.0
-was released yesterday, and 3.5.1 has been released today after
-some early bug reports in 3.5.0
-
-## Changes
-
-### 3.5.0 - 2016-09-22
-
-This is a feature release.
-
-* fractions() and decimals() strategies now support min_value and max_value
-  parameters. Thanks go to Anne Mulhern for the development of this feature.
-* The Hypothesis pytest plugin now supports a --hypothesis-show-statistics parameter
-  that gives detailed statistics about the tests that were run. Huge thanks to
-  Jean-Louis Fuchs(https://github.com/ganwell) and Adfinis-SyGroup(https://www.adfinis-sygroup.ch/)
-  for funding the development of this feature.
-* There is a new event() function that can be used to add custom statistics.
-
-Additionally there have been some minor bug fixes:
-
-* In some cases Hypothesis should produce fewer duplicate examples (this will mostly
-  only affect cases with a single parameter).
-* py.test command line parameters are now under an option group for Hypothesis (thanks
-  to David Keijser for fixing this)
-* Hypothesis would previously error if you used function annotations on your tests under
-  Python 3.4.
-* The repr of many strategies using lambdas has been improved to include the lambda body
-  (this was previously supported in many but not all cases).
-
-
-### 3.5.1 - 2016-09-23
-
-This is a bug fix release.
-
-* Hypothesis now runs cleanly in -B and -BB modes, avoiding mixing bytes and unicode.
-* unittest.TestCase tests would not have shown up in the new statistics mode. Now they
-  do.
-* Similarly, stateful tests would not have shown up in statistics and now they do.
-* Statistics now print with pytest node IDs (the names you'd get in pytest verbose mode).
-
-
-## Notes
-
-Aside from the above changes, there are a couple big things behind the scenes of this
-release that make it a big deal.
-
-The first is that the flagship chunk of work, statistics, is a long-standing want to
-have that has never quite been prioritised. By funding it, Jean-Louis and Adfinis-SyGroup
-successfully bumped it up to the top of the priority list, making it the first funded
-feature in Hypothesis for Python!
-
-Another less significant but still important is that this release marks the first real
-break with an unofficial Hypothesis for Python policy of not having any dependencies
-other than the standard library and backports. This release adds a dependency on the
-uncompyle6 package. This may seem like an odd choice, but it was invaluable for fixing
-the repr behaviour, which in turn was really needed for providing good statistics
-for filter and recursive strategies.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-10-01-pytest-integration-sponsorship.md Deleted

@@ -1,65 +0,0 @@
----
-layout: post
-tags: news python non-technical
-date: 2016-10-01 00:00
-title: Seeking funding for deeper integration between Hypothesis and pytest
-published: true
-author: drmaciver
----
-
-Probably the number one complaint I hear from Hypothesis users is that it
-"doesn't work" with py.test fixtures. This isn't true(http://hypothesis.works/articles/hypothesis-pytest-fixtures/),
-but it does have one very specific limitation in how it works that annoys people:
-It only runs function scoped fixtures once for the entire test, not once per
-example. Because of the way people use function scoped fixtures for handling
-stateful things like databases, this often causes people problems.
-
-I've been maintaining for a while(https://github.com/pytest-dev/pytest/issues/916) that
-this is impossible to fix without some changes on the pytest end.
-
-The good news is that this turns out not to be the case. After some conversations with
-pytest developers, some examining of other pytest plugins, and a bunch of prototyping,
-I'm pretty sure it's possible. It's just really annoying and a lot of work.
-
-So that's the good news. The bad news is that this isn't going to happen without
-someone funding the work.
-
-I've now spent about a week of fairly solid work on this, and what I've got is
-quite promising: The core objective of running pytest fixtures for every examples
-works fairly seamlessly.
-
-But it's now in the long tail of problems that will need to be squashed before
-this counts as an actual production ready releasable piece of work. A number of
-things *don't* work. For example, currently it's running some module scoped
-fixtures once per example too, which it clearly shouldn't be doing. It also
-currently has some pretty major performance problems that are bad enough that
-I would consider them release blocking.
-
-As a result I'd estimate there's easily another 2-3 weeks of work needed to
-get this out the door.
-
-Which brings us to the crux of the matter: 2-3 additional weeks of free work
-on top of the one I've already done is 3-4 weeks more free work than I
-particularly want to do on this feature, so without sponsorship it's not
-getting finished.
-
-I typically charge £400/day for work on Hypothesis (this is heavily discounted
-off my normal rates), so 2-3 weeks comes to £4000 to £6000 (roughly $5000
-to $8000) that has to come from somewhere.
-
-I know there are a number of companies out there using pytest and Hypothesis
-together. I know from the amount of complaining about this integration that
-this is a real problem you're experiencing. So, I think this money should
-come from those companies. Besides helping to support a tool you've already
-got a lot of value out of, this will expand the scope of what you can easily
-test with Hypothesis a lot, and will be hugely beneficial to your bug finding
-efforts.
-
-This is a model that has worked well before with the funding of the recent
-statistics work by Jean-Louis Fuchs(https://github.com/ganwell) and
-Adfinis-SyGroup(https://www.adfinis-sygroup.ch/), and I'm confident it can
-work well again.
-
-If you work at such a company and would like to talk about funding some or
-part of this development, please email me at
-drmaciver@hypothesis.works(mailto:drmaciver@hypothesis.works).

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-10-17-canonical-serialization.md Deleted

@@ -1,130 +0,0 @@
----
-layout: post
-tags: python intro technical properties
-date: 2016-10-17 06:00
-title: Another invariant to test for encoders
-published: true
-author: drmaciver
----
-
-The encode/decode invariant({{site.url}}{% post_url 2016-04-16-encode-decode-invariant %})
-is one of the most important properties to know about for testing your code with Hypothesis
-or other property-based testing systems, because it captures a very common pattern and is
-very good at finding bugs.
-
-But how do you go beyond it? If encoders are that common, surely there must be other things
-to test with them?
-
-
-
-The first thing that people tend to try is to simply reverse the order of operations. Continuing
-the same example from the encode/decode post, this would look something like this:
-
-```python
-from hypothesis import given
-from hypothesis.strategies import characters, integers, lists, tuples
-
-
-@given(lists(tuples(characters(), integers(1, 10))))
-def test_encode_inverts_decode(s):
-    assert encode(decode(s)) == s
-```
-
-But unlike the other way around, this test can fail for reasons that are not obviously
-errors in the system under test. In particular this will fail with the example ('0', 1), ('0', 1),
-because this will be decoded into '00', which will then be encoded into ('0', 2).
-
-In general, it is quite common to have multiple non-canonical representations of data
-when encoding: e.g. JSON has non-significant whitespace, an IP address has a wide range
-of human readable representations, most compressors will evolve to improve their compression
-over time but will still be able to handle compressed files made with old versions of
-the code, etc.
-
-So this test *shouldn't* be expected to pass.
-
-To rescue this, we might imagine we had some sort of function make\_canonical which
-took an encoded data representation and replaced it with a canonical version of that (e.g.
-by normalizing whitespace). The test could then look like this:
-
-
-```python
-@given(lists(tuples(characters(), integers(1, 10))))
-def test_encode_inverts_decode(s):
-    assert make_canonical(encode(decode(s))) == make_canonical(s)
-```
-
-But where would we get that make\_canonical function from? It's not something we really
-want to write ourselves.
-
-Fortunately we can put together the pieces we already have to define such a function
-fairly easily. To see this, lets think about what properties make\_canonical should have.
-
-The following seem reasonable:
-
-1. encode should always produce canonical data. i.e. encode(t) == make_canonical(encode(t))
-2. Canonical data should represent the same value. i.e. decode(s) == decode(make_canonical(s))
-
-But we already know that decode(encode(t)) == t from our original property, so we have a
-natural source of data that is the output of encode: We just decode the data and then
-encode it again.
-
-This gives us the following natural definition of make_canonical:
-
-```python
-def make_canonical(data):
-    return encode(decode(data))
-```
-
-But this is nearly the same as the thing we were testing, so we can rewrite our test as:
-
-```python
-@given(lists(tuples(characters(), integers(1, 10))))
-def test_encode_inverts_decode(s):
-    assert make_canonical(make_canonical(s)) == make_canonical(s)
-```
-
-This property is called
-being idempotent (annoyingly "idempotent" gets used to mean something subtly different
-in most API design, but this is the original mathematical meaning).
-
-It's less obviously necessary than the original one, and you can certainly
-write encode/decode pairs that are arguably correct but don't have it (e.g. because
-they change the order of keys in a dictionary, or include a timestamp or sequence
-number in the output), but I think it's
-still worth having and testing. Enforcing consistency like this both helps with debugging
-when things go wrong and also tends to flush out other bugs along the way.
-
-Even if you don't want to enforce this property, it highlights an important issue: You
-do need *some* sort of testing of the decoder that doesn't just operate on output from
-the encoder, because the encoder will potentially only output a relatively small subset
-of the valid range of the format.
-
-Often however you'll get the property for free. If the encode and decode functions
-have the property that whenever x == y then f(x) == f(y), then this property automatically
-holds, because make_canonical(x) is encode(decode(encode(decode(x)))), and we know from the
-first property that decode(encode(t)) == t, so with t = decode(x) this expression is
-encode(decode(x)), which is make_canonical(x) as required.
-
-Most encode/decode pairs will have this property, but not all.
-
-The easiest ways to fail to have it are to have side-effects (the aforementioned sequence
-number or randomization), but even without side effects it's possible for it to fail
-if equality doesn't capture every detail about the type. For example in
-Python, if 1.0 was serialized as 1, then the two would compare equal and the property
-would pass, but when re-encoding it might exhibit very different properties (although
-you'd hope that it wouldn't). Another example is that in Python an OrderedDict and a
-dict compare equal regardless of iteration order, which means that two apparently
-equal types might encode to different things if they have different iteration orders
-defined.
-
-Ultimately these issues are probably quite niche. It's likely still worth testing for
-this property, both because of these problems and also because often mathematically
-equivalent properties can still catch different issues({{site.url}}{% post_url 2016-06-30-tests-as-complete-specifications %}),
-but it's significantly less important than the more general property we started
-with.
-
---------------------------------------
-
-Thanks to Georges Dubus(https://twitter.com/georgesdubus) who pointed out
-the key insight behind the last section on this property following from the original
-one.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-10-31-hypothesis-3.6.0-release.md Deleted

@@ -1,57 +0,0 @@
----
-layout: post
-tags: news python non-technical
-date: 2016-10-31 00:00
-title: 3.6.0 Release of Hypothesis for Python
-published: true
-author: drmaciver
----
-
-This is a release announcement for the 3.6.0 release of Hypothesis for
-Python. It's a bit of an emergency release.
-
-Hypothesis 3.5.0 inadvertently added a dependency on GPLed code (see below
-for how this happened) which this release removes. This means that if you
-are running Hypothesis 3.5.x then there is a good chance you are in violation
-of the GPL and you should update immediately.
-
-Apologies for any inconvenience this may have caused.
-
-
-
-### From the Changelog
-
-This release reverts Hypothesis to its old pretty printing of lambda functions
-based on attempting to extract the source code rather than decompile the bytecode.
-This is unfortunately slightly inferior in some cases and may result in you
-occasionally seeing things like `lambda x: <unknown>` in statistics reports and
-strategy reprs.
-
-This removes the dependencies on uncompyle6, xdis and spark-parser.
-
-The reason for this is that the new functionality was based on uncompyle6, which
-turns out to introduce a hidden GPLed dependency - it in turn depended on xdis,
-and although the library was licensed under the MIT license, it contained some
-GPL licensed source code and thus should have been released under the GPL.
-
-My interpretation is that Hypothesis itself was never in violation of the GPL
-(because the license it is under, the Mozilla Public License v2, is fully
-compatible with being included in a GPL licensed work), but I have not consulted
-a lawyer on the subject. Regardless of the answer to this question, adding a
-GPLed dependency will likely cause a lot of users of Hypothesis to inadvertently
-be in violation of the GPL.
-
-As a result, if you are running Hypothesis 3.5.x you really should upgrade to
-this release immediately.
-
-### Notes
-
-This Halloween release brought to you by the specter of inadvertent GPL
-violations (but sadly this is entirely real and neither trick nor treat).
-
-This dependency also caused a number of other problems, so in many ways its
-not entirely a bad thing that it's gone, but it's still sad to remove
-functionality. At some point in the future I will try to restore the
-lost functionality, but doing it without access to uncompyle6 will be a
-moderate amount of work, so it's not going to be high priority in the
-near future.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-12-05-integrated-shrinking.md Deleted

@@ -1,167 +0,0 @@
----
-layout: post
-tags: technical details python alternatives
-date: 2016-12-05 10:00
-title: Integrated vs type based shrinking
-published: true
-author: drmaciver
----
-
-One of the big differences between Hypothesis and Haskell QuickCheck is
-how shrinking is handled.
-
-Specifically, the way shrinking is handled in Haskell QuickCheck is bad
-and the way it works in Hypothesis (and also in test.check and EQC) is
-good. If you're implementing a property based testing system, you should
-use the good way. If you're using a property based testing system and it
-doesn't use the good way, you need to know about this failure mode.
-
-Unfortunately many (and possibly most) implementations of property based
-testing are based on Haskell's QuickCheck and so make the same mistake.
-
-
-
-The big difference is whether shrinking is integrated into generation.
-
-In Haskell's QuickCheck, shrinking is defined based on *types*: Any
-value of a given type shrinks the same way, regardless of how it is
-generated. In Hypothesis, test.check, etc. instead shrinking is part
-of the generation, and the generator controls how the values it produces
-shrinks (this works differently in Hypothesis and test.check, and probably
-differently again in EQC, but the user visible result is largely the
-same)
-
-This is not a trivial distinction. Integrating shrinking into generation 
-has two large benefits:
-
-* Shrinking composes nicely, and you can shrink anything you can generate
-  regardless of whether there is a defined shrinker for the type produced.
-* You can guarantee that shrinking satisfies the same invariants as generation.
-
-The first is mostly important from a convenience point of view: Although
-there are some things it let you do that you can't do in the type based
-approach, they're mostly of secondary importance. It largely just saves
-you from the effort of having to write your own shrinkers.
-
-But the second is *really* important, because the lack of it makes your
-test failures potentially extremely confusing.
-
-To see this, lets consider the following example in Hypothesis:
-
-```python
-from hypothesis import given
-from hypothesis.strategies import integers
-
-even_numbers = integers().map(lambda x: x * 2)
-
-
-@given(even_numbers)
-def test_even_numbers_are_even(n):
-    assert n % 2 == 0
-```
-
-This test always passes: We generate an even number by multiplying
-an integer we've generated by two. No problem.
-
-Now suppose we made the test fail:
-
-
-```python
-from hypothesis import given
-from hypothesis.strategies import integers
-
-even_numbers = integers().map(lambda x: x * 2)
-
-
-@given(even_numbers)
-def test_even_numbers_are_even(n):
-    assert n % 2 == 0
-    assert n <= 4
-```
-
-This test will of course fail: Any value of n which is at least 5 will
-fail the test.
-
-But which assertion will fail, and what value will cause it to fail?
-
-In Hypothesis it's the second one, and it will fail with n=6: The numbers
-passed in will still always be even integers, and the smallest even
-integer which fails the test is 6.
-
-But suppose Hypothesis implemented type based shrinking (very early
-versions of it *did* implement type based shrinking, but this stopped
-being the case somewhere well before 1.0 when the API looked very
-different).
-
-In that case Hypothesis would just know that these things that were
-failing the tests were integers, so it would say "How about 1? 1 is a
-perfectly valid integer. Lets try 1".
-
-It would pass in n=1, the first assertion would trigger, and the test
-would promptly fail. A successful shrink!
-
-But it's completely not what we wanted. We were just trying to test on
-even integers and the shrinking messed this up.
-
-This is in some sense the classic 
-shrinkers are fuzzers(http://blog.regehr.org/archives/1284) problem
-where an error is reduced to a different error, but it's a particularly
-annoying version of that because an error we care about is being reduced
-to an error we don't care about.
-
-So we have to duplicate
-the constraint logic in our test to make this work:
-
-
-```python
-from hypothesis import assume, given
-from hypothesis.strategies import integers
-
-even_numbers = integers().map(lambda x: x * 2)
-
-
-@given(even_numbers)
-def test_even_numbers_are_even(n):
-    assume(n % 2 == 0)
-    assert n % 2 == 0
-    assert n <= 4
-```
-
-(Having both the assume and the first assert there is of course
-redundant)
-
-In this example the problem was relatively obvious and so easy to
-work around, but as your invariants get more implicit and subtle
-it becomes really problematic: In Hypothesis it's easy and
-convenient to 
-generate quite complex data({{site.url}}{% post_url 2016-05-11-generating-the-right-data %}),
-and trying to recreate the invariants that are automatically
-satisfied with that in your tests and/or your custom shrinkers would
-quickly become a nightmare.
-
-I don't think it's an accident that the main systems to get this right are
-in dynamic languages. It's certainly not *essential* - the original proposal that
-lead to the implementation for test.check was for
-Haskell(https://mail.haskell.org/pipermail/libraries/2013-November/021674.html),
-and Jack(https://github.com/ambiata/disorder.hs/tree/master/disorder-jack) is
-an alternative property based system for Haskell that does this - but you
-feel the pain much more quickly in dynamic languages because the typical
-workaround for this problem in Haskell is to define a newtype, which lets you
-turn off the default shrinking for your types and possibly define your own.
-
-But that's a workaround for a problem that shouldn't be there in the first place,
-and using it will still result in your having to encode the invariants into your
-your shrinkers, which is more work and more brittle than just having it work
-automatically.
-
-So although (as far as I know) none of the currently popular property based
-testing systems for statically typed languages implement this behaviour
-correctly, they absolutely can and they absolutely should. It will improve
-users' lives significantly.
-
-This of course goes doubly for dynamic languages, where even working around
-this problem is hard.
-
-So, in conclusion, just say no to type based shrinking. It's a bad idea,
-and failures your property based tests will become significantly harder
-to understand in its presence.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-12-08-compositional-shrinking.md Deleted

@@ -1,145 +0,0 @@
----
-layout: post
-tags: technical details python alternatives
-date: 2016-12-08 9:00
-title: Compositional shrinking
-published: true
-author: drmaciver
----
-
-In my last article about shrinking({{site.url}}{% post_url 2016-12-05-integrated-shrinking %}),
-I discussed the problems with basing shrinking on the type of the values
-to be shrunk.
-
-In writing it though I forgot that there was a halfway house which is
-also somewhat bad (but significantly less so) that you see in a couple
-of implementations.
-
-This is when the shrinking is not type based, but still follows the
-classic shrinking API that takes a value and returns a lazy list of
-shrinks of that value. Examples of libraries that do this are
-theft(https://github.com/silentbicycle/theft) and
-QuickTheories(https://github.com/NCR-CoDE/QuickTheories).
-
-This works reasonably well and solves the major problems with type
-directed shrinking, but it's still somewhat fragile and importantly
-does not compose nearly as well as the approaches that Hypothesis
-or test.check take.
-
-Ideally, as well as not being based on the types of the values being
-generated, shrinking should not be based on the actual values generated
-at all.
-
-This may seem counter-intuitive, but it actually works pretty well.
-
-
-
-Rather than going into implementation details just yet, lets start
-with why this is important.
-
-Consider the example from the last post:
-
-
-```python
-from hypothesis import given
-from hypothesis.strategies import integers
-
-even_numbers = integers().map(lambda x: x * 2)
-
-
-@given(even_numbers)
-def test_even_numbers_are_even(n):
-    assert n % 2 == 0
-```
-
-We took a strategy and composed it with a function mapping over
-the values that that strategy produced to get a new strategy.
-
-Suppose the Hypothesis strategy implementation looked something
-like the following:
-
-```python
-class SearchStrategy:
-    def generate(self, random):
-        raise NotImplementedErro()
-
-    def shrink(self, value):
-        return ()
-```
-
-i.e. we can generate a value and we can shrink a value that we've
-previously generated. By default we don't know how to generate values
-(subclasses have to implement that) and we can't shrink anything,
-which subclasses are able to fix if they want or leave as is if
-they're fine with that.
-
-(This is in fact how a very early implementation of it looked)
-
-This is essentially the approach taken by theft or QuickTheories,
-and the problem with it is that under this implementation the
-'map' function we used above is impossible to define in a way
-that preserves shrinking: In order to shrink a generated value,
-you need some way to invert the function you're composing with
-(which is in general impossible even if your language somehow
-exposed the facilities to do it, which it almost certainly
-doesn't) so you could take the generated value, map it back
-to the value that produced it, shrink that and then compose
-with the mapping function.
-
-Hypothesis and test.check both support even more complicated
-composition of strategies (Hypothesis somewhat better than
-test.check - both support the same operations, but Hypothesis's
-underlying implementation works somewhat better for more
-complicated compositions), but even the simplest of compositions
-fails if you need to be able to shrink arbitrary values.
-
-The key idea for fixing this is as follows: In order to shrink
-*outputs* it almost always suffices to shrink *inputs*. Although
-in theory you can get functions where simpler input leads to more
-complicated output, in practice this seems to be rare enough
-that it's OK to just shrug and accept more complicated test
-output in those cases.
-
-Given that, the way to shrink the output of a mapped strategy
-is to just shrink the value generated from the first strategy
-and feed it to the mapping function.
-
-Which means that you need an API that can support that sort
-of shrinking.
-
-The way this works in test.check is that instead of generating
-a single value it generates an entire (lazy) tree of values
-with shrinks for them. See Reid Draper's article on the
-subject(http://reiddraper.com/writing-simple-check/) for slightly
-more detail.
-
-This supports mapping fairly easily: We just apply the mapping
-function to the rose tree - both the initial generated value,
-and all the shrunk child values.
-
-Hypothesis's implementation is more complicated so will have to
-wait for another article, but the key idea behind it is that
-Hypothesis takes the "Shrinking outputs can be done by shrinking
-inputs" idea to its logical conclusion and has a single unified
-intermediate representation that *all* generation is based off.
-Strategies can provide hints about possibly useful shrinks to
-perform on that representation, but otherwise have very little
-control over the shrinking process at all. This supports mapping
-even more easily, because a strategy is just a function which
-takes an IR object and returns a value, so the mapped strategy
-just does the same thing and applies the mapping function.
-
-Obviously I think Hypothesis's implementation is better, but
-test.check's implementation is entirely respectable too and
-is probably easier to copy right now if you're implementing
-a property based testing system from scratch.
-
-But I do think that whichever one you start from it's important
-to take away the key idea: You can shrink outputs by shrinking
-inputs, and strategies should compose in a way that preserves
-shrinking.
-
-The result is significantly more convenient to use because it
-means that users will rarely or never have to write their own
-shrinking functions, and there are fewer possible places for
-shrinking and generation to get out of sync.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2016-12-10-how-hypothesis-works.md Deleted

@@ -1,442 +0,0 @@
----
-layout: post
-tags: python details technical
-date: 2016-12-10 11:00
-title: How Hypothesis Works
-published: true
-author: drmaciver
----
-
-Hypothesis has a very different underlying implementation to any other
-property-based testing system. As far as I know, it's an entirely novel
-design that I invented.
-
-Central to this design is the following feature set which *every*
-Hypothesis strategy supports automatically (the only way to break
-this is by having the data generated depend somehow on external
-global state):
-
-1. All generated examples can be safely mutated
-2. All generated examples can be saved to disk (this is important because
-   Hypothesis remembers and replays previous failures).
-3. All generated examples can be shrunk
-4. All invariants that hold in generation must hold during shrinking (
-   though the probability distribution can of course change, so things
-   which are only supported with high probability may not be).
-
-(Essentially no other property based systems manage one of these claims,
-let alone all)
-
-The initial mechanisms for supporting this were fairly complicated, but
-after passing through a number of iterations I hit on a very powerful
-underlying design that unifies all of these features.
-
-It's still fairly complicated in implementation, but most of that is
-optimisations and things needed to make the core idea work. More
-importantly, the complexity is quite contained: A fairly small kernel
-handles all of the complexity, and there is little to no additional
-complexity (at least, compared to how it normally looks) in defining
-new strategies, etc.
-
-This article will give a high level overview of that model and how
-it works.
-
-
-
-Hypothesis consists of essentially three parts, each built on top
-of the previous:
-
-1. A low level interactive byte stream fuzzer called *Conjecture*
-2. A strategy library for turning Conjecture's byte streams into
-   high level structured data.
-3. A testing interface for driving test with data from Hypothesis's
-   strategy library.
-
-I'll focus purely on the first two here, as the latter is complex
-but mostly a matter of plumbing.
-
-The basic object exposed by Conjecture is a class called TestData,
-which essentially looks like an open file handle you can read
-bytes from:
-
-```python
-class TestData:
-    def draw_bytes(self, n):
-        ...
-```
-
-(note: The Python code in this article isn't an exact copy of what's
-found in Hypothesis, but has been simplified for pedagogical reasons).
-
-A strategy is then just an object which implements a single abstract
-method from the strategy class:
-
-```python
-class SearchStrategy:
-    def do_draw(self, data):
-        raise NotImplementedError()
-```
-
-The testing interface then turns test functions plus the strategies
-they need into something that takes a TestData object and returns
-True if the test fails and False if it passes.
-
-For a simple example, we can implement a strategy for unsigned
-64-bit integers as follows:
-
-
-```python
-class Int64Strategy:
-    def do_draw(self, data):
-        return int.from_bytes(data.draw_bytes(8), byteorder="big", signed=False)
-```
-
-As well as returning bytes, draw_bytes can raise an exception
-that stops the test. This is useful as a way to stop examples
-from getting too big (and will also be necessary for shrinking,
-as we'll see in a moment).
-
-From this it should be fairly clear how we support saving and
-mutation: Saving every example is possible because we can just
-write the bytes that produced it to disk, and mutation is possible
-because strategies are just returning values that we don't
-in any way hang on to.
-
-But how does shrinking work?
-
-Well the key idea is the one I mentioned in
-my last article about shrinking
-({{site.url}}{% post_url 2016-12-08-compositional-shrinking %}) -
-shrinking inputs suffices to shrink outputs. In this case the
-input is the byte stream.
-
-Once Hypothesis has found a failure it begins shrinking the
-byte stream using a TestData object that looks like the following:
-
-```python
-class ShrinkingTestData:
-    def __init__(self, data):
-        self.data = data
-        self.index = 0
-
-    def draw_bytes(self, n):
-        if self.index + n > len(self.data):
-            raise StopTest()
-        result = self.dataself.index : self.index + n
-        self.index += n
-        return result
-```
-
-Shrinking now reduces to shrinking the byte array that gets
-passed in as data, subject to the condition that our transformed
-test function still returns True.
-
-Shrinking of the byte array is designed to try to minimize it
-according to the following rules:
-
-1. Shorter is always simpler.
-2. Given two byte arrays of the same length, the one which is
-   lexicographically earlier (considering bytes as unsigned 8
-   bit integers) is simpler.
-
-You can imagine that some variant of Delta Debugging(https://en.wikipedia.org/wiki/Delta_Debugging)
-is used for the purpose of shrinking the byte array,
-repeatedly deleting data and lowering bytes until no
-byte may be deleted or lowered. It's a lot more complicated
-than that, but I'm mostly going to gloss over that part
-for now.
-
-As long as the strategy is well written (and to some extent
-even when it's not - it requires a certain amount of active
-sabotage to create strategies that produce more complex data
-given fewer bytes) this results in shrinks to the byte array
-giving good shrinks to the generated data. e.g. our 64-bit
-unsigned integers are chosen to be big endian so that
-shrinking the byte data lexicographically shrinks the integer
-towards zero.
-
-In order to get really good deleting behaviour in our strategies
-we need to be a little careful about how we arrange things, so
-that deleting in the underlying bytestream corresponds to
-deleting in generated data.
-
-For example, suppose we tried to implement lists as follows:
-
-
-```python
-class ListStrategy(SearchStrategy):
-    def __init__(self, elements):
-        self.elements = elements
-
-    def do_draw(self, data):
-        n_elements = integers(0, 10).do_draw(self.elements)
-        return self.elements.do_draw(data) for _ in range(n_elements)
-```
-
-The problem with this is that deleting data doesn't actually
-result in deleting elements - all that will happen is that
-drawing will run off the end of the buffer. You can
-potentially shrink n_elmements, but that only lets you
-delete things from the end of the list and will leave a
-bunch of left over data at the end if you do - if this is
-the last data drawn that's not a problem, and it might be
-OK anyway if the data usefully runs into the next strategy,
-but it works fairly unreliably.
-
-I am in fact working on an improvement to how shrinking works
-for strategies that are defined like this - they're quite
-common in user code, so they're worth supporting - but it's
-better to just have deletion of elements correspond to
-deletion of data in the underlying bytestream. We can do
-this as follows:
-
-
-```python
-class ListStrategy(SearchStrategy):
-    def __init__(self, elements):
-        self.elements = elements
-
-    def do_draw(self, data):
-        result = 
-        while booleans().do_draw(data):
-            result.append(self.elements.do_draw(data))
-        return result
-```
-
-We now draw lists as a series True, element,
-True, element, ..., False, etc. So if you delete the
-interval in the byte stream that starts with a True
-and finishes at the end of an element, that just deletes
-that element from the list and shifts everything afterwards
-left one space.
-
-Given some careful strategy design this ends up working
-pretty well. It does however run into problems in two
-minor cases:
-
-1. It doesn't generate very good data
-2. It doesn't shrink very well
-
-Fortunately both of these are fixable.
-
-The reason for the lack of good data is that Conjecture
-doesn't know enough to produce a good distribution of bytes
-for the specific special values for your strategy. e.g. in
-our unsigned 64 bit integer examples above it can probably
-guess that 0 is a special value, but it's not necessarily
-obvious that e.g. focusing on small values is quite useful.
-
-This gets worse as you move further away from things that
-look like unsigned integers. e.g. if you're turning bytes
-into floats, how is Conjecture supposed to know that
-Infinity is an interesting value?
-
-The simple solution is to allow the user to provide a
-distribution hint:
-
-
-```python
-class TestData:
-    def draw_bytes(self, n, distribution=None):
-        ...
-```
-
-Where a distribution function takes a Random object
-and a number of bytes.
-
-This lets users specify the distribution of bytes. It
-won't necessarily be respected - e.g. it certainly isn't
-in shrinking, but the fuzzer can and does mutate the
-values during generation too - but it provides a good
-starting point which allows you to highlight special
-values, etc.
-
-So for example we could redefine our integer strategy
-as:
-
-
-```python
-class Int64Strategy:
-    def do_draw(self, data):
-        def biased_distribution(random, n):
-            if random.randint(0, 1):
-                return random.randint(0, 100).to_bytes(n, byteorder="big", signed=False)
-            else:
-                return uniform(random, n)
-
-        return int.from_bytes(
-            data.draw_bytes(8, biased_distribution), byteorder="big", signed=False
-        )
-```
-
-Now we have a biased integer distribution which will
-produce integers between 0 and 100 half the time.
-
-We then use the strategies to generate our initial
-buffers. For example we could pass in a TestData
-implementation that looked like this:
-
-```python
-class GeneratingTestData(TestData):
-    def __init__(self, random, max_bytes):
-        self.max_bytes = max_bytes
-        self.random = random
-        self.record = bytearray()
-
-    def draw_bytes(self, n, distribution):
-        if n + len(self.record) > self.max_bytes:
-            raise StopTest()
-        result = distribution(self.random, n)
-        self.record.extend(result)
-        return result
-```
-
-This draws data from the provided distribution
-and records it, so at the end we have a record of
-all the bytes we've drawn so that we can replay
-the test afterwards.
-
-This turns out to be mostly enough. I've got some
-pending research to replace this API with something
-a bit more structured (the ideal would be that instead
-of opaque distribution objects you draw from an explicit
-mixture of grammars), but for the moment research on
-big changes like that is side lined because nobody is
-funding Hypothesis development, so I've not got very far
-with it.
-
-Initial designs tried to avoid this approach by using
-data from the byte stream to define the distribution,
-but this ended up producing quite opaque structures in
-the byte stream that didn't shrink very well, and this
-turned out to be simpler.
-
-The second problem of it not shrinking well is also
-fairly easily resolved: The problem is not that we
-*can't* shrink it well, but that shrinking ends up
-being slow because we can't tell what we need to
-do: In our lists example above, the only way we
-currently have to delete elements is to delete the
-corresponding intervals, and the only way we have
-to find the right intervals is to try *all* of them.
-This potentially requires O(n^2) deletions to get the
-right one.
-
-The solution is just to do a bit more book keeping as we
-generate data to mark useful intervals. TestData now
-looks like this:
-
-```python
-class TestData:
-    def start_interval(self):
-        ...
-
-    def stop_interval(self):
-        ...
-
-    def draw_bytes(self, n):
-        ...
-
-    def draw(self, strategy):
-        self.start_interval()
-        result = strategy.do_draw(self)
-        self.stop_interval()
-        return result
-```
-
-
-We then pass everything through data.draw instead
-of strategy.do_draw to maintain this bookkeeping.
-
-These mark useful boundaries in the bytestram that
-we can try deleting: Intervals which don't cross a
-value boundary are much more likely to be useful to
-delete.
-
-There are a large number of other details that are
-required to make Hypothesis work: The shrinker and
-the strategy library are both carefully developed
-to work together, and this requires a fairly large
-number of heuristics and special cases to make things
-work, as well as a bunch of book keeping beyond the
-intervals that I've glossed over.
-
-It's not a perfect system, but it works and works well:
-This has been the underlying implementation of Hypothesis
-since the 3.0 release in early 2016, and the switch over
-was nearly transparent to end users: the previous
-implementation was much closer to a classic QuickCheck
-model (with a great deal of extra complexity to support
-the full Hypothesis feature set).
-
-In a lot of cases it even works better than heavily
-customized solutions: For example, a benefit of the byte
-based approach is that all parts of the data are
-fully comprehensible to it. Often more structured
-shrinkers get stuck in local minima because shrinking
-one part of the data requires simultaneously shrinking
-another part of the data, whileas Hypothesis can just
-spot patterns in the data and speculatively shrink
-them together to see if it works.
-
-The support for chaining data generation together
-is another thing that benefits here. In Hypothesis
-you can chain strategies together like this:
-
-
-```python
-class SearchStrategy:
-    def do_draw(self, data):
-        raise NotImplementedError()
-
-    def flatmap(self, bind):
-        return FlatmappedStrategy(self, bind)
-
-
-class FlatmappedStrategy(SearchStrategy):
-    def __init__(self, base, bind):
-        self.base = base
-        self.bind = bind
-
-    def do_draw(self, data):
-        value = data.draw(self.base)
-        return data.draw(self.bind(value))
-```
-
-The idea is that flatmap lets you chain strategy definitions together by
-drawing data that is dependent on a value from other strategies.
-
-This works fairly well in modern Hypothesis, but has historically (e.g. in
-test.check or pre 3.0 Hypothesis) been a problem for integrated testing and
-generation.
-
-The reason this is normally a problem is that if you shrink the first value
-you've drawn then you essentially *have* to invalidate the value drawn from
-bind(value): There's no real way to retain it because it came from a completely
-different generator. This potentially results in throwing away a lot of
-previous work if a shrink elsewhere suddenly makes it to shrink the
-initial value.
-
-With the Hypothesis byte stream approach this is mostly a non-issue: As long as
-the new strategy has roughly the same shape as the old strategy it will just
-pick up where the old shrinks left off because they operate on the same
-underlying byte stream.
-
-This sort of structure *does* cause problems for Hypothesis if shrinking the
-first value would change the structure of the bound strategy too much, but
-in practice it usually seems to work out pretty well because there's enough
-flexibility in how the shrinks happen that the shrinker can usually work past
-it.
-
-This model has proven pretty powerful even in its current form, but there's
-also a lot of scope to expand it.
-
-But hopefully not by too much. One of the advantages of the model in its
-current form though is its simplicity. The Hypothesis for Java
-prototype(https://github.com/HypothesisWorks/hypothesis-java) was written in
-an afternoon and is pretty powerful. The whole of the Conjecture implementation
-in Python is a bit under a thousand significant lines of fairly portable code.
-Although the strategy library and testing interface are still a fair bit of
-work, I'm still hopeful that the Hypothesis/Conjecture approach is the tool
-needed to bring an end to the dark era of property based testing libraries
-that don't implement shrinking at all.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2017-03-09-hypothesis-for-researchers.md Deleted

@@ -1,336 +0,0 @@
----
-layout: post
-tags: python details technical
-date: 2017-03-09 11:00
-title: Hypothesis for Computer Science Researchers
-published: true
-author: drmaciver
----
-
-I'm in the process of trying to turn my work on Hypothesis into a PhD(http://www.drmaciver.com/2017/03/looking-into-starting-a-phd/)
-and I realised that I don't have a good self-contained summary as to why researchers should care about it.
-
-So this is that piece. I'll try to give a from scratch introduction to the why and what of Hypothesis. It's primarily
-intended for potential PhD supervisors, but should be of general interest as well (especially if you
-work in this field).
-
-### Why should I care about Hypothesis from a research point of view?
-
-The short version:
-
-Hypothesis takes an existing effective style of testing (property-based testing) which has proven highly effective in practice
-and makes it accessible to a much larger audience. It does so by taking several previously unconnected ideas from the existing
-research literature on testing and verification, and combining them to produce a novel implementation that has proven very effective
-in practice.
-
-The long version is the rest of this article.
-
-
-
-The remainder is divided into several sections:
-
-* What is Hypothesis?(#what-is-hypothesis) is a from-scratch introduction to Hypothesis. If you are already familiar with
-  property-based testing (e.g. from QuickCheck) you can probably skip this.
-* How is Hypothesis innovative?(#how-is-hypothesis-innovative) is about the current state of the art of Hypothesis and why
-  it's interesting. If you've already read How Hypothesis Works(http://hypothesis.works/articles/how-hypothesis-works/) this
-  is unlikely to teach you anything new and you can skip it.
-* What prior art is it based on?(#what-prior-art-is-it-based-on) is a short set of references for some of the inspirations
-  for Hypothesis. You probably shouldn't skip this, because it's short and the linked material is all interesting.
-* What are some interesting research directions?(#what-are-some-interesting-research-directions) explores possible directions
-  I'm looking into for the future of Hypothesis, some of which I would hope to include in any PhD related to it that I worked
-  on. You probably shouldn't skip this if you care about this document at all.
-* What should you do with this information?(#what-should-you-do-with-this-information) simply closes off the article and
-  winds things down.
-
-So, without further ado, the actual content.
-
-### What is Hypothesis?
-
-Hypothesis is an implementation of *property-based testing*, an idea that originated with a Haskell library called QuickCheck.
-
-Property-based testing is a way to augment your unit tests with a source of structured random data that allows a tool to explore
-the edge cases of your tests and attempt to find errors automatically. I've made a longer and more formal discussion(http://hypothesis.works/articles/what-is-property-based-testing/)
-of this definition in the past. 
-
-An example of a property-based test using Hypothesis:
-
-```python
-from hypothesis import given, strategies as st
-
-
-@given(st.lists(st.integers()))
-def test_sort_is_idempotent(ls):
-    sort1 = sorted(ls)
-    assert sorted(sort1) == sort1
-```
-
-This exposes a normal function which can be picked up by a standard runner such as py.test. You can also just call it
-directly:
-
-```python
-if __name__ == "__main__":
-    test_sort_is_idempotent()
-```
-
-When the test is run, Hypothesis will generate random lists of integers
-and pass them to the test. The test sorts the integers, then sorts them again, and asserts that the two results are the same.
-
-As long as the test passes for every input Hypothesis feeds it this will appear to be a normal test. If it fails however,
-Hypothesis will then repeatedly rerun it with progressively simpler examples to try and find a minimal input that causes
-the failure.
-
-To see this, suppose we implemented the following rather broken implementation of sorted:
-
-```python
-def sorted(ls):
-    return list(reversed(ls))
-```
-
-Then on running we would see the following output:
-
-```
-      @given(st.lists(st.integers()))
-      def test_sort_is_idempotent(ls):
-        sort1 = sorted(ls)
-  >     assert sorted(sort1) == sort1
-  E     assert 0, 1 == 1, 0
-  E       At index 0 diff: 0 != 1
-  E       Use -v to get the full diff
-
-  sorting.py:12: AssertionError
-
-  ---- Hypothesis ----
-
-  Falsifying example: test_sort_is_idempotent(ls=0, 1)
-```
-
-Hypothesis probably started with a much more complicated example (the test fails for essentially any list with more
-than one element) and then successfully reduced it to the simplest possible example: A list with two distinct elements.
-
-Importantly, when the test is rerun, Hypothesis will start from the falsifying example it found last time rather than
-trying to generate and shrink a new one from scratch. In this particular case that doesn't matter very much - the
-example is found very quickly and it always finds the same one - but for more complex and slower tests this is an
-vital part of the development work flow: It means that tests run much faster and don't stop failing until
-the bug is actually fixed.
-
-Tests can also draw more data as they execute:
-
-```python
-@given(st.lists(st.integers(), min_size=1), st.data())
-def test_sort_is_idempotent(ls, data):
-    ls.sort()
-    i = data.draw(st.integers(0, len(ls) - 1))
-    assert lsi - 1 <= lsi
-```
-
-This fails because we've forgotten than `i` may be zero, and also about Python's negative indexing of lists:
-
-```
-      @given(st.lists(st.integers(), min_size=1), st.data())
-      def test_sort_is_idempotent(ls, data):
-          ls.sort()
-          i = data.draw(st.integers(0, len(ls) - 1))
-  >       assert lsi - 1 <= lsi
-  E       assert 1 <= 0
-
-  sorting.py:15: AssertionError
-    
-  ---- Hypothesis ----
-
-  Falsifying example: test_sort_is_idempotent(ls=0, 1, data=data(...))
-  Draw 1: 0
-```
-
-Simplification and example saving work as normal for data drawn in this way.
-
-Hypothesis also has a form of model based testing(http://hypothesis.works/articles/rule-based-stateful-testing/),
-in which you specify a set of valid operations on your API and it attempts to generate whole programs using those
-operations and find a simple one that breaks.
-
-### How is Hypothesis innovative?
-
-From an end user point of view, Hypothesis adds several important things:
-
-* It exists at all and people use it. Historically this sort of testing has been found mostly within the functional
-  programming community, and attempts to make it work in other languages have not seen much success or widespread
-  adoption. Some of this is due to novel implementation details in Hypothesis, and some is due to design decisions
-  making it "feel" like normal testing instead of formal methods.
-* Specifying data generators is much easier than in traditional QuickCheck methods, and you get a great deal more
-  functionality "for free" when you do. This is similar to test.check(https://github.com/clojure/test.check) for
-  Clojure, or indeed to the Erlang version of QuickCheck(http://www.quviq.com/products/erlang-quickcheck/), but
-  some of the design decisions of Hypothesis make it significantly more flexible here.
-* The fact that arbitrary examples can be saved and replayed significantly improves the development work-flow. Other
-  implementations of property-based testing either don't do this at all, only save the seed, or rely on being able to
-  serialize the generated objects (which can break invariants when reading them back in).
-* The fact that you can generate additional data within the test is often extremely useful, and seems to be unique
-  to Hypothesis in this category of testing tool.
-
-These have worked together well to fairly effectively bring property based testing "to the masses", and Hypothesis
-has started to see increasingly widespread use within the Python community, and is being actively used in the
-development of tools and libraries, as well as in the development of both CPython and pypy, the two major implementations
-of Python.
-
-Much of this was made possible by Hypothesis's novel implementation.
-
-From an implementation point of view, the novel feature of Hypothesis is this: Unlike other implementations of
-property-based testing, it does not need to understand the structure of the data it is generating at all (it sometimes
-has to make guesses about it, but its correctness is not dependent on the accuracy of those guesses).
-
-Hypothesis is divided into three logically distinct parts:
-
-1. A core engine called *Conjecture*, which can be thought of as an interactive fuzzer for lightly structured byte streams.
-2. A strategy library, which is designed to take Conjecture's output and turn it into arbitrary values representable
-   in the programming language.
-3. An interface to external test runners that takes tests built on top of the strategy library and runs them using Conjecture
-   (in Python this mostly just consists of exposing a function that the test runners can pick up, but in the
-   Java Prototype(http://github.com/HypothesisWorks/hypothesis-java) this is more involved and ends up having
-   to interact with some interesting JUnit specific features.
-
-Conjecture is essentially the interesting part of Hypothesis's implementation and is what supports most of its functionality:
-Generation, shrinking, and serialization are all built into the core engine, so implementations of strategies do not require
-any awareness of these features to be correct. They simply repeatedly ask the Conjecture engine for blocks of bytes, which
-it duly provides, and they return the desired result.
-
-If you want to know more about this, I have previously written
-How Hypothesis Works(http://hypothesis.works/articles/how-hypothesis-works/), which provides a bit more detail
-about Conjecture and how Hypothesis is built on top of it.
-
-### What prior art is it based on?
-
-I've done a fair bit of general reading of the literature in the course of working on Hypothesis.
-
-The two main papers on which Hypothesis is based are: 
-
-* QuickCheck: a lightweight tool for random testing of Haskell programs(https://dl.acm.org/citation.cfm?id=351266) essentially
-  started the entire field of property-based testing. Hypothesis began life as a QuickCheck implementation, and its user facing
-  API continues to be heavily based on QuickCheck, even though the implementation has diverged very heavily from it.
-* EXPLODE: a lightweight, general system for finding serious storage system errors(https://dl.acm.org/citation.cfm?id=1298469)
-  provided the key idea on which the Conjecture engine is based - instead of doing static data generation separate from the tests,
-  provide tests with an interactive primitive from which they can draw data.
-
-Additionally, the following are major design inspirations in the Conjecture engine, although their designs are not currently
-used directly:
-
-* American Fuzzy Lop(http://lcamtuf.coredump.cx/afl/) is an excellent security-oriented fuzzer, although one without much
-  academic connections. I've learned a fair bit about the design of fuzzers from it. For a variety of pragmatic reasons I don't
-  currently use its most important innovation (branch coverage metrics as a tool for corpus discovery), but I've successfully
-  prototyped implementations of that on top of Hypothesis which work pretty well.
-* Swarm Testing(https://dl.acm.org/citation.cfm?id=2336763) drove a lot of the early designs of Hypothesis's data generation.
-  It is currently not explicitly present in the Conjecture implementation, but some of what Conjecture does to induce deliberate
-  correlations in data is inspired by it.
-
-### What are some interesting research directions?
-
-I have a large number of possible directions that my work on Hypothesis could be taken. 
-
-None of these are *necessarily* a thing that would be the focus of a PhD - in doing a PhD I would almost certainly
-focus on a more specific research question that might include some or all of them. These are just areas that I am interested
-in exploring which I think might form an interesting starting point, and whatever focus I actually end up with will likely
-be more carefully tailored in discussion with my potential supervisors.
-
-One thing that's also worth considering: Most of these research directions are ones that would result in improvements
-to Hypothesis without changing its public interface. This results in a great practical advantage to performing the
-research because of the relatively large (and ever-growing) corpus of open source projects which are already using
-Hypothesis - many of these changes could at least partly be validated by just running peoples' existing tests and seeing
-if any new and interesting bugs are found!
-
-Without further ado, here are some of what I think are the most interesting directions to go next.
-
-#### More structured byte streams
-
-My current immediate research focus on Hypothesis is to replace the core Conjecture primitive with a more structured one
-that bears a stronger resemblance to its origins in EXPLODE. This is designed to address a number of practical problems
-that Hypothesis users currently experience (mostly performance related), but it also opens up a number of other novel
-abstractions that can be built on top of the core engine.
-
-The idea is to pare down the interface so that when calling in to Conjecture you simply draw a single byte, specifying
-a range of possible valid bytes. This gives Conjecture much more fine-grained information to work with, which opens up
-a number of additional features and abstractions that can be built on top of it.
-
-From this primitive you can then rebuild arbitrary weighted samplers that shrink correctly (using a variation of the
-Alias Method), and arbitrary grammars (probably using Boltzmann Samplers(https://dl.acm.org/citation.cfm?id=1024669)
- or similar).
-
-This will provide a much more thorough basis for high quality data generation than the current rather ad hoc method
-of specifying byte streams.
-
-This is perhaps more engineering than research, but I think it would at the bare minimum make any paper I wrote about
-the core approach of Hypothesis significantly more compelling, and it contains a number of interesting applications of
-the theory.
-
-#### Glass box testing
-
-Currently Conjecture treats the tests it calls as a black box and does not get much information about what the tests
-it executes are actually doing.
-
-One obvious thing to do which brings in some more ideas from e.g. American Fuzzy Lop is to use more coverage information,
-but so far I haven't had much success with making my prototypes of this idea suitable for real world use. The primary
-reason for this so far has been that all of the techniques I've found have worked well when tests are allowed
-to run for minutes or hours, but the current design focus of Hypothesis assumes tests have seconds to run at most,
-which limits the utility of these methods and means they haven't been a priority so far.
-
-But in principle this should be an extremely profitable line of attack, even with that limitation, and I would like
-to explore it further.
-
-The main idea would be to add a notion of "tags" to the core Conjecture engine which could be used to guide the
-search. Coverage would be one source of tags, but others are possible. For example, my previous work on
-Schroedinteger(https://github.com/DRMacIver/schroedinteger) implements what is essentially a form of lightweight
-Concolic testing(https://en.wikipedia.org/wiki/Concolic_testing) that would be another possibly interesting source
-of information to use.
-
-Exactly how much of this is original research and how much is just applications of existing research is yet to be
-determined, but I think it very likely that at the very least figuring out how to make use of this sort of information
-in sharply bounded time is likely to bear interesting fruit. The opportunity to see how Concolic testing behaves in the
-wild is also likely to result in a number of additional questions.
-
-#### Making the Conjecture engine smarter
-
-A thing I've looked into in the past is the possible use of grammar inference to improve shrinking and data generation.
-
-At the time the obstacle I ran into was that the algorithm I was using -
-an optimized variation of L\* search(https://dl.acm.org/citation.cfm?id=73047) - did not get good performance in
-practice on the problems I tried it on.
-
-Synthesizing Program Input Grammars(https://arxiv.org/abs/1608.01723) promises to lift this restriction by providing
-much better grammar inference in practical scenarios that are quite closely related to this problem domain, so I would
-like to revisit this and see if it can prove useful.
-
-There are likely a number of other ways that the Conjecture engine can probe the state of the system under test
-to determine interesting potential behaviours, especially in combination with glass box testing features.
-
-I think there are a lot of potentially interesting research directions in here - especially if this is combined with
-the glass box testing. Given that I haven't even been able to make this perform acceptably in the past, the first
-one would be to see if I can!
-
-This will also require a fair bit of practical experimentation to see what works well at actually finding bugs and what
-doesn't. This is one area in particular where a corpus of open source projects tested with Hypothesis will be extremely
-helpful.
-
-#### Other testing abstractions
-
-Despite Hypothesis primarily being a library for property based testing, the core Conjecture engine actually has
-very little to do with property-based testing and is a more powerful low-level testing abstraction. It would be interesting
-to see how far that could be taken - the existing stateful/model-based testing is one partial step in that direction,
-but it could also potentially be used more directly for other things. e.g. in tandem with some of the above features
-it could be used for low-level fuzzing of binaries, or using it to drive thread scheduling.
-
-The nice thing about the Conjecture separation is that because it is so self-contained, it can be used as the core
-building block on which other tools can be rebuilt and gain a lot of its major features for free.
-
-I don't currently have any concrete plans in this direction, but it seems likely there are some interesting possibilities
-here that will emerge after more review of the testing literature.
-
-This is probably just engineering unless some particularly interesting application emerges, but I think the basic
-potential of the technology would probably give pretty good odds of such an application.
-
-### What should you do with this information?
-
-It depends who you are.
-
-* If I'm already talking to you because you're a potential PhD supervisor, tell me what about this interests you and
-  ask me lots of questions.
-* If you're a potential PhD supervisor who I'm *not* already talking to but you'd like me to, please let me know!
-* If you're somebody else, it's rather up to you. Feel free to send me papers, questions, etc.
-
-Whoever you are, if you found this document interesting I'd love to hear from you. Drop me an email at
-david@drmaciver.com(mailto:david@drmaciver.com).

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2017-04-05-how-not-to-die-hard-with-hypothesis.md Deleted

@@ -1,215 +0,0 @@
----
-layout: post
-tags: python technical intro
-date: 2017-04-05 10:00
-title: Solving the Water Jug Problem from Die Hard 3 with TLA+ and Hypothesis
-published: true
-author: nchammas
----
-
-_This post was originally published on the author's personal site(http://nchammas.com/writing/how-not-to-die-hard-with-hypothesis).
-It is reproduced here with his permission._
-
-In the movie Die Hard with a Vengeance(https://en.wikipedia.org/wiki/Die_Hard_with_a_Vengeance)
-(aka Die Hard 3), there is
-this famous scene(https://www.youtube.com/watch?v=6cAbgAaEOVE) where
-John McClane (Bruce Willis) and Zeus Carver (Samuel L. Jackson)
-are forced to solve a problem or be blown up: Given a 3 gallon jug and
-5 gallon jug, how do you measure out exactly 4 gallons of water?
-
-<div style="text-align: center;">
-<iframe
-    width="560"
-    height="315"
-    src="https://www.youtube.com/embed/6cAbgAaEOVE?rel=0"
-    frameborder="0"
-    allowfullscreen>
-</iframe>
-<p>
-(The video title is wrong. It's Die Hard 3.)
-</p>
-</div>
-
-
-
-Apparently, you can solve this problem using a formal specification
-language like TLA+(https://en.wikipedia.org/wiki/TLA%2B). I don't know
-much about this topic, but it appears that a formal specification language(https://en.wikipedia.org/wiki/Formal_specification)
-is much like a programming language in that it lets you describe the
-behavior of a system. However, it's much more rigorous and builds
-on mathematical techniques that enable you to reason more effectively
-about the behavior of the system you're describing than you can with
-a typical programming language.
-
-In a recent discussion on Hacker News about TLA+,
-I came across this comment(https://news.ycombinator.com/item?id=13919251)
-which linked to a fun and simple example
-showing how to solve the Die Hard 3 problem with TLA+(https://github.com/tlaplus/Examples/blob/master/specifications/DieHard/DieHard.tla).
-I had to watch the first two lectures from Leslie Lamport's video course on TLA+(http://lamport.azurewebsites.net/video/videos.html)
-to understand the example well, but once I did I was reminded of the
-idea of property-based testing and, specifically, Hypothesis(http://hypothesis.works/).
-
-So what's property-based testing? It's a powerful way of testing your
-logic by giving your machine a high-level description of how your code
-should behave and letting it generate test cases automatically to see
-if that description holds. Compare that to traditional unit testing,
-for example, where you manually code up specific inputs and outputs
-and make sure they match.
-
-## How not to Die Hard with Hypothesis
-
-Hypothesis has an excellent implementation of property-based testing
-for Python(https://github.com/HypothesisWorks/hypothesis-python).
-I thought to myself: I wonder if you can write that
-Die Hard specification using Hypothesis? As it turns out, Hypothesis
-supports stateful testing(https://hypothesis.readthedocs.io/en/latest/stateful.html),
-and I was able to port the TLA+ example(https://github.com/tlaplus/Examples/blob/master/specifications/DieHard/DieHard.tla)
-to Python pretty easily:
-
-```python
-from hypothesis import note, settings
-from hypothesis.stateful import RuleBasedStateMachine, invariant, rule
-
-
-class DieHardProblem(RuleBasedStateMachine):
-    small = 0
-    big = 0
-
-    @rule()
-    def fill_small(self):
-        self.small = 3
-
-    @rule()
-    def fill_big(self):
-        self.big = 5
-
-    @rule()
-    def empty_small(self):
-        self.small = 0
-
-    @rule()
-    def empty_big(self):
-        self.big = 0
-
-    @rule()
-    def pour_small_into_big(self):
-        old_big = self.big
-        self.big = min(5, self.big + self.small)
-        self.small = self.small - (self.big - old_big)
-
-    @rule()
-    def pour_big_into_small(self):
-        old_small = self.small
-        self.small = min(3, self.small + self.big)
-        self.big = self.big - (self.small - old_small)
-
-    @invariant()
-    def physics_of_jugs(self):
-        assert 0 <= self.small <= 3
-        assert 0 <= self.big <= 5
-
-    @invariant()
-    def die_hard_problem_not_solved(self):
-        note(f"> small: {self.small} big: {self.big}")
-        assert self.big != 4
-
-
-# The default of 200 is sometimes not enough for Hypothesis to find
-# a falsifying example.
-with settings(max_examples=2000):
-    DieHardTest = DieHardProblem.TestCase
-```
-
-Calling `pytest` on this file quickly digs up a solution:
-
-```
-self = DieHardProblem({})
-
-    @invariant()
-    def die_hard_problem_not_solved(self):
-        note("> small: {s} big: {b}".format(s=self.small, b=self.big))
->       assert self.big != 4
-E       AssertionError: assert 4 != 4
-E        +  where 4 = DieHardProblem({}).big
-
-how-not-to-die-hard-with-hypothesis.py:17: AssertionError
------------------------------ Hypothesis -----------------------------
-> small: 0 big: 0
-Step #1: fill_big()
-> small: 0 big: 5
-Step #2: pour_big_into_small()
-> small: 3 big: 2
-Step #3: empty_small()
-> small: 0 big: 2
-Step #4: pour_big_into_small()
-> small: 2 big: 0
-Step #5: fill_big()
-> small: 2 big: 5
-Step #6: pour_big_into_small()
-> small: 3 big: 4
-====================== 1 failed in 0.22 seconds ======================
-```
-
-## What's Going on Here
-
-The code and test output are pretty self-explanatory, but here's a
-recap of what's going on:
-
-We're defining a state machine. That state machine has an initial
-state (two empty jugs) along with some possible transitions. Those
-transitions are captured with the `rule()` decorator. The initial
-state and possible transitions together define how our system works.
-
-Next we define invariants, which are properties that must always hold
-true in our system. Our first invariant, `physics_of_jugs`, says that
-the jugs must hold an amount of water that makes sense. For example,
-the big jug can never hold more than 5 gallons of water.
-
-Our next invariant, `die_hard_problem_not_solved`, is where it gets
-interesting. Here we're declaring that the problem of getting exactly
-4 gallons in the big jug _cannot_ be solved. Since Hypothesis's job
-is to test our logic for bugs, it will give our state machine a
-thorough shake down and see if we ever violate our invariants.
-In other words, we're basically goading Hypothesis into solving the
-Die Hard problem for us.
-
-I'm not entirely clear on how Hypothesis does its work, but I know
-the basic summary is this: It takes the program properties we've
-specified -- including things like rules, invariants, data types, and
-function signatures -- and generates data or actions to probe the
-behavior of our program. If Hypothesis finds a piece of data or
-sequence of actions that get our program to violate its stated properties, it
-tries to whittle that down to a _minimum falsifying example_---i.e.
-something that exposes the same problem but with a minimum number of
-steps. This makes it much easier for you to understand how Hypothesis
-broke your code.
-
-Hypothesis's output above tells us that it was able to violate the
-`die_hard_problem_not_solved` invariant and provides us with a
-minimal reproduction showing exactly how it did so. That reproduction
-is our solution to the problem. It's also how McClane and Carver did
-it in the movie!
-
-## Final Thoughts
-
-All in all, I was pretty impressed with how straightforward it was to
-translate the TLA+ example into Python using Hypothesis. And when
-Hypothesis spit out the solution, I couldn't help but smile. It's
-pretty cool to see your computer essentially generate a program that
-solves a problem for you. And the Python version of the Die Hard
-"spec" is not much more verbose than the
-original in TLA+, though TLA+'s notation for current vs. next value
-(e.g. `small` vs. `small'`) is elegant and cuts out the need to have
-variables like `old_small` and `old_big`.
-
-I don't know how Hypothesis compares to TLA+ in a general sense. I've
-only just started to learn about property-based testing and TLA+, and
-I wonder if they have a place in the work that I do these days, which
-is mostly Data Engineering-type stuff. Still, I found this little
-exercise fun, and I hope you learned something interesting from it.
-
-_Thanks to Julia, Dan, Laura, Anjana, and Cip for reading drafts
-of this post._
-
-Julia: http://jvns.ca/
-Dan: https://danluu.com/

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2017-07-16-types-and-properties.md Deleted

@@ -1,190 +0,0 @@
----
-layout: post
-tags: technical details python alternatives
-date: 2017-07-16 10:00
-title: Moving Beyond Types
-published: true
-author: drmaciver
----
-
-If you look at the original property-based testing library, the Haskell version of QuickCheck,
-tests are very closely tied to types: The way you typically specify a property is by inferring
-the data that needs to be generated from the types the test function expects for its arguments.
-
-This is a bad idea.
-
-
-
-The first part of why
-I've talked about already({{site.url}}{% post_url 2016-12-05-integrated-shrinking %}) -
-you don't want to tie the shrinking of the data to its type, because it makes testing
-significantly more brittle.
-
-But you could solve that and still have data generation be tied to type, and it would still
-be a bad idea.
-
-The reason for this is very simple: Often you want to generate something much more specific
-than any value of a given type.
-
-If you look at the Hypothesis strategies module(https://hypothesis.readthedocs.io/en/latest/data.html)
-and what you can generate, many of these look like types. But if you look closer, nearly
-every single one of them has options to configure them to be more specific.
-
-Consider something like the following:
-
-```python
-from statistics import mean
-
-from hypothesis import given, strategies as st
-
-
-@given(st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1))
-def test_mean_is_in_bounds(ls):
-    assert min(ls) <= mean(ls) <= max(ls)
-```
-
-In this test we've restricted the domain we're testing on so we can focus on a property
-that doesn't hold in generality:  The mean of an empty list is an
-error, so that needs a special case test for it, and calculations with `NaN` or infinity
-are special cases that don't always have a well-defined result and even when they do
-don't necessarily satisfy this property.
-
-This happens a lot: Frequently there are properties that only hold in some restricted
-domain, and so you want more specific tests for that domain to complement your other
-tests for the larger range of data.
-
-When this happens you need tools to generate something more specific, and those requirements
-don't map naturally to types.
-
-Consider writing this code based on types instead:
-
-```python
-from statistics import mean
-from typing import List
-
-from hypothesis import given, strategies as st
-
-
-@given(ls=...)
-def test_mean_is_in_bounds(ls: Listfloat):
-    assert min(ls) <= mean(ls) <= max(ls)
-```
-
-(this code doesn't work at the time of this writing, but it will soon -
-the pull request to implement it(https://github.com/HypothesisWorks/hypothesis-python/pull/643)
-is in fairly late-stage review).
-
-But this doesn't do the right thing: We've dropped the conditions from the
-previous test that our floats are all finite and our lists are all non-empty. So now
-we have to add a precondition to make the test valid:
-
-```python
-import math
-from statistics import mean
-from typing import List
-
-from hypothesis import assume, given, strategies as st
-
-
-@given(ls=...)
-def test_mean_is_in_bounds(ls: Listfloat):
-    assume(len(ls) > 1)
-    assume(all(math.isfinite(x) for x in ls))
-    assert min(ls) <= mean(ls) <= max(ls)
-```
-
-But this is now substantially longer and less readable than the original approach!
-
-In Haskell, traditionally we would fix this with a newtype declaration which wraps the type.
-We could find a newtype NonEmptyList and a newtype FiniteFloat and then say that we actually
-wanted a NonEmptyListFiniteFloat there.
-
-In Python we could probably do more or less the same thing, either by creating new wrapper
-types or by subclassing list and float (which you shouldn't do. Subclassing builtins in Python
-leads to really weird behaviour) if we wanted to save a few lines, but it's much more noisy.
-
-But why should we bother? Especially if we're only using these in one test, we're not actually
-interested in these types at all, and it just adds a whole bunch of syntactic noise when you
-could just pass the data generators directly. Defining new types for the data you want to generate
-is purely a workaround for a limitation of the API.
-
-If you were working in a dependently typed language where you could already naturally express
-this in the type system it *might* be OK (I don't have any direct experience of working in
-type systems that strong), but I'm sceptical of being able to make it work well - you're unlikely
-to be able to automatically derive data generators in the general case, because the needs of
-data generation "go in the opposite direction" from types (a type is effectively a predicate which
-consumes a value, where a data generator is a function that produces a value, so in order to produce
-a generator for a type automatically you need to basically invert the predicate). I suspect most
-approaches here  will leave you with a bunch of sharp edges, but I would be interested to see
-experiments in this direction.
-
-That being said, I don't think it's that useful to do. Where stronger types are naturally
-present in the program, taking advantage of them to get better testing is certainly worth
-doing, but creating a specific type to represent the exact range of valid inputs to a
-specific test isn't because for tests the impact of a run time error that you could have caught at
-compile time is substantially reduced (all it causes is a spurious test failure - where your
-tests are long running or non-deterministic as in property-based testing this *does* matter,
-but it still doesn't cause a problem in production).
-
-But this is creating hard problems where none need exist, and beside which it's not the situation
-with most of the current generation of languages and property based libraries for them.
-Here, using explicit data generators is a clear improvement, and just as well-typed
-(in a statically typed language each data generator has a return type after all).
-
-You *can* use data generators directly in Haskell QuickCheck too, with an explicit
-forAll(https://hackage.haskell.org/package/QuickCheck-2.10.0.1/docs/Test-QuickCheck-Property.html#v:forAll)
-but it's almost as awkward as the newtype approach, particularly if you want more than one
-data generator (it's even more awkward if you want shrinking - you have to use forAllWithShrink and
-explicitly pass a shrink function).
-
-This is more or less intrinsic to the type based approach. If you want tinkering with the
-data generation to be non-awkward, starting from data generators needs to become the default.
-
-And experience suggests that when you make customising the data generation easy, people do
-it. It's nice to be able to be more specific in your testing, but if you make it too high
-effort people either don't do it, or do it using less effective methods like adding
-preconditions to tests (assume in Hypothesis, or `==>` in QuickCheck), either of which reduces
-the quality of your testing and causes more bugs to slip through as a result.
-
-Fortunately, it already *is* the default in most of the newer implementations of
-property-based testing. The only holdouts are ones that directly copied Haskell QuickCheck.
-
-Originally this was making a virtue of a necessity - most of the implementations
-which started off the trend of data generator first tests are either for dynamic languages
-(e.g. Erlang, Clojure, Python) or languages with very weak type systems (e.g. C) where
-type first is more or less impossible, but it's proven to be a much more usable design.
-
-And it's perfectly compatible with static typing too. Hedgehog(https://hackage.haskell.org/package/hedgehog)
-is a relatively recent property-based testing library for Haskell that takes this approach,
-and it works just as well in Haskell as it does in any language.
-
-It's also perfectly compatible with being able to derive a data generator from a type
-for the cases where you really want to. We saw a hint at that with the upcoming
-Hypothesis implementation above. You could easily do the same by having something
-like the following in Haskell (mimicking the type class of QuickCheck):
-
-```haskell
-class Arbitrary a where
-  arbitrary :: Gen a
-```
-
-You can then simply use `arbitrary` like you would any other data generator. As far as I know
-Hedgehog doesn't do this anywhere (but you can use QuickCheck's Arbitrary with
-the hedgehog-quickcheck package), but in principle there's nothing stopping it.
-
-Having this also makes it much easier to define new data generators. I'm unlikely to use the
-support for `@given` much, but I'm much more excited that it will also
-work with `builds`, which will allow for a fairly seamless transition between
-inferring the default strategy for a type and writing a custom generator. You
-will, for example, be able to do `builds(MyType)` and have every constructor
-argument automatically filled in (if it's suitably annotated), but you can
-also do e.g. `builds(MyType, some_field=some_generator)` to override a particular
-default while leaving the others alone.
-
-(This API is somewhere where the dynamic nature of Python helps a fair bit, but you
-could almost certainly do something equivalent in Haskell with a bit more noise
-or a bit more template Haskell)
-
-So this approach doesn't have to be data generator-only, even if it's data generator first,
-but if you're going to pick one the flexibility of the data generator based test specification
-is hard to beat, regardless of how good your type system is.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2017-09-14-multi-bug-discovery.md Deleted

@@ -1,197 +0,0 @@
----
-layout: post
-tags: technical details python
-date: 2017-09-26 12:00
-title: When multiple bugs attack
-published: true
-author: drmaciver
----
-
-When Hypothesis finds an example triggering a bug, it tries to shrink the example
-down to something simpler that triggers it. This is a pretty common feature, and
-most property-based testing libraries implement something similar (though there
-are a number of differences between them). Stand-alone test case reducers are
-also fairly common, as it's a useful thing to be able to do when reporting bugs
-in external projects - rather than submitting a giant file triggering the bug,
-a good test case reducer can often shrink it down to a couple of lines.
-
-But there's a problem with doing this: How do you know that the bug you started
-with is the same as the bug you ended up with?
-
-This isn't just an academic question. It's very common for the bug you started
-with to slip to another one(https://blog.regehr.org/archives/1284).
-
-Consider for example, the following test:
-
-```python
-from hypothesis import given, strategies as st
-
-
-def mean(ls):
-    return sum(ls) / len(ls)
-
-
-@given(st.lists(st.floats()))
-def test(ls):
-    assert min(ls) <= mean(ls) <= max(ls)
-```
-
-This has a number of interesting ways to fail: We could pass `NaN`, we could
-pass `-float('inf'), +float('inf')`, we could pass numbers which trigger a
-precision error, etc.
-
-But after test case reduction, we'll pass the empty list and it will fail
-because we tried to take the min of an empty sequence.
-
-This isn't necessarily a huge problem - we're still finding a bug after all
-(though in this case as much in the test as in the code under test) -
-and sometimes it's even desirable - you find more bugs this way, and sometimes
-they're ones that Hypothesis would have missed - but often it's not, and an
-interesting and rare bug slips to a boring and common one.
-
-Historically Hypothesis has had a better answer to this than most - because
-of the Hypothesis example database, all intermediate bugs are saved and a
-selection of them will be replayed when you rerun the test. So if you fix
-one bug then rerun the test, you'll find the other bugs that were previously
-being hidden from you by that simpler bug.
-
-But that's still not a great user experience - it means that you're not getting
-nearly as much information as you could be, and you're fixing bugs in
-Hypothesis's priority order rather than yours. Wouldn't it be better if Hypothesis
-just told you about all of the bugs it found and you could prioritise them yourself?
-
-Well, as of Hypothesis 3.29.0, released a few weeks ago, now it does!
-
-If you run the above test now, you'll get the following:
-
-```
-Falsifying example: test(ls=nan)
-Traceback (most recent call last):
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 671, in run
-    print_example=True, is_final=True
-  File "/home/david/hypothesis-python/src/hypothesis/executors.py", line 58, in default_new_style_executor
-    return function(data)
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 120, in run
-    return test(*args, **kwargs)
-  File "broken.py", line 8, in test
-    def test(ls):
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 531, in timed_test
-    result = test(*args, **kwargs)
-  File "broken.py", line 9, in test
-    assert min(ls) <= mean(ls) <= max(ls)
-AssertionError
-
-Falsifying example: test(ls=)
-Traceback (most recent call last):
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 671, in run
-    print_example=True, is_final=True
-  File "/home/david/hypothesis-python/src/hypothesis/executors.py", line 58, in default_new_style_executor
-    return function(data)
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 120, in run
-    return test(*args, **kwargs)
-  File "broken.py", line 8, in test
-    def test(ls):
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 531, in timed_test
-    result = test(*args, **kwargs)
-  File "broken.py", line 9, in test
-    assert min(ls) <= mean(ls) <= max(ls)
-ValueError: min() arg is an empty sequence
-
-You can add @seed(67388524433957857561882369659879357765) to this test to reproduce this failure.
-Traceback (most recent call last):
-  File "broken.py", line 12, in <module>
-    test()
-  File "broken.py", line 8, in test
-    def test(ls):
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 815, in wrapped_test
-    state.run()
-  File "/home/david/hypothesis-python/src/hypothesis/core.py", line 732, in run
-    len(self.falsifying_examples,)))
-hypothesis.errors.MultipleFailures: Hypothesis found 2 distinct failures.
-```
-
-(The stack traces are a bit noisy, I know.
-We have an issue open about cleaning them up(https://github.com/HypothesisWorks/hypothesis-python/issues/848)).
-
-All of the different bugs are minimized simultaneously and take full advantage of Hypothesis's
-example shrinking, so each bug is as easy (or hard) to read as if it were the only bug we'd found.
-
-This isn't perfect: The heuristic we use for determining if two bugs are the same is whether they
-have the same exception type and the exception is thrown from the same line. This will necessarily
-conflate some bugs that are actually different - for example, `float('nan')`,
-`-float('inf'), float('inf')` and `3002399751580415.0, 3002399751580415.0, 3002399751580415.0`
-each trigger the assertion in the test, but they are arguably "different" bugs.
-
-But that's OK. The heuristic is deliberately conservative - the point is not that it can
-distinguish whether any two examples are the same bug, just that any two examples it distinguishes
-are different enough that it's interesting to show both, and this heuristic definitely manages that.
-
-As far as I know this is a first in property-based testing libraries (though something like it is
-common in fuzzing tools, and theft is hot on our tail with something similar(
-https://github.com/silentbicycle/theft/compare/develop-failure_tagging)) and there's been
-some interesting related but mostly orthogonal research(
-http://www.cse.chalmers.se/~nicsma/papers/more-bugs.pdf) in Erlang QuickCheck.
-
-It was also surprisingly easy.
-
-A lot of things went right in writing this feature, some of them technical, some of them social,
-somewhere in between.
-
-The technical ones are fairly straightforward: Hypothesis's core model turned out to be very
-well suited to this feature. Because Hypothesis has a single unified intermediate representation
-which defines a total ordering for simplicity, adapting Hypothesis to shrink multiple things at
-once was quite easy - whenever we attempt a shrink and it produces a different bug than the one
-we were looking for, we compare it to our existing best example for that bug and replace it if
-the current one is better (or we've discovered a new bug). We then just repeatedly run the shrinking
-process for each bug we know about until they've all been fully shrunk.
-
-This is in a sense not surprising - I've been thinking about the problem of multiple-shrinking for
-a long time and, while this is the first time it's actually appeared in Hypothesis, the current
-choice of model was very much informed by it.
-
-The social ones are perhaps more interesting. Certainly I'm very pleased with how they turned
-out here.
-
-The first is that this work emerged tangentially from
-the recent Stripe funded work(https://stripe.com/blog/hypothesis) - Stripe paid me
-to develop some initial support for testing Pandas code with Hypothesis, and I observed
-a bunch of bug slippage happening in the wild while I was testing that (it turns out there
-are quite a lot of ways to trigger exceptions from Pandas - they weren't really Pandas
-bugs so much as bugs in the Pandas integration, but they still slipped between several
-different exception types), so that was what got me thinking about this problem again.
-
-Not by accident, this feature also greatly simplified the implementation
-of the new deadline feature(https://hypothesis.readthedocs.io/en/latest/settings.html#hypothesis.settings.deadline)
-that Smarkets(https://smarkets.com/) funded, which was going to have to have a lot of
-logic about how deadlines and bugs interacted, but all that went away as soon as we were
-able to handle multiple bugs sensibly.
-
-This has been a relatively consistent theme in Hypothesis development - practical problems
-tend to spark related interesting theoretical developments. It's not a huge exaggeration
-to say that the fundamental Hypothesis model exists because I wanted to support testing
-Django nicely. So the recent funded development from Stripe and Smarkets has been a
-great way to spark a lot of seemingly unrelated development and improve Hypothesis
-for everyone, even outside the scope of the funded work.
-
-Another thing that really helped here is our review process, and the review from Zac
-in particular(https://github.com/HypothesisWorks/hypothesis-python/pull/836).
-
-This wasn't the feature I originally set out to develop. It started out life as a
-much simpler feature that used much of the same machinery, and just had a goal of
-avoiding slipping to new errors all together. Zac pushed back with some good questions
-around whether this was really the correct thing to do, and after some experimentation
-and feedback I eventually hit on the design that lead to displaying all of the errors.
-
-Our review handbook(https://github.com/HypothesisWorks/hypothesis-python/blob/master/guides/review.rst)
-emphasises that code review is a collaborative design process, and I feel this was
-a particularly good example of that. We've created a great culture of code review,
-and we're reaping the benefits (and if you want to get in on it, we could always
-use more people able and willing to do review...).
-
-All told, I'm really pleased with how this turned out. I think it's a nice example
-of getting a lot of things right up front and this resulting in a really cool new
-feature.
-
-I'm looking forward to seeing how it behaves in the wild. If you notice any
-particularly fun examples, do let me know(mailto:david@drmaciver.com), or write
-up a post about them yourself!

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2017-09-28-threshold-problem.md Deleted

@@ -1,106 +0,0 @@
----
-layout: post
-tags: technical details python
-date: 2017-09-28 11:00
-title: The Threshold Problem
-published: true
-author: drmaciver
----
-
-In my last post({{site.url}}{% post_url 2017-09-14-multi-bug-discovery %}) I mentioned
-the problem of bug slippage: When you start with one bug, reduce the test case, and end
-up with another bug.
-
-I've run into another related problem twice now, and it's not one I've seen talked about
-previously.
-
-The problem is this: Sometimes shrinking makes a bug seem much less interesting than it
-actually is.
-
-
-
-I first noticed this problem when Ned Batchelder(https://nedbatchelder.com/) asked me
-about some confusing behaviour he was seeing: He was testing some floating point code and
-had an assertion that the error was not greater than some threshold. Let's say 0.5 (I could
-dig up the IRC logs, but the exact number doesn't matter).
-
-Hypothesis said "Ah ha! Here is an example where the error is 0.500001. A bug!".
-
-Ned sighed and thought "Oh great, floating point precision issues", but on further
-investigation it turned out that that wasn't it at all. The error could be arbitrarily large,
-it's just that Hypothesis reliably gave an example where it was almost as small as it could
-possibly be and still fail.
-
-This wasn't a bug, either. This is how Hypothesis, QuickCheck, and all of the other tools
-in this family are designed to work.
-
-The problem is that test case reduction is designed to produce the simplest example
-possible to demonstrate the bug. If the bug can be expressed as happening when some
-score exceeds some threshold, and the score is one that tends to increase with example
-size, then the failing example that a property-based testing library gives you will tend
-to be one where the score is barely above that threshold, making the problem look much
-less bad than it actually is.
-
-This isn't even a bug in Hypothesis - QuickCheck or any other property-based testing would
-do the same. It's literally working as intended.
-
-Arguably it's not even really a problem: Hypothesis has demonstrated the bug, and it's
-done so with a simple example which should thus be easy to understand.
-
-But I can't help but feel that we could do better. It definitely produces misleading
-examples even if they technically demonstrate the right problem, and misleading examples
-are a great way to waste the user's time.
-
-I also ran into this problem again recently, where it was more of a problem because it
-was resulting in flaky tests.
-
-I recently introduced a deadline feature(https://hypothesis.readthedocs.io/en/latest/settings.html?highlight=deadline#hypothesis.settings.deadline)
-as part of the work on Hypothesis performance legibility that Smarkets(https://smarkets.com/)
-are funding. This causes slow examples to be treated as failures: If an example passes
-but took longer than your deadline to run, it raises `DeadlineExceeded`. This is treated
-as a normal error and Hypothesis shrinks it like anything else (including allowing it to
-participate in the multi-shrinking process).
-
-The problem is that it's exactly this sort of threshold problem: You literally have a
-score (the run time) and a threshold (the deadline) such that when the score exceeds
-the threshold the test fails. Large examples are certainly likely to be slower, so you
-will consistently get examples which are right on the boundary of being too slow.
-
-Which is fine, except that  Hypothesis relies on repeatability to display test errors -
-once it has a minimized example, it replays the test so it can show you the example,
-print the exception, etc. And test run times are not actually repeatable - a test that
-takes 201ms on first running might take 199ms on the next run. This then results in
-Hypothesis thinking the test is flaky - it previously raised `DeadlineExceeded`, and now it
-doesn't. This lead to Issue 892(http://github.com/HypothesisWorks/hypothesis-python/issues/892),
-where Florian Bruhin ran into precisely this problem when testing Qutebrowser(https://www.qutebrowser.org/).
-
-The solution I've ended up opting for there(https://github.com/HypothesisWorks/hypothesis-python/pull/899)
-is to temporarily raise the deadline during shrinking
-to something halfway between the actual deadline and the largest runtime we've seen. This
-ensures that we shrink to a larger threshold than the deadline, and then when we replay
-we should comfortably exceed the real deadline unless the test performance actually *is*
-really flaky (in which case I've also improved the error message).
-
-This solution is currently very specific to the problem of the deadlines, and that's
-fine - there's no need to rush to a fully general solution, and deadlines have slightly
-different constraints than other variants of this due to the unreliability of timing -
-but it is something I'd like to see solved more generally.
-
-One thing I have thought about for a while is adding some notion of scoring to
-Hypothesis - e.g. letting people record some score that recorded your progress
-in testing (testing games where the score could be e.g. the level you've reached, or
-your literal score in the game, was one use case I had in mind). This would seem to be
-another good example for that - if you could make your score available to Hypothesis
-in some way (or if Hypothesis could figure it out automatically!), then a similar
-solution to the above could be used: If Hypothesis notices that the score of the
-shrunk example is drastically different from the score of the starting example, it
-could try rerunning the shrinking process with the additional constraint that the
-score should stay closer to that of the original example, and display the newly shrunk
-example with the larger (or smaller) score alongside it. This would work as part
-of the new multiple failures reporting, so you would see both examples side by side.
-
-This needs more thought before I jump in and implement something, but I think this is
-an important problem to solve to improve the usability of Hypothesis in particular and
-property-based testing in general. Shrinking is a great start to making the problems
-testing exposes legible to users, but it's only a start, and we need to do more to
-try to improve developers' productivity when debugging the problems we show them.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2018-01-08-smarkets.md Deleted

@@ -1,192 +0,0 @@
----
-layout: post
-tags: python
-date: 2018-01-08 06:00
-title: Smarkets's funding of Hypothesis
-published: true
-author: drmaciver
----
-
-Happy new year everybody!
-
-In this post I'd like to tell you about one of the nice things that happened in 2017:
-The Hypothesis work that was funded by Smarkets(https://smarkets.com/careers)
-Smarkets are an exchange for peer-to-peer trading of bets but, more importantly for us,
-they are fairly heavy users of Hypothesis for the Python part of their stack.
-
-
-
-Smarkets approached me a while back to talk about possibly funding some Hypothesis development.
-We talked a bit about what their biggest pain points with Hypothesis were,
-and it emerged that they were having a lot of trouble with Hypothesis performance.
-
-We talked a bit about how to speed Hypothesis up, and I suggested some diagnostic tests
-they could do to see where the problem was, and it fairly quickly emerged that in fact
-they mostly *weren't* having trouble with Hypothesis performance - Hypothesis indeed was
-much slower than it should have been in their use case, but more than an order of magnitude
-more time was spent in their test code rather than in Hypothesis.
-
-So on further discussion we decided that actually their big problem was not the performance
-of Hypothesis per se, but instead the *legibility* of Hypothesis performance problems - when
-tests using Hypothesis were slow, it was non-obvious why that might be the case, and it
-might be extremely difficult to reproduce the problem.
-
-This is the sort of problem where it's really useful to have user feedback and funding,
-because it's more or less a non-problem for me and - to a lesser extent - anyone who already
-works on Hypothesis. Because we've got much deeper knowledge of the internals and the failure
-modes, we're largely just used to working around these issues. More feedback from Hypothesis
-would be *helpful*, but it's not *essential*.
-
-So, given that in the normal course of things Hypothesis development is mostly driven by what
-we feel like working on, this is really the sort of work that will only happen with a source
-of external funding for it. Thus it's really great that Smarkets were willing to step up and
-fund it!
-
-After some discussion we ended up settling on four features that would significantly improve
-the situation for them:
-
-### Identification of examples causing slow tests
-
-This was the introduction of the deadline(https://hypothesis.readthedocs.io/en/latest/settings.html#hypothesis.settings.deadline)
-feature, which causes Hypothesis to treat slow tests as failures - when set, a test that takes
-longer than its set deadline (not counting data generation) raises a `DeadlineExceeded` error.
-
-This is a bit of a blunt instrument, but it is *very* effective at getting test runtime under control!
-
-There turned out to be some amusing complications in developing it, so this feature was spread over a
-number of releases as we found and worked out its various kinks (3.27.0, 3.31.1, 3.38.2).
-
-One of the interesting problems we found was that deadlines have a
-threshold problem({{site.url}}{% post_url 2017-09-28-threshold-problem %}) - because the shrinking
-process tends to find examples which are just on the cusp of failure, often when you rerun a fully shrunk example it doesn't fail!
-
-I went back and forth on the best solution for this for a while, but in the end the best solution turned out to be a simple one -
-raise the deadline during example generation and shrinking, then replay with the actual set deadline.
-
-This does mean that tests that are *right* on the cusp of being too slow may pass artificially, but that's substantially better
-than introducing flaky failures.
-
-On top of this we also needed to make this feature play well with inline data generation(https://hypothesis.readthedocs.io/en/latest/data.html#drawing-interactively-in-tests) -
-the complicating factor was that data generation is much faster when replaying examples or shrinking than it is during generation
-(the generation logic is rather too complicated. I have some long-term plans to make it simpler, which would make this difference largely go away).
-Fortunately, the work done for the next feature made this easy to do.
-
-### Breakdown of generation time in statistics
-
-This was a fairly simple change, prompted by the initial confusion we had in diagnosing
-Smarket's test problems: If you can't tell the difference between slow data generation and
-slow tests, your initial guesses about performance may be very misleading! So this change
-updated the statistics reporting system(https://hypothesis.readthedocs.io/en/latest/details.html#statistics)
-to report what fraction of time is spent in data generation. If you run tests with statistics
-you'll now see a line like the following:
-
-```
-- Fraction of time spent in data generation: ~ 12%
-```
-
-A small change, but a very helpful one! This came in in Hypothesis 3.38.4.
-
-### Health check overhaul
-
-Hypothesis has had a health check system for a while. Its general goal is to suggest that
-you might not want to do that thing you're doing - roughly analogous to compiler warnings.
-It's useful for guiding you into correct use of Hypothesis and helping you avoid things that
-might degrade the quality of your testing.
-
-It's historically had some problems: In particular the main source of health checks did not
-actually run your tests! They just run the data generation with the test stubbed out.
-This meant that you could very easily accidentally bypass the health checks by e.g.
-using inline data generation, or doing your filtering with assume.
-
-It also had the problem that it wasn't running the real data generation algorithm but instead
-an approximation to it.
-This meant that things that  would work fine in practice would sometimes fail health checks.
-
-This piece of work was an overhaul of the health check system to solve these problems and to expand the scope of the problems it could find.
-
-It ended up working very well. So well in fact that it found some problems in Hypothesis's built in library of strategies!
-
-It was split across a number of releases:
-
-* In 3.37.0 we deprecated a number of existing health checks that no longer did anything useful.
-* In 3.38.0 I overhauled the health check system to be based on actual test execution, solving the existing limitations of it.
-* In 3.39.0 I added a new health check that tests whether the smallest example of the test was too large to allow reasonable testing -
-  accidentally generating very large examples being a common source of performance bugs.
-
-The health check in 3.39.0 turned out to catch a major problem in Hypothesis's handling of blacklist\_characters and some
-regular expression constructs, so prior to that we had to release 3.38.8 to fix those!
-
-Over all I'm much happier with the new health check system and think it does a much better job of shaping user behaviour to get better results out of Hypothesis.
-
-### Printing reproduction steps
-
-Historically output from Hypothesis has looked something like this:
-
-```
-Falsifying example: test_is_minimal(ls=0, v=1)
-```
-
-Or, if you had a failed health check, like the following:
-
-```
-hypothesis.errors.FailedHealthCheck: It looks like your strategy is filtering out a lot of data. Health check found 50 filtered examples but only
-0 good ones. This will make your tests much slower, and also will probably distort the data generation quite a lot. You should adapt your strategy
- to filter less. This can also be caused by a low max_leaves parameter in recursive() calls.
-
-See https://hypothesis.readthedocs.io/en/latest/healthchecks.html for more information about this. If you want to disable just this health check,
-add HealthCheck.filter_too_much to the suppress_health_check settings for this test.
-```
-
-This is fine if you're running the tests locally, but if your failure is on CI this can be difficult to reproduce.
-If you got a falsifying example, you're only able to reproduce it if all of your arguments have sensible reprs (which may not be the case even if you restrict yourself to Hypothesis's built in strategies - e.g. using inline data generation prevents it!).
-If you got a health check failure, there's nothing that helps you reproduce it at all!
-
-So the proposed feature for this was to print out the random seed that produced this:
-
-```
-You can add @seed(302934307671667531413257853548643485645) to this test or run pytest with --hypothesis-seed=302934307671667531413257853548643485645 to reproduce this failure.
-```
-
-This was a great idea, and seemed to work out pretty well when we introduced it in 3.30.0, but on heavier use in the wild turned out to have some fairly major problems!
-
-The big issue is that in order to reproduce Hypothesis's behaviour on a given run you need to know not
-just the random seed that got you there, but also the state of Hypothesis's example database!
-Hypothesis maintains a cache of many of the previously run examples(https://hypothesis.readthedocs.io/en/latest/database.html),
-and uses it to inform the testing by replaying test cases that e.g. failed the last time they were run,
-or covered some hard to reach line in the code.
-Even for examples that don't come from the database, Hypothesis under the hood is a mutation based
-fuzzer, so all the examples it finds will depend on the examples it loaded.
-
-The initial solution to this (3.40.0) was just to turn off seed printing when its output would be misleading.
-This worked, but was fairly non-ideal even just for Smarkets - they *do* use the database in their CI, so this would result in a lot of failures to print.
-
-After some discussion, I decided that given that the feature wasn't nearly as useful as intended,
-so I threw in an extra freebie feature to make up the gap in functionality:
-@reproduce\_failure(https://hypothesis.readthedocs.io/en/latest/reproducing.html#reproducing-an-example-with-with-reproduce-failure).
-This uses Hypothesis's internal format to replicate the functionality of the database in a way that is easy to copy and paste into your code.
-It took some careful designing to make it usable - my big concern was that people would leave this in their code, blocking future upgrades to Hypothesis - but in the end I'm *reasonably* happy with the result.
-
-As a bonus, the work here allowed me to sort out one big concern about seed printing: We still needed a way to reproduce health check failures when the database was being used.
-The solution was in the end easy: We just don't use the examples from the database in the part where the main health checks are running.
-This still leaves a few health checks which could theoretically be hard to reproduce (the main one is the hung test health check, but that one tends to reproduce fairly reliably on any seed if you have deadlines on).
-
-So this leaves us with a state where health check failures will suggest `@seed` and example failures will suggest `@reproduce_failure` (where necessary. The linked documentation spells this out in more detail).
-
-### Ten releases later
-
-In the end the Smarkets work came to a total of exactly 10 releases, some larger than other.
-
-The end result has been very beneficial, and not just to Smarkets!
-I've had several users report back improvements to their tests as a result of the new health checks,
-and I've personally found the `@reproduce_failure` feature remarkably useful.
-
-I'm very happy to have done this work, and am grateful to Smarkets for funding it.
-
-I think this sort of thing where commercial users fund the "boring" features that are very useful for people using the tool at scale but maintainers are unlikely to work on under their own initiative is a
-very good one, and I hope we'll do more of it in future.
-
-As a bonus, Smarkets kindly agreed to put online the talk I gave them about Hypothesis (largely intended
-to raise awareness of it and property-based testing among their teams who aren't using it yet).
-If you want to learn more about some of the philosophy and practice behind using this sort of
-testing, or want something to send to people who aren't convinced yet, you can watch it
-here(https://smarketshq.com/a-talk-on-hypothesis-e7182b95ced1).

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/_posts/2018-02-27-continuous-releases.md Deleted

@@ -1,121 +0,0 @@
----
-layout: post
-tags: development-process
-date: 2018-02-27 07:00
-title: The Hypothesis continuous release process
-published: true
-author: alexwlchan
----
-
-If you watch the Hypothesis changelogchangelog, you'll notice the rate of releases sped up dramatically in 2017.
-We released over a hundred different versions, sometimes multiple times a day.
-
-This is all thanks to our continuous release process.
-We've completely automated the process of releasing, so every pull request that changes code gets a new release, without any human input.
-In this post, I'll explain how our continuous releases work, and why we find it so useful.
-
-changelog: https://hypothesis.readthedocs.io/en/latest/changes.html
-
-
-
-## How it works
-
-In the past, Hypothesis was released manually.
-Somebody had to write a changelog, tag a new release on GitHub, and run some manual pip commands to publish a new version to PyPI -- and only David had the credentials for the latter.
-
-This meant that releases were infrequent, and features spent a long time in master before they were available to `pip install`.
-The pace of development picked up in 2017 -- partly as new maintainers arrived, and partly groundwork for David's upcoming (now started) PhDphd -- and we wanted to be able to release more frequently.
-We decided to automate the entire release process.
-
-Now, when you create a pull request that changes the Hypothesis code -- anything that gets installed by pip -- you have to include a `RELEASE.rst` file which describes your change.
-Here's an example from a recent pull requestrecent:
-
-    RELEASE_TYPE: patch
-
-    This release changes the way in which Hypothesis tries to shrink the size of
-    examples. It probably won't have much impact, but might make shrinking faster
-    in some cases. It is unlikely but not impossible that it will change the
-    resulting examples.
-
-The first line says whether this is a major, minor, or patch release (using semantic versioningsemver).
-The rest is a description of the changes in your patch.
-
-We have a test in CI that checks for this file -- any change to the core code needs a release file, even fixing a typotypo.
-If you need a release file but haven't written one, the tests fail and your pull request won't be merged.
-
-Sometimes we write a release file even if there aren't changes to the core code, but we think it's worth a release anyway.
-For example, changes to the installation code in `setup.py`, or larger changes to our test code for the benefit of downstream packagers.
-
-Once you've written a release file and the pull request is merged into master, and after all the other tests have passed, our CI uses this file to create a new release.
-
-First, it works out the new version number, and updates it in version.pyversion.py.
-Then it copies the release description into the changelog, including the new version number and the current date.
-For example:
-
-    --------------------
-    3.44.25 - 2018-02-05
-    --------------------
-
-    This release changes the way in which Hypothesis tries to shrink the size of
-    examples. It probably won't have much impact, but might make shrinking faster
-    in some cases. It is unlikely but not impossible that it will change the
-    resulting examples.
-
-These two changes are saved as a new commit, and that commit gets tagged as the new release.
-The tag and the commit are pushed to GitHub, and then CI builds a new package and publishes it to PyPI.
-
-So with no very little extra work, every code change triggers a new release, and it's usually available within half an hour of merging the pull request.
-
-This exact system might not scale to larger teams.
-In particular, you can't merge new features until the code in master has been released -- you get conflicts around `RELEASE.rst` -- so you can only merge one pull request at a time.
-And in Hypothesis, we never backport bugfixes to old major or minor releases -- you'd need some changes to support that.
-
-But Hypothesis only has one full-time contributor, and everybody else works on it in their free time, we don't create patches fast enough for this to be a problem.
-For us, it works exceptionally well.
-
-phd: http://www.drmaciver.com/2017/04/life-changes-announcement-academia-edition/
-recent: https://github.com/HypothesisWorks/hypothesis-python/pull/1101
-semver: https://semver.org/
-typo: https://github.com/HypothesisWorks/hypothesis-python/pull/1069
-version.py: https://github.com/HypothesisWorks/hypothesis-python/blob/master/src/hypothesis/version.py
-
-## Why bother?
-
-Moving to continuous releases has been amazing.
-
-The big benefit is that nobody has to do manual releases any more.
-Before we had this system, changelogs had to be assembled and written by hand, which meant reading the commit log since the last release.
-This is both boring and prone to error -- in the past, a release might contain multiple changes, and it was easy to overlook or forget something in the changelog.
-No more!
-
-Another benefit is that our releases happen much more quickly.
-Every patch is available as soon as our tests confirm it's okay, not when somebody remembers to do a release.
-If something's been merged, it's either available for download, or it will be very shortly.
-
-Releasing more often means each individual release is much smaller, which makes it much easier to find the source of bugs or regressions.
-If somebody finds a bug, we can trace it to a specific release (and corresponding pull request), and there's a relatively small amount of code to inspect.
-
-Automation also makes our release process more reliable.
-Manual steps have scope for error, and we've had a few dodgy releases in the past.
-This process has cut over 100 releases near flawlessly.
-
-Finally, every contributor gets to make a release.
-If you submit a patch that gets accepted, your change is available immediately, and it's entirely your work.
-This may less of tangible benefit, but it gives off nice fuzzy feelings, especially if it's your first patch.
-(Speaking of which, we're always looking for new contributorscontributors!)
-
-contributors: https://github.com/HypothesisWorks/hypothesis-python/blob/master/CONTRIBUTING.rst
-
-## I'm ruined for everything else
-
-I've become used to code being available almost immediately after it's merged into master -- which isn't true for the vast majority of projects.
-When I go to a repo with a bug report, see that a bugfix was merged two weeks ago, but there's yet to be a new release, it's hard not to feel a little impatient.
-
-I've started using this in my other repos -- both these scripts exactly, and derivatives of the same idea.
-
-If you'd like to try this yourself (and I'd really encourage you to do so!), all the scripts for this process are under the same MPL license as Hypothesis itself.
-Look in the scripts directoryscripts of the main repo.
-In particular, `check-release-file.py` looks for a release note on pull requests, and `deploy.py` is what actually cuts the release.
-The code will probably need tweaking for your repo (it's closely based on the Hypothesis repo), but hopefully it provides a useful starting point.
-
-scripts: https://github.com/HypothesisWorks/hypothesis-python/tree/master/scripts

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/alternatives Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/alternatives/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/alternatives/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/alternatives/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/details Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/details/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/details/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/details/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/development-process Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/development-process/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/development-process/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/development-process/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/example Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/example/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/example/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/example/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/faq Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/faq/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/faq/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/faq/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/intro Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/intro/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/intro/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/intro/index.md Deleted

@@ -1,22 +0,0 @@
----
-layout: blog_listing
-date: 2015-04-15 15:00
-tag: intro
----
-
-These are a collection of introductory articles that can help you to learn how to use Hypothesis
-effectively. You don't have to read all of these to get started! Feel free to dip in and out as
-the mood takes you.
-
-We recommend the following reading order:
-
-1. What is Hypothesis?(/articles/what-is-hypothesis/)
-2. Getting started with Hypothesis(/articles/getting-started-with-hypothesis/)
-3. Evolving toward property-based testing with Hypothesis(/articles/incremental-property-based-testing/)
-4. Generating the right data(/articles/generating-the-right-data/)
-5. Testing performance optimizations(/articles/testing-performance-optimizations/)
-6. The Encode/Decode Invariant(/articles/encode-decode-invariant)
-7. Rule Based Stateful Testing(/articles/rule-based-stateful-testing)
-
-After that, either just experiment with Hypothesis on your own, with help from the documentation(https://hypothesis.readthedocs.io),
-or check out some of the other articles here(/articles/) for more inspiration.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/news Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/news/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/news/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/news/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/non-technical Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/non-technical/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/non-technical/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/non-technical/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/principles Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/principles/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/principles/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/principles/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/properties Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/properties/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/properties/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/properties/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/python Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/python/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/python/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/python/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/technical Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/technical/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/technical/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/technical/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/writing-good-software Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/writing-good-software/feed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/writing-good-software/feed/index.xml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/articles/writing-good-software/index.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/assets Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/assets/css Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/assets/css/jekyll-github.css Deleted

@@ -1,68 +0,0 @@
-/*
- * GitHub style for Pygments syntax highlighter, for use with Jekyll
- * Courtesy of GitHub.com
- */
-
-.highlight pre, pre, .highlight .hll { background-color: #f8f8f8; border: 1px solid #ccc; padding: 6px 10px; border-radius: 3px; }
-.highlight .c { color: #999988; font-style: italic; }
-.highlight .err { color: #a61717; background-color: #e3d2d2; }
-.highlight .k { font-weight: bold; }
-.highlight .o { font-weight: bold; }
-.highlight .cm { color: #999988; font-style: italic; }
-.highlight .cp { color: #999999; font-weight: bold; }
-.highlight .c1 { color: #999988; font-style: italic; }
-.highlight .cs { color: #999999; font-weight: bold; font-style: italic; }
-.highlight .gd { color: #000000; background-color: #ffdddd; }
-.highlight .gd .x { color: #000000; background-color: #ffaaaa; }
-.highlight .ge { font-style: italic; }
-.highlight .gr { color: #aa0000; }
-.highlight .gh { color: #999999; }
-.highlight .gi { color: #000000; background-color: #ddffdd; }
-.highlight .gi .x { color: #000000; background-color: #aaffaa; }
-.highlight .go { color: #888888; }
-.highlight .gp { color: #555555; }
-.highlight .gs { font-weight: bold; }
-.highlight .gu { color: #800080; font-weight: bold; }
-.highlight .gt { color: #aa0000; }
-.highlight .kc { font-weight: bold; }
-.highlight .kd { font-weight: bold; }
-.highlight .kn { font-weight: bold; }
-.highlight .kp { font-weight: bold; }
-.highlight .kr { font-weight: bold; }
-.highlight .kt { color: #445588; font-weight: bold; }
-.highlight .m { color: #009999; }
-.highlight .s { color: #dd1144; }
-.highlight .n { color: #333333; }
-.highlight .na { color: teal; }
-.highlight .nb { color: #0086b3; }
-.highlight .nc { color: #445588; font-weight: bold; }
-.highlight .no { color: teal; }
-.highlight .ni { color: purple; }
-.highlight .ne { color: #990000; font-weight: bold; }
-.highlight .nf { color: #990000; font-weight: bold; }
-.highlight .nn { color: #555555; }
-.highlight .nt { color: navy; }
-.highlight .nv { color: teal; }
-.highlight .ow { font-weight: bold; }
-.highlight .w { color: #bbbbbb; }
-.highlight .mf { color: #009999; }
-.highlight .mh { color: #009999; }
-.highlight .mi { color: #009999; }
-.highlight .mo { color: #009999; }
-.highlight .sb { color: #dd1144; }
-.highlight .sc { color: #dd1144; }
-.highlight .sd { color: #dd1144; }
-.highlight .s2 { color: #dd1144; }
-.highlight .se { color: #dd1144; }
-.highlight .sh { color: #dd1144; }
-.highlight .si { color: #dd1144; }
-.highlight .sx { color: #dd1144; }
-.highlight .sr { color: #009926; }
-.highlight .s1 { color: #dd1144; }
-.highlight .ss { color: #990073; }
-.highlight .bp { color: #999999; }
-.highlight .vc { color: teal; }
-.highlight .vg { color: teal; }
-.highlight .vi { color: teal; }
-.highlight .il { color: #009999; }
-.highlight .gc { color: #999; background-color: #EAF2F5; }

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/assets/css/site.css Deleted

@@ -1,272 +0,0 @@
-@import url(https://fonts.googleapis.com/css?family=Lato:400,700);
-
-/* global settings */
-body {
-  font-family: 'Lato', 'sans-serif';
-  padding-bottom:60px;
-  padding-top:50px;
-}
-
-.page-header{
-  margin: 10px 0;
-  text-align:center;
-  padding-bottom:25px;
-}
-.page-header h1{
-  margin: 0;
-}
-
-
-/*navbar stuff*/
-.name-holder{
-  margin-left:10px;
-}
-
-
-/*Primary navigation bar*/
-
-.navbar .navbar-brand {
-  padding: 0px;
-}
-.navbar .navbar-brand img {
-  height: 51px;/* because the navbar has a height of 50px and 1px border bottom*/
-}
-
-
-body{
-  font-size: 18px;
-}
-
-p {
-  margin: 0.5em auto 0.75em auto;
-}
-
-h4, h3{
-  margin: 1em auto 0.5em auto;
-}
-
-h4 {
-  font-size: 20px;
-}
-
-h3 {
-  font-size: 25px;
-}
-
-
-h2 {
-  font-size: 30px;
-}
-
-.navbar-right li{
-  font-size: 20px;
-  text-align: center;
-}
-@media (max-width: 992px) {
-  #main-menu li{
-    font-size: 15px;
-  }
-  #main-menu li a {
-    padding-left: 10px;
-    padding-right: 10px;
-  }
-}
-
-
-/*makes an anchor inactive(not clickable)*/
-
-.inactive-link {
-   pointer-events: none;
-   cursor: default;
-}
-
-/*blog stuff */
-.blog-short{
-  border-bottom:1px solid #ddd;
-  padding-bottom:30px;
-  display: table;
-
-}
-.blog-short .excerpt{
-  min-height:100px;
-}
-.margin10{margin-bottom:10px; margin-right:10px;}
-
-
-/*footer*/
-.footer {
-    background-color: #f5f5f5;
-    bottom: 0;
-    min-height: 10px;
-    position: fixed;
-    width: 100%;
-    font-weight: bold;
-}
-
-/* social buttons */
-/*social buttons */
-.social-btn-holder{
-  padding:10px;
-  margin-top:5px;
-  margin-bottom:5px;
-}
-.social-btn-holder .btn-social{
-  font-size:12px;
-  font-weight:bold;
-}
-
-.btn-social{
-  color: white;
-  opacity:0.9;
-}
-.btn-social:hover {
-  color: white;
-  opacity:1;
-}
-.btn-facebook {
-background-color: #3b5998;
-}
-.btn-twitter {
-background-color: #00aced;
-}
-.btn-linkedin {
-background-color:#0e76a8;
-}
-.btn-github{
-  background-color:#000000;
-}
-.btn-google {
-  background-color: #c32f10;
-}
-.btn-stackoverflow{
-  background-color: #D38B28;
-}
-
-.btn-hackerrank{
-  background-color: #27AB5B;
-}
-.btn-soundcloud{
-  background-color: #FF7202;
-}
-
-
-/* utility classes */
-.no-margin:{
-  margin:0;
-}
-.border-bottom{
-    border-bottom: 1px solid #eee;
-}
-.centered-text{
-  text-align: center;
-}
-
-
-/* front page stuff */
-.imgcontainer img{
-  width: 100%;
-}
-
-div.page{
-}
-
-#site-title{
-  line-height: 50px;
-  color: #002E62;
-  font-weight: bold;
-}
-
-.container h1,h2,h3,h4,h5,h6{
-    color: #002e62;
-}
-a{
- color: #0069df;
-}
-#main-menu a{
-  color:#002e62;
-}
-
-.label-tag{
-  background-color: #002e62;
-}
-.label-tag a{
-  color: white;
-}
-.blog-header{
-  background-color: #f8f8f8
-}
-
-blockquote.testimonial {
-  width: 100%;
-  display: block;
-  background: #f9f9f9;
-  border: none;
-  margin: 1em 0 1em 0;
-  font-size: 20px;
-  padding: 1em;
-  text-align: left;
-}
-
-blockquote.testimonial footer{
-  margin-top: 10px;
-}
-
-blockquote.testimonial p {
-  margin-top: 0;
-}
-
-
-blockquote.testimonial footer{
-  text-align: right;
-}
-
-h2 {
-  font-size: 40px;
-  text-align: center;
-  margin: 40px auto 15px auto;
-}
-
-h1 {
-  font-size: 50px;
-  text-align: center;
-  margin: 0px auto 25px auto;
-}
-
-form#tinyletter {
-  display: block;
-  width: 100%;
-  margin: 1.5em 0 0;
-  padding-right: 1em;
-  text-align: right;
-}
-
-input#tlemail {
-  width: 200px;
-}
-
-div.article-listing div.panel {
-  width: 90%;
-  margin: 0 auto 10px auto ;
-}
-
-div.article-listing div.panel-heading {
-  text-align: center;
-}
-
-div.panel div.rss-plug{
-  text-align: right;
-}
-
-div.container {
-  max-width: 50em;
-}
-
-pre {
-    margin: 1em 2em 0.5em 2em;
-}
-
-
-.post-metadata div.author {
-    font-size: 20px;
-}
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/assets/js Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/assets/js/site.js Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/index.md Deleted

@@ -1,70 +0,0 @@
----
-title: Most testing is ineffective
-layout: page
-date: 2015-04-23 22:03
----
-
-Normal "automated" software testing is surprisingly manual. Every scenario the computer runs, someone had to
-write by hand. Hypothesis can fix this.
-
-Hypothesis is a new generation of tools for automating your testing process. It combines human understanding of
-your problem domain with machine intelligence to improve the quality of your testing process while spending
-*less* time writing tests.
-
-Don't believe us? Here's what some of our users have to say:
-
-<blockquote class="testimonial blockquote-reverse pull">
-<p>
-At Lyst we've used it in a wide variety of situations, from testing APIs to machine learning algorithms and in all
-cases it's given us a great deal more confidence in that code.
-</p>
-<footer><a href="/testimonials/#alex-stapleton">Alex Stapleton</a>, Lead Backend Engineer at <a href="https://www.lyst.com/">Lyst</a></footer>
-</blockquote>
-
-
-<blockquote class="blockquote-reverse pull testimonial">
-When it comes to validating the correctness of your tools, nothing comes close to the thoroughness and power of Hypothesis.
-
- <footer><a href="/testimonials/#cory-benfield">Cory Benfield</a>, <a href="https://github.com/Lukasa">Open source Python developer</a></footer>
-</blockquote>
-
-
-<blockquote class="blockquote-reverse pull testimonial">
-Hypothesis has been brilliant for expanding the coverage of our test cases, and also for making them much easier to read and understand, so we’re sure we’re testing the things we want in the way we want.
- <footer><a href="/testimonials/#kristian-glass">Kristian Glass</a>, Director of Technology at <a href="https://www.laterpay.net/">LaterPay</a></footer>
-</blockquote>
-
-<blockquote class="blockquote-reverse pull testimonial">
-Hypothesis has located real defects in our code which went undetected by traditional test cases, simply because Hypothesis is more relentlessly devious about test case generation than us mere humans!
- <footer><a href="/testimonials/#sixty-north">Rob Smallshire</a>, <a href="http://sixty-north.com/">Sixty North</a></footer>
-</blockquote>
-
-See more at our testimonials page(/testimonials/).
-
-## What is Hypothesis?
-
-Hypothesis is a modern implementation of property based testing(https://en.wikipedia.org/wiki/QuickCheck), designed from the ground up for mainstream languages.
-
-Hypothesis runs your tests against a much wider range of scenarios than a human tester could, finding edge cases
-in your code that you would otherwise have missed. It then turns them into simple and easy to understand failures
-that save you time and money compared to fixing them if they slipped through the cracks and a user had run into
-them instead.
-
-Hypothesis currently has a fully featured open source Python implementation(https://github.com/HypothesisWorks/hypothesis-python/) and a proof of concept Java implementation(https://github.com/HypothesisWorks/hypothesis-java) that we are looking for customers to partner with to turn into a finished project.
-Plans for C and C++ support are also in the works.
-
-## How do I use it?
-
-Hypothesis integrates into your normal testing workflow. Getting started is as simple as installing a library and
-writing some code using it - no new services to run, no new test runners to learn.
-
-Right now only the Python version of Hypothesis is production ready. To get started with it, check out
-the documentation(https://hypothesis.readthedocs.io/en/latest/) or read some of the
-introductory articles here on this site(/articles/intro/).
-
-Once you've got started, or if you have a large number of people who want to get started all at once,
-you may wish to engage our training services(/training).
-
-If you still want to know more, sign up to our newsletter to get an email every 1-2 weeks about the latest and greatest Hypothesis developments and how to test your software better.
-
-<form id="tinyletter" action="https://tinyletter.com/DRMacIver" method="post" target="popupwindow" onsubmit="window.open('https://tinyletter.com/DRMacIver', 'popupwindow', 'scrollbars=yes,width=800,height=600'); return true;"><input type="email" name="email" id="tlemail" placeholder="Your email address"/><input type="hidden" value="1" name="embed" /><input type="submit" value="Subscribe"/></form>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/products Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/products/index.md Deleted

@@ -1,51 +0,0 @@
----
-title: Products
-layout: page
-date: 2015-05-19 15:00
----
-
-## Hypothesis for Python
-
-This is our current primary focus and the only currently production ready
-implementation of the Hypothesis design.
-
-It features:
-
-* A full implementation of property based testing(
-  {{site.url}}{% post_url  2016-05-13-what-is-property-based-testing %}) for
-  Python, including stateful testing({{site.url}}{% post_url  2016-04-19-rule-based-stateful-testing %}).
-* An extensive library of data generators and tools for writing your own.
-* Compatible with py.test, unittest, nose and Django testing, and probably many
-  others besides.
-* Supports CPython and PyPy 3.6 and later (older versions are EoL upstream).
-* Open source under the Mozilla Public License 2.0(https://www.mozilla.org/en-US/MPL/2.0/)
-
-To use Hypothesis for Python, simply add the *hypothesis* package to your requirements,
-or *pip install hypothesis* directly.
-
-The code is available on GitHub(https://github.com/HypothesisWorks/hypothesis-python)
-and documentation is available on readthedocs(https://hypothesis.readthedocs.io/).
-
-## Hypothesis for Java
-
-Hypothesis for Java is currently a *feasibility prototype* only and is not ready
-for production use. We are looking for initial customers to help fund getting it
-off the ground.
-
-As a prototype it currently features:
-
-* Enough of the core Hypothesis model to be useful.
-* Good JUnit integration.
-* A small library of data generators.
-
-The end goal is for Hypothesis for Java to have feature parity with Hypothesis
-for Python, and to take advantage of the JVM's excellent concurrency support
-to provide parallel testing of your code, but it's not there yet.
-
-The current prototype is released under the AGPL3 (this is not the intended
-license for the full version, which will most likely be Apache licensed) and
-is available on GitHub(https://github.com/HypothesisWorks/hypothesis-java).
-
-Email us at hello@hypothesis.works(mailto:hello@hypothesis.works) if you want
-to know more about Hypothesis for Java or want to discuss being an early customer
-of it.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/provision.sh Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/scratch Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/scratch/README.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/scratch/voting.py Deleted

@@ -1,78 +0,0 @@
-# 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/.
-
-from collections import Counter
-
-from hypothesis import find, strategies as st
-
-
-@st.composite
-def election(draw, max_candidates=10):
-    candidates = list(range(draw(st.integers(2, max_candidates))))
-    return draw(st.lists(st.permutations(candidates), min_size=1))
-
-
-def candidates_for_election(election):
-    return sorted({c for cs in election for c in cs})
-
-
-def plurality_winner(election):
-    counts = Counter(vote0 for vote in election)
-    winning_score = max(counts.values())
-    winners = c for c, v in counts.items() if v == winning_score
-    if len(winners) > 1:
-        return None
-    else:
-        return winners0
-
-
-def irv_winner(election):
-    candidates = candidates_for_election(election)
-    while len(candidates) > 1:
-        scores = Counter()
-        for vote in election:
-            for c in vote:
-                if c in candidates:
-                    scoresc += 1
-                    break
-        losing_score = min(scoresc for c in candidates)
-        candidates = c for c in candidates if scoresc > losing_score
-    if not candidates:
-        return None
-    else:
-        return candidates0
-
-
-def differing_without_ties(election):
-    irv = irv_winner(election)
-    if irv is None:
-        return False
-    plurality = plurality_winner(election)
-    if plurality is None:
-        return False
-    return irv != plurality
-
-
-def is_majority_dominated(election, c):
-    scores = Counter()
-    for vote in election:
-        for d in vote:
-            if d == c:
-                break
-            scoresd += 1
-    return any(score > len(election) / 2 for score in scores.values())
-
-
-def find_majority_dominated_winner(method):
-    def test(election):
-        winner = method(election)
-        return winner is not None and is_majority_dominated(election, winner)
-
-    return find(election(), test)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/services Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/services/index.md Deleted

@@ -1,47 +0,0 @@
----
-title: Services and Support
-layout: page
-date: 2015-04-23 21:08
----
-
-We provide a range of contracting services in the areas of both development and training to help you make the most out of Hypothesis. There are possibilities for both remote work and on-site engagements.
-
-For remote engagements, we can accommodate distributed teams by offering training sessions over video conferencing solutions. We can also provide a second set of eyes for pair and team programming efforts, or participate in selective code reviews to ensure you and your team are using Hypothesis optimally.
-
-## Ports to new languages
-
-Hypothesis is designed to be easy to port to new languages, but we will rarely start on new ports unless someone pays for the development. So if there's a language you want to use Hypothesis in and you currently can't, hire us to fix that!
-
-As well as making Hypothesis available in a new language, we usually learn new things about the design space when doing this which tends to produce improvements that get rolled back into other languages and makes the next port that much easier.
-
-We currently have a prototype Java port(https://github.com/HypothesisWorks/hypothesis-java) and are actively considering a port to C (which would in turn simplify the port to many other languages), but most languages should be feasible so if you'd like a port to a different one, just ask us.
-
-This one comes with the added bonus that it will make you very popular! We get a lot of questions about Hypothesis ports from people who can't fund them, and anyone who funds the development of a version of Hypothesis will get mentioned prominently in the README and documentation.
-
-## Performance tweaks
-
-Hypothesis performance is currently pretty good, and for most use cases the bottleneck will be your test code rather than Hypothesis. There are, however, pathological cases where it tends to slow down. This is particularly true if you are generating very complex data.
-
-If you find yourself in this situation, we can help! We'll first try to help you analyze exactly *why* your tests are slow and see if we can help you modify them to be faster. If the problem does turn out to be something we should fix on the Hypothesis end, we can do that too.
-
-If you're really pushing Hypothesis performance hard you may wish to consider hiring us to complete the C port and then rebuild the version for Python (or your language of choice) on top of it.
-
-## Feature requests
-
-As well as performance improvements, we're available for hire for any other specific development on Hypothesis.
-
-There are a large number of directions that Hypothesis can go in and only so much time in the day. If there's a particular feature you need us to bump something up our priority list, you can hire us to implement it.
-
-## Custom testing projects
-
-Although we think anyone can use Hypothesis (even *without* the benefit of our training(/training/)), sometimes you really just want an expert to do the work, either to help you get started or to give you confidence in the results. If you have a particular piece of software that you really need to be well tested, you can hire us to do that for you.
-
-## Support contracts
-
-We can provide support contracts guaranteeing priority to your bug reports and answering your questions when you get stuck. Availability of these is somewhat limited due to capacity constraints, but we are still able to take on new customers.
-
-## Get in touch!
-
-If any of the above sound just like what you need, or if there's another Hypothesis related project that doesn't
-quite fit, drop us a line at hello@hypothesis.works(mailto:hello@hypothesis.works) and lets talk
-details!

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/sitemap.xml Deleted

@@ -1,41 +0,0 @@
----
-layout: null
-sitemap:
-  exclude: "yes"
----
-
-<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  {% for post in site.posts %}
-    {% unless post.published == false %}
-    <url>
-      <loc>{{ post.url | prepend: site.baseurl}}</loc>
-      {% if post.sitemap.lastmod %}
-        <lastmod>{{ post.lastmodified | date_to_xmlschema }}</lastmod>
-      {% elsif post.date %}
-        <lastmod>{{ post.date | date_to_xmlschema  }}</lastmod>
-      {% else %}
-        <lastmod>{{ site.time | date_to_xmlschema }}</lastmod>
-      {% endif %}
-      <changefreq>weekly</changefreq>
-      <priority>0.5</priority>
-    </url>
-    {% endunless %}
-  {% endfor %}
-  {% for page in site.pages %}
-    {% unless page.sitemap.exclude == "yes" %}
-    <url>
-      <loc>{{ page.url | prepend: site.baseurl }}</loc>
-      {% if page.lastmodified %}
-        <lastmod>{{ page.lastmodified | date_to_xmlschema}}</lastmod>
-      {% elsif page.date %}
-        <lastmod>{{ page.date | date_to_xmlschema }}</lastmod>
-      {% else %}
-        <lastmod>{{ site.time | date_to_xmlschema }}</lastmod>
-      {% endif %}
-      <changefreq>weekly</changefreq>
-      <priority>0.5</priority>
-    </url>
-    {% endunless %}
-  {% endfor %}
-</urlset>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/testimonials Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/testimonials/index.html Deleted

@@ -1,159 +0,0 @@
----
-title: Testimonials
-layout: page
-date: 2015-04-25 22:03
----
-
-<blockquote class="testimonial blockquote-reverse pull" id='alex-stapleton'>
-<p>
-Hypothesis is easy to learn and powerful implementation of property based testing,
-and generally an invaluable tool. At Lyst we've used it in a wide variety of
-situations, from testing APIs to machine learning algorithms and in all
-cases it's given us a great deal more confidence in that code.
-</p>
-<footer>Alex Stapleton, Lead Backend Engineer at <a href="https://www.lyst.com/">Lyst</a></footer></cite>
-</blockquote>
-
-<blockquote class="testimonial blockquote-reverse pull" id='cory-benfield'>
-<p>
-Hypothesis is the single most powerful tool in my toolbox for working with
-algorithmic code, or any software that produces predictable output from a wide
-range of sources. When using it with <a href="http://python-hyper.org/priority/">Priority</a>, Hypothesis consistently found
-errors in my assumptions and extremely subtle bugs that would have taken months
-of real-world use to locate. In some cases, Hypothesis found subtle deviations
-from the correct output of the algorithm that may never have been noticed at
-all.
-</p>
-<p>
-When it comes to validating the correctness of your tools, nothing comes close
-to the thoroughness and power of Hypothesis.
-</p>
- <footer><a href="https://github.com/Lukasa">Cory Benfield</a></footer></cite>
-</blockquote>
-
-<blockquote class="testimonial blockquote-reverse pull" id='kristian-glass'>
-<p>Hypothesis has been brilliant for expanding the coverage of our test cases,
-and also for making them much easier to read and understand,
-so we're sure we're testing the things we want in the way we want.</p>
- <footer><a href="/testimonials/#kristian-glass">Kristian Glass</a>, Director of Technology at <a href="https://www.laterpay.net/">LaterPay</a></footer></cite>
-</blockquote>
-
-<blockquote class="testimonial blockquote-reverse pull" id='sixty-north'>
-<p>
-At Sixty North we use Hypothesis for testing
-<a href="https://github.com/sixty-north/segpy">Segpy</a>, an open source Python library for
-shifting data between Python data structures and SEG Y files which contain
-geophysical data from the seismic reflection surveys used in oil and gas
-exploration.</p>
-
-<p>This is our first experience of property-based testing – as opposed to example-based
-testing.  Not only are our tests more powerful, they are also much better
-explanations of what we expect of the production code. In fact, the tests are much
-closer to being specifications.  Hypothesis has located real defects in our code
-which went undetected by traditional test cases, simply because Hypothesis is more
-relentlessly devious about test case generation than us mere humans!  We found
-Hypothesis particularly beneficial for Segpy because SEG Y is an antiquated format
-that uses legacy text encodings (EBCDIC) and even a legacy floating point format
-we implemented from scratch in Python.</p>
-
-<p>
-Hypothesis is sure to find a place in most of our future Python codebases and many
-existing ones too.
-</p>
- <footer>Rob Smallshire, <a href="http://sixty-north.com/">Sixty North</a></footer></cite>
-</blockquote>
-
-
-<blockquote class="testimonial blockquote-reverse pull" id='seth-morton'>
-<p>
-When I first heard about Hypothesis, I knew I had to include it in my two
-open-source Python libraries, <a href="https://github.com/SethMMorton/natsort">natsort</a>
-and <a href="https://github.com/SethMMorton/fastnumbers">fastnumbers</a>.</p>
-
-<p>Quite frankly,
-I was a little appalled at the number of bugs and "holes" I found in the code. I can
-now say with confidence that my libraries are more robust to "the wild." In
-addition, Hypothesis gave me the confidence to expand these libraries to fully
-support Unicode input, which I never would have had the stomach for without such
-thorough testing capabilities. Thanks!
-</p>
-
- <footer><a href="https://github.com/SethMMorton">Seth Morton</a></footer></cite>
-
-</blockquote>
-
-<blockquote class="testimonial blockquote-reverse pull" id='mulkieran'>
-<p>
-Just found out about this excellent QuickCheck for Python implementation and
-ran up a few tests for my <a href="https://github.com/mulkieran/bytesize">bytesize</a>
-package last night. Refuted a few hypotheses in the process.
-</p>
-
-<p>
-Looking forward to using it with a bunch of other projects as well.
-</p>
-<footer>
-<a href="https://github.com/mulkieran">mulkieran</a>
-</footer>
-</blockquote>
-
-
-<blockquote class="testimonial blockquote-reverse pull" id='adam-johnson'>
-<p> I have written a small library to serialize dicts to MariaDB's dynamic columns binary format, <a href=https://github.com/adamchainz/mariadb-dyncol">mariadb-dyncol</a>. When I first
-developed it, I thought I had tested it really well - there were hundreds of
-test cases, some of them even taken from MariaDB's test suite itself. I was
-ready to release.
-</p>
-
-<p>
-Lucky for me, I tried Hypothesis with David at the PyCon UK sprints. Wow! It
-found bug after bug after bug. Even after a first release, I thought of a way
-to make the tests do more validation, which revealed a further round of bugs!
-Most impressively, Hypothesis found a complicated off-by-one error in a
-condition with 4095 versus 4096 bytes of data - something that I would never
-have found.
-</p>
-<p>
-Long live Hypothesis! (Or at least, property-based testing).
-</p>
-<footer>
-<a href="https://github.com/adamchainz">Adam Johnson</a>
-</footer>
-</blockquote>
-
-<blockquote class="testimonial blockquote-reverse pull" id='adam-johnson'>
-<p>
-Adopting Hypothesis improved <a href="https://github.com/jab/bidict">bidict</a>'s
-test coverage and significantly increased our ability to make changes to
-the code with confidence that correct behavior would be preserved.
-Thank you, David, for the great testing tool.
-</p>
-<footer>
-<a href="https://github.com/jab">Josh Bronson</a>
-</footer>
-</blockquote>
-
-
-<blockquote class="testimonial blockquote-reverse pull" id='jon-moore'>
-<p>
-One extremely satisfied user here. Hypothesis is a really solid implementation 
-of property-based testing, adapted well to Python, and with good features
-such as failure-case shrinkers. I first used it on a project where we needed 
-to verify that a vendor's Python and non-Python implementations of an algorithm
-matched, and it found about a dozen cases that previous example-based testing
-and code inspections had not. Since then I've been evangelizing for it at our firm.
-</p>
-<footer>
-<a href="https://github.com/jonmoore">Jon Moore</a>
-</footer>
-</blockquote>
-
-<h3>Your name goes here</h3>
-<p>
-Want to add to the list by telling us about your Hypothesis experience? Drop us
-an email at <a href="mailto:testimonials@hypothesis.works">testimonials@hypothesis.works</a>
-and we'll add it to the list!
-</p>
-<p>
-
-</p>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/training Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/HypothesisWorks.github.io/training/index.md Deleted

@@ -1,62 +0,0 @@
----
-title: Training
-layout: page
-date: 2015-04-23 21:51
----
-
-## Why should my company get Hypothesis training?
-
-Hypothesis **makes your testing less labor-intensive and more thorough**. You'll find bugs you never even suspected were there in less time than your existing testing tools and methodology require.
-
-You don't *need* training to use Hypothesis, if you're not using Hypothesis already, why not just try it out first?
-
-Hypothesis has extensive documentation(https://hypothesis.readthedocs.io/en/latest/), and a body of introductory articles are available right here(/articles/intro/) to get you started. These resources and will help you and your team begin testing with Hypothesis in no time. Give it a spin!
-
-Now that you *are* using Hypothesis, ask your team two questions:
-
-1. Is Hypothesis useful?
-2. Could we be getting more out of it?
-
-The answers to both will be a resounding yes.
-
-If you want to take your usage of Hypothesis to the next level and find
-even more bugs with even less work, our training can help.
-
-The exact nature of the workshop depends on your needs. To find out more about our offerings, read on!
-
-## What do you need?
-
-* I need my team to get better at testing(#i-need-my-team-to-get-better-at-testing)
-* I need my product to be better tested(#i-need-my-product-to-be-better-tested)
-* I need something else(#i-need-something-else-or-something-more)
-
-### I need my team to get better at testing
-
-In that case you want our **structured** workshop.
-
-* One day on-site workshop, up to 10 people.
-* Video conferencing format for distributed remote teams available on request.
-* Beginner friendly.
-* We work through a series of examples illustrating key Hypothesis concepts.
-* Attendees come away with a deeper understanding of how Hypothesis can improve their testing.
-
-Drop us a line at training@hypothesis.works(mailto:training@hypothesis.works) to find out more.
-
-### I need my product to be better tested
-
-In that case you want our **exploratory** workshop.
-
-* One day on-site workshop, up to 10 people.
-* Video conferencing format for distributed remote teams available on request.
-* Some experience and familiarity with your software and Hypothesis expected.
-* We work as a group to improve the test quality of your software using Hypothesis.
-* Attendees come away with a better understanding of how Hypothesis fits into your specific testing needs and processes.
-* You get better tested software as soon as the workshop is over!
-
-Drop us a line at training@hypothesis.works(mailto:training@hypothesis.works) to find out more.
-
-### I need something else, or something more
-
-If you're looking for a customized training experience (e.g. because you want a longer or shorter course, or are looking to dive deeper into a specific topic), we are able to create a customized training that fits your needs and format requirements.
-
-Drop us a line at training@hypothesis.works(mailto:training@hypothesis.works) and we can discuss the details.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/Makefile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/README.rst Deleted

@@ -1,69 +0,0 @@
-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 monochome 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!
-
-.. image:: ./stickers.jpg
-   :alt: Hypothesis stickers suitable for your laptop
-
-Zac also hands out `custom hard-enamel pins <./pin.jpg>`__ to Hypothesis contributors,
-including anyone who has a pull request merged, does outreach, attends a paid workshop,
-donates money, and so on - we value all kinds of contributions!
-
-Like stickers, you can collect a pin in person at certain Python conferences, or
-`sponsor Zac <https://github.com/sponsors/Zac-HD/>`__ to get them by Australia Post.
-
-
-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
-re-use 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:
-
-.. image:: inkscape.png
-    :width: 800px
-    :align: left
-    :alt: Inkscape showing Hypothesis colour palette
-
-
-GIMP:
-
-.. image:: gimp.png
-    :width: 800px
-    :align: left
-    :alt: GIMP showing Hypothesis colour palette

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/dragonfly-blue.svg Deleted

@@ -1,62 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="916px" height="753px" viewBox="0 0 916 753" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    
-    <title>dragonfly-original</title>
-    <desc>Created with Sketch.</desc>
-    <defs>
-        <radialGradient cx="87.4039429%" cy="14.4845811%" fx="87.4039429%" fy="14.4845811%" r="94.5513154%" gradientTransform="translate(0.874039,0.144846),scale(1.000000,0.704958),rotate(99.804066),translate(-0.874039,-0.144846)" id="radialGradient-1">
-            <stop stop-color="#A3FFF7" offset="0%"></stop>
-            <stop stop-color="#2787B2" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="168.273474%" cy="10.2506186%" fx="168.273474%" fy="10.2506186%" r="196.025438%" gradientTransform="translate(1.682735,0.102506),scale(1.000000,0.457065),rotate(123.395495),translate(-1.682735,-0.102506)" id="radialGradient-2">
-            <stop stop-color="#57538B" offset="0%"></stop>
-            <stop stop-color="#44425F" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="105.741592%" cy="60.558597%" fx="105.741592%" fy="60.558597%" r="74.6427458%" gradientTransform="translate(1.057416,0.605586),scale(1.000000,0.901154),rotate(102.456365),translate(-1.057416,-0.605586)" id="radialGradient-3">
-            <stop stop-color="#A3E9FF" offset="0%"></stop>
-            <stop stop-color="#65C3D5" offset="100%"></stop>
-        </radialGradient>
-        <linearGradient x1="64.5297057%" y1="20.7545785%" x2="48.840717%" y2="84.7584781%" id="linearGradient-4">
-            <stop stop-color="#80D3E7" offset="0%"></stop>
-            <stop stop-color="#5CC9EC" offset="100%"></stop>
-        </linearGradient>
-        <radialGradient cx="115.296233%" cy="-3.97219145%" fx="115.296233%" fy="-3.97219145%" r="112.724099%" gradientTransform="translate(1.152962,-0.039722),scale(1.000000,0.864287),rotate(90.000000),translate(-1.152962,0.039722)" id="radialGradient-5">
-            <stop stop-color="#57538B" offset="0%"></stop>
-            <stop stop-color="#44425F" offset="100%"></stop>
-        </radialGradient>
-    </defs>
-    <g id="dragonfly-original" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <path d="M448.39305,20 C459.901314,14.5328726 473.702898,104.112866 489.797803,288.739981 L440.210507,353.345378 C422.313676,327.937962 408.386422,308.846686 398.428747,296.071549 C383.492233,276.908844 378.016041,259.313599 383.900964,241.04772 C389.785886,222.78184 434.106456,20 448.39305,20 Z" id="Path-Copy" fill-opacity="0.241479846" fill="#5CECE6"></path>
-        <path d="M467.397011,316.10532 C378.111038,314.63156 332.678764,314.63156 331.100187,316.10532 C328.732321,318.315959 369.075348,351.446765 373.957028,352.81113 C378.838709,354.175494 404.775006,349.888229 420.38259,348.582377 C430.787646,347.711809 446.45912,346.51542 467.397011,344.993211 L467.397011,316.10532 Z" id="Path-2" fill-opacity="0.241479846" fill="#5CECE6" transform="translate(399.198506, 334.037969) rotate(19.000000) translate(-399.198506, -334.037969) "></path>
-        <path d="M445.011719,311.421875 L362.219727,310.662598 C345.66862,310.837728 337.006348,311.448568 336.23291,312.495117 C335.937757,312.894494 341.692263,311.645924 353.786133,311.421875 C367.806048,311.162144 431.982422,313.516846 435.748047,314.516846 C438.258464,315.183512 441.346354,316.468262 445.011719,318.371094 L445.011719,311.421875 Z" id="Path-8" fill="#5CC9EC" style="mix-blend-mode: multiply;" transform="translate(390.616917, 314.516846) rotate(19.000000) translate(-390.616917, -314.516846) "></path>
-        <path d="M450.206841,19.7548269 C450.206841,19.7548269 452.240283,18.3219322 458,36.6357422 C459.131865,40.2346633 461.362033,49.9586216 464.690504,65.8076172 C470.512505,91.8846201 474.408639,117.517758 476.378906,142.707031 C478.349173,167.896304 479.280927,203.986268 479.174167,250.976922 L470.525802,293.949818 C472.211807,220.972439 472.211807,169.106028 470.525802,138.350586 C469.192125,114.022152 464.89168,76.8779065 459.916992,52.3935547 C455.458352,30.4490817 450.206841,19.7548269 450.206841,19.7548269 Z" id="Path-7" fill="#5CC9EC" style="mix-blend-mode: multiply;"></path>
-        <g id="Torso" transform="translate(399.000000, 255.000000)">
-            <path d="M161.823602,396.139098 C162.329198,399.046195 162.375183,400.499743 161.961556,400.499743 C158.99599,400.499743 129.413006,363.140503 73.2126025,288.422025 C73.197618,288.514065 73.182633,288.606183 73.1676404,288.69837 L73.1675957,288.698363 C73.078945,289.243461 72.56519,289.613485 72.0200919,289.524834 C71.6829437,289.470003 71.397108,289.246869 71.2620892,288.933109 C24.0052051,179.116455 0.376763113,117.740946 0.376763113,104.806581 C0.376763113,97.2568897 26.4564061,62.5545413 78.6156921,0.699535721 L78.6157249,0.699563325 C78.8097278,0.4694978 79.0970295,0.339040863 79.3979261,0.344384179 L116.317425,1 C118.40385,5.10381325 136.329265,5.23535123 170.093671,1.39461393 C171.19116,1.26978046 172.182053,2.05826716 172.306893,3.15575523 C172.345817,3.497936 172.295722,3.84436999 172.161461,4.16150806 C136.479591,88.4453818 112.413475,145.820205 99.9631131,176.285978 C122.380882,251.93039 138.74644,308.434327 149.059789,345.797791 C149.294526,345.771116 149.532546,345.828365 149.730604,345.961514 C249.351096,412.933971 309.434042,454.88788 329.979443,471.823241 C329.319363,471.962805 331.319806,468.382717 335.98077,461.082976 C340.069143,454.679995 348.234346,489.287899 345.886122,491.018724 C344.332186,492.164096 282.978012,460.537554 161.823602,396.139098 Z" id="Combined-Shape" fill="url(#radialGradient-1)" fill-rule="nonzero"></path>
-            <path d="M99.9170169,176.333366 L79.6540067,222.545571 L73.4246629,288.35038 L111.552821,338.710841 L91.6408491,308.642271 C85.2525472,297.432211 81.8492351,290.668248 81.4309128,288.35038 C81.0125905,286.032513 81.7069859,264.594689 83.5140991,224.036907 C95.2377828,194.771407 101.041885,179.941523 100.926407,179.547256 C100.810928,179.15299 100.474465,178.081693 99.9170169,176.333366 Z" id="Path-5" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-            <path d="M148.871773,345.214827 L161.81839,396.348024 L183.43111,407.460626 C177.524031,401.132905 173.473585,395.923369 171.279772,391.832019 C169.085959,387.740668 162.489108,372.8879 151.48922,347.273715 L148.871773,345.214827 Z" id="Path-6" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-            <path d="M332.617343,466.493423 C330.665707,469.605725 329.784136,471.389481 329.972627,471.844691 C330.452274,472.883855 338.525838,481.491308 339.203433,480.762315 C339.655163,480.276319 338.746293,473.513875 336.476822,460.474984 C336.178789,460.823859 335.789224,461.374433 335.308126,462.126705 C334.827028,462.878978 333.9301,464.33455 332.617343,466.493423 Z" id="Path-7" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-            <path d="M76.1442239,3.5968032 L169.5,4 C164.06184,18.33515 160.591343,26.5340358 159.088511,28.5966575 C156.834261,31.6905899 155.201736,35.4369869 151.515611,39.9497227 C145.239425,47.6333401 140.730853,49.771696 132.541527,52.2486703 C112.107357,58.4292653 79.8424076,41.5505655 73.6554177,37.9957119 C70.6392196,36.2626974 64.6419478,33.1296793 55.6636023,28.5966575 C57.4696781,26.2569339 59.4722212,23.6764704 61.6712315,20.8552671 C63.8306299,18.0848837 68.6549607,12.3320624 76.1442239,3.5968032 Z" id="Path-8" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-        </g>
-        <g id="Head2" transform="translate(454.000000, 60.000000)">
-            <g id="Head">
-                <path d="M97.3713627,89.0305409 C104.305932,86.5539075 112.186751,86.5539075 121.01382,89.0305409 C133.194706,92.4481627 162.426547,105.025636 173.843805,110.003364 C184.997265,117.541347 180.005956,160.880651 176.350815,198.31263 C171.351935,208.850152 164.425238,216.424781 155.570721,221.036516 L115.526395,201.767851 L89.5779926,95.8151106 L97.3713627,89.0305409 Z" id="Path-3" fill="#44425F"></path>
-                <path d="M139.881696,101.02458 C142.22756,101.268288 158.205971,106.402978 160.086284,108.364838 C161.966597,110.326698 171.023288,114.490703 173.256781,120.265403 C175.490274,126.040103 177.082929,130.375266 177.082929,136.314069 C177.082929,141.766868 177.512664,157.069779 177.082929,163.151392 C176.732822,168.106109 172.475643,183.341356 170.983968,184.932088 C169.492294,186.52282 161.581744,194.939932 160.086284,193.272513 C158.590824,191.605094 157.467803,185.635643 159.627739,177.716392 C161.787675,169.797142 166.7687,147.307843 163.480806,132.207414 C161.79019,124.442863 162.104509,124.608382 156.679317,117.108719 C151.553646,110.023107 135.370809,106.819799 135.087065,105.674397 C134.502996,103.316663 136.94169,100.719148 139.881696,101.02458 Z" id="Path-10-Copy" fill="url(#radialGradient-2)"></path>
-                <path d="M121.495825,125.130842 C118.696706,104.363509 116.911691,87.7707463 116.140779,75.3525527 C114.98441,56.7252623 113.816199,45.788746 116.140779,40.7942004 C117.169231,38.5844879 124.895889,30.8864639 131.333407,26.4912081 C135.117533,23.9075725 140.958729,20.2540662 148.856994,15.5306891 L148.857,15.5306991 C149.330987,15.2472421 149.945016,15.4016971 150.228473,15.8756839 C150.414385,16.1865587 150.417648,16.5736656 150.237004,16.8876306 C135.236666,42.9586736 126.996065,57.8248921 125.515201,61.4862858 C123.201405,67.2070807 119.576148,82.3498332 122.841086,123.115086 C122.95715,124.564239 122.50873,125.236158 121.495825,125.130842 Z" id="Path-4-Copy" fill="#7AD0E3" transform="translate(133.018264, 69.821995) rotate(42.000000) translate(-133.018264, -69.821995) "></path>
-                <path d="M45.1066914,100.583831 C61.5842365,92.3903388 95.6959048,86.3600771 102.505156,86.3600771 C109.363353,86.7929987 145.353453,104.181327 148.025168,106.363609 C157.75662,114.312355 163.345005,121.051809 164.031444,154.917303 C164.717883,188.782798 150.558191,254.744765 142.7403,257.072475 C141.623325,257.405045 133.776061,261.766473 129.710116,260.608738 C120.09941,257.872189 88.2922899,242.620723 34.2887566,214.85434 L34.2887568,214.854339 C32.0610331,213.708936 30.4114556,211.686923 29.7367275,209.274571 L7.83902273,130.983821 C6.82933843,127.373901 8.16282677,123.516162 11.1862655,121.300355 C22.0779521,113.318093 33.3847608,106.412585 45.1066914,100.583831 Z" id="Path" fill="url(#radialGradient-3)"></path>
-                <path d="M82.0588275,89.9177926 C64.5481975,95.460078 53.4291233,99.6017308 48.7016047,102.342751 C43.9740862,105.083771 39.9039698,109.748827 36.4912554,116.337919 L35.2997188,135.564911 L7.49499003,136.927141 L10.2691655,125.174182 C8.55751637,124.566886 8.55751637,123.585263 10.2691655,122.229314 C20.3427306,114.249147 36.3906019,105.181718 42.1713548,102.342751 C46.8947947,100.023038 55.3020052,96.0297427 65.1486205,93.2189619 C68.6656206,92.2150113 74.3023562,91.1146215 82.0588275,89.9177926 Z" id="Path-9" fill="#53C2E6" style="mix-blend-mode: multiply;"></path>
-                <path d="M5.43616668,121.434455 C7.29120191,119.262384 31.7219189,114.862582 35.4966272,115.801333 C39.2713355,116.740083 80.4090014,151.265502 82.5280782,156.132421 C83.9407961,159.377034 85.5286639,187.725564 87.2916816,241.178012 L89.2494499,242.560938 C85.5832378,246.076848 83.3427805,247.726466 82.5280782,247.50979 C41.2724219,239.821114 23.267391,227.296992 19.7245333,221.851872 C11.9437611,207.010794 -1.34939033,142.563061 0.51396648,136.811848 C2.37732329,131.060634 3.58113144,123.606527 5.43616668,121.434455 Z" id="Path-2" fill="#44425F"></path>
-                <path d="M32.9076022,110.502757 C30.1084838,89.7354241 28.3234685,73.142661 27.5525563,60.7244673 C26.3961879,42.0971769 25.2279768,31.1606606 27.5525563,26.1661151 C28.5810087,23.9564025 36.3076668,16.2583785 42.7451848,11.8631227 C49.1827029,7.4678669 61.1180521,-0.579918242 62.4619077,0.541813039 C63.8057632,1.66354432 43.009273,30.4494202 40.6954769,36.170215 C38.3816808,41.8910098 30.9879256,67.7217478 34.2528633,108.487 C34.3689277,109.936153 33.9205074,110.608072 32.9076022,110.502757 Z" id="Path-4" fill="url(#linearGradient-4)"></path>
-            </g>
-            <path d="M8.63310706,127.202269 C5.95572019,128.454678 5.20317086,131.937202 6.91813896,133.657358 C7.75128055,134.493019 19.2129444,130.223718 27.2558624,133.657358 C35.7687711,137.291643 43.8998846,146.294186 49.3480648,152.078974 C59.9436357,163.329177 62.8306833,174.869446 65.0579722,182.770018 C67.2852611,190.67059 69.865751,204.185293 72.0063946,204.844331 C74.1470381,205.50337 76.2716368,200.426256 76.7309642,198.294463 C77.1902916,196.162671 74.7702284,165.722628 72.5184608,161.295289 C69.7545534,155.861 61.617573,149.207334 57.7246837,145.398445 C53.2437467,141.014196 47.9070872,135.80037 43.0184199,132.000819 C36.5183393,126.948853 32.3545059,123.801175 29.7323307,123.087966 C27.1101556,122.374756 10.7694235,126.202958 8.63310706,127.202269 Z" id="Path-10" fill="url(#radialGradient-5)"></path>
-        </g>
-        <g id="WINGS" transform="translate(29.000000, 61.000000)" fill="#5CECE6" fill-opacity="0.241479846">
-            <path d="M6.0249161,0.25293065 C15.5493123,0.25293065 159.806941,83.4152808 438.797803,249.739981 C426.621938,313.173647 414.172014,350.987591 401.448031,363.181811 C396.871751,366.982634 242.49924,377.504562 205.784274,353.906914 C169.069308,330.309265 82.8950806,154.029775 42.6649825,82.8064061 C2.43488447,11.5830373 -8.26167817,0.25293065 6.0249161,0.25293065 Z" id="Path"></path>
-            <path d="M409.740103,337.207143 L414.75227,341.623204 C416.332561,343.015546 416.562452,345.394778 415.277973,347.063924 C385.900518,385.239157 365.364394,410.983894 353.6696,424.298134 C317.82617,465.105012 291.004384,487.907183 284.183544,492.165961 C274.180266,498.411783 217.391793,494.294315 113.818126,479.813559 L113.818126,479.813559 C111.630267,479.507672 110.104627,477.486091 110.410515,475.298232 C110.602511,473.92498 111.492009,472.749119 112.761222,472.190745 C183.590786,441.03018 234.369734,417.751843 265.098064,402.355736 C297.247575,386.247561 344.031096,364.316747 405.448628,336.563294 L405.448628,336.563294 C406.881342,335.915877 408.560453,336.167793 409.740103,337.207143 Z" id="Path-3"></path>
-        </g>
-        <path d="M521.443261,340.577276 C546.30194,332.468269 560.315831,329.021804 563.484934,330.237882 C566.480187,331.387248 582.465044,348.501234 611.439506,381.579839 L611.439474,381.579867 C611.803359,381.995295 611.761575,382.627053 611.346147,382.990938 C610.995884,383.297743 610.480213,383.322185 610.102502,383.049884 L556.946165,344.728267 L520.464075,345.799786 C519.912029,345.816 519.451362,345.381622 519.435148,344.829575 C519.431097,344.691668 519.455627,344.554415 519.507195,344.426449 L520.82589,341.154177 C520.936334,340.880105 521.162341,340.668913 521.443261,340.577276 Z" id="Path-4" fill="#44425F"></path>
-        <path d="M506.414364,381.586703 C531.29108,373.47094 545.314603,370.021333 548.484934,371.237882 C551.419733,372.36405 564.837593,381.261399 588.738513,397.929927 L588.738518,397.929921 C589.191523,398.245847 589.302647,398.869189 588.986721,399.322195 C588.726045,399.695977 588.245634,399.84625 587.818424,399.68764 C560.902514,389.69458 546.123298,384.376258 543.480774,383.732675 C540.679676,383.050471 527.988256,384.014898 505.406513,386.625957 L505.406508,386.625913 C504.857903,386.689347 504.361747,386.296037 504.298313,385.747432 C504.277175,385.564618 504.306897,385.379516 504.384206,385.21251 L505.817051,382.117288 C505.933784,381.865115 506.150186,381.672888 506.414364,381.586703 Z" id="Path-4-Copy" fill="#44425F"></path>
-        <path d="M494.044012,419.354094 C517.459848,407.345507 530.754854,401.950226 533.92903,403.16825 C536.859966,404.292936 541.224417,414.63211 547.02238,434.18577 L547.022418,434.185758 C547.179428,434.715277 546.877451,435.271819 546.347932,435.42883 C545.945513,435.548153 545.511405,435.403483 545.261018,435.066607 C536.308991,423.022325 531.523762,416.790359 530.905331,416.37071 C530.232685,415.914271 517.674809,418.596502 493.231705,424.417404 L493.231715,424.417444 C492.694432,424.545393 492.155155,424.213563 492.027206,423.67628 C491.974807,423.456246 491.998547,423.224948 492.09455,423.020147 L493.594876,419.819474 C493.688907,419.61888 493.846884,419.455189 494.044012,419.354094 Z" id="Path-4-Copy-2" fill="#44425F"></path>
-        <path d="M464.769043,327.676758 C466.070098,320.809447 466.956091,315.867398 467.427022,312.85061 L467.427014,312.850609 C467.615922,311.640465 467.050212,310.437004 465.997873,309.810332 C359.187565,246.204365 286.279449,202.962548 247.273525,180.084882 C197.563856,150.92928 158.761879,128.710967 130.000107,112.134757 C88.2828363,88.0240712 63.0469376,73.9638992 54.2924107,69.9542411 C46.0086205,65.3939219 40.7412302,62.7581855 38.4902397,62.0470321 C35.1137541,60.9803019 32.8250987,60.6160491 30.5469802,62.0470321 C29.6167636,62.6313407 29.3154207,62.9050099 29.2239997,63.68054 C33.4199707,62.7313353 36.8015411,62.9756923 39.3687109,64.4136112 C205.426131,157.42542 321.123792,227.346021 387.343878,270.041479 C430.225662,297.689547 445.17041,314.791504 448.166016,320.442871 C451.161621,326.094238 453.821777,334.911133 453.821777,338.591797 C453.821777,340.839149 453.980486,348.033245 455.584961,359.591797 C455.584961,359.591797 455.584961,359.591797 455.584961,359.591797 L455.584961,359.591797 C455.656556,360.107565 456.132708,360.467638 456.648476,360.396043 C457.028395,360.343305 457.338498,360.06567 457.432761,359.693872 C460.783988,346.47559 463.229434,335.803223 464.769043,327.676758 Z" id="Path-5" fill="#5CC9EC" style="mix-blend-mode: multiply;"></path>
-        <path d="M439.870282,399.247627 L439.870282,399.247627 C438.401615,397.301624 435.773551,396.64523 433.56236,397.672139 L141.547928,533.287832 C140.497326,533.869591 139.851997,534.632619 139.611942,535.576918 L142.24392,535.131326 C268.226667,477.077409 348.102078,440.395103 381.870154,425.084408 C412.766116,411.07595 428.989239,403.985533 430.539523,403.813157 C436.398371,402.986255 439.743299,402.493364 440.574306,402.334484 C442.230643,402.01781 442.350516,401.274171 440.933924,400.103568 L439.870282,399.247627 Z" id="Path-6" fill="#5CC9EC" style="mix-blend-mode: multiply;"></path>
-    </g>
-</svg>
\ No newline at end of file

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/dragonfly-rainbow-150w.svg Deleted

@@ -1,434 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:version="1.0 (1.0+r73+1)"
-   sodipodi:docname="dragonfly-rainbow-150w.svg"
-   id="svg1106"
-   version="1.1"
-   viewBox="0 0 150 152.09776"
-   height="152.09776"
-   width="150">
-  <metadata
-     id="metadata1110">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title>dragonfly-rainbow</dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <sodipodi:namedview
-     inkscape:current-layer="svg1106"
-     inkscape:window-maximized="1"
-     inkscape:window-y="27"
-     inkscape:window-x="58"
-     inkscape:cy="356.77141"
-     inkscape:cx="429"
-     inkscape:zoom="1.0876494"
-     fit-margin-bottom="0"
-     fit-margin-right="0"
-     fit-margin-left="0"
-     fit-margin-top="0"
-     showgrid="false"
-     id="namedview1108"
-     inkscape:window-height="1017"
-     inkscape:window-width="1862"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0"
-     guidetolerance="10"
-     gridtolerance="10"
-     objecttolerance="10"
-     borderopacity="1"
-     bordercolor="#666666"
-     pagecolor="#ffffff" />
-  
-  <title
-     id="title985">dragonfly-rainbow</title>
-  <desc
-     id="desc987">Created with Sketch.</desc>
-  <defs
-     id="defs1066">
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-1"
-       gradientTransform="scale(0.56957037,1.7557093)"
-       r="534.17731"
-       fy="184.49359"
-       fx="807.33826"
-       cy="184.49359"
-       cx="807.33826">
-      <stop
-         id="stop989"
-         offset="0%"
-         stop-color="#A564FA" />
-      <stop
-         id="stop991"
-         offset="24.5111198%"
-         stop-color="#62B7FF" />
-      <stop
-         id="stop993"
-         offset="41.9778053%"
-         stop-color="#88FF7F" />
-      <stop
-         id="stop995"
-         offset="58.739699%"
-         stop-color="#FFFC36" />
-      <stop
-         id="stop997"
-         offset="75.0018748%"
-         stop-color="#FFCA78" />
-      <stop
-         id="stop999"
-         offset="100%"
-         stop-color="#FF8080" />
-    </radialGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-2"
-       gradientTransform="scale(1.8926797,0.52835142)"
-       r="283.55212"
-       fy="616.19232"
-       fx="253.40367"
-       cy="616.19232"
-       cx="253.40367">
-      <stop
-         id="stop1002"
-         offset="0%"
-         stop-color="#A564FA" />
-      <stop
-         id="stop1004"
-         offset="21.6138712%"
-         stop-color="#62B7FF" />
-      <stop
-         id="stop1006"
-         offset="41.8910414%"
-         stop-color="#88FF7F" />
-      <stop
-         id="stop1008"
-         offset="65.0496561%"
-         stop-color="#FFFC36" />
-      <stop
-         id="stop1010"
-         offset="80.7109711%"
-         stop-color="#FFCA78" />
-      <stop
-         id="stop1012"
-         offset="100%"
-         stop-color="#FF8080" />
-    </radialGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-3"
-       gradientTransform="scale(0.8396175,1.1910185)"
-       r="389.5553"
-       fy="59.966087"
-       fx="360.55658"
-       cy="59.966087"
-       cx="360.55658">
-      <stop
-         id="stop1015"
-         offset="0%"
-         stop-color="#A3FFF7" />
-      <stop
-         id="stop1017"
-         offset="100%"
-         stop-color="#2787B2" />
-    </radialGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-4"
-       gradientTransform="scale(0.67606567,1.4791462)"
-       r="122.57336"
-       fy="74.692276"
-       fx="304.905"
-       cy="74.692276"
-       cx="304.905">
-      <stop
-         id="stop1020"
-         offset="0%"
-         stop-color="#57538B" />
-      <stop
-         id="stop1022"
-         offset="100%"
-         stop-color="#44425F" />
-    </radialGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-5"
-       gradientTransform="scale(0.9473238,1.0556053)"
-       r="123.3506"
-       fy="181.88686"
-       fx="182.66612"
-       cy="181.88686"
-       cx="182.66612">
-      <stop
-         id="stop1025"
-         offset="0%"
-         stop-color="#A3E9FF" />
-      <stop
-         id="stop1027"
-         offset="100%"
-         stop-color="#65C3D5" />
-    </radialGradient>
-    <linearGradient
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="scale(0.57434822,1.741104)"
-       id="linearGradient-6"
-       y2="53.83707"
-       x2="76.516861"
-       y1="13.371927"
-       x1="86.435898">
-      <stop
-         id="stop1030"
-         offset="0%"
-         stop-color="#80D3E7" />
-      <stop
-         id="stop1032"
-         offset="100%"
-         stop-color="#5CC9EC" />
-    </linearGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-7"
-       gradientTransform="scale(0.92967021,1.0756503)"
-       r="85.831139"
-       fy="111.3249"
-       fx="94.24353"
-       cy="111.3249"
-       cx="94.24353">
-      <stop
-         id="stop1035"
-         offset="0%"
-         stop-color="#57538B" />
-      <stop
-         id="stop1037"
-         offset="100%"
-         stop-color="#44425F" />
-    </radialGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-8"
-       gradientTransform="scale(1.0911176,0.91649147)"
-       r="582.97235"
-       fy="304.70624"
-       fx="402.15445"
-       cy="304.70624"
-       cx="402.15445">
-      <stop
-         id="stop1040"
-         offset="0%"
-         stop-color="#A564FA" />
-      <stop
-         id="stop1042"
-         offset="24.1466546%"
-         stop-color="#62B7FF" />
-      <stop
-         id="stop1044"
-         offset="45.841836%"
-         stop-color="#88FF7F" />
-      <stop
-         id="stop1046"
-         offset="60.610354%"
-         stop-color="#FFFC36" />
-      <stop
-         id="stop1048"
-         offset="74.9039628%"
-         stop-color="#FFCA78" />
-      <stop
-         id="stop1050"
-         offset="100%"
-         stop-color="#FF8080" />
-    </radialGradient>
-    <radialGradient
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient-9"
-       gradientTransform="scale(1.3876331,0.72065158)"
-       r="487.23328"
-       fy="466.53384"
-       fx="311.21716"
-       cy="466.53384"
-       cx="311.21716">
-      <stop
-         id="stop1053"
-         offset="0%"
-         stop-color="#A564FA" />
-      <stop
-         id="stop1055"
-         offset="28.1627643%"
-         stop-color="#62B7FF" />
-      <stop
-         id="stop1057"
-         offset="50.2941087%"
-         stop-color="#88FF7F" />
-      <stop
-         id="stop1059"
-         offset="64.8973129%"
-         stop-color="#FFFC36" />
-      <stop
-         id="stop1061"
-         offset="77.3685942%"
-         stop-color="#FFCA78" />
-      <stop
-         id="stop1063"
-         offset="100%"
-         stop-color="#FF8080" />
-    </radialGradient>
-  </defs>
-  <g
-     transform="matrix(0.2094087,0,0,0.2094087,-6.0728523,-4.131339)"
-     fill-rule="evenodd"
-     fill="none"
-     stroke-width="1"
-     stroke="none"
-     id="dragonfly-rainbow">
-    <path
-       style="fill:url(#radialGradient-1)"
-       fill="url(#radialGradient-1)"
-       fill-opacity="0.44"
-       id="Path-Copy"
-       d="m 448.39305,20 c 11.50826,-5.467127 25.30985,84.11287 41.40475,268.73998 l -49.58729,64.6054 C 422.31368,327.93796 408.38642,308.84669 398.42875,296.07155 383.49223,276.90884 378.01604,259.3136 383.90096,241.04772 389.78589,222.78184 434.10646,20 448.39305,20 Z" />
-    <path
-       style="fill:url(#radialGradient-2)"
-       transform="rotate(24,399.19851,334.03797)"
-       fill="url(#radialGradient-2)"
-       fill-opacity="0.62"
-       id="Path-2"
-       d="m 467.39701,316.10532 c -89.28597,-1.47376 -134.71825,-1.47376 -136.29682,0 -2.36787,2.21064 37.97516,35.34145 42.85684,36.70581 4.88168,1.36436 30.81798,-2.9229 46.42556,-4.22875 10.40506,-0.87057 26.07653,-2.06696 47.01442,-3.58917 z" />
-    <path
-       transform="rotate(24,392.61692,313.51685)"
-       style="mix-blend-mode:overlay"
-       fill="#9013fe"
-       id="Path-8"
-       d="m 447.01172,310.42187 -82.79199,-0.75927 c -16.55111,0.17513 -25.21338,0.78597 -25.98682,1.83252 -0.29515,0.39937 5.45935,-0.8492 17.55322,-1.07325 14.01992,-0.25973 78.19629,2.09498 81.96192,3.09498 2.51041,0.66666 5.5983,1.95141 9.26367,3.85424 z" />
-    <path
-       style="mix-blend-mode:overlay"
-       fill="#9013fe"
-       id="Path-7"
-       d="m 450.20684,19.754827 c 0,0 2.03344,-1.432895 7.79316,16.880915 1.13186,3.598921 3.36203,13.32288 6.6905,29.171875 5.822,26.077003 9.71814,51.710143 11.68841,76.899413 1.97026,25.18927 2.90202,61.27924 2.79526,108.26989 l -8.64837,42.9729 c 1.68601,-72.97738 1.68601,-124.84379 0,-155.59923 -1.33368,-24.32844 -5.63412,-61.472684 -10.60881,-85.957035 -4.45864,-21.944473 -9.71015,-32.638728 -9.71015,-32.638728 z" />
-    <g
-       transform="translate(399,255)"
-       id="Torso">
-      <path
-         style="fill:url(#radialGradient-3)"
-         fill-rule="nonzero"
-         fill="url(#radialGradient-3)"
-         id="Combined-Shape"
-         d="m 161.8236,396.1391 c 0.5056,2.90709 0.55158,4.36064 0.13796,4.36064 -2.96557,0 -32.54855,-37.35924 -88.748957,-112.07771 -0.01498,0.092 -0.02997,0.18415 -0.04496,0.27634 l -4.4e-5,-1e-5 c -0.08865,0.5451 -0.602406,0.91513 -1.147504,0.82647 -0.337148,-0.0548 -0.622984,-0.27796 -0.758003,-0.59172 C 24.005205,179.11645 0.37676311,117.74095 0.37676311,104.80658 0.37676311,97.25689 26.456406,62.554541 78.615692,0.69953572 l 3.3e-5,2.76e-5 C 78.809728,0.4694978 79.09703,0.33904086 79.397926,0.34438418 L 116.31743,1 c 2.08642,4.1038132 20.01183,4.2353512 53.77624,0.3946139 1.09749,-0.1248334 2.08838,0.6636533 2.21322,1.7611413 0.0389,0.3421808 -0.0112,0.6886148 -0.14543,1.0057529 C 136.47959,88.445382 112.41348,145.8202 99.963113,176.28598 c 22.417767,75.64441 38.783327,132.14835 49.096677,169.51181 0.23474,-0.0267 0.47276,0.0306 0.67081,0.16372 99.6205,66.97246 159.70344,108.92637 180.24884,125.86173 -0.66008,0.13956 1.34037,-3.44052 6.00133,-10.74026 4.08837,-6.40298 12.25358,28.20492 9.90535,29.93574 -1.55393,1.14538 -62.90811,-30.48117 -184.06252,-94.87962 z" />
-      <path
-         style="mix-blend-mode:multiply"
-         fill-rule="evenodd"
-         fill="#53c2e6"
-         id="Path-5"
-         d="m 99.917017,176.33337 -20.26301,46.2122 -6.229344,65.80481 38.128157,50.36046 -19.911971,-30.06857 c -6.388302,-11.21006 -9.791614,-17.97402 -10.209936,-20.29189 -0.418322,-2.31787 0.276073,-23.75569 2.083186,-64.31347 11.723684,-29.2655 17.527781,-44.09539 17.412311,-44.48965 -0.11548,-0.39427 -0.45195,-1.46557 -1.009393,-3.21389 z" />
-      <path
-         style="mix-blend-mode:multiply"
-         fill-rule="evenodd"
-         fill="#53c2e6"
-         id="Path-6"
-         d="m 148.87177,345.21483 12.94662,51.13319 21.61272,11.11261 c -5.90708,-6.32773 -9.95752,-11.53726 -12.15134,-15.62861 -2.19381,-4.09135 -8.79066,-18.94412 -19.79055,-44.55831 z" />
-      <path
-         style="mix-blend-mode:multiply"
-         fill-rule="evenodd"
-         fill="#53c2e6"
-         id="path1075"
-         d="m 332.61734,466.49342 c -1.95163,3.1123 -2.8332,4.89606 -2.64471,5.35127 0.47964,1.03916 8.55321,9.64662 9.2308,8.91762 0.45173,-0.48599 -0.45714,-7.24844 -2.72661,-20.28733 -0.29803,0.34888 -0.6876,0.89945 -1.16869,1.65173 -0.4811,0.75227 -1.37803,2.20784 -2.69079,4.36671 z" />
-      <path
-         style="mix-blend-mode:multiply"
-         fill-rule="evenodd"
-         fill="#53c2e6"
-         id="path1077"
-         d="M 76.144224,3.5968032 169.5,4 c -5.43816,14.33515 -8.90866,22.534036 -10.41149,24.596657 -2.25425,3.093933 -3.88677,6.84033 -7.5729,11.353066 -6.27619,7.683617 -10.78476,9.821973 -18.97408,12.298947 -20.43417,6.180595 -52.699122,-10.698105 -58.886112,-14.252958 -3.016198,-1.733015 -9.01347,-4.866033 -17.991816,-9.399055 1.806076,-2.339723 3.808619,-4.920187 6.007629,-7.74139 2.159399,-2.770383 6.98373,-8.523205 14.472993,-17.2584638 z" />
-    </g>
-    <g
-       transform="translate(454,60)"
-       id="Head2">
-      <g
-         id="Head">
-        <path
-           fill="#44425f"
-           id="Path-3"
-           d="m 97.371363,89.030541 c 6.934567,-2.476634 14.815387,-2.476634 23.642457,0 12.18089,3.417622 41.41273,15.995099 52.82998,20.972819 11.15346,7.53799 6.16216,50.87729 2.50701,88.30927 -4.99888,10.53752 -11.92557,18.11215 -20.78009,22.72389 L 115.52639,201.76785 89.577993,95.815111 Z" />
-        <path
-           style="fill:url(#radialGradient-4)"
-           fill="url(#radialGradient-4)"
-           id="Path-10-Copy"
-           d="m 139.8817,101.02458 c 2.34586,0.24371 18.32427,5.3784 20.20458,7.34026 1.88032,1.96186 10.93701,6.12586 13.1705,11.90056 2.23349,5.7747 3.82615,10.10987 3.82615,16.04867 0,5.4528 0.42973,20.75571 0,26.83732 -0.35011,4.95472 -4.60729,20.18997 -6.09896,21.7807 -1.49168,1.59073 -9.40223,10.00784 -10.89769,8.34042 -1.49546,-1.66742 -2.61848,-7.63687 -0.45854,-15.55612 2.15993,-7.91925 7.14096,-30.40855 3.85307,-45.50898 -1.69062,-7.76455 -1.3763,-7.59903 -6.80149,-15.09869 -5.12567,-7.08561 -21.30851,-10.28892 -21.59226,-11.43432 -0.58406,-2.35774 1.85463,-4.95525 4.79464,-4.64982 z" />
-        <path
-           transform="rotate(42,133.01826,69.821995)"
-           fill="#7ad0e3"
-           id="Path-4-Copy"
-           d="m 121.49582,125.13084 c -2.79911,-20.76733 -4.58413,-37.360094 -5.35504,-49.778287 -1.15637,-18.627291 -2.32458,-29.563807 0,-34.558353 1.02845,-2.209712 8.75511,-9.907736 15.19263,-14.302992 3.78412,-2.583636 9.62532,-6.237142 17.52358,-10.960519 l 1e-5,10e-6 c 0.47399,-0.283457 1.08802,-0.129002 1.37147,0.344985 0.18591,0.310875 0.18918,0.697982 0.009,1.011947 -15.00033,26.071043 -23.24093,40.937261 -24.7218,44.598655 -2.3138,5.720795 -5.93905,20.863547 -2.67411,61.628804 0.11606,1.44915 -0.33236,2.12107 -1.34527,2.01575 z" />
-        <path
-           style="fill:url(#radialGradient-5)"
-           fill="url(#radialGradient-5)"
-           id="Path"
-           d="m 45.106691,100.58383 c 16.477546,-8.193491 50.589214,-14.223753 57.398469,-14.223753 6.85819,0.432922 42.84829,17.821253 45.52001,20.003533 9.73145,7.94874 15.31983,14.6882 16.00627,48.55369 0.68644,33.8655 -13.47325,99.82746 -21.29114,102.15517 -1.11698,0.33257 -8.96424,4.694 -13.03018,3.53627 -9.61071,-2.73655 -41.41783,-17.98802 -95.421363,-45.7544 v 0 c -2.227724,-1.1454 -3.877301,-3.16742 -4.55203,-5.57977 L 7.8390227,130.98382 c -1.0096843,-3.60992 0.3238041,-7.46766 3.3472423,-9.68347 10.891687,-7.98226 22.198496,-14.88776 33.920426,-20.71652 z" />
-        <path
-           style="mix-blend-mode:multiply"
-           fill="#53c2e6"
-           id="Path-9"
-           d="m 82.058828,89.917793 c -17.510631,5.542285 -28.629705,9.683938 -33.357223,12.424957 -4.727519,2.74102 -8.797635,7.40608 -12.21035,13.99517 l -1.191536,19.22699 -27.804729,1.36223 2.774176,-11.75296 c -1.7116496,-0.60729 -1.7116496,-1.58892 0,-2.94487 10.073565,-7.98016 26.121436,-17.04759 31.902189,-19.88656 4.72344,-2.31971 13.13065,-6.313007 22.977266,-9.123788 3.517,-1.003951 9.153735,-2.104341 16.910207,-3.301169 z" />
-        <path
-           fill="#44425f"
-           id="path1085"
-           d="m 5.4361667,121.43446 c 1.8550352,-2.17208 26.2857523,-6.57188 30.0604603,-5.63313 3.774708,0.93875 44.912374,35.46417 47.031451,40.33109 1.412718,3.24461 3.000586,31.59314 4.763604,85.04559 l 1.957768,1.38293 c -3.666212,3.51591 -5.906669,5.16553 -6.721372,4.94885 C 41.272422,239.82111 23.267391,227.29699 19.724533,221.85187 11.943761,207.01079 -1.3493903,142.56306 0.51396648,136.81185 2.3773233,131.06063 3.5811314,123.60653 5.4361667,121.43446 Z" />
-        <path
-           style="fill:url(#linearGradient-6)"
-           fill="url(#linearGradient-6)"
-           id="Path-4"
-           d="M 32.907602,110.50276 C 30.108484,89.735424 28.323468,73.142661 27.552556,60.724467 c -1.156368,-18.62729 -2.324579,-29.563806 0,-34.558352 1.028453,-2.209713 8.755111,-9.907737 15.192629,-14.302992 C 49.182703,7.4678669 61.118052,-0.57991824 62.461908,0.54181304 63.805763,1.6635443 43.009273,30.44942 40.695477,36.170215 38.381681,41.89101 30.987926,67.721748 34.252863,108.487 c 0.116065,1.44915 -0.332356,2.12107 -1.345261,2.01576 z" />
-      </g>
-      <path
-         style="fill:url(#radialGradient-7)"
-         fill="url(#radialGradient-7)"
-         id="Path-10"
-         d="m 8.6331071,127.20227 c -2.6773869,1.25241 -3.4299362,4.73493 -1.7149681,6.45509 0.8331415,0.83566 12.294805,-3.43364 20.337723,0 8.512909,3.63428 16.644023,12.63683 22.092203,18.42161 10.595571,11.25021 13.482618,22.79048 15.709907,30.69105 2.227289,7.90057 4.807779,21.41527 6.948423,22.07431 2.140643,0.65904 4.265242,-4.41807 4.724569,-6.54987 0.459328,-2.13179 -1.960736,-32.57183 -4.212503,-36.99917 -2.763908,-5.43429 -10.900888,-12.08796 -14.793777,-15.89685 -4.480937,-4.38424 -9.817597,-9.59807 -14.706264,-13.39762 -6.500081,-5.05197 -10.663914,-8.19964 -13.286089,-8.91285 -2.622175,-0.71321 -18.962907,3.11499 -21.0992239,4.1143 z" />
-    </g>
-    <g
-       fill-opacity="0.44"
-       transform="translate(29,61)"
-       id="WINGS">
-      <path
-         style="fill:url(#radialGradient-8)"
-         fill="url(#radialGradient-8)"
-         id="path1091"
-         d="m 6.0249161,0.25293065 c 9.5243959,0 153.7820239,83.16235035 432.7728839,249.48704935 -12.17586,63.43367 -24.62579,101.24761 -37.34977,113.44183 -4.57628,3.80082 -158.94879,14.32275 -195.66376,-9.2749 C 169.06931,330.30926 82.895081,154.02977 42.664982,82.806406 2.4348845,11.583037 -8.2616782,0.25293065 6.0249161,0.25293065 Z" />
-      <path
-         style="fill:url(#radialGradient-9)"
-         fill="url(#radialGradient-9)"
-         id="path1093"
-         d="m 409.7401,337.20714 5.01217,4.41606 c 1.58029,1.39235 1.81018,3.77158 0.5257,5.44072 -29.37745,38.17524 -49.91358,63.91997 -61.60837,77.23421 -35.84343,40.80688 -62.66522,63.60905 -69.48606,67.86783 -10.00327,6.24582 -66.79175,2.12835 -170.36541,-12.3524 v 0 c -2.18786,-0.30589 -3.7135,-2.32747 -3.40761,-4.51533 0.19199,-1.37325 1.08149,-2.54911 2.3507,-3.10749 70.82957,-31.16056 121.60851,-54.4389 152.33684,-69.835 32.14951,-16.10818 78.93304,-38.03899 140.35057,-65.79245 v 0 c 1.43271,-0.64741 3.11182,-0.3955 4.29147,0.64385 z" />
-    </g>
-    <path
-       fill="#44425f"
-       id="path1096"
-       d="m 521.44326,340.57728 c 24.85868,-8.10901 38.87257,-11.55548 42.04167,-10.3394 2.99526,1.14937 18.98011,18.26335 47.95458,51.34196 l -4e-5,3e-5 c 0.36389,0.41542 0.3221,1.04718 -0.0933,1.41107 -0.35027,0.3068 -0.86594,0.33124 -1.24365,0.0589 l -53.15634,-38.32161 -36.48209,1.07152 c -0.55204,0.0162 -1.01271,-0.41817 -1.02892,-0.97022 -0.004,-0.1379 0.0205,-0.27516 0.072,-0.40312 l 1.31869,-3.27227 c 0.11044,-0.27407 0.33645,-0.48527 0.61737,-0.5769 z" />
-    <path
-       fill="#44425f"
-       id="path1098"
-       d="m 506.41436,381.5867 c 24.87672,-8.11576 38.90024,-11.56537 42.07057,-10.34882 2.9348,1.12617 16.35266,10.02352 40.25358,26.69205 l 10e-6,-1e-5 c 0.453,0.31593 0.56413,0.93927 0.2482,1.39228 -0.26068,0.37378 -0.74109,0.52405 -1.1683,0.36544 -26.91591,-9.99306 -41.69512,-15.31138 -44.33765,-15.95497 -2.80109,-0.6822 -15.49251,0.28223 -38.07426,2.89329 v -5e-5 c -0.54861,0.0634 -1.04476,-0.32987 -1.1082,-0.87848 -0.0211,-0.18281 0.009,-0.36791 0.0859,-0.53492 l 1.43284,-3.09522 c 0.11673,-0.25218 0.33314,-0.4444 0.59731,-0.53059 z" />
-    <path
-       fill="#44425f"
-       id="Path-4-Copy-2"
-       d="m 494.04401,419.35409 c 23.41584,-12.00858 36.71084,-17.40386 39.88502,-16.18584 2.93094,1.12469 7.29539,11.46386 13.09335,31.01752 l 4e-5,-10e-6 c 0.15701,0.52952 -0.14497,1.08606 -0.67449,1.24307 -0.40242,0.11932 -0.83653,-0.0254 -1.08691,-0.36222 -8.95203,-12.04428 -13.73726,-18.27625 -14.35569,-18.6959 -0.67265,-0.45644 -13.23052,2.22579 -37.67363,8.04669 l 1e-5,4e-5 c -0.53728,0.12795 -1.07656,-0.20388 -1.2045,-0.74116 -0.0524,-0.22003 -0.0287,-0.45133 0.0673,-0.65613 l 1.50033,-3.20068 c 0.094,-0.20059 0.252,-0.36428 0.44913,-0.46538 z" />
-    <path
-       style="mix-blend-mode:overlay"
-       fill="#9013fe"
-       id="path1101"
-       d="m 464.76904,327.67676 c 1.30106,-6.86731 2.18705,-11.80936 2.65798,-14.82615 h -1e-5 c 0.18891,-1.21015 -0.3768,-2.41361 -1.42914,-3.04028 C 359.18756,246.20436 286.27945,202.96255 247.27352,180.08488 197.56386,150.92928 158.76188,128.71097 130.00011,112.13476 88.282836,88.024071 63.046938,73.963899 54.292411,69.954241 46.00862,65.393922 40.74123,62.758186 38.49024,62.047032 c -3.376486,-1.06673 -5.665141,-1.430983 -7.94326,0 -0.930216,0.584309 -1.231559,0.857978 -1.32298,1.633508 4.195971,-0.949205 7.577541,-0.704848 10.144711,0.733071 C 205.42613,157.42542 321.12379,227.34602 387.34388,270.04148 c 42.88178,27.64807 57.82653,44.75002 60.82214,50.40139 2.9956,5.65137 5.65576,14.46826 5.65576,18.14893 0,2.24735 0.15871,9.44145 1.76318,21 0,0 0,0 0,0 v 0 c 0.0716,0.51577 0.54775,0.87584 1.06352,0.80424 0.37991,-0.0527 0.69002,-0.33037 0.78428,-0.70217 3.35123,-13.21828 5.79667,-23.89065 7.33628,-32.01711 z" />
-    <path
-       style="mix-blend-mode:overlay"
-       fill="#9013fe"
-       id="path1103"
-       d="m 439.87028,399.24763 v 0 c -1.46867,-1.94601 -4.09673,-2.6024 -6.30792,-1.57549 L 141.54793,533.28783 c -1.0506,0.58176 -1.69593,1.34479 -1.93599,2.28909 l 2.63198,-0.44559 c 125.98275,-58.05392 205.85816,-94.73623 239.62623,-110.04692 30.89597,-14.00846 47.11909,-21.09888 48.66937,-21.27125 5.85885,-0.8269 9.20378,-1.3198 10.03479,-1.47868 1.65633,-0.31667 1.77621,-1.06031 0.35961,-2.23091 z" />
-  </g>
-</svg>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/dragonfly-rainbow.png Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/dragonfly-rainbow.svg Deleted

@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="916px" height="753px" viewBox="0 0 916 753" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    
-    <title>dragonfly-rainbow</title>
-    <desc>Created with Sketch.</desc>
-    <defs>
-        <radialGradient cx="72.3132293%" cy="91.1780826%" fx="72.3132293%" fy="91.1780826%" r="281.148922%" gradientTransform="translate(0.723132,0.911781),scale(1.000000,0.324410),rotate(-91.458626),scale(1.000000,0.644776),translate(-0.723132,-0.911781)" id="radialGradient-1">
-            <stop stop-color="#A564FA" offset="0%"></stop>
-            <stop stop-color="#62B7FF" offset="24.5111198%"></stop>
-            <stop stop-color="#88FF7F" offset="41.9778053%"></stop>
-            <stop stop-color="#FFFC36" offset="58.739699%"></stop>
-            <stop stop-color="#FFCA78" offset="75.0018748%"></stop>
-            <stop stop-color="#FF8080" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="108.955456%" cy="27.7500231%" fx="108.955456%" fy="27.7500231%" r="393.464142%" gradientTransform="translate(1.089555,0.277500),scale(0.279155,1.000000),rotate(-177.328375),scale(1.000000,0.644776),translate(-1.089555,-0.277500)" id="radialGradient-2">
-            <stop stop-color="#A564FA" offset="0%"></stop>
-            <stop stop-color="#62B7FF" offset="21.6138712%"></stop>
-            <stop stop-color="#88FF7F" offset="41.8910414%"></stop>
-            <stop stop-color="#FFFC36" offset="65.0496561%"></stop>
-            <stop stop-color="#FFCA78" offset="80.7109711%"></stop>
-            <stop stop-color="#FF8080" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="87.4039429%" cy="14.4845811%" fx="87.4039429%" fy="14.4845811%" r="94.5513154%" gradientTransform="translate(0.874039,0.144846),scale(1.000000,0.704958),rotate(99.804066),translate(-0.874039,-0.144846)" id="radialGradient-3">
-            <stop stop-color="#A3FFF7" offset="0%"></stop>
-            <stop stop-color="#2787B2" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="168.273474%" cy="10.2506186%" fx="168.273474%" fy="10.2506186%" r="196.025438%" gradientTransform="translate(1.682735,0.102506),scale(1.000000,0.457065),rotate(123.395495),translate(-1.682735,-0.102506)" id="radialGradient-4">
-            <stop stop-color="#57538B" offset="0%"></stop>
-            <stop stop-color="#44425F" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="105.741592%" cy="60.558597%" fx="105.741592%" fy="60.558597%" r="74.6427458%" gradientTransform="translate(1.057416,0.605586),scale(1.000000,0.901154),rotate(102.456365),translate(-1.057416,-0.605586)" id="radialGradient-5">
-            <stop stop-color="#A3E9FF" offset="0%"></stop>
-            <stop stop-color="#65C3D5" offset="100%"></stop>
-        </radialGradient>
-        <linearGradient x1="64.5297057%" y1="20.7545785%" x2="48.840717%" y2="84.7584781%" id="linearGradient-6">
-            <stop stop-color="#80D3E7" offset="0%"></stop>
-            <stop stop-color="#5CC9EC" offset="100%"></stop>
-        </linearGradient>
-        <radialGradient cx="115.296233%" cy="-3.97219145%" fx="115.296233%" fy="-3.97219145%" r="112.724099%" gradientTransform="translate(1.152962,-0.039722),scale(1.000000,0.864287),rotate(90.000000),translate(-1.152962,0.039722)" id="radialGradient-7">
-            <stop stop-color="#57538B" offset="0%"></stop>
-            <stop stop-color="#44425F" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="100%" cy="75.6998354%" fx="100%" fy="75.6998354%" r="144.962291%" gradientTransform="translate(1.000000,0.756998),scale(0.839957,1.000000),rotate(-148.053071),scale(1.000000,0.644776),translate(-1.000000,-0.756998)" id="radialGradient-8">
-            <stop stop-color="#A564FA" offset="0%"></stop>
-            <stop stop-color="#62B7FF" offset="24.1466546%"></stop>
-            <stop stop-color="#88FF7F" offset="45.841836%"></stop>
-            <stop stop-color="#FFFC36" offset="60.610354%"></stop>
-            <stop stop-color="#FFCA78" offset="74.9039628%"></stop>
-            <stop stop-color="#FF8080" offset="100%"></stop>
-        </radialGradient>
-        <radialGradient cx="105.150577%" cy="0%" fx="105.150577%" fy="0%" r="221.13843%" gradientTransform="translate(1.051506,0.000000),scale(0.519339,1.000000),rotate(156.288366),scale(1.000000,0.644776),translate(-1.051506,-0.000000)" id="radialGradient-9">
-            <stop stop-color="#A564FA" offset="0%"></stop>
-            <stop stop-color="#62B7FF" offset="28.1627643%"></stop>
-            <stop stop-color="#88FF7F" offset="50.2941087%"></stop>
-            <stop stop-color="#FFFC36" offset="64.8973129%"></stop>
-            <stop stop-color="#FFCA78" offset="77.3685942%"></stop>
-            <stop stop-color="#FF8080" offset="100%"></stop>
-        </radialGradient>
-    </defs>
-    <g id="dragonfly-rainbow" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <path d="M448.39305,20 C459.901314,14.5328726 473.702898,104.112866 489.797803,288.739981 L440.210507,353.345378 C422.313676,327.937962 408.386422,308.846686 398.428747,296.071549 C383.492233,276.908844 378.016041,259.313599 383.900964,241.04772 C389.785886,222.78184 434.106456,20 448.39305,20 Z" id="Path-Copy" fill-opacity="0.44" fill="url(#radialGradient-1)"></path>
-        <path d="M467.397011,316.10532 C378.111038,314.63156 332.678764,314.63156 331.100187,316.10532 C328.732321,318.315959 369.075348,351.446765 373.957028,352.81113 C378.838709,354.175494 404.775006,349.888229 420.38259,348.582377 C430.787646,347.711809 446.45912,346.51542 467.397011,344.993211 L467.397011,316.10532 Z" id="Path-2" fill-opacity="0.62" fill="url(#radialGradient-2)" transform="translate(399.198506, 334.037969) rotate(24.000000) translate(-399.198506, -334.037969) "></path>
-        <path d="M447.011719,310.421875 L364.219727,309.662598 C347.66862,309.837728 339.006348,310.448568 338.23291,311.495117 C337.937757,311.894494 343.692263,310.645924 355.786133,310.421875 C369.806048,310.162144 433.982422,312.516846 437.748047,313.516846 C440.258464,314.183512 443.346354,315.468262 447.011719,317.371094 L447.011719,310.421875 Z" id="Path-8" fill="#9013FE" style="mix-blend-mode: overlay;" transform="translate(392.616917, 313.516846) rotate(24.000000) translate(-392.616917, -313.516846) "></path>
-        <path d="M450.206841,19.7548269 C450.206841,19.7548269 452.240283,18.3219322 458,36.6357422 C459.131865,40.2346633 461.362033,49.9586216 464.690504,65.8076172 C470.512505,91.8846201 474.408639,117.517758 476.378906,142.707031 C478.349173,167.896304 479.280927,203.986268 479.174167,250.976922 L470.525802,293.949818 C472.211807,220.972439 472.211807,169.106028 470.525802,138.350586 C469.192125,114.022152 464.89168,76.8779065 459.916992,52.3935547 C455.458352,30.4490817 450.206841,19.7548269 450.206841,19.7548269 Z" id="Path-7" fill="#9013FE" style="mix-blend-mode: overlay;"></path>
-        <g id="Torso" transform="translate(399.000000, 255.000000)">
-            <path d="M161.823602,396.139098 C162.329198,399.046195 162.375183,400.499743 161.961556,400.499743 C158.99599,400.499743 129.413006,363.140503 73.2126025,288.422025 C73.197618,288.514065 73.182633,288.606183 73.1676404,288.69837 L73.1675957,288.698363 C73.078945,289.243461 72.56519,289.613485 72.0200919,289.524834 C71.6829437,289.470003 71.397108,289.246869 71.2620892,288.933109 C24.0052051,179.116455 0.376763113,117.740946 0.376763113,104.806581 C0.376763113,97.2568897 26.4564061,62.5545413 78.6156921,0.699535721 L78.6157249,0.699563325 C78.8097278,0.4694978 79.0970295,0.339040863 79.3979261,0.344384179 L116.317425,1 C118.40385,5.10381325 136.329265,5.23535123 170.093671,1.39461393 C171.19116,1.26978046 172.182053,2.05826716 172.306893,3.15575523 C172.345817,3.497936 172.295722,3.84436999 172.161461,4.16150806 C136.479591,88.4453818 112.413475,145.820205 99.9631131,176.285978 C122.380882,251.93039 138.74644,308.434327 149.059789,345.797791 C149.294526,345.771116 149.532546,345.828365 149.730604,345.961514 C249.351096,412.933971 309.434042,454.88788 329.979443,471.823241 C329.319363,471.962805 331.319806,468.382717 335.98077,461.082976 C340.069143,454.679995 348.234346,489.287899 345.886122,491.018724 C344.332186,492.164096 282.978012,460.537554 161.823602,396.139098 Z" id="Combined-Shape" fill="url(#radialGradient-3)" fill-rule="nonzero"></path>
-            <path d="M99.9170169,176.333366 L79.6540067,222.545571 L73.4246629,288.35038 L111.552821,338.710841 L91.6408491,308.642271 C85.2525472,297.432211 81.8492351,290.668248 81.4309128,288.35038 C81.0125905,286.032513 81.7069859,264.594689 83.5140991,224.036907 C95.2377828,194.771407 101.041885,179.941523 100.926407,179.547256 C100.810928,179.15299 100.474465,178.081693 99.9170169,176.333366 Z" id="Path-5" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-            <path d="M148.871773,345.214827 L161.81839,396.348024 L183.43111,407.460626 C177.524031,401.132905 173.473585,395.923369 171.279772,391.832019 C169.085959,387.740668 162.489108,372.8879 151.48922,347.273715 L148.871773,345.214827 Z" id="Path-6" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-            <path d="M332.617343,466.493423 C330.665707,469.605725 329.784136,471.389481 329.972627,471.844691 C330.452274,472.883855 338.525838,481.491308 339.203433,480.762315 C339.655163,480.276319 338.746293,473.513875 336.476822,460.474984 C336.178789,460.823859 335.789224,461.374433 335.308126,462.126705 C334.827028,462.878978 333.9301,464.33455 332.617343,466.493423 Z" id="Path-7" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-            <path d="M76.1442239,3.5968032 L169.5,4 C164.06184,18.33515 160.591343,26.5340358 159.088511,28.5966575 C156.834261,31.6905899 155.201736,35.4369869 151.515611,39.9497227 C145.239425,47.6333401 140.730853,49.771696 132.541527,52.2486703 C112.107357,58.4292653 79.8424076,41.5505655 73.6554177,37.9957119 C70.6392196,36.2626974 64.6419478,33.1296793 55.6636023,28.5966575 C57.4696781,26.2569339 59.4722212,23.6764704 61.6712315,20.8552671 C63.8306299,18.0848837 68.6549607,12.3320624 76.1442239,3.5968032 Z" id="Path-8" fill="#53C2E6" fill-rule="evenodd" style="mix-blend-mode: multiply;"></path>
-        </g>
-        <g id="Head2" transform="translate(454.000000, 60.000000)">
-            <g id="Head">
-                <path d="M97.3713627,89.0305409 C104.305932,86.5539075 112.186751,86.5539075 121.01382,89.0305409 C133.194706,92.4481627 162.426547,105.025636 173.843805,110.003364 C184.997265,117.541347 180.005956,160.880651 176.350815,198.31263 C171.351935,208.850152 164.425238,216.424781 155.570721,221.036516 L115.526395,201.767851 L89.5779926,95.8151106 L97.3713627,89.0305409 Z" id="Path-3" fill="#44425F"></path>
-                <path d="M139.881696,101.02458 C142.22756,101.268288 158.205971,106.402978 160.086284,108.364838 C161.966597,110.326698 171.023288,114.490703 173.256781,120.265403 C175.490274,126.040103 177.082929,130.375266 177.082929,136.314069 C177.082929,141.766868 177.512664,157.069779 177.082929,163.151392 C176.732822,168.106109 172.475643,183.341356 170.983968,184.932088 C169.492294,186.52282 161.581744,194.939932 160.086284,193.272513 C158.590824,191.605094 157.467803,185.635643 159.627739,177.716392 C161.787675,169.797142 166.7687,147.307843 163.480806,132.207414 C161.79019,124.442863 162.104509,124.608382 156.679317,117.108719 C151.553646,110.023107 135.370809,106.819799 135.087065,105.674397 C134.502996,103.316663 136.94169,100.719148 139.881696,101.02458 Z" id="Path-10-Copy" fill="url(#radialGradient-4)"></path>
-                <path d="M121.495825,125.130842 C118.696706,104.363509 116.911691,87.7707463 116.140779,75.3525527 C114.98441,56.7252623 113.816199,45.788746 116.140779,40.7942004 C117.169231,38.5844879 124.895889,30.8864639 131.333407,26.4912081 C135.117533,23.9075725 140.958729,20.2540662 148.856994,15.5306891 L148.857,15.5306991 C149.330987,15.2472421 149.945016,15.4016971 150.228473,15.8756839 C150.414385,16.1865587 150.417648,16.5736656 150.237004,16.8876306 C135.236666,42.9586736 126.996065,57.8248921 125.515201,61.4862858 C123.201405,67.2070807 119.576148,82.3498332 122.841086,123.115086 C122.95715,124.564239 122.50873,125.236158 121.495825,125.130842 Z" id="Path-4-Copy" fill="#7AD0E3" transform="translate(133.018264, 69.821995) rotate(42.000000) translate(-133.018264, -69.821995) "></path>
-                <path d="M45.1066914,100.583831 C61.5842365,92.3903388 95.6959048,86.3600771 102.505156,86.3600771 C109.363353,86.7929987 145.353453,104.181327 148.025168,106.363609 C157.75662,114.312355 163.345005,121.051809 164.031444,154.917303 C164.717883,188.782798 150.558191,254.744765 142.7403,257.072475 C141.623325,257.405045 133.776061,261.766473 129.710116,260.608738 C120.09941,257.872189 88.2922899,242.620723 34.2887566,214.85434 L34.2887568,214.854339 C32.0610331,213.708936 30.4114556,211.686923 29.7367275,209.274571 L7.83902273,130.983821 C6.82933843,127.373901 8.16282677,123.516162 11.1862655,121.300355 C22.0779521,113.318093 33.3847608,106.412585 45.1066914,100.583831 Z" id="Path" fill="url(#radialGradient-5)"></path>
-                <path d="M82.0588275,89.9177926 C64.5481975,95.460078 53.4291233,99.6017308 48.7016047,102.342751 C43.9740862,105.083771 39.9039698,109.748827 36.4912554,116.337919 L35.2997188,135.564911 L7.49499003,136.927141 L10.2691655,125.174182 C8.55751637,124.566886 8.55751637,123.585263 10.2691655,122.229314 C20.3427306,114.249147 36.3906019,105.181718 42.1713548,102.342751 C46.8947947,100.023038 55.3020052,96.0297427 65.1486205,93.2189619 C68.6656206,92.2150113 74.3023562,91.1146215 82.0588275,89.9177926 Z" id="Path-9" fill="#53C2E6" style="mix-blend-mode: multiply;"></path>
-                <path d="M5.43616668,121.434455 C7.29120191,119.262384 31.7219189,114.862582 35.4966272,115.801333 C39.2713355,116.740083 80.4090014,151.265502 82.5280782,156.132421 C83.9407961,159.377034 85.5286639,187.725564 87.2916816,241.178012 L89.2494499,242.560938 C85.5832378,246.076848 83.3427805,247.726466 82.5280782,247.50979 C41.2724219,239.821114 23.267391,227.296992 19.7245333,221.851872 C11.9437611,207.010794 -1.34939033,142.563061 0.51396648,136.811848 C2.37732329,131.060634 3.58113144,123.606527 5.43616668,121.434455 Z" id="Path-2" fill="#44425F"></path>
-                <path d="M32.9076022,110.502757 C30.1084838,89.7354241 28.3234685,73.142661 27.5525563,60.7244673 C26.3961879,42.0971769 25.2279768,31.1606606 27.5525563,26.1661151 C28.5810087,23.9564025 36.3076668,16.2583785 42.7451848,11.8631227 C49.1827029,7.4678669 61.1180521,-0.579918242 62.4619077,0.541813039 C63.8057632,1.66354432 43.009273,30.4494202 40.6954769,36.170215 C38.3816808,41.8910098 30.9879256,67.7217478 34.2528633,108.487 C34.3689277,109.936153 33.9205074,110.608072 32.9076022,110.502757 Z" id="Path-4" fill="url(#linearGradient-6)"></path>
-            </g>
-            <path d="M8.63310706,127.202269 C5.95572019,128.454678 5.20317086,131.937202 6.91813896,133.657358 C7.75128055,134.493019 19.2129444,130.223718 27.2558624,133.657358 C35.7687711,137.291643 43.8998846,146.294186 49.3480648,152.078974 C59.9436357,163.329177 62.8306833,174.869446 65.0579722,182.770018 C67.2852611,190.67059 69.865751,204.185293 72.0063946,204.844331 C74.1470381,205.50337 76.2716368,200.426256 76.7309642,198.294463 C77.1902916,196.162671 74.7702284,165.722628 72.5184608,161.295289 C69.7545534,155.861 61.617573,149.207334 57.7246837,145.398445 C53.2437467,141.014196 47.9070872,135.80037 43.0184199,132.000819 C36.5183393,126.948853 32.3545059,123.801175 29.7323307,123.087966 C27.1101556,122.374756 10.7694235,126.202958 8.63310706,127.202269 Z" id="Path-10" fill="url(#radialGradient-7)"></path>
-        </g>
-        <g id="WINGS" transform="translate(29.000000, 61.000000)" fill-opacity="0.44">
-            <path d="M6.0249161,0.25293065 C15.5493123,0.25293065 159.806941,83.4152808 438.797803,249.739981 C426.621938,313.173647 414.172014,350.987591 401.448031,363.181811 C396.871751,366.982634 242.49924,377.504562 205.784274,353.906914 C169.069308,330.309265 82.8950806,154.029775 42.6649825,82.8064061 C2.43488447,11.5830373 -8.26167817,0.25293065 6.0249161,0.25293065 Z" id="Combined-Shape" fill="url(#radialGradient-8)"></path>
-            <path d="M409.740103,337.207143 L414.75227,341.623204 C416.332561,343.015546 416.562452,345.394778 415.277973,347.063924 C385.900518,385.239157 365.364394,410.983894 353.6696,424.298134 C317.82617,465.105012 291.004384,487.907183 284.183544,492.165961 C274.180266,498.411783 217.391793,494.294315 113.818126,479.813559 L113.818126,479.813559 C111.630267,479.507672 110.104627,477.486091 110.410515,475.298232 C110.602511,473.92498 111.492009,472.749119 112.761222,472.190745 C183.590786,441.03018 234.369734,417.751843 265.098064,402.355736 C297.247575,386.247561 344.031096,364.316747 405.448628,336.563294 L405.448628,336.563294 C406.881342,335.915877 408.560453,336.167793 409.740103,337.207143 Z" id="Path-3" fill="url(#radialGradient-9)"></path>
-        </g>
-        <path d="M521.443261,340.577276 C546.30194,332.468269 560.315831,329.021804 563.484934,330.237882 C566.480187,331.387248 582.465044,348.501234 611.439506,381.579839 L611.439474,381.579867 C611.803359,381.995295 611.761575,382.627053 611.346147,382.990938 C610.995884,383.297743 610.480213,383.322185 610.102502,383.049884 L556.946165,344.728267 L520.464075,345.799786 C519.912029,345.816 519.451362,345.381622 519.435148,344.829575 C519.431097,344.691668 519.455627,344.554415 519.507195,344.426449 L520.82589,341.154177 C520.936334,340.880105 521.162341,340.668913 521.443261,340.577276 Z" id="Path-4" fill="#44425F"></path>
-        <path d="M506.414364,381.586703 C531.29108,373.47094 545.314603,370.021333 548.484934,371.237882 C551.419733,372.36405 564.837593,381.261399 588.738513,397.929927 L588.738518,397.929921 C589.191523,398.245847 589.302647,398.869189 588.986721,399.322195 C588.726045,399.695977 588.245634,399.84625 587.818424,399.68764 C560.902514,389.69458 546.123298,384.376258 543.480774,383.732675 C540.679676,383.050471 527.988256,384.014898 505.406513,386.625957 L505.406508,386.625913 C504.857903,386.689347 504.361747,386.296037 504.298313,385.747432 C504.277175,385.564618 504.306897,385.379516 504.384206,385.21251 L505.817051,382.117288 C505.933784,381.865115 506.150186,381.672888 506.414364,381.586703 Z" id="Path-4-Copy" fill="#44425F"></path>
-        <path d="M494.044012,419.354094 C517.459848,407.345507 530.754854,401.950226 533.92903,403.16825 C536.859966,404.292936 541.224417,414.63211 547.02238,434.18577 L547.022418,434.185758 C547.179428,434.715277 546.877451,435.271819 546.347932,435.42883 C545.945513,435.548153 545.511405,435.403483 545.261018,435.066607 C536.308991,423.022325 531.523762,416.790359 530.905331,416.37071 C530.232685,415.914271 517.674809,418.596502 493.231705,424.417404 L493.231715,424.417444 C492.694432,424.545393 492.155155,424.213563 492.027206,423.67628 C491.974807,423.456246 491.998547,423.224948 492.09455,423.020147 L493.594876,419.819474 C493.688907,419.61888 493.846884,419.455189 494.044012,419.354094 Z" id="Path-4-Copy-2" fill="#44425F"></path>
-        <path d="M464.769043,327.676758 C466.070098,320.809447 466.956091,315.867398 467.427022,312.85061 L467.427014,312.850609 C467.615922,311.640465 467.050212,310.437004 465.997873,309.810332 C359.187565,246.204365 286.279449,202.962548 247.273525,180.084882 C197.563856,150.92928 158.761879,128.710967 130.000107,112.134757 C88.2828363,88.0240712 63.0469376,73.9638992 54.2924107,69.9542411 C46.0086205,65.3939219 40.7412302,62.7581855 38.4902397,62.0470321 C35.1137541,60.9803019 32.8250987,60.6160491 30.5469802,62.0470321 C29.6167636,62.6313407 29.3154207,62.9050099 29.2239997,63.68054 C33.4199707,62.7313353 36.8015411,62.9756923 39.3687109,64.4136112 C205.426131,157.42542 321.123792,227.346021 387.343878,270.041479 C430.225662,297.689547 445.17041,314.791504 448.166016,320.442871 C451.161621,326.094238 453.821777,334.911133 453.821777,338.591797 C453.821777,340.839149 453.980486,348.033245 455.584961,359.591797 C455.584961,359.591797 455.584961,359.591797 455.584961,359.591797 L455.584961,359.591797 C455.656556,360.107565 456.132708,360.467638 456.648476,360.396043 C457.028395,360.343305 457.338498,360.06567 457.432761,359.693872 C460.783988,346.47559 463.229434,335.803223 464.769043,327.676758 Z" id="Path-5" fill="#9013FE" style="mix-blend-mode: overlay;"></path>
-        <path d="M439.870282,399.247627 L439.870282,399.247627 C438.401615,397.301624 435.773551,396.64523 433.56236,397.672139 L141.547928,533.287832 C140.497326,533.869591 139.851997,534.632619 139.611942,535.576918 L142.24392,535.131326 C268.226667,477.077409 348.102078,440.395103 381.870154,425.084408 C412.766116,411.07595 428.989239,403.985533 430.539523,403.813157 C436.398371,402.986255 439.743299,402.493364 440.574306,402.334484 C442.230643,402.01781 442.350516,401.274171 440.933924,400.103568 L439.870282,399.247627 Z" id="Path-6" fill="#9013FE" style="mix-blend-mode: overlay;"></path>
-    </g>
-</svg>
\ No newline at end of file

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/favicon.ico Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/favicon.png Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/gimp.png Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/hypothesis.gpl Deleted

@@ -1,24 +0,0 @@
-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)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/hypothesis.sketch Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/hypothesis2.sketch Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/inkscape.png Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/pin.jpg Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/sticker.png Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/brand/stickers.jpg Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/build.sh Deleted

@@ -1,47 +0,0 @@
-#!/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).
-
-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"
-
-if  -n "${GITHUB_ACTIONS-}"  ||  -n "${CODESPACES-}"  ; then
-    # We're on GitHub Actions or Codespaces and already set up a suitable Python
-    PYTHON=$(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" 3.8.13
-    PYTHON=$(pythonloc 3.8.13)/bin/python
-fi
-
-TOOL_REQUIREMENTS="$ROOT/requirements/tools.txt"
-
-TOOL_HASH=$("$PYTHON" "$SCRIPTS/tool-hash.py" < "$TOOL_REQUIREMENTS")
-
-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"
-  "$PYTHON" -m pip install --upgrade pip
-  "$PYTHON" -m pip install --upgrade virtualenv
-  "$PYTHON" -m virtualenv "$TOOL_VIRTUALENV"
-  "$TOOL_PYTHON" -m pip install --no-warn-script-location -r requirements/tools.txt
-fi
-
-"$TOOL_PYTHON" -m hypothesistooling "$@"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/.gitignore Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/CHANGELOG.md Deleted

@@ -1,47 +0,0 @@
-# Conjecture for Rust 0.7.0 (2021-02-01)
-
-This release improves flexibility and performance of `distributions::Sampler::new` by allowing it to accept `&f32` instead of a `Vec`.
-It also positively affects `distributions::good_bitlengths` as it does not have to allocate a vector anymore.
-
-# Conjecture for Rust 0.6.0 (2021-01-27)
-
-This release is required following an unsuccessful deploy of 0.5.0 due to usage of a cargo keyword that was too long.
-
-# Conjecture for Rust 0.5.0 (2021-01-27)
-
-Adds support for skipping shrinking. While shrinking is extremely helpful and important in general, it has the potential to be quite time consuming. It can be useful to observe a raw failure before choosing to allow the engine to try to shrink. hypothesis-python(https://hypothesis.readthedocs.io/en/latest/settings.html#phases) already provides the ability to skip shrinking, so there is precedent for this being useful.
-
-Also swaps out the deprecated tempdir crate with tempfile.
-
-# Conjecture for Rust 0.4.0 (2018-10-24)
-
-This release extends Conjecture for Rust with support for saving examples it discovers on disk in an example database,
-in line with Hypothesis for Python's existing functionality for this.
-
-# Conjecture for Rust 0.3.0 (2018-07-16)
-
-This release adds support for annotating interesting examples
-to indicate that they are logically distinct. When multiple distinct
-reasons for being interesting are found, Conjecture will attempt to
-shrink all of them.
-
-# Conjecture for Rust 0.2.1 (2018-06-25)
-
-This release fixes an occasional assertion failure that could occur
-when shrinking a failing test.
-
-# Conjecture for Rust 0.2.0 (2018-06-25)
-
-This release brings over all of the core code and API that was previously in
-hypothesis-ruby.
-
-# Conjecture for Rust 0.1.1 (2018-06-23)
-
-This is an essentially no-op release that just updates the package homepage and
-puts this package under the Hypothesis continuous release system.
-
-# Conjecture for Rust 0.1.0 (2018-06-19)
-
-This is an initial empty package release of Conjecture for Rust, solely
-to start fleshing out the release system and package dependency architecture
-between this and Hypothesis for Ruby. It literally does nothing.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/Cargo.toml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/README.md Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src/data.rs Deleted

@@ -1,205 +0,0 @@
-// Module representing core data types that Hypothesis
-// needs.
-
-use rand::{ChaChaRng, Rng};
-use std::cmp::Ordering;
-use std::collections::HashSet;
-
-pub type DataStream = Vec<u64>;
-pub type DataStreamSlice = u64;
-
-#derive(Debug, Clone)
-pub struct FailedDraw;
-
-#derive(Debug, Clone)
-enum BitGenerator {
-    Random(ChaChaRng),
-    Recorded(DataStream),
-}
-
-// Records information corresponding to a single draw call.
-#derive(Debug, Clone)
-pub struct DrawInProgress {
-    depth: usize,
-    start: usize,
-    end: Option<usize>,
-}
-
-// Records information corresponding to a single draw call.
-#derive(Debug, Clone)
-pub struct Draw {
-    pub depth: usize,
-    pub start: usize,
-    pub end: usize,
-}
-
-// Main entry point for running a test:
-// A test function takes a DataSource, uses it to
-// produce some data, and the DataSource records the
-// relevant information about what they did.
-#derive(Debug, Clone)
-pub struct DataSource {
-    bitgenerator: BitGenerator,
-    record: DataStream,
-    sizes: Vec<u64>,
-    draws: Vec<DrawInProgress>,
-    draw_stack: Vec<usize>,
-    written_indices: HashSet<usize>,
-}
-
-impl DataSource {
-    fn new(generator: BitGenerator) -> DataSource {
-        DataSource {
-            bitgenerator: generator,
-            record: DataStream::new(),
-            sizes: Vec::new(),
-            draws: Vec::new(),
-            draw_stack: Vec::new(),
-            written_indices: HashSet::new(),
-        }
-    }
-
-    pub fn from_random(random: ChaChaRng) -> DataSource {
-        DataSource::new(BitGenerator::Random(random))
-    }
-
-    pub fn from_vec(record: DataStream) -> DataSource {
-        DataSource::new(BitGenerator::Recorded(record))
-    }
-
-    pub fn start_draw(&mut self) {
-        let i = self.draws.len();
-        let depth = self.draw_stack.len();
-        let start = self.record.len();
-
-        self.draw_stack.push(i);
-        self.draws.push(DrawInProgress {
-            start,
-            end: None,
-            depth,
-        });
-    }
-
-    pub fn stop_draw(&mut self) {
-        assert!(!self.draws.is_empty());
-        assert!(!self.draw_stack.is_empty());
-        let i = self.draw_stack.pop().unwrap();
-        let end = self.record.len();
-        self.drawsi.end = Some(end);
-    }
-
-    pub fn write(&mut self, value: u64) -> Result<(), FailedDraw> {
-        match self.bitgenerator {
-            BitGenerator::Recorded(ref mut v) if self.record.len() >= v.len() => Err(FailedDraw),
-            _ => {
-                self.sizes.push(0);
-                self.record.push(value);
-                Ok(())
-            }
-        }
-    }
-
-    pub fn bits(&mut self, n_bits: u64) -> Result<u64, FailedDraw> {
-        self.sizes.push(n_bits);
-        let mut result = match self.bitgenerator {
-            BitGenerator::Random(ref mut random) => random.next_u64(),
-            BitGenerator::Recorded(ref mut v) => {
-                if self.record.len() >= v.len() {
-                    return Err(FailedDraw);
-                } else {
-                    vself.record.len()
-                }
-            }
-        };
-
-        if n_bits < 64 {
-            let mask = (1 << n_bits) - 1;
-            result &= mask;
-        };
-
-        self.record.push(result);
-
-        Ok(result)
-    }
-
-    pub fn into_result(self, status: Status) -> TestResult {
-        TestResult {
-            record: self.record,
-            status,
-            written_indices: self.written_indices,
-            sizes: self.sizes,
-            draws: self
-                .draws
-                .into_iter()
-                .filter_map(|d| match d {
-                    DrawInProgress {
-                        depth,
-                        start,
-                        end: Some(end),
-                    } if start < end => Some(Draw { start, end, depth }),
-                    DrawInProgress { end: None, .. } => {
-                        assert!(status == Status::Invalid || status == Status::Overflow);
-                        None
-                    }
-                    _ => None,
-                })
-                .collect(),
-        }
-    }
-}
-
-// Status indicates the result that we got from completing
-// a single test execution.
-#derive(Debug, Clone, Eq, PartialEq, Copy)
-pub enum Status {
-    // The test tried to read more data than we had for it.
-    Overflow,
-
-    // Some important precondition of the test was not
-    // satisfied.
-    Invalid,
-
-    // This test ran successfully to completion without
-    // anything of note happening.
-    Valid,
-
-    // This was an interesting test execution! (Usually this
-    // means failing, but for things like find it may not).
-    Interesting(u64),
-}
-
-// Once a data source is finished it "decays" to a
-// TestResult, that retains a trace of all the information
-// we needed from the DataSource. It is these we keep around,
-// not the original DataSource objects.
-#derive(Debug, Clone)
-pub struct TestResult {
-    pub record: DataStream,
-    pub status: Status,
-    pub draws: Vec<Draw>,
-    pub sizes: Vec<u64>,
-    pub written_indices: HashSet<usize>,
-}
-
-impl Ord for TestResult {
-    fn cmp(&self, other: &TestResult) -> Ordering {
-        self.record
-            .len()
-            .cmp(&other.record.len())
-            .then(self.record.cmp(&other.record))
-    }
-}
-
-impl PartialOrd for TestResult {
-    fn partial_cmp(&self, other: &TestResult) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl PartialEq for TestResult {
-    fn eq(&self, other: &TestResult) -> bool {
-        self.record == other.record
-    }
-}
-
-impl Eq for TestResult {}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src/database.rs Deleted

@@ -1,152 +0,0 @@
-use crypto_hash::{hex_digest, Algorithm};
-use std::fmt::Debug;
-use std::fs;
-use std::io;
-use std::io::prelude::*;
-use std::path::{Path, PathBuf};
-
-pub type Key = str;
-
-pub trait Database: Debug + Send {
-    fn save(&mut self, key: &Key, value: &u8);
-    fn delete(&mut self, key: &Key, value: &u8);
-    fn fetch(&mut self, key: &Key) -> Vec<Vec<u8>>;
-}
-
-pub type BoxedDatabase = Box<dyn Database>;
-
-#derive(Debug)
-pub struct NoDatabase;
-
-impl Database for NoDatabase {
-    fn save(&mut self, _key: &Key, _value: &u8) {}
-    fn delete(&mut self, _key: &Key, _value: &u8) {}
-    fn fetch(&mut self, _key: &Key) -> Vec<Vec<u8>> {
-        vec!
-    }
-}
-
-#derive(Debug)
-pub struct DirectoryDatabase {
-    path: PathBuf,
-}
-
-fn expect_io_error(expected: io::ErrorKind, result: io::Result<()>) {
-    match result {
-        Ok(()) => (),
-        Err(error) => {
-            if error.kind() != expected {
-                panic!("IO Error: {:?}", error.kind());
-            }
-        }
-    }
-}
-
-impl DirectoryDatabase {
-    pub fn new<P: AsRef<Path>>(path: P) -> DirectoryDatabase {
-        let mut result = DirectoryDatabase {
-            path: PathBuf::new(),
-        };
-        result.path.push(path);
-        result
-    }
-
-    fn path_for_key(&self, key: &Key) -> PathBuf {
-        let hashed_key = hex_digest(Algorithm::SHA1, key.as_bytes());
-        let mut result = PathBuf::new();
-        result.push(&self.path);
-        result.push(&hashed_key0..7);
-        expect_io_error(io::ErrorKind::AlreadyExists, fs::create_dir_all(&result));
-        result
-    }
-
-    fn path_for_entry(&self, key: &Key, value: &u8) -> PathBuf {
-        let mut result = self.path_for_key(key);
-        result.push(&hex_digest(Algorithm::SHA1, value)0..7);
-        result
-    }
-}
-
-impl Database for DirectoryDatabase {
-    fn save(&mut self, key: &Key, value: &u8) {
-        let mut target = fs::File::create(self.path_for_entry(key, &value)).unwrap();
-        target.write_all(value).unwrap();
-        target.sync_all().unwrap();
-    }
-
-    fn delete(&mut self, key: &Key, value: &u8) {
-        let target = self.path_for_entry(key, &value);
-        expect_io_error(io::ErrorKind::NotFound, fs::remove_file(target));
-    }
-
-    fn fetch(&mut self, key: &Key) -> Vec<Vec<u8>> {
-        let mut results = Vec::new();
-        for entry_result in fs::read_dir(self.path_for_key(key)).unwrap() {
-            let path = entry_result.unwrap().path();
-            let file = fs::File::open(path).unwrap();
-            let mut buf_reader = io::BufReader::new(file);
-            let mut contents = Vec::new();
-            buf_reader.read_to_end(&mut contents).unwrap();
-            results.push(contents);
-        }
-        results
-    }
-}
-
-#cfg(test)
-mod tests {
-    use super::*;
-    use tempfile::TempDir;
-
-    #derive(Debug)
-    struct TestDatabase {
-        _temp: TempDir,
-        db: DirectoryDatabase,
-    }
-
-    impl TestDatabase {
-        pub fn new() -> TestDatabase {
-            let dir = TempDir::new().unwrap();
-            let db = DirectoryDatabase::new(dir.path());
-            TestDatabase { _temp: dir, db }
-        }
-    }
-
-    impl Database for TestDatabase {
-        fn save(&mut self, key: &Key, value: &u8) {
-            self.db.save(key, value)
-        }
-
-        fn delete(&mut self, key: &Key, value: &u8) {
-            self.db.delete(key, value)
-        }
-
-        fn fetch(&mut self, key: &Key) -> Vec<Vec<u8>> {
-            self.db.fetch(key)
-        }
-    }
-
-    #test
-    fn can_delete_non_existing_key() {
-        let mut db = TestDatabase::new();
-        db.delete("foo", b"bar");
-    }
-
-    #test
-    fn appears_in_listing_after_saving() {
-        let mut db = TestDatabase::new();
-        db.save("foo", b"bar");
-        let results = db.fetch("foo");
-        assert!(results.len() == 1);
-        assert!(results0.as_slice() == b"bar");
-    }
-
-    #test
-    fn can_delete_key() {
-        let mut db = TestDatabase::new();
-        db.save("foo", b"bar");
-        db.delete("foo", b"bar");
-        let results = db.fetch("foo");
-        assert!(results.is_empty());
-    }
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src/distributions.rs Deleted

@@ -1,242 +0,0 @@
-use crate::data::{DataSource, FailedDraw};
-
-use std::cmp::{Ord, Ordering, PartialOrd, Reverse};
-use std::collections::BinaryHeap;
-use std::mem;
-
-use std::u64::MAX as MAX64;
-
-type Draw<T> = Result<T, FailedDraw>;
-
-pub fn weighted(source: &mut DataSource, probability: f64) -> Result<bool, FailedDraw> {
-    // TODO: Less bit-hungry implementation.
-
-    let truthy = (probability * (u64::max_value() as f64 + 1.0)).floor() as u64;
-    let probe = source.bits(64)?;
-    Ok(match (truthy, probe) {
-        (0, _) => false,
-        (MAX64, _) => true,
-        (_, 0) => false,
-        (_, 1) => true,
-        _ => probe >= MAX64 - truthy,
-    })
-}
-
-pub fn bounded_int(source: &mut DataSource, max: u64) -> Draw<u64> {
-    let bitlength = 64 - max.leading_zeros() as u64;
-    if bitlength == 0 {
-        source.write(0)?;
-        return Ok(0);
-    }
-    loop {
-        let probe = source.bits(bitlength)?;
-        if probe <= max {
-            return Ok(probe);
-        }
-    }
-}
-
-#derive(Debug, Clone)
-pub struct Repeat {
-    min_count: u64,
-    max_count: u64,
-    p_continue: f64,
-
-    current_count: u64,
-}
-
-impl Repeat {
-    pub fn new(min_count: u64, max_count: u64, expected_count: f64) -> Repeat {
-        Repeat {
-            min_count,
-            max_count,
-            p_continue: 1.0 - 1.0 / (1.0 + expected_count),
-            current_count: 0,
-        }
-    }
-
-    pub fn reject(&mut self) {
-        assert!(self.current_count > 0);
-        self.current_count -= 1;
-    }
-
-    pub fn should_continue(&mut self, source: &mut DataSource) -> Result<bool, FailedDraw> {
-        if self.min_count == self.max_count {
-            if self.current_count < self.max_count {
-                self.current_count += 1;
-                return Ok(true);
-            } else {
-                return Ok(false);
-            }
-        } else if self.current_count < self.min_count {
-            source.write(1)?;
-            self.current_count += 1;
-            return Ok(true);
-        } else if self.current_count >= self.max_count {
-            source.write(0)?;
-            return Ok(false);
-        }
-
-        let result = weighted(source, self.p_continue)?;
-        if result {
-            self.current_count += 1;
-        } else {
-        }
-        Ok(result)
-    }
-}
-
-#derive(Debug, Clone)
-struct SamplerEntry {
-    primary: usize,
-    alternate: usize,
-    use_alternate: f32,
-}
-
-impl SamplerEntry {
-    fn single(i: usize) -> SamplerEntry {
-        SamplerEntry {
-            primary: i,
-            alternate: i,
-            use_alternate: 0.0,
-        }
-    }
-}
-
-impl Ord for SamplerEntry {
-    fn cmp(&self, other: &SamplerEntry) -> Ordering {
-        self.primary
-            .cmp(&other.primary)
-            .then(self.alternate.cmp(&other.alternate))
-    }
-}
-
-impl PartialOrd for SamplerEntry {
-    fn partial_cmp(&self, other: &SamplerEntry) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl PartialEq for SamplerEntry {
-    fn eq(&self, other: &SamplerEntry) -> bool {
-        self.cmp(other) == Ordering::Equal
-    }
-}
-
-impl Eq for SamplerEntry {}
-
-#derive(Debug, Clone)
-pub struct Sampler {
-    table: Vec<SamplerEntry>,
-}
-
-impl Sampler {
-    pub fn new(weights: &f32) -> Sampler {
-        // FIXME: The correct thing to do here is to allow this,
-        // return early, and make this reject the data, but we don't
-        // currently have the status built into our data properly...
-        assert!(!weights.is_empty());
-
-        let mut table = Vec::new();
-
-        let mut small = BinaryHeap::new();
-        let mut large = BinaryHeap::new();
-
-        let total: f32 = weights.iter().sum();
-
-        let mut scaled_probabilities = Vec::new();
-
-        let n = weights.len() as f32;
-
-        for (i, w) in weights.iter().enumerate() {
-            let scaled = n * w / total;
-            scaled_probabilities.push(scaled);
-            if (scaled - 1.0).abs() < f32::EPSILON {
-                table.push(SamplerEntry::single(i))
-            } else if scaled > 1.0 {
-                large.push(Reverse(i));
-            } else {
-                assert!(scaled < 1.0);
-                small.push(Reverse(i));
-            }
-        }
-
-        while !(small.is_empty() || large.is_empty()) {
-            let Reverse(lo) = small.pop().unwrap();
-            let Reverse(hi) = large.pop().unwrap();
-
-            assert!(lo != hi);
-            assert!(scaled_probabilitieshi > 1.0);
-            assert!(scaled_probabilitieslo < 1.0);
-            scaled_probabilitieshi = (scaled_probabilitieshi + scaled_probabilitieslo) - 1.0;
-            table.push(SamplerEntry {
-                primary: lo,
-                alternate: hi,
-                use_alternate: 1.0 - scaled_probabilitieslo,
-            });
-
-            if scaled_probabilitieshi < 1.0 {
-                small.push(Reverse(hi))
-            } else if scaled_probabilitieshi > 1.0 {
-                large.push(Reverse(hi))
-            } else {
-                table.push(SamplerEntry::single(hi))
-            }
-        }
-        for &Reverse(i) in small.iter() {
-            table.push(SamplerEntry::single(i))
-        }
-        for &Reverse(i) in large.iter() {
-            table.push(SamplerEntry::single(i))
-        }
-
-        for ref mut entry in table.iter_mut() {
-            if entry.alternate < entry.primary {
-                mem::swap(&mut entry.primary, &mut entry.alternate);
-                entry.use_alternate = 1.0 - entry.use_alternate;
-            }
-        }
-
-        table.sort();
-        assert!(!table.is_empty());
-        Sampler { table }
-    }
-
-    pub fn sample(&self, source: &mut DataSource) -> Draw<usize> {
-        assert!(!self.table.is_empty());
-        let i = bounded_int(source, self.table.len() as u64 - 1)? as usize;
-        let entry = &self.tablei;
-        let use_alternate = weighted(source, entry.use_alternate as f64)?;
-        if use_alternate {
-            Ok(entry.alternate)
-        } else {
-            Ok(entry.primary)
-        }
-    }
-}
-
-pub fn good_bitlengths() -> Sampler {
-    let weights = 
-        4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, // 1 byte
-        2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, // 2 bytes
-        1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, // 3 bytes
-        0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, // 4 bytes
-        0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 5 bytes
-        0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 6 bytes
-        0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 7 bytes
-        0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 8 bytes (last bit spare for sign)
-    ;
-    assert!(weights.len() == 63);
-    Sampler::new(&weights)
-}
-
-pub fn integer_from_bitlengths(source: &mut DataSource, bitlengths: &Sampler) -> Draw<i64> {
-    let bitlength = bitlengths.sample(source)? as u64 + 1;
-    let base = source.bits(bitlength)? as i64;
-    let sign = source.bits(1)?;
-    if sign > 0 {
-        Ok(-base)
-    } else {
-        Ok(base)
-    }
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src/engine.rs Deleted

@@ -1,803 +0,0 @@
-// Core module that provides a main execution loop and
-// the API that can be used to get test data from it.
-
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-use rand::{ChaChaRng, Rng, SeedableRng};
-
-use std::cmp::Reverse;
-use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
-use std::io;
-use std::mem;
-use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
-use std::thread;
-
-use crate::data::{DataSource, DataStreamSlice, Status, TestResult};
-use crate::database::BoxedDatabase;
-use crate::intminimize::minimize_integer;
-
-#derive(Debug, PartialEq)
-pub enum Phase {
-    Shrink,
-}
-
-impl Phase {
-    pub fn all() -> Vec<Self> {
-        vec!Phase::Shrink
-    }
-}
-
-impl TryFrom<&str> for Phase {
-    type Error = String;
-
-    fn try_from(value: &str) -> Result<Self, String> {
-        match value {
-            "shrink" => Ok(Phase::Shrink),
-            _ => Err(format!(
-                "Cannot convert to Phase: {} is not a valid Phase",
-                value
-            )),
-        }
-    }
-}
-
-#derive(Debug, Clone)
-enum LoopExitReason {
-    Complete,
-    MaxExamples,
-    Shutdown,
-}
-
-#derive(Debug)
-enum LoopCommand {
-    RunThis(DataSource),
-    Finished(LoopExitReason, MainGenerationLoop),
-}
-
-#derive(Debug)
-struct MainGenerationLoop {
-    name: String,
-    database: BoxedDatabase,
-    receiver: Receiver<TestResult>,
-    sender: SyncSender<LoopCommand>,
-    max_examples: u64,
-    random: ChaChaRng,
-    phases: Vec<Phase>,
-
-    best_example: Option<TestResult>,
-    minimized_examples: HashMap<u64, TestResult>,
-    fully_minimized: HashSet<u64>,
-
-    valid_examples: u64,
-    invalid_examples: u64,
-    interesting_examples: u64,
-}
-
-type StepResult = Result<(), LoopExitReason>;
-
-impl MainGenerationLoop {
-    fn run(mut self) {
-        let result = self.loop_body();
-        match result {
-            // Silent shutdown when the main thread terminates
-            Err(LoopExitReason::Shutdown) => (),
-            Err(reason) => {
-                // Must clone because otherwise it is borrowed.
-                let shutdown_sender = self.sender.clone();
-                shutdown_sender
-                    .send(LoopCommand::Finished(reason, self))
-                    .unwrap()
-            }
-            Ok(_) => panic!("BUG: Generation loop was not supposed to return normally."),
-        }
-    }
-
-    fn run_previous_examples(&mut self) -> Result<(), LoopExitReason> {
-        for v in self.database.fetch(&self.name) {
-            let result = self.execute(DataSource::from_vec(bytes_to_u64s(&v)))?;
-            let should_delete = match &result.status {
-                Status::Interesting(_) => u64s_to_bytes(&result.record) != v,
-                _ => true,
-            };
-            if should_delete {
-                println!("Deleting!");
-                self.database.delete(&self.name, v.as_slice());
-            }
-        }
-        Ok(())
-    }
-
-    fn loop_body(&mut self) -> StepResult {
-        self.run_previous_examples()?;
-
-        if self.interesting_examples == 0 {
-            self.generate_examples()?;
-        }
-
-        if !self.phases.contains(&Phase::Shrink) {
-            return Err(LoopExitReason::Complete);
-        }
-        // At the start of this loop we usually only have one example in
-        // self.minimized_examples, but as we shrink we may find other ones.
-        // Additionally, we may have multiple different failing examples from
-        // a previous run.
-        //
-        // The reason why we loop is twofold:
-        // a) This allows us to include newly discovered examples. Labels that
-        //    are not found in self.minimized_examples at the beginning of the
-        //    loop will be added for the next iteration around.
-        // b) If we've previously marked a label as finished it can become
-        //    unfinished again if when shrinking another label, as when trying
-        //    to shrink one label we might accidentally find an improved shrink
-        //    for another.
-        //
-        // In principle this might cause us to loop for a very long time before
-        // eventually settling on a fixed point, but when that happens we
-        // should hit limits on shrinking (which we haven't implemented yet).
-        while self.minimized_examples.len() > self.fully_minimized.len() {
-            let keys: Vec<u64> = self.minimized_examples.keys().copied().collect();
-            for label in &keys {
-                if self.fully_minimized.insert(*label) {
-                    let target = self.minimized_exampleslabel.clone();
-                    let mut shrinker =
-                        Shrinker::new(self, target, |r| r.status == Status::Interesting(*label));
-
-                    shrinker.run()?;
-                }
-            }
-        }
-
-        Err(LoopExitReason::Complete)
-    }
-
-    fn generate_examples(&mut self) -> Result<TestResult, LoopExitReason> {
-        while self.valid_examples < self.max_examples
-            && self.invalid_examples < 10 * self.max_examples
-        {
-            let r = self.random.gen();
-            let result = self.execute(DataSource::from_random(r))?;
-            if let Status::Interesting(_) = result.status {
-                return Ok(result);
-            }
-        }
-        Err(LoopExitReason::MaxExamples)
-    }
-
-    fn execute(&mut self, source: DataSource) -> Result<TestResult, LoopExitReason> {
-        let result = match self.sender.send(LoopCommand::RunThis(source)) {
-            Ok(_) => match self.receiver.recv() {
-                Ok(t) => t,
-                Err(_) => return Err(LoopExitReason::Shutdown),
-            },
-            Err(_) => return Err(LoopExitReason::Shutdown),
-        };
-        match result.status {
-            Status::Overflow => (),
-            Status::Invalid => self.invalid_examples += 1,
-            Status::Valid => self.valid_examples += 1,
-            Status::Interesting(n) => {
-                self.best_example = Some(result.clone());
-                let mut changed = false;
-                let minimized_examples = &mut self.minimized_examples;
-                let database = &mut self.database;
-                let name = &self.name;
-
-                minimized_examples
-                    .entry(n)
-                    .or_insert_with(|| result.clone());
-                minimized_examples.entry(n).and_modify(|e| {
-                    if result < *e {
-                        changed = true;
-                        database.delete(name, &u64s_to_bytes(&(*e.record)));
-                        *e = result.clone()
-                    };
-                });
-                if changed {
-                    self.fully_minimized.remove(&n);
-                }
-                self.interesting_examples += 1;
-                database.save(&self.name, &u64s_to_bytes(result.record.as_slice()));
-            }
-        }
-
-        Ok(result)
-    }
-}
-
-struct Shrinker<'owner, Predicate> {
-    _predicate: Predicate,
-    shrink_target: TestResult,
-    changes: u64,
-    expensive_passes_enabled: bool,
-    main_loop: &'owner mut MainGenerationLoop,
-}
-
-impl<'owner, Predicate> Shrinker<'owner, Predicate>
-where
-    Predicate: Fn(&TestResult) -> bool,
-{
-    fn new(
-        main_loop: &'owner mut MainGenerationLoop,
-        shrink_target: TestResult,
-        predicate: Predicate,
-    ) -> Shrinker<'owner, Predicate> {
-        assert!(predicate(&shrink_target));
-        Shrinker {
-            main_loop,
-            _predicate: predicate,
-            shrink_target,
-            changes: 0,
-            expensive_passes_enabled: false,
-        }
-    }
-
-    fn predicate(&mut self, result: &TestResult) -> bool {
-        let succeeded = (self._predicate)(result);
-        if succeeded
-            && (
-                // In the presence of writes it may be the case that we thought
-                // we were going to shrink this but didn't actually succeed because
-                // the written value was used.
-                result.record.len() < self.shrink_target.record.len()
-                    || (result.record.len() == self.shrink_target.record.len()
-                        && result.record < self.shrink_target.record)
-            )
-        {
-            self.changes += 1;
-            self.shrink_target = result.clone();
-        }
-        succeeded
-    }
-
-    fn run(&mut self) -> StepResult {
-        let mut prev = self.changes + 1;
-
-        while prev != self.changes {
-            prev = self.changes;
-            self.adaptive_delete()?;
-            self.minimize_individual_blocks()?;
-            self.minimize_duplicated_blocks()?;
-            if prev == self.changes {
-                self.expensive_passes_enabled = true;
-            }
-            if !self.expensive_passes_enabled {
-                continue;
-            }
-
-            self.reorder_blocks()?;
-            self.lower_and_delete()?;
-            self.delete_all_ranges()?;
-        }
-        Ok(())
-    }
-
-    fn lower_and_delete(&mut self) -> StepResult {
-        let mut i = 0;
-        while i < self.shrink_target.record.len() {
-            if self.shrink_target.recordi > 0 {
-                let mut attempt = self.shrink_target.record.clone();
-                attempti -= 1;
-                let (succeeded, result) = self.execute(&attempt)?;
-                if !succeeded && result.record.len() < self.shrink_target.record.len() {
-                    let mut j = 0;
-                    while j < self.shrink_target.draws.len() {
-                        // Having to copy this is an annoying consequence of lexical lifetimes -
-                        // if we borrowed it immutably then we'd not be allowed to call self.incorporate
-                        // down below. Fortunately these things are tiny structs of integers so it doesn't
-                        // really matter.
-                        let d = self.shrink_target.drawsj.clone();
-                        if d.start > i {
-                            let mut attempt2 = attempt.clone();
-                            attempt2.drain(d.start..d.end);
-                            if self.incorporate(&attempt2)? {
-                                break;
-                            }
-                        }
-                        j += 1;
-                    }
-                }
-            }
-            i += 1;
-        }
-        Ok(())
-    }
-
-    fn reorder_blocks(&mut self) -> StepResult {
-        let mut i = 0;
-        while i < self.shrink_target.record.len() {
-            let mut j = i + 1;
-            while j < self.shrink_target.record.len() {
-                assert!(i < self.shrink_target.record.len());
-                if self.shrink_target.recordi == 0 {
-                    break;
-                }
-                if self.shrink_target.recordj < self.shrink_target.recordi {
-                    let mut attempt = self.shrink_target.record.clone();
-                    attempt.swap(i, j);
-                    self.incorporate(&attempt)?;
-                }
-                j += 1;
-            }
-            i += 1;
-        }
-        Ok(())
-    }
-
-    fn try_delete_range(
-        &mut self,
-        target: &TestResult,
-        i: usize,
-        k: usize,
-    ) -> Result<bool, LoopExitReason> {
-        // Attempts to delete k non-overlapping draws starting from the draw at index i.
-
-        let mut stack: Vec<(usize, usize)> = Vec::new();
-        let mut j = i;
-        while j < target.draws.len() && stack.len() < k {
-            let m = target.drawsj.start;
-            let n = target.drawsj.end;
-            assert!(m < n);
-            if m < n && (stack.is_empty() || stackstack.len() - 1.1 <= m) {
-                stack.push((m, n))
-            }
-            j += 1;
-        }
-
-        let mut attempt = target.record.clone();
-        while !stack.is_empty() {
-            let (m, n) = stack.pop().unwrap();
-            attempt.drain(m..n);
-        }
-
-        if attempt.len() >= self.shrink_target.record.len() {
-            Ok(false)
-        } else {
-            self.incorporate(&attempt)
-        }
-    }
-
-    fn adaptive_delete(&mut self) -> StepResult {
-        let mut i = 0;
-        let target = self.shrink_target.clone();
-
-        while i < target.draws.len() {
-            // This is an adaptive pass loosely modelled after timsort. If
-            // little or nothing is deletable here then we don't try any more
-            // deletions than the naive greedy algorithm would, but if it looks
-            // like we have an opportunity to delete a lot then we try to do so.
-
-            // What we're trying to do is to find a large k such that we can
-            // delete k but not k + 1 draws starting from this point, and we
-            // want to do that in O(log(k)) rather than O(k) test executions.
-
-            // We try a quite careful sequence of small shrinks here before we
-            // move on to anything big. This is because if we try to be
-            // aggressive too early on we'll tend to find that we lose out when
-            // the example is "nearly minimal".
-            if self.try_delete_range(&target, i, 2)? {
-                if self.try_delete_range(&target, i, 3)? && self.try_delete_range(&target, i, 4)? {
-                    let mut hi = 5;
-                    // At this point it looks like we've got a pretty good
-                    // opportunity for a long run here. We do an exponential
-                    // probe upwards to try and find some k where we can't
-                    // delete many intervals. We do this rather than choosing
-                    // that upper bound to immediately be large because we
-                    // don't really expect k to be huge. If it turns out that
-                    // it is, the subsequent example is going to be so tiny that
-                    // it doesn't really matter if we waste a bit of extra time
-                    // here.
-                    while self.try_delete_range(&target, i, hi)? {
-                        assert!(hi <= target.draws.len());
-                        hi *= 2;
-                    }
-                    // We now know that we can delete the first lo intervals but
-                    // not the first hi. We preserve that property while doing
-                    // a binary search to find the point at which we stop being
-                    // able to delete intervals.
-                    let mut lo = 4;
-                    while lo + 1 < hi {
-                        let mid = lo + (hi - lo) / 2;
-                        if self.try_delete_range(&target, i, mid)? {
-                            lo = mid;
-                        } else {
-                            hi = mid;
-                        }
-                    }
-                }
-            } else {
-                self.try_delete_range(&target, i, 1)?;
-            }
-            // We unconditionally bump i because we have always tried deleting
-            // one more example than we succeeded at deleting, so we expect the
-            // next example to be undeletable.
-            i += 1;
-        }
-        Ok(())
-    }
-
-    fn delete_all_ranges(&mut self) -> StepResult {
-        let mut i = 0;
-        while i < self.shrink_target.record.len() {
-            let start_length = self.shrink_target.record.len();
-
-            let mut j = i + 1;
-            while j < self.shrink_target.record.len() {
-                assert!(j > i);
-                let mut attempt = self.shrink_target.record.clone();
-                attempt.drain(i..j);
-                assert!(attempt.len() + (j - i) == self.shrink_target.record.len());
-                let deleted = self.incorporate(&attempt)?;
-                if !deleted {
-                    j += 1;
-                }
-            }
-            if start_length == self.shrink_target.record.len() {
-                i += 1;
-            }
-        }
-        Ok(())
-    }
-
-    fn try_lowering_value(&mut self, i: usize, v: u64) -> Result<bool, LoopExitReason> {
-        if v >= self.shrink_target.recordi {
-            return Ok(false);
-        }
-
-        let mut attempt = self.shrink_target.record.clone();
-        attempti = v;
-        let (succeeded, result) = self.execute(&attempt)?;
-        assert!(result.record.len() <= self.shrink_target.record.len());
-        let lost_bytes = self.shrink_target.record.len() - result.record.len();
-        if !succeeded && result.status == Status::Valid && lost_bytes > 0 {
-            attempt.drain(i + 1..i + lost_bytes + 1);
-            assert!(attempt.len() + lost_bytes == self.shrink_target.record.len());
-            self.incorporate(&attempt)
-        } else {
-            Ok(succeeded)
-        }
-    }
-
-    fn minimize_individual_blocks(&mut self) -> StepResult {
-        let mut i = 0;
-
-        while i < self.shrink_target.record.len() {
-            if !self.shrink_target.written_indices.contains(&i) {
-                minimize_integer(self.shrink_target.recordi, |v| {
-                    self.try_lowering_value(i, v)
-                })?;
-            }
-
-            i += 1;
-        }
-
-        Ok(())
-    }
-
-    fn calc_duplicates(&self) -> Vec<Vec<usize>> {
-        assert!(self.shrink_target.record.len() == self.shrink_target.sizes.len());
-        let mut duplicates: HashMap<(u64, u64), Vec<usize>> = HashMap::new();
-        for (i, (u, v)) in self
-            .shrink_target
-            .record
-            .iter()
-            .zip(self.shrink_target.sizes.iter())
-            .enumerate()
-        {
-            if !self.shrink_target.written_indices.contains(&i) {
-                duplicates.entry((*u, *v)).or_insert_with(Vec::new).push(i);
-            }
-        }
-
-        let mut result: Vec<Vec<usize>> = duplicates
-            .drain()
-            .filter_map(|(_, elements)| {
-                if elements.len() > 1 {
-                    Some(elements)
-                } else {
-                    None
-                }
-            })
-            .collect();
-        result.sort_by_key(|v| Reverse(v.len()));
-        result
-    }
-
-    fn minimize_duplicated_blocks(&mut self) -> StepResult {
-        let mut i = 0;
-        let mut targets = self.calc_duplicates();
-
-        while i < targets.len() {
-            let target = mem::replace(&mut targetsi, Vec::new());
-            let max_target = *target.iter().max().unwrap();
-
-            i += 1;
-            assert!(!target.is_empty());
-            let v = self.shrink_target.recordtarget0;
-
-            let w = minimize_integer(v, |t| {
-                if max_target >= self.shrink_target.record.len() {
-                    return Ok(false);
-                }
-                let mut attempt = self.shrink_target.record.clone();
-                for i in &target {
-                    attempt*i = t
-                }
-                self.incorporate(&attempt)
-            })?;
-            if w != v {
-                targets = self.calc_duplicates();
-            }
-        }
-        Ok(())
-    }
-
-    fn execute(&mut self, buf: &DataStreamSlice) -> Result<(bool, TestResult), LoopExitReason> {
-        // TODO: Later there will be caching here
-        let result = self.main_loop.execute(DataSource::from_vec(buf.to_vec()))?;
-        Ok((self.predicate(&result), result))
-    }
-
-    fn incorporate(&mut self, buf: &DataStreamSlice) -> Result<bool, LoopExitReason> {
-        assert!(
-            buf.len() <= self.shrink_target.record.len(),
-            "Expected incorporate to not increase length, but buf.len() = {} \
-             while shrink target was {}",
-            buf.len(),
-            self.shrink_target.record.len()
-        );
-        if buf.len() == self.shrink_target.record.len() {
-            assert!(buf < &self.shrink_target.record);
-        }
-        if self.shrink_target.record.starts_with(buf) {
-            return Ok(false);
-        }
-        let (succeeded, _) = self.execute(buf)?;
-        Ok(succeeded)
-    }
-}
-
-#derive(Debug, Clone, Eq, PartialEq)
-enum EngineState {
-    AwaitingCompletion,
-    ReadyToProvide,
-}
-
-#derive(Debug)
-pub struct Engine {
-    // The next response from the main loop. Once
-    // this is set to Some(Finished(_)) it stays that way,
-    // otherwise it is cleared on access.
-    loop_response: Option<LoopCommand>,
-
-    state: EngineState,
-
-    // Communication channels with the main testing loop
-    handle: Option<thread::JoinHandle<()>>,
-    receiver: Receiver<LoopCommand>,
-    sender: SyncSender<TestResult>,
-}
-
-fn bytes_to_u64s(bytes: &u8) -> Vec<u64> {
-    let mut reader = io::Cursor::new(bytes);
-    let mut result = Vec::new();
-    while let Ok(n) = reader.read_u64::<BigEndian>() {
-        result.push(n);
-    }
-    result
-}
-
-fn u64s_to_bytes(ints: &u64) -> Vec<u8> {
-    let mut result = Vec::new();
-    for n in ints {
-        result.write_u64::<BigEndian>(*n).unwrap();
-    }
-    result
-}
-
-impl Engine {
-    pub fn new(
-        name: String,
-        max_examples: u64,
-        phases: Vec<Phase>,
-        seed: &u32,
-        db: BoxedDatabase,
-    ) -> Engine {
-        let (send_local, recv_remote) = sync_channel(1);
-        let (send_remote, recv_local) = sync_channel(1);
-
-        let main_loop = MainGenerationLoop {
-            database: db,
-            name,
-            max_examples,
-            phases,
-            random: ChaChaRng::from_seed(seed),
-            sender: send_remote,
-            receiver: recv_remote,
-            best_example: None,
-            minimized_examples: HashMap::new(),
-            fully_minimized: HashSet::new(),
-            valid_examples: 0,
-            invalid_examples: 0,
-            interesting_examples: 0,
-        };
-
-        let handle = thread::Builder::new()
-            .name("Hypothesis main loop".to_string())
-            .spawn(move || {
-                main_loop.run();
-            })
-            .unwrap();
-
-        Engine {
-            loop_response: None,
-            sender: send_local,
-            receiver: recv_local,
-            handle: Some(handle),
-            state: EngineState::ReadyToProvide,
-        }
-    }
-
-    pub fn mark_finished(&mut self, source: DataSource, status: Status) {
-        self.consume_test_result(source.into_result(status))
-    }
-
-    pub fn next_source(&mut self) -> Option<DataSource> {
-        assert!(self.state == EngineState::ReadyToProvide);
-        self.state = EngineState::AwaitingCompletion;
-
-        self.await_loop_response();
-
-        let mut local_result = None;
-        mem::swap(&mut local_result, &mut self.loop_response);
-
-        match local_result {
-            Some(LoopCommand::RunThis(source)) => Some(source),
-            None => panic!("BUG: Loop response should not be empty at this point"),
-            _ => {
-                self.loop_response = local_result;
-                None
-            }
-        }
-    }
-
-    pub fn list_minimized_examples(&self) -> Vec<TestResult> {
-        match self.loop_response {
-            Some(LoopCommand::Finished(
-                _,
-                MainGenerationLoop {
-                    ref minimized_examples,
-                    ..
-                },
-            )) => {
-                let mut results: Vec<TestResult> = minimized_examples.values().cloned().collect();
-                results.sort();
-                results
-            }
-            _ => Vec::new(),
-        }
-    }
-
-    pub fn best_source(&self) -> Option<DataSource> {
-        match self.loop_response {
-            Some(LoopCommand::Finished(
-                _,
-                MainGenerationLoop {
-                    best_example: Some(ref result),
-                    ..
-                },
-            )) => Some(DataSource::from_vec(result.record.clone())),
-            _ => None,
-        }
-    }
-
-    fn consume_test_result(&mut self, result: TestResult) {
-        assert!(self.state == EngineState::AwaitingCompletion);
-        self.state = EngineState::ReadyToProvide;
-
-        if self.has_shutdown() {
-            return;
-        }
-
-        // NB: Deliberately not matching on result. If this fails,
-        // that's OK - it means the loop has shut down and when we ask
-        // for data from it we'll get its shutdown response.
-        let _ = self.sender.send(result);
-    }
-
-    pub fn was_unsatisfiable(&self) -> bool {
-        match self.loop_response {
-            Some(LoopCommand::Finished(_, ref main_loop)) => {
-                main_loop.interesting_examples == 0 && main_loop.valid_examples == 0
-            }
-            _ => false,
-        }
-    }
-
-    fn has_shutdown(&mut self) -> bool {
-        matches!(self.loop_response, Some(LoopCommand::Finished(..)))
-    }
-
-    fn await_thread_termination(&mut self) {
-        let mut maybe_handle = None;
-        mem::swap(&mut self.handle, &mut maybe_handle);
-        if let Some(handle) = maybe_handle {
-            if let Err(boxed_msg) = handle.join() {
-                // FIXME: This is awful but as far as I can tell this is
-                // genuinely the only way to get the actual message out of the
-                // panic in the child thread! It's boxed as an Any, and the
-                // debug of Any just says "Any". Fortunately the main loop is
-                // very much under our control so this doesn't matter too much
-                // here, but yuck!
-                if let Some(msg) = boxed_msg.downcast_ref::<&str>() {
-                    panic!(msg.to_string());
-                } else if let Some(msg) = boxed_msg.downcast_ref::<String>() {
-                    panic!(msg.clone());
-                } else {
-                    panic!("BUG: Unexpected panic format in main loop");
-                }
-            }
-        }
-    }
-
-    fn await_loop_response(&mut self) {
-        if self.loop_response.is_none() {
-            match self.receiver.recv() {
-                Ok(response) => {
-                    self.loop_response = Some(response);
-                    if self.has_shutdown() {
-                        self.await_thread_termination();
-                    }
-                }
-                Err(_) => {
-                    self.await_thread_termination();
-                    panic!("BUG: Unexpected silent termination of generation loop.")
-                }
-            }
-        }
-    }
-}
-
-#cfg(test)
-mod tests {
-    use super::*;
-    use crate::data::FailedDraw;
-    use crate::database::NoDatabase;
-
-    fn run_to_results<F>(mut f: F) -> Vec<TestResult>
-    where
-        F: FnMut(&mut DataSource) -> Result<Status, FailedDraw>,
-    {
-        let seed: u32; 2 = 0, 0;
-        let mut engine = Engine::new(
-            "run_to_results".to_string(),
-            1000,
-            Phase::all(),
-            &seed,
-            Box::new(NoDatabase),
-        );
-        while let Some(mut source) = engine.next_source() {
-            if let Ok(status) = f(&mut source) {
-                engine.mark_finished(source, status);
-            } else {
-                engine.mark_finished(source, Status::Overflow);
-            }
-        }
-        engine.list_minimized_examples()
-    }
-
-    #test
-    fn minimizes_all_examples() {
-        let results = run_to_results(|source| {
-            let n = source.bits(64)?;
-            if n >= 100 {
-                Ok(Status::Interesting(n % 2))
-            } else {
-                Ok(Status::Valid)
-            }
-        });
-
-        assert!(results.len() == 2);
-        assert_eq!(results0.record0, 100);
-        assert_eq!(results1.record0, 101);
-    }
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src/intminimize.rs Deleted

@@ -1,149 +0,0 @@
-use std::cmp::min;
-
-const SMALL: u64 = 5;
-
-struct Minimizer<'a, F> {
-    criterion: &'a mut F,
-    best: u64,
-}
-
-impl<'a, F, T> Minimizer<'a, F>
-where
-    F: 'a + FnMut(u64) -> Result<bool, T>,
-{
-    fn test(&mut self, candidate: u64) -> Result<bool, T> {
-        if candidate == self.best {
-            return Ok(true);
-        }
-        if candidate > self.best {
-            return Ok(false);
-        }
-        let result = (self.criterion)(candidate)?;
-        if result {
-            self.best = candidate;
-        }
-        Ok(result)
-    }
-
-    fn modify<G>(&mut self, g: G) -> Result<bool, T>
-    where
-        G: Fn(u64) -> u64,
-    {
-        let x = g(self.best);
-        self.test(x)
-    }
-}
-
-pub fn minimize_integer<F, T>(start: u64, mut criterion: F) -> Result<u64, T>
-where
-    F: FnMut(u64) -> Result<bool, T>,
-{
-    if start == 0 {
-        return Ok(start);
-    }
-
-    for i in 0..min(start, SMALL) {
-        if criterion(i)? {
-            return Ok(i);
-        }
-    }
-    if start <= SMALL {
-        return Ok(start);
-    }
-
-    let mut minimizer = Minimizer {
-        best: start,
-        criterion: &mut criterion,
-    };
-
-    loop {
-        if !minimizer.modify(|x| x >> 1)? {
-            break;
-        }
-    }
-
-    for i in 0..64 {
-        minimizer.modify(|x| x ^ (1 << i))?;
-    }
-
-    assert!(minimizer.best >= SMALL);
-
-    for i in 0..64 {
-        let left_mask = 1 << i;
-        let mut right_mask = left_mask >> 1;
-        while right_mask != 0 {
-            minimizer.modify(|x| {
-                if x & left_mask == 0 || x & right_mask != 0 {
-                    x
-                } else {
-                    x ^ (right_mask | left_mask)
-                }
-            })?;
-            right_mask >>= 1;
-        }
-    }
-
-    if !minimizer.modify(|x| x - 1)? {
-        return Ok(minimizer.best);
-    }
-
-    let mut lo = 0;
-    let mut hi = minimizer.best;
-    while lo + 1 < hi {
-        let mid = lo + (hi - lo) / 2;
-        if minimizer.test(mid)? {
-            hi = mid;
-        } else {
-            lo = mid;
-        }
-    }
-
-    Ok(minimizer.best)
-}
-
-#cfg(test)
-mod tests {
-    use super::*;
-
-    fn non_failing_minimize<F>(start: u64, criterion: F) -> u64
-    where
-        F: Fn(u64) -> bool,
-    {
-        let mut best = start;
-
-        loop {
-            let ran: Result<u64, ()> = minimize_integer(best, |x| Ok(criterion(x)));
-            let result = ran.unwrap();
-            assert!(result <= best);
-            if result == best {
-                return best;
-            }
-            best = result;
-        }
-    }
-
-    #test
-    fn minimize_down_to() {
-        let n = non_failing_minimize(100, |x| x >= 10);
-        assert_eq!(n, 10);
-    }
-
-    #test
-    fn unset_relevant_bits() {
-        let x = 0b101010101010;
-        let y = 0b111111111111;
-        let n = non_failing_minimize(y, |k| k & x == x);
-        assert_eq!(n, x);
-    }
-
-    #test
-    fn sort_bits() {
-        let x: u64 = 0b1011011011000111;
-        let y: u64 = 0b0000001111111111;
-        let c = x.count_ones();
-        assert_eq!(c, y.count_ones());
-
-        let n = non_failing_minimize(x, |k| k.count_ones() == c);
-        assert_eq!(y, n);
-    }
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/conjecture-rust/src/lib.rs Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/README.rst Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/api-style.rst Deleted

@@ -1,207 +0,0 @@
-===============
-House API Style
-===============
-
-Note: Currently this guide is very specific to the *Python* version of Hypothesis.
-It needs updating for the Ruby version (and, in future, other versions).
-
-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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/documentation.rst Deleted

@@ -1,91 +0,0 @@
-=====================================
-The Hypothesis Documentation Handbook
-=====================================
-
-Note: Currently this guide is very specific to the *Python* version of Hypothesis.
-It needs updating for the Ruby version (and, in future, other versions).
-
-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, or ``RELEASE.md`` for the Ruby and Rust
-versions.  Note that any change to ``conjecture-rust`` is automatically also
-and change for our Ruby package, and therefore requires *two* release files!
-
-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!

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/internals.rst Deleted

@@ -1,334 +0,0 @@
-===================================
-How to Work on Hypothesis Internals
-===================================
-
-Note: Currently this guide is very specific to the *Python* version of Hypothesis.
-Over time the core will be factored out into a small separate set of libraries -
-the current migration plan is to move all of the Python code into Rust and have
-the Python and Ruby versions both depend on this. Eventually we will likely need
-to have more than one core library - e.g. a Java one as well.
-
-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/cover/test_conjecture_engine.py <https://github.com/HypothesisWorks/hypothesis/blob/master/hypothesis-python/tests/cover/test_conjecture_engine.py>`_,
-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.intervalsi
-            if not self.incorporate_new_buffer(
-                self.shrink_target.buffer:u + self.shrink_target.bufferv:
-            ):
-                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.bufferv:
-            )
-
-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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/review.rst Deleted

@@ -1,320 +0,0 @@
-===================================
-The Hypothesis Code Review Handbook
-===================================
-
-Note: This review guide was written with the Python version in mind,
-but should apply to *all* versions. If you find a place where it's a bit
-too Python specific, please fix it or file an issue.
-
-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
------------------
-
-The repository includes Hypothesis implementations for multiple languages,
-which have different review requirements due to different levels of project
-maturity:
-
-- all changes to hypothesis-python and the language-independent build
-  infrastructure must be signed off by at least one person with write access to
-  the repo other than the author of the change. (These requirements will apply
-  to any Hypothesis implementations with a 1.0 release.)
-- changes by `DRMacIver <https://github.com/DRMacIver>`_ to hypothesis-ruby do
-  not require review, but will be posted as pull requests, often for long
-  enough that if someone wants to review and ask questions, they can.
-
-----------------
-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. Note that currently this only covers the API style for the Python
-   version. We are still figuring out the API style for the Ruby version.
-
-~~~~~~~~~
-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.
-
-Note that the same rules will apply to the Ruby and Rust packages from version
-1.0, but are more relaxed in practice while we are catching up with features
-that are already well proven in Python.
-
-~~~~~~~~~~~~~~~~~~~~~~
-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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/strategies-that-shrink.rst Deleted

@@ -1,264 +0,0 @@
-===================================
-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_example``.  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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/guides/testing-hypothesis.rst Deleted

@@ -1,55 +0,0 @@
-==================
-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 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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/.coveragerc Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/LICENSE.txt Deleted

@@ -1,382 +0,0 @@
-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.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/README.rst Deleted

@@ -1,59 +0,0 @@
-==========
-Hypothesis
-==========
-
-Hypothesis is an advanced testing library for Python. It lets you write tests which
-are parametrized by a source of examples, and then generates simple and comprehensible
-examples that make your tests fail. This lets you find more bugs in your code with less
-work.
-
-e.g.
-
-.. code-block:: python
-
-  @given(st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1))
-  def test_mean(xs):
-      assert min(xs) <= mean(xs) <= max(xs)
-
-.. code-block::
-
-  Falsifying example: test_mean(
-    xs=1.7976321109618856e+308, 6.102390043022755e+303
-  )
-
-Hypothesis is extremely practical and advances the state of the art of
-unit testing by some way. It's easy to use, stable, and powerful. If
-you're not using Hypothesis to test your project then you're missing out.
-
-------------------------
-Quick Start/Installation
-------------------------
-
-If you just want to get started:
-
-.. code-block::
-
-  pip install hypothesis
-
-
------------------
-Links of interest
------------------
-
-The main Hypothesis site is at `hypothesis.works <https://hypothesis.works/>`_, and contains a lot
-of good introductory and explanatory material.
-
-Extensive documentation and examples of usage are `available at readthedocs <https://hypothesis.readthedocs.io/en/latest/>`_.
-
-If you want to talk to people about using Hypothesis, `we have both an IRC channel
-and a mailing list <https://hypothesis.readthedocs.io/en/latest/community.html>`_.
-
-If you want to receive occasional updates about Hypothesis, including useful tips and tricks, there's a
-`TinyLetter mailing list to sign up for them <https://tinyletter.com/DRMacIver/>`_.
-
-If you want to contribute to Hypothesis, `instructions are here <https://github.com/HypothesisWorks/hypothesis-python/blob/master/CONTRIBUTING.rst>`_.
-
-If you want to hear from people who are already using Hypothesis, some of them `have written
-about it <https://hypothesis.readthedocs.io/en/latest/endorsements.html>`_.
-
-If you want to create a downstream package of Hypothesis, please read `these guidelines for packagers <https://hypothesis.readthedocs.io/en/latest/packaging.html>`_.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/_static Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/_static/.empty Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/changes.rst Deleted

@@ -1,12230 +0,0 @@
-=========
-Changelog
-=========
-
-This is a record of all past Hypothesis releases and what went into them,
-in reverse chronological order. All previous releases should still be available
-:pypi:`on PyPI <hypothesis>`.
-
-
-Hypothesis 6.x
-==============
-
-.. only:: has_release_file
-
-    --------------------
-    Current pull request
-    --------------------
-
-    .. include:: ../RELEASE.rst
-
-.. _v6.47.0:
-
--------------------
-6.47.0 - 2022-06-07
--------------------
-
-The :doc:`Ghostwritter <ghostwriter>` can now write tests for
-:obj:`@classmethod <classmethod>` or :obj:`@staticmethod <staticmethod>`
-methods, in addition to the existing support for functions and other callables
-(:issue:`3318`).  Thanks to Cheuk Ting Ho for the patch.
-
-.. _v6.46.11:
-
---------------------
-6.46.11 - 2022-06-02
---------------------
-
-Mention :func:`hypothesis.strategies.timezones`
-in the documentation of :func:`hypothesis.strategies.datetimes` for completeness.
-
-Thanks to George Macon for this addition.
-
-.. _v6.46.10:
-
---------------------
-6.46.10 - 2022-06-01
---------------------
-
-This release contains some small improvements to our documentation.
-Thanks to Felix Divo for his contribution!
-
-.. _v6.46.9:
-
--------------------
-6.46.9 - 2022-05-25
--------------------
-
-This patch by Adrian Garcia Badaracco adds type annotations
-to some private internals (:issue:`3074`).
-
-.. _v6.46.8:
-
--------------------
-6.46.8 - 2022-05-25
--------------------
-
-This patch by Phillip Schanely makes changes to the
-:func:`~hypothesis.strategies.floats` strategy when ``min_value`` or ``max_value`` is
-present.
-Hypothesis will now be capable of generating every representable value in the bounds.
-You may notice that hypothesis is more likely to test values near boundaries, and values
-that are very close to zero.
-
-These changes also support future integrations with symbolic execution tools and fuzzers
-(:issue:`3086`).
-
-.. _v6.46.7:
-
--------------------
-6.46.7 - 2022-05-19
--------------------
-
-This patch updates the type annotations for :func:`~hypothesis.strategies.tuples` and
-:func:`~hypothesis.strategies.one_of` so that type-checkers require its arguments to be
-positional-only, and so that it no longer fails under pyright-strict mode (see
-:issue:`3348`). Additional changes are made to Hypothesis' internals improve pyright
-scans.
-
-.. _v6.46.6:
-
--------------------
-6.46.6 - 2022-05-18
--------------------
-
-This patch by Cheuk Ting Ho adds support for :pep:`655` ``Required`` and ``NotRequired`` as attributes of
-:class:`~python:typing.TypedDict` in :func:`~hypothesis.strategies.from_type` (:issue:`3339`).
-
-.. _v6.46.5:
-
--------------------
-6.46.5 - 2022-05-15
--------------------
-
-This patch fixes :func:`~hypothesis.extra.numpy.from_dtype` with long-precision
-floating-point datatypes (typecode ``g``; see :func:`numpy:numpy.typename`).
-
-.. _v6.46.4:
-
--------------------
-6.46.4 - 2022-05-15
--------------------
-
-This patch improves some error messages for custom signatures
-containing invalid parameter names (:issue:`3317`).
-
-.. _v6.46.3:
-
--------------------
-6.46.3 - 2022-05-11
--------------------
-
-This patch by Cheuk Ting Ho makes it an explicit error to call :func:`~hypothesis.strategies.from_type`
-or :func:`~hypothesis.strategies.register_type_strategy` with types that have no runtime instances (:issue:`3280`).
-
-.. _v6.46.2:
-
--------------------
-6.46.2 - 2022-05-03
--------------------
-
-This patch fixes silently dropping examples when the :func:`@example <hypothesis.example>`
-decorator is applied to itself (:issue:`3319`).  This was always a weird pattern, but now it
-works.  Thanks to Ray Sogata, Keeri Tramm, and Kevin Khuong for working on this patch!
-
-.. _v6.46.1:
-
--------------------
-6.46.1 - 2022-05-01
--------------------
-
-This patch fixes a rare bug where we could incorrectly treat
-:obj:`~python:inspect.Parameter.empty` as a type annotation,
-if the callable had an explicitly assigned ``__signature__``.
-
-.. _v6.46.0:
-
--------------------
-6.46.0 - 2022-05-01
--------------------
-
-This release adds an ``allow_nil`` argument to :func:`~hypothesis.strategies.uuids`,
-which you can use to... generate the nil UUID.  Thanks to Shlok Gandhi for the patch!
-
-.. _v6.45.4:
-
--------------------
-6.45.4 - 2022-05-01
--------------------
-
-This patch fixes some missing imports for certain :doc:`Ghostwritten <ghostwriter>`
-tests.  Thanks to Mel Seto for fixing :issue:`3316`.
-
-.. _v6.45.3:
-
--------------------
-6.45.3 - 2022-04-30
--------------------
-
-This patch teaches :doc:`the Ghostwriter <ghostwriter>` to recognize
-many more common argument names (:issue:`3311`).
-
-.. _v6.45.2:
-
--------------------
-6.45.2 - 2022-04-29
--------------------
-
-This patch fixes :issue:`3314`, where Hypothesis would raise an internal
-error from :func:`~hypothesis.provisional.domains` or (only on Windows)
-from :func:`~hypothesis.strategies.timezones` in some rare circumstances
-where the installation was subtly broken.
-
-Thanks to Munir Abdinur for this contribution.
-
-.. _v6.45.1:
-
--------------------
-6.45.1 - 2022-04-27
--------------------
-
-This release fixes deprecation warnings about ``sre_compile`` and ``sre_parse``
-imports and ``importlib.resources`` usage when running Hypothesis on Python 3.11.
-
-Thanks to Florian Bruhin for this contribution.
-
-.. _v6.45.0:
-
--------------------
-6.45.0 - 2022-04-22
--------------------
-
-This release updates :func:`xps.indices` by introducing an ``allow_newaxis``
-argument, defaulting to ``False``. If ``allow_newaxis=True``, indices can be
-generated that add dimensions to arrays, which is achieved by the indexer
-containing ``None``. This change is to support a specification change that
-expand dimensions via indexing (`data-apis/array-api#408
-<https://github.com/data-apis/array-api/pull/408>`_).
-
-.. _v6.44.0:
-
--------------------
-6.44.0 - 2022-04-21
--------------------
-
-This release adds a ``names`` argument to :func:`~hypothesis.extra.pandas.indexes`
-and :func:`~hypothesis.extra.pandas.series`, so that you can create Pandas
-objects with specific or varied names.
-
-Contributed by Sam Watts.
-
-.. _v6.43.3:
-
--------------------
-6.43.3 - 2022-04-18
--------------------
-
-This patch updates the type annotations for :func:`@given <hypothesis.given>`
-so that type-checkers will warn on mixed positional and keyword arguments,
-as well as fixing :issue:`3296`.
-
-.. _v6.43.2:
-
--------------------
-6.43.2 - 2022-04-16
--------------------
-
-Fixed a type annotation for ``pyright --strict`` (:issue:`3287`).
-
-.. _v6.43.1:
-
--------------------
-6.43.1 - 2022-04-13
--------------------
-
-This patch makes it an explicit error to call
-:func:`~hypothesis.strategies.register_type_strategy` with a
-`Pydantic GenericModel <https://pydantic-docs.helpmanual.io/usage/models/#generic-models>`__
-and a callable, because ``GenericModel`` isn't actually a generic type at
-runtime and so you have to register each of the "parametrized versions"
-(actually subclasses!) manually.  See :issue:`2940` for more details.
-
-.. _v6.43.0:
-
--------------------
-6.43.0 - 2022-04-12
--------------------
-
-This release makes it an explicit error to apply
-:func:`@pytest.fixture <pytest:pytest.fixture>` to a function which has
-already been decorated with :func:`@given() <hypothesis.given>`.  Previously,
-``pytest`` would convert your test to a fixture, and then never run it.
-
-.. _v6.42.3:
-
--------------------
-6.42.3 - 2022-04-10
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` on a :class:`~python:typing.TypedDict`
-with complex annotations, defined in a file using ``from __future__ import annotations``.
-Thanks to Katelyn Gigante for identifying and fixing this bug!
-
-.. _v6.42.2:
-
--------------------
-6.42.2 - 2022-04-10
--------------------
-
-The Hypothesis pytest plugin was not outputting valid xunit2 nodes when
-``--junit-xml`` was specified. This has been broken since Pytest 5.4, which
-changed the internal API for adding nodes to the junit report.
-
-This also fixes the issue when using hypothesis with ``--junit-xml`` and
-``pytest-xdist`` where the junit xml report would not be xunit2 compatible.
-Now, when using with ``pytest-xdist``, the junit report will just omit the
-``<properties>`` node.
-
-For more details, see `this pytest issue <https://github.com/pytest-dev/pytest/issues/1126#issuecomment-484581283>`__,
-`this pytest issue <https://github.com/pytest-dev/pytest/issues/7767#issuecomment-1082436256>`__,
-and :issue:`1935`
-
-Thanks to Brandon Chinn for this bug fix!
-
-.. _v6.42.1:
-
--------------------
-6.42.1 - 2022-04-10
--------------------
-
-This patch fixes pretty-printing of regular expressions in Python 3.11.0a7, and
-updates our vendored `list of top-level domains <https://www.iana.org/domains/root/db>`__,.
-
-.. _v6.42.0:
-
--------------------
-6.42.0 - 2022-04-09
--------------------
-
-This release makes ``st.functions(pure=True)`` less noisy (:issue:`3253`),
-and generally improves pretty-printing of functions.
-
-.. _v6.41.0:
-
--------------------
-6.41.0 - 2022-04-01
--------------------
-
-This release changes the implementation of :const:`~hypothesis.infer` to be an alias
-for :obj:`python:Ellipsis`. E.g. ``@given(a=infer)`` is now equivalent to ``@given(a=...)``. Furthermore, ``@given(...)`` can now be specified so that
-:func:`@given <hypothesis.given>` will infer the strategies for *all* arguments of the
-decorated function based on its annotations.
-
-.. _v6.40.3:
-
--------------------
-6.40.3 - 2022-04-01
--------------------
-
-This patch simplifies the repr of the strategies namespace returned in
-:func:`~hypothesis.extra.array_api.make_strategies_namespace`, e.g.
-
-.. code-block:: pycon
-
-    >>> from hypothesis.extra.array_api import make_strategies_namespace
-    >>> from numpy import array_api as xp
-    >>> xps = make_strategies_namespace(xp)
-    >>> xps
-    make_strategies_namespace(numpy.array_api)
-
-.. _v6.40.2:
-
--------------------
-6.40.2 - 2022-04-01
--------------------
-
-Fixed :func:`~hypothesis.strategies.from_type` support for
-:pep:`604` union types, like ``int | None`` (:issue:`3255`).
-
-.. _v6.40.1:
-
--------------------
-6.40.1 - 2022-04-01
--------------------
-
-Fixed an internal error when ``given()`` was passed a lambda.
-
-.. _v6.40.0:
-
--------------------
-6.40.0 - 2022-03-29
--------------------
-
-:doc:`The Ghostwriter <ghostwriter>` can now write tests which check that
-two or more functions are equivalent on valid inputs, *or* raise the same
-type of exception for invalid inputs (:issue:`3267`).
-
-.. _v6.39.6:
-
--------------------
-6.39.6 - 2022-03-27
--------------------
-
-This patch makes some quality-of-life improvements to the
-:doc:`Ghostwriter <ghostwriter>`: we guess the :func:`~hypothesis.strategies.text`
-strategy for arguments named ``text`` (...obvious in hindsight, eh?);
-and improved the error message if you accidentally left in a
-:func:`~hypothesis.strategies.nothing` or broke your :pypi:`rich` install.
-
-.. _v6.39.5:
-
--------------------
-6.39.5 - 2022-03-26
--------------------
-
-This patch improves our error detection and message when Hypothesis is run
-on a Python implementation without support for ``-0.0``, which is required
-for the :func:`~hypothesis.strategies.floats` strategy but can be disabled by
-`unsafe compiler options <https://simonbyrne.github.io/notes/fastmath/>`__
-(:issue:`3265`).
-
-.. _v6.39.4:
-
--------------------
-6.39.4 - 2022-03-17
--------------------
-
-This patch tweaks some internal formatting.  There is no user-visible change.
-
-.. _v6.39.3:
-
--------------------
-6.39.3 - 2022-03-07
--------------------
-
-If the :obj:`~hypothesis.Phase.shrink` phase is disabled, we now stop the
-:obj:`~hypothesis.Phase.generate` phase as soon as an error is found regardless
-of the value of the ``report_multiple_examples`` setting, since that's
-probably what you wanted (:issue:`3244`).
-
-.. _v6.39.2:
-
--------------------
-6.39.2 - 2022-03-07
--------------------
-
-This patch clarifies rare error messages in
-:func:`~hypothesis.strategies.builds` (:issue:`3225`) and
-:func:`~hypothesis.strategies.floats` (:issue:`3207`).
-
-.. _v6.39.1:
-
--------------------
-6.39.1 - 2022-03-03
--------------------
-
-This patch fixes a regression where the bound inner function
-(``your_test.hypothesis.inner_test``) would be invoked with positional
-arguments rather than passing them by name, which broke
-:pypi:`pytest-asyncio` (:issue:`3245`).
-
-.. _v6.39.0:
-
--------------------
-6.39.0 - 2022-03-01
--------------------
-
-This release improves Hypothesis' handling of positional-only arguments,
-which are now allowed :func:`@st.composite <hypothesis.strategies.composite>`
-strategies.
-
-On Python 3.8 and later, the first arguments to :func:`~hypothesis.strategies.builds`
-and :func:`~hypothesis.extra.django.from_model` are now natively positional-only.
-In cases which were already errors, the ``TypeError`` from incorrect usage will
-therefore be raises immediately when the function is called, rather than when
-the strategy object is used.
-
-.. _v6.38.0:
-
--------------------
-6.38.0 - 2022-02-26
--------------------
-
-This release makes :func:`~hypothesis.strategies.floats` error *consistently* when
-your floating-point hardware has been configured to violate IEEE-754 for
-:wikipedia:`subnormal numbers <Subnormal_number>`, instead of
-only when an internal assertion was tripped (:issue:`3092`).
-
-If this happens to you, passing ``allow_subnormal=False`` will suppress the explicit
-error.  However, we strongly recommend fixing the root cause by disabling global-effect
-unsafe-math compiler options instead, or at least consulting e.g. Simon Byrne's
-`Beware of fast-math <https://simonbyrne.github.io/notes/fastmath/>`__ explainer first.
-
-.. _v6.37.2:
-
--------------------
-6.37.2 - 2022-02-21
--------------------
-
-This patch fixes a bug in stateful testing, where returning a single value
-wrapped in :func:`~hypothesis.stateful.multiple` would be printed such that
-the assigned variable was a tuple rather than the single element
-(:issue:`3236`).
-
-.. _v6.37.1:
-
--------------------
-6.37.1 - 2022-02-21
--------------------
-
-This patch fixes a warning under :pypi:`pytest` 7 relating to our
-rich traceback display logic (:issue:`3223`).
-
-.. _v6.37.0:
-
--------------------
-6.37.0 - 2022-02-18
--------------------
-
-When distinguishing multiple errors, Hypothesis now looks at the inner
-exceptions of :pep:`654` ``ExceptionGroup``\ s.
-
-.. _v6.36.2:
-
--------------------
-6.36.2 - 2022-02-13
--------------------
-
-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.36.1:
-
--------------------
-6.36.1 - 2022-01-31
--------------------
-
-This patch fixes some deprecation warnings from :pypi:`pytest` 7.0,
-along with some code formatting and docs updates.
-
-.. _v6.36.0:
-
--------------------
-6.36.0 - 2022-01-19
--------------------
-
-This release disallows using :obj:`python:typing.Final`
-with :func:`~hypothesis.strategies.from_type`
-and :func:`~hypothesis.strategies.register_type_strategy`.
-
-Why?
-Because ``Final`` can only be used during ``class`` definition.
-We don't generate class attributes.
-
-It also does not make sense as a runtime type on its own.
-
-.. _v6.35.1:
-
--------------------
-6.35.1 - 2022-01-17
--------------------
-
-This patch fixes ``hypothesis write`` output highlighting with :pypi:`rich`
-version 12.0 and later.
-
-.. _v6.35.0:
-
--------------------
-6.35.0 - 2022-01-08
--------------------
-
-This release disallows using :obj:`python:typing.ClassVar`
-with :func:`~hypothesis.strategies.from_type`
-and :func:`~hypothesis.strategies.register_type_strategy`.
-
-Why?
-Because ``ClassVar`` can only be used during ``class`` definition.
-We don't generate class attributes.
-
-It also does not make sense as a runtime type on its own.
-
-.. _v6.34.2:
-
--------------------
-6.34.2 - 2022-01-05
--------------------
-
-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.34.1:
-
--------------------
-6.34.1 - 2021-12-31
--------------------
-
-This patch fixes :issue:`3169`, an extremely rare bug which would
-trigger if an internal least-recently-reused cache dropped a newly
-added entry immediately after it was added.
-
-.. _v6.34.0:
-
--------------------
-6.34.0 - 2021-12-31
--------------------
-
-This release fixes :issue:`3133` and :issue:`3144`, where attempting
-to generate Pandas series of lists or sets would fail with confusing
-errors if you did not specify ``dtype=object``.
-
-.. _v6.33.0:
-
--------------------
-6.33.0 - 2021-12-30
--------------------
-
-This release disallows using :obj:`python:typing.TypeAlias`
-with :func:`~hypothesis.strategies.from_type`
-and :func:`~hypothesis.strategies.register_type_strategy`.
-
-Why? Because ``TypeAlias`` is not really a type,
-it is a tag for type checkers that some expression is a type alias,
-not something else.
-
-It does not make sense for Hypothesis to resolve it as a strategy.
-References :issue:`2978`.
-
-.. _v6.32.1:
-
--------------------
-6.32.1 - 2021-12-23
--------------------
-
-This patch updates our autoformatting tools, improving our code style without any API changes.
-
-.. _v6.32.0:
-
--------------------
-6.32.0 - 2021-12-23
--------------------
-
-This release drops support for Python 3.6, which `reached end of life upstream
-<https://devguide.python.org/#status-of-python-branches>`__ on 2021-12-23.
-
-.. _v6.31.6:
-
--------------------
-6.31.6 - 2021-12-15
--------------------
-
-This patch adds a temporary hook for a downstream tool,
-which is not part of the public API.
-
-.. _v6.31.5:
-
--------------------
-6.31.5 - 2021-12-14
--------------------
-
-This release updates our copyright headers to `use a general authorship statement and omit the year
-<https://www.linuxfoundation.org/blog/copyright-notices-in-open-source-software-projects/>`__.
-
-.. _v6.31.4:
-
--------------------
-6.31.4 - 2021-12-11
--------------------
-
-This patch makes the ``.example()`` method more representative of
-test-time data generation, albeit often at a substantial cost to
-readability (:issue:`3182`).
-
-.. _v6.31.3:
-
--------------------
-6.31.3 - 2021-12-10
--------------------
-
-This patch improves annotations on some of Hypothesis' internal functions, in order to
-deobfuscate the signatures of some strategies. In particular, strategies shared between
-:ref:`hypothesis.extra.numpy <hypothesis-numpy>` and
-:ref:`the hypothesis.extra.array_api extra <array-api>` will benefit from this patch.
-
-.. _v6.31.2:
-
--------------------
-6.31.2 - 2021-12-10
--------------------
-
-This patch fix invariants display in stateful falsifying examples (:issue:`3185`).
-
-.. _v6.31.1:
-
--------------------
-6.31.1 - 2021-12-10
--------------------
-
-This patch updates :func:`xps.indices` so no flat indices are generated, i.e.
-generated indices will now always explicitly cover each axes of an array if no
-ellipsis is present. This is to be consistent with a specification change that
-dropped support for flat indexing
-(`#272 <https://github.com/data-apis/array-api/pull/272>`_).
-
-.. _v6.31.0:
-
--------------------
-6.31.0 - 2021-12-09
--------------------
-
-This release makes us compatible with :pypi:`Django` 4.0, in particular by adding
-support for use of :mod:`zoneinfo` timezones (though we respect the new
-``USE_DEPRECATED_PYTZ`` setting if you need it).
-
-.. _v6.30.1:
-
--------------------
-6.30.1 - 2021-12-05
--------------------
-
-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.30.0:
-
--------------------
-6.30.0 - 2021-12-03
--------------------
-
-This release adds an ``allow_subnormal`` argument to the
-:func:`~hypothesis.strategies.floats` strategy, which can explicitly toggle the
-generation of :wikipedia:`subnormal floats <Subnormal_number>` (:issue:`3155`).
-Disabling such generation is useful when testing flush-to-zero builds of
-libraries.
-
-:func:`nps.from_dtype() <hypothesis.extra.numpy.from_dtype>` and
-:func:`xps.from_dtype` can also accept the ``allow_subnormal`` argument, and
-:func:`xps.from_dtype` or :func:`xps.arrays` will disable subnormals by default
-if the array module ``xp`` is detected to flush-to-zero (like is typical with
-CuPy).
-
-.. _v6.29.3:
-
--------------------
-6.29.3 - 2021-12-02
--------------------
-
-This patch fixes a bug in :func:`~hypothesis.extra.numpy.mutually_broadcastable_shapes`,
-which restricted the patterns of singleton dimensions that could be generated for
-dimensions that extended beyond ``base_shape`` (:issue:`3170`).
-
-.. _v6.29.2:
-
--------------------
-6.29.2 - 2021-12-02
--------------------
-
-This patch clarifies our pretty-printing of DataFrames (:issue:`3114`).
-
-.. _v6.29.1:
-
--------------------
-6.29.1 - 2021-12-02
--------------------
-
-This patch documents :func:`~hypothesis.strategies.timezones`
-`Windows-only requirement <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__
-for the :pypi:`tzdata` package, and ensures that
-``pip install hypothesiszoneinfo`` will install the latest version.
-
-.. _v6.29.0:
-
--------------------
-6.29.0 - 2021-11-29
--------------------
-
-This release teaches :func:`~hypothesis.strategies.builds` to use
-:func:`~hypothesis.strategies.deferred` when resolving unrecognised type hints,
-so that you can conveniently register strategies for recursive types
-with constraints on some arguments (:issue:`3026`):
-
-.. code-block:: python
-
-    class RecursiveClass:
-        def __init__(self, value: int, next_node: typing.Optional"SomeClass"):
-            assert value > 0
-            self.value = value
-            self.next_node = next_node
-
-
-    st.register_type_strategy(
-        RecursiveClass, st.builds(RecursiveClass, value=st.integers(min_value=1))
-    )
-
-.. _v6.28.1:
-
--------------------
-6.28.1 - 2021-11-28
--------------------
-
-This release fixes some internal calculations related to collection sizes (:issue:`3143`).
-
-.. _v6.28.0:
-
--------------------
-6.28.0 - 2021-11-28
--------------------
-
-This release modifies our :pypi:`pytest` plugin, to avoid importing Hypothesis
-and therefore triggering :ref:`Hypothesis' entry points <entry-points>` for
-test suites where Hypothesis is installed but not actually used (:issue:`3140`).
-
-.. _v6.27.3:
-
--------------------
-6.27.3 - 2021-11-28
--------------------
-
-This release fixes :issue:`3080`, where :func:`~hypothesis.strategies.from_type`
-failed on unions containing :pep:`585` builtin generic types (like ``listint``)
-in Python 3.9 and later.
-
-.. _v6.27.2:
-
--------------------
-6.27.2 - 2021-11-26
--------------------
-
-This patch makes the :command:`hypothesis codemod`
-:ref:`command <hypothesis-cli>` somewhat faster.
-
-.. _v6.27.1:
-
--------------------
-6.27.1 - 2021-11-22
--------------------
-
-This patch changes the backing datastructures of :func:`~hypothesis.register_random`
-and a few internal caches to use :class:`weakref.WeakKeyDictionary`.  This reduces
-memory usage and may improve performance when registered :class:`~random.Random`
-instances are only used for a subset of your tests (:issue:`3131`).
-
-.. _v6.27.0:
-
--------------------
-6.27.0 - 2021-11-22
--------------------
-
-This release teaches Hypothesis' multiple-error reporting to format tracebacks
-using :pypi:`pytest` or :pypi:`better-exceptions`, if they are installed and
-enabled (:issue:`3116`).
-
-.. _v6.26.0:
-
--------------------
-6.26.0 - 2021-11-21
--------------------
-
-Did you know that of the 2\ :superscript:`64` possible floating-point numbers,
-2\ :superscript:`53` of them are ``nan`` - and Python prints them all the same way?
-
-While nans *usually* have all zeros in the sign bit and mantissa, this
-`isn't always true <https://wingolog.org/archives/2011/05/18/value-representation-in-javascript-implementations>`__,
-and :wikipedia:`'signaling' nans might trap or error <https://en.wikipedia.org/wiki/NaN#Signaling_NaN>`.
-To help distinguish such errors in e.g. CI logs, Hypothesis now prints ``-nan`` for
-negative nans, and adds a comment like ``# Saw 3 signaling NaNs`` if applicable.
-
-.. _v6.25.0:
-
--------------------
-6.25.0 - 2021-11-19
--------------------
-
-This release adds special filtering logic to make a few special cases
-like ``s.map(lambda x: x)`` and ``lists().filter(len)`` more efficient
-(:issue:`2701`).
-
-.. _v6.24.6:
-
--------------------
-6.24.6 - 2021-11-18
--------------------
-
-This patch makes :func:`~hypothesis.strategies.floats` generate
-:wikipedia:`"subnormal" floating point numbers <Subnormal_number>`
-more often, as these rare values can have strange interactions with
-`unsafe compiler optimisations like -ffast-math
-<https://simonbyrne.github.io/notes/fastmath/#flushing_subnormals_to_zero>`__
-(:issue:`2976`).
-
-.. _v6.24.5:
-
--------------------
-6.24.5 - 2021-11-16
--------------------
-
-This patch fixes a rare internal error in the :func:`~hypothesis.strategies.datetimes`
-strategy, where the implementation of ``allow_imaginary=False`` crashed when checking
-a time during the skipped hour of a DST transition *if* the DST offset is negative -
-only true of ``Europe/Dublin``, who we presume have their reasons - and the ``tzinfo``
-object is a :pypi:`pytz` timezone (which predates :pep:`495`).
-
-.. _v6.24.4:
-
--------------------
-6.24.4 - 2021-11-15
--------------------
-
-This patch gives Hypothesis it's own internal :class:`~random.Random` instance,
-ensuring that test suites which reset the global random state don't induce
-weird correlations between property-based tests (:issue:`2135`).
-
-.. _v6.24.3:
-
--------------------
-6.24.3 - 2021-11-13
--------------------
-
-This patch updates documentation of :func:`~hypothesis.note`
-(:issue:`3147`).
-
-.. _v6.24.2:
-
--------------------
-6.24.2 - 2021-11-05
--------------------
-
-This patch updates internal testing for the :ref:`Array API extra <array-api>`
-to be consistent with new specification changes: ``sum()`` not accepting
-boolean arrays (`#234 <https://github.com/data-apis/array-api/pull/234>`_),
-``unique()`` split into separate functions
-(`#275 <https://github.com/data-apis/array-api/pull/275>`_), and treating NaNs
-as distinct (`#310 <https://github.com/data-apis/array-api/pull/310>`_). It has
-no user visible impact.
-
-.. _v6.24.1:
-
--------------------
-6.24.1 - 2021-11-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.24.0:
-
--------------------
-6.24.0 - 2021-10-23
--------------------
-
-This patch updates our vendored `list of top-level domains
-<https://data.iana.org/TLD/tlds-alpha-by-domain.txt>`__, which is used
-by the provisional :func:`~hypothesis.provisional.domains` strategy.
-
-(did you know that gTLDs can be both `added <https://newgtlds.icann.org/en/>`__
-and `removed <https://www.icann.org/resources/pages/gtld-registry-agreement-termination-2015-10-09-en>`__?)
-
-.. _v6.23.4:
-
--------------------
-6.23.4 - 2021-10-20
--------------------
-
-This patch adds an error for when ``shapes`` in :func:`xps.arrays()` is not
-passed as either a valid shape or strategy.
-
-.. _v6.23.3:
-
--------------------
-6.23.3 - 2021-10-18
--------------------
-
-This patch updates our formatting with :pypi:`shed`.
-
-.. _v6.23.2:
-
--------------------
-6.23.2 - 2021-10-08
--------------------
-
-This patch replaces external links to :doc:`NumPy <numpy:index>` API docs
-with :mod:`sphinx.ext.intersphinx` cross-references. It is purely a documentation improvement.
-
-.. _v6.23.1:
-
--------------------
-6.23.1 - 2021-09-29
--------------------
-
-This patch cleans up internal logic for :func:`xps.arrays()`. There is no
-user-visible change.
-
-.. _v6.23.0:
-
--------------------
-6.23.0 - 2021-09-26
--------------------
-
-This release follows :pypi:`pytest` in considering :class:`SystemExit` and
-:class:`GeneratorExit` exceptions to be test failures, meaning that we will
-shink to minimal examples and check for flakiness even though they subclass
-:class:`BaseException` directly (:issue:`2223`).
-
-:class:`KeyboardInterrupt` continues to interrupt everything, and will be
-re-raised immediately.
-
-.. _v6.22.0:
-
--------------------
-6.22.0 - 2021-09-24
--------------------
-
-This release adds :class:`~hypothesis.extra.django.LiveServerTestCase` and
-:class:`~hypothesis.extra.django.StaticLiveServerTestCase` for django test.
-Thanks to Ivan Tham for this feature!
-
-.. _v6.21.6:
-
--------------------
-6.21.6 - 2021-09-19
--------------------
-
-This patch fixes some new linter warnings such as :pypi:`flake8-bugbear`'s
-``B904`` for explicit exception chaining, so tracebacks might be a bit nicer.
-
-.. _v6.21.5:
-
--------------------
-6.21.5 - 2021-09-16
--------------------
-
-This release fixes ``None`` being inferred as the float64 dtype in
-:func:`~xps.from_dtype()` and :func:`~xps.arrays()` from the
-:ref:`Array API extra <array-api>`.
-
-.. _v6.21.4:
-
--------------------
-6.21.4 - 2021-09-16
--------------------
-
-This release fixes the type hint for the
-:func:`@given() <hypothesis.given>` decorator
-when decorating an ``async`` function (:issue:`3099`).
-
-.. _v6.21.3:
-
--------------------
-6.21.3 - 2021-09-15
--------------------
-
-This release improves Ghostwritten tests for builtins (:issue:`2977`).
-
-.. _v6.21.2:
-
--------------------
-6.21.2 - 2021-09-15
--------------------
-
-This release deprecates use of both ``min_dims > len(shape)`` and
-``max_dims > len(shape)`` when ``allow_newaxis == False`` in
-:func:`~hypothesis.extra.numpy.basic_indices` (:issue:`3091`).
-
-.. _v6.21.1:
-
--------------------
-6.21.1 - 2021-09-13
--------------------
-
-This release improves the behaviour of :func:`~hypothesis.strategies.builds`
-and :func:`~hypothesis.strategies.from_type` in certain situations involving
-decorators (:issue:`2495` and :issue:`3029`).
-
-.. _v6.21.0:
-
--------------------
-6.21.0 - 2021-09-11
--------------------
-
-This release introduces strategies for array/tensor libraries adopting the
-`Array API standard <https://data-apis.org/>`__ (:issue:`3037`).
-They are available in :ref:`the hypothesis.extra.array_api extra <array-api>`,
-and work much like the existing :doc:`strategies for NumPy <numpy>`.
-
-.. _v6.20.1:
-
--------------------
-6.20.1 - 2021-09-10
--------------------
-
-This patch fixes :issue:`961`, where calling ``given()`` inline on a
-bound method would fail to handle the ``self`` argument correctly.
-
-.. _v6.20.0:
-
--------------------
-6.20.0 - 2021-09-09
--------------------
-
-This release allows :func:`~hypothesis.strategies.slices` to generate ``step=None``,
-and fixes an off-by-one error where the ``start`` index could be equal to ``size``.
-This works fine for all Python sequences and Numpy arrays, but is undefined behaviour
-in the `Array API standard <https://data-apis.org/>`__ (see :pull:`3065`).
-
-.. _v6.19.0:
-
--------------------
-6.19.0 - 2021-09-08
--------------------
-
-This release makes :doc:`stateful testing <stateful>` more likely to tell you
-if you do something unexpected and unsupported:
-
-- The :obj:`~hypothesis.HealthCheck.return_value` health check now applies to
-  :func:`~hypothesis.stateful.rule` and :func:`~hypothesis.stateful.initialize`
-  rules, if they don't have ``target`` bundles, as well as
-  :func:`~hypothesis.stateful.invariant`.
-- Using a :func:`~hypothesis.stateful.consumes` bundle as a ``target`` is
-  deprecated, and will be an error in a future version.
-
-If existing code triggers these new checks, check for related bugs and
-misunderstandings - these patterns *never* had any effect.
-
-.. _v6.18.0:
-
--------------------
-6.18.0 - 2021-09-06
--------------------
-
-This release teaches :func:`~hypothesis.strategies.from_type` a neat trick:
-when resolving an :obj:`python:typing.Annotated` type, if one of the annotations
-is a strategy object we use that as the inferred strategy.  For example:
-
-.. code-block:: python
-
-    PositiveInt = Annotatedint, st.integers(min_value=1)
-
-If there are multiple strategies, we use the last outer-most annotation.
-See :issue:`2978` and :pull:`3082` for discussion.
-
-*Requires Python 3.9 or later for*
-:func:`get_type_hints(..., include_extras=False) <typing.get_type_hints>`.
-
-.. _v6.17.4:
-
--------------------
-6.17.4 - 2021-08-31
--------------------
-
-This patch makes unique :func:`~hypothesis.extra.numpy.arrays` much more
-efficient, especially when there are only a few valid elements - such as
-for eight-bit integers (:issue:`3066`).
-
-.. _v6.17.3:
-
--------------------
-6.17.3 - 2021-08-30
--------------------
-
-This patch fixes the repr of :func:`~hypothesis.extra.numpy.array_shapes`.
-
-.. _v6.17.2:
-
--------------------
-6.17.2 - 2021-08-30
--------------------
-
-This patch wraps some internal helper code in our proxies decorator to prevent
-mutations of method docstrings carrying over to other instances of the respective
-methods.
-
-.. _v6.17.1:
-
--------------------
-6.17.1 - 2021-08-29
--------------------
-
-This patch moves some internal helper code in preparation for :issue:`3065`.
-There is no user-visible change, unless you depended on undocumented internals.
-
-.. _v6.17.0:
-
--------------------
-6.17.0 - 2021-08-27
--------------------
-
-This release adds type annotations to the :doc:`stateful testing <stateful>` API.
-
-Thanks to Ruben Opdebeeck for this contribution!
-
-.. _v6.16.0:
-
--------------------
-6.16.0 - 2021-08-27
--------------------
-
-This release adds the :class:`~hypothesis.strategies.DrawFn` type as a reusable
-type hint for the ``draw`` argument of
-:func:`@composite <hypothesis.strategies.composite>` functions.
-
-Thanks to Ruben Opdebeeck for this contribution!
-
-.. _v6.15.0:
-
--------------------
-6.15.0 - 2021-08-22
--------------------
-
-This release emits a more useful error message when :func:`@given() <hypothesis.given>`
-is applied to a coroutine function, i.e. one defined using ``async def`` (:issue:`3054`).
-
-This was previously only handled by the generic :obj:`~hypothesis.HealthCheck.return_value`
-health check, which doesn't direct you to use either :ref:`a custom executor <custom-function-execution>`
-or a library such as :pypi:`pytest-trio` or :pypi:`pytest-asyncio` to handle it for you.
-
-.. _v6.14.9:
-
--------------------
-6.14.9 - 2021-08-20
--------------------
-
-This patch fixes a regression in Hypothesis 6.14.8, where :func:`~hypothesis.strategies.from_type`
-failed to resolve types which inherit from multiple parametrised generic types,
-affecting the :pypi:`returns` package (:issue:`3060`).
-
-.. _v6.14.8:
-
--------------------
-6.14.8 - 2021-08-16
--------------------
-
-This patch ensures that registering a strategy for a subclass of a a parametrised
-generic type such as ``class Lines(Sequencestr):`` will not "leak" into unrelated
-strategies such as ``st.from_type(Sequenceint)`` (:issue:`2951`).
-Unfortunately this fix requires :pep:`560`, meaning Python 3.7 or later.
-
-.. _v6.14.7:
-
--------------------
-6.14.7 - 2021-08-14
--------------------
-
-This patch fixes :issue:`3050`, where :pypi:`attrs` classes could
-cause an internal error in the :doc:`ghostwriter <ghostwriter>`.
-
-.. _v6.14.6:
-
--------------------
-6.14.6 - 2021-08-07
--------------------
-
-This patch improves the error message for :issue:`3016`, where :pep:`585`
-builtin generics with self-referential forward-reference strings cannot be
-resolved to a strategy by :func:`~hypothesis.strategies.from_type`.
-
-.. _v6.14.5:
-
--------------------
-6.14.5 - 2021-07-27
--------------------
-
-This patch fixes ``hypothesis.strategies._internal.types.is_a_new_type``.
-It was failing on Python ``3.10.0b4``, where ``NewType`` is a function.
-
-.. _v6.14.4:
-
--------------------
-6.14.4 - 2021-07-26
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` and
-:func:`~hypothesis.strategies.register_type_strategy` for
-:obj:`python:typing.NewType` on Python 3.10, which changed the
-underlying implementation (see :bpo:`44353` for details).
-
-.. _v6.14.3:
-
--------------------
-6.14.3 - 2021-07-18
--------------------
-
-This patch updates our autoformatting tools, improving our code style without any API changes.
-
-.. _v6.14.2:
-
--------------------
-6.14.2 - 2021-07-12
--------------------
-
-This patch ensures that we shorten tracebacks for tests which fail due
-to inconsistent data generation between runs (i.e. raise ``Flaky``).
-
-.. _v6.14.1:
-
--------------------
-6.14.1 - 2021-07-02
--------------------
-
-This patch updates some internal type annotations.
-There is no user-visible change.
-
-.. _v6.14.0:
-
--------------------
-6.14.0 - 2021-06-09
--------------------
-
-The :ref:`explain phase <phases>` now requires shrinking to be enabled,
-and will be automatically skipped for deadline-exceeded errors.
-
-.. _v6.13.14:
-
---------------------
-6.13.14 - 2021-06-04
---------------------
-
-This patch improves the :func:`~hypothesis.strategies.tuples` strategy
-type annotations, to preserve the element types for up to length-five
-tuples (:issue:`3005`).
-
-As for :func:`~hypothesis.strategies.one_of`, this is the best we can do
-before a `planned extension <https://mail.python.org/archives/list/typing-sig@python.org/thread/LOQFV3IIWGFDB7F5BDX746EZJG4VVBI3/>`__
-to :pep:`646` is released, hopefully in Python 3.11.
-
-.. _v6.13.13:
-
---------------------
-6.13.13 - 2021-06-04
---------------------
-
-This patch teaches :doc:`the Ghostwriter <ghostwriter>` how to find
-:doc:`custom ufuncs <numpy:reference/ufuncs>` from *any* module that defines them,
-and that ``yaml.unsafe_load()`` does not undo ``yaml.safe_load()``.
-
-.. _v6.13.12:
-
---------------------
-6.13.12 - 2021-06-03
---------------------
-
-This patch reduces the amount of internal code excluded from our test suite's
-code coverage checks.
-
-There is no user-visible change.
-
-.. _v6.13.11:
-
---------------------
-6.13.11 - 2021-06-02
---------------------
-
-This patch removes some old internal helper code that previously existed
-to make Python 2 compatibility easier.
-
-There is no user-visible change.
-
-.. _v6.13.10:
-
---------------------
-6.13.10 - 2021-05-30
---------------------
-
-This release adjusts some internal code to help make our test suite more
-reliable.
-
-There is no user-visible change.
-
-.. _v6.13.9:
-
--------------------
-6.13.9 - 2021-05-30
--------------------
-
-This patch cleans up some internal code related to filtering strategies.
-
-There is no user-visible change.
-
-.. _v6.13.8:
-
--------------------
-6.13.8 - 2021-05-28
--------------------
-
-This patch slightly improves the performance of some internal code for
-generating integers.
-
-.. _v6.13.7:
-
--------------------
-6.13.7 - 2021-05-27
--------------------
-
-This patch fixes a bug in :func:`~hypothesis.strategies.from_regex` that
-caused ``from_regex("", fullmatch=True)`` to unintentionally generate non-empty
-strings (:issue:`4982`).
-
-The only strings that completely match an empty regex pattern are empty
-strings.
-
-.. _v6.13.6:
-
--------------------
-6.13.6 - 2021-05-26
--------------------
-
-This patch fixes a bug that caused :func:`~hypothesis.strategies.integers`
-to shrink towards negative values instead of positive values in some cases.
-
-.. _v6.13.5:
-
--------------------
-6.13.5 - 2021-05-24
--------------------
-
-This patch fixes rare cases where ``hypothesis write --binary-op`` could
-print :doc:`reproducing instructions <reproducing>` from the internal
-search for an identity element.
-
-.. _v6.13.4:
-
--------------------
-6.13.4 - 2021-05-24
--------------------
-
-This patch removes some unnecessary intermediate list-comprehensions,
-using the latest versions of :pypi:`pyupgrade` and :pypi:`shed`.
-
-.. _v6.13.3:
-
--------------------
-6.13.3 - 2021-05-23
--------------------
-
-This patch adds a ``.hypothesis`` property to invalid test functions, bringing
-them inline with valid tests and fixing a bug where :pypi:`pytest-asyncio` would
-swallow the real error message and mistakenly raise a version incompatibility
-error.
-
-.. _v6.13.2:
-
--------------------
-6.13.2 - 2021-05-23
--------------------
-
-Some of Hypothesis's numpy/pandas strategies use a ``fill`` argument to speed
-up generating large arrays, by generating a single fill value and sharing that
-value among many array slots instead of filling every single slot individually.
-
-When no ``fill`` argument is provided, Hypothesis tries to detect whether it is
-OK to automatically use the ``elements`` argument as a fill strategy, so that
-it can still use the faster approach.
-
-This patch fixes a bug that would cause that optimization to trigger in some
-cases where it isn't 100% guaranteed to be OK.
-
-If this makes some of your numpy/pandas tests run more slowly, try adding an
-explicit ``fill`` argument to the relevant strategies to ensure that Hypothesis
-always uses the faster approach.
-
-.. _v6.13.1:
-
--------------------
-6.13.1 - 2021-05-20
--------------------
-
-This patch strengthens some internal import-time consistency checks for the
-built-in strategies.
-
-There is no user-visible change.
-
-.. _v6.13.0:
-
--------------------
-6.13.0 - 2021-05-18
--------------------
-
-This release adds URL fragment generation to the :func:`~hypothesis.provisional.urls`
-strategy (:issue:`2908`). Thanks to Pax (R. Margret) for contributing this patch at the
-`PyCon US Mentored Sprints <https://us.pycon.org/2021/summits/mentored-sprints/>`__!
-
-.. _v6.12.1:
-
--------------------
-6.12.1 - 2021-05-17
--------------------
-
-This patch fixes :issue:`2964`, where ``.map()`` and ``.filter()`` methods
-were omitted from the ``repr()`` of :func:`~hypothesis.strategies.just` and
-:func:`~hypothesis.strategies.sampled_from` strategies, since
-:ref:`version 5.43.7 <v5.43.7>`.
-
-.. _v6.12.0:
-
--------------------
-6.12.0 - 2021-05-06
--------------------
-
-This release automatically rewrites some simple filters, such as
-``integers().filter(lambda x: x > 9)`` to the more efficient
-``integers(min_value=10)``, based on the AST of the predicate.
-
-We continue to recommend using the efficient form directly wherever
-possible, but this should be useful for e.g. :pypi:`pandera` "``Checks``"
-where you already have a simple predicate and translating manually
-is really annoying.  See :issue:`2701` for ideas about floats and
-simple text strategies.
-
-.. _v6.11.0:
-
--------------------
-6.11.0 - 2021-05-06
--------------------
-
-:func:`hypothesis.target` now returns the ``observation`` value,
-allowing it to be conveniently used inline in expressions such as
-``assert target(abs(a - b)) < 0.1``.
-
-.. _v6.10.1:
-
--------------------
-6.10.1 - 2021-04-26
--------------------
-
-This patch fixes a deprecation warning if you're using recent versions
-of :pypi:`importlib-metadata` (:issue:`2934`), which we use to load
-:ref:`third-party plugins <entry-points>` such as `Pydantic's integration
-<https://pydantic-docs.helpmanual.io/hypothesis_plugin/>`__.
-On older versions of :pypi:`importlib-metadata`, there is no change and
-you don't need to upgrade.
-
-.. _v6.10.0:
-
--------------------
-6.10.0 - 2021-04-17
--------------------
-
-This release teaches the :doc:`Ghostwriter <ghostwriter>` to read parameter
-types from Sphinx, Google, or Numpy-style structured docstrings, and improves
-some related heuristics about how to test scientific and numerical programs.
-
-.. _v6.9.2:
-
-------------------
-6.9.2 - 2021-04-15
-------------------
-
-This release improves the :doc:`Ghostwriter's <ghostwriter>` handling
-of exceptions, by reading ``:raises ...:`` entries in function docstrings
-and ensuring that we don't suppresss the error raised by test assertions.
-
-.. _v6.9.1:
-
-------------------
-6.9.1 - 2021-04-12
-------------------
-
-This patch updates our autoformatting tools, improving our code style without any API changes.
-
-.. _v6.9.0:
-
-------------------
-6.9.0 - 2021-04-11
-------------------
-
-This release teaches :func:`~hypothesis.strategies.from_type` how to see
-through :obj:`python:typing.Annotated`.  Thanks to Vytautas Strimaitis
-for reporting and fixing :issue:`2919`!
-
-.. _v6.8.12:
-
--------------------
-6.8.12 - 2021-04-11
--------------------
-
-If :pypi:`rich` is installed, the :command:`hypothesis write` command
-will use it to syntax-highlight the :doc:`Ghostwritten <ghostwriter>`
-code.
-
-.. _v6.8.11:
-
--------------------
-6.8.11 - 2021-04-11
--------------------
-
-This patch improves an error message from :func:`~hypothesis.strategies.builds`
-when :func:`~hypothesis.strategies.from_type` would be more suitable (:issue:`2930`).
-
-.. _v6.8.10:
-
--------------------
-6.8.10 - 2021-04-11
--------------------
-
-This patch updates the type annotations for :func:`~hypothesis.extra.numpy.arrays` to reflect that
-``shape: SearchStrategyint`` is supported.
-
-.. _v6.8.9:
-
-------------------
-6.8.9 - 2021-04-07
-------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` with
-:mod:`abstract types <python:abc>` which have either required but
-non-type-annotated arguments to ``__init__``, or where
-:func:`~hypothesis.strategies.from_type` can handle some concrete
-subclasses but not others.
-
-.. _v6.8.8:
-
-------------------
-6.8.8 - 2021-04-07
-------------------
-
-This patch teaches :command:`hypothesis write` to check for possible roundtrips
-in several more cases, such as by looking for an inverse in the module which
-defines the function to test.
-
-.. _v6.8.7:
-
-------------------
-6.8.7 - 2021-04-07
-------------------
-
-This patch adds a more helpful error message if you try to call
-:func:`~hypothesis.strategies.sampled_from` on an :class:`~python:enum.Enum`
-which has no members, but *does* have :func:`~python:dataclasses.dataclass`-style
-annotations (:issue:`2923`).
-
-.. _v6.8.6:
-
-------------------
-6.8.6 - 2021-04-06
-------------------
-
-The :func:`~hypothesis.strategies.fixed_dictionaries` strategy now preserves
-dict iteration order instead of sorting the keys.  This also affects the
-pretty-printing of keyword arguments to :func:`@given() <hypothesis.given>`
-(:issue:`2913`).
-
-.. _v6.8.5:
-
-------------------
-6.8.5 - 2021-04-05
-------------------
-
-This patch teaches :command:`hypothesis write` to default to ghostwriting
-tests with ``--style=pytest`` only if :pypi:`pytest` is installed, or
-``--style=unittest`` otherwise.
-
-.. _v6.8.4:
-
-------------------
-6.8.4 - 2021-04-01
-------------------
-
-This patch adds type annotations for the :class:`~hypothesis.settings` decorator,
-to avoid an error when running mypy in strict mode.
-
-.. _v6.8.3:
-
-------------------
-6.8.3 - 2021-03-28
-------------------
-
-This patch improves the :doc:`Ghostwriter's <ghostwriter>` handling
-of strategies to generate various fiddly types including frozensets,
-keysviews, valuesviews, regex matches and patterns, and so on.
-
-.. _v6.8.2:
-
-------------------
-6.8.2 - 2021-03-27
-------------------
-
-This patch fixes some internal typos.  There is no user-visible change.
-
-.. _v6.8.1:
-
-------------------
-6.8.1 - 2021-03-14
-------------------
-
-This patch lays more groundwork for filter rewriting (:issue:`2701`).
-There is no user-visible change... yet.
-
-.. _v6.8.0:
-
-------------------
-6.8.0 - 2021-03-11
-------------------
-
-This release :func:`registers <hypothesis.strategies.register_type_strategy>` the
-remaining builtin types, and teaches :func:`~hypothesis.strategies.from_type` to
-try resolving :class:`~python:typing.ForwardRef` and :class:`~python:typing.Type`
-references to built-in types.
-
-.. _v6.7.0:
-
-------------------
-6.7.0 - 2021-03-10
-------------------
-
-This release teaches :class:`~hypothesis.stateful.RuleBasedStateMachine` to avoid
-checking :func:`~hypothesis.stateful.invariant`\ s until all
-:func:`~hypothesis.stateful.initialize` rules have been run.  You can enable checking
-of specific invariants for incompletely initialized machines by using
-``@invariant(check_during_init=True)`` (:issue:`2868`).
-
-In previous versions, it was possible if awkward to implement this behaviour
-using :func:`~hypothesis.stateful.precondition` and an auxiliary variable.
-
-.. _v6.6.1:
-
-------------------
-6.6.1 - 2021-03-09
-------------------
-
-This patch improves the error message when :func:`~hypothesis.strategies.from_type`
-fails to resolve a forward-reference inside a :class:`python:typing.Type`
-such as ``Type"int"`` (:issue:`2565`).
-
-.. _v6.6.0:
-
-------------------
-6.6.0 - 2021-03-07
-------------------
-
-This release makes it an explicit error to apply :func:`~hypothesis.stateful.invariant`
-to a :func:`~hypothesis.stateful.rule` or :func:`~hypothesis.stateful.initialize` rule
-in :doc:`stateful testing <stateful>`.  Such a combination had unclear semantics,
-especially in combination with :func:`~hypothesis.stateful.precondition`, and was never
-meant to be allowed (:issue:`2681`).
-
-.. _v6.5.0:
-
-------------------
-6.5.0 - 2021-03-07
-------------------
-
-This release adds :ref:`the explain phase <phases>`, in which Hypothesis
-attempts to explain *why* your test failed by pointing to suspicious lines
-of code (i.e. those which were always, and only, run on failing inputs).
-We plan to include "generalising" failing examples in this phase in a
-future release (:issue:`2192`).
-
-.. _v6.4.3:
-
-------------------
-6.4.3 - 2021-03-04
-------------------
-
-This patch fixes :issue:`2794`, where nesting :func:`~hypothesis.strategies.deferred`
-strategies within :func:`~hypothesis.strategies.recursive` strategies could
-trigger an internal assertion.  While it was always possible to get the same
-results from a more sensible strategy, the convoluted form now works too.
-
-.. _v6.4.2:
-
-------------------
-6.4.2 - 2021-03-04
-------------------
-
-This patch fixes several problems with ``mypy`` when `--no-implicit-reexport <https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-no-implicit-reexport>`_ was activated in user projects.
-
-Thanks to Nikita Sobolev for fixing :issue:`2884`!
-
-.. _v6.4.1:
-
-------------------
-6.4.1 - 2021-03-04
-------------------
-
-This patch fixes an exception that occurs when using type unions of
-the :pypi:`typing_extensions` ``Literal`` backport on Python 3.6.
-
-Thanks to Ben Anhalt for identifying and fixing this bug.
-
-.. _v6.4.0:
-
-------------------
-6.4.0 - 2021-03-02
-------------------
-
-This release fixes :doc:`stateful testing methods <stateful>` with multiple
-:func:`~hypothesis.stateful.precondition` decorators.  Previously, only the
-outer-most precondition was checked (:issue:`2681`).
-
-.. _v6.3.4:
-
-------------------
-6.3.4 - 2021-02-28
-------------------
-
-This patch refactors some internals of :class:`~hypothesis.stateful.RuleBasedStateMachine`.
-There is no change to the public API or behaviour.
-
-.. _v6.3.3:
-
-------------------
-6.3.3 - 2021-02-26
-------------------
-
-This patch moves some internal code, so that future work can avoid
-creating import cycles.  There is no user-visible change.
-
-.. _v6.3.2:
-
-------------------
-6.3.2 - 2021-02-25
-------------------
-
-This patch enables :func:`~hypothesis.strategies.register_type_strategy` for subclasses of
-:class:`python:typing.TypedDict`.  Previously, :func:`~hypothesis.strategies.from_type`
-would ignore the registered strategy (:issue:`2872`).
-
-Thanks to Ilya Lebedev for identifying and fixing this bug!
-
-.. _v6.3.1:
-
-------------------
-6.3.1 - 2021-02-24
-------------------
-
-This release lays the groundwork for automatic rewriting of simple filters,
-for example converting ``integers().filter(lambda x: x > 9)`` to
-``integers(min_value=10)``.
-
-Note that this is **not supported yet**, and we will continue to recommend
-writing the efficient form directly wherever possible - predicate rewriting
-is provided mainly for the benefit of downstream libraries which would
-otherwise have to implement it for themselves (e.g. :pypi:`pandera` and
-:pypi:`icontract-hypothesis`).  See :issue:`2701` for details.
-
-.. _v6.3.0:
-
-------------------
-6.3.0 - 2021-02-20
-------------------
-
-The Hypothesis :pypi:`pytest` plugin now requires pytest version 4.6 or later.
-If the plugin detects an earlier version of pytest, it will automatically
-deactivate itself.
-
-`(4.6.x is the earliest pytest branch that still accepts community bugfixes.)
-<https://docs.pytest.org/en/stable/py27-py34-deprecation.html>`__
-
-Hypothesis-based tests should continue to work in earlier versions of
-pytest, but enhanced integrations provided by the plugin
-(such as ``--hypothesis-show-statistics`` and other command-line flags)
-will no longer be available in obsolete pytest versions.
-
-.. _v6.2.0:
-
-------------------
-6.2.0 - 2021-02-12
-------------------
-
-If you use :pypi:`pytest-html`, Hypothesis now includes the
-:ref:`summary statistics for each test <statistics>` in the HTML report,
-whether or not the ``--hypothesis-show-statistics`` argument was passed
-to show them in the command-line output.
-
-.. _v6.1.1:
-
-------------------
-6.1.1 - 2021-01-31
-------------------
-
-This patch updates our automatic code formatting to use :pypi:`shed`,
-which includes :pypi:`autoflake`, :pypi:`black`, :pypi:`isort`, and
-:pypi:`pyupgrade` (:issue:`2780`).
-
-.. _v6.1.0:
-
-------------------
-6.1.0 - 2021-01-29
-------------------
-
-This release teaches Hypothesis to distinguish between errors based on the
-`__cause__ or __context__ of otherwise identical exceptions
-<https://docs.python.org/3/library/exceptions.html>`__, which is particularly
-useful when internal errors can be wrapped by a library-specific or semantically
-appropriate exception such as:
-
-.. code-block:: python
-
-    try:
-        do_the_thing(foo, timeout=10)
-    except Exception as err:
-        raise FooError("Failed to do the thing") from err
-
-Earlier versions of Hypothesis only see the ``FooError``, while we can now
-distinguish a ``FooError`` raised because of e.g. an internal assertion from
-one raised because of a ``TimeoutExceeded`` exception.
-
-.. _v6.0.4:
-
-------------------
-6.0.4 - 2021-01-27
-------------------
-
-This release prevents a race condition inside :func:`~hypothesis.strategies.recursive` strategies.
-The race condition occurs when the same :func:`~hypothesis.strategies.recursive` strategy is shared among tests
-that are running in multiple threads (:issue:`2717`).
-
-.. _v6.0.3:
-
-------------------
-6.0.3 - 2021-01-23
-------------------
-
-This patch improves the type annotations for :func:`~hypothesis.strategies.one_of`,
-by adding overloads to handle up to five distinct arguments as
-:obj:`~python:typing.Union` before falling back to :obj:`~python:typing.Any`,
-as well as annotating the ``|`` (``__or__``) operator for strategies (:issue:`2765`).
-
-.. _v6.0.2:
-
-------------------
-6.0.2 - 2021-01-14
-------------------
-
-This release makes some small improvements to how filtered strategies work. It should improve the performance of shrinking filtered strategies,
-and may under some (probably rare) circumstances improve the diversity of generated examples.
-
-.. _v6.0.1:
-
-------------------
-6.0.1 - 2021-01-13
-------------------
-
-This patch fixes an interaction where our :ref:`test statistics <statistics>`
-handling made Pytest's ``--junit-xml`` output fail to validate against the
-strict ``xunit2`` schema (:issue:`1975`).
-
-.. _v6.0.0:
-
-------------------
-6.0.0 - 2021-01-08
-------------------
-
-Welcome to the next major version of Hypothesis!
-
-There are no new features here, as we release those in minor versions.
-Instead, 6.0 is a chance for us to remove deprecated features (many already
-converted into no-ops), and turn a variety of warnings into errors.
-
-If you were running on the last version of Hypothesis 5.x *without any
-Hypothesis deprecation warnings*, this will be a very boring upgrade.
-**In fact, nothing will change for you at all.**
-
-Changes
-~~~~~~~
-- Many functions now use :pep:`3102` keyword-only arguments where passing positional
-  arguments :ref:`was deprecated since 5.5 <v5.5.0>`.
-- :func:`hypothesis.extra.django.from_model` no longer accepts ``model`` as a
-  keyword argument, where it could conflict with fields named "model".
-- :func:`~hypothesis.strategies.randoms` now defaults to ``use_true_random=False``.
-- :func:`~hypothesis.strategies.complex_numbers` no longer accepts
-  ``min_magnitude=None``; either use ``min_magnitude=0`` or just omit the argument.
-- ``hypothesis.provisional.ip4_addr_strings`` and ``ip6_addr_strings`` are removed
-  in favor of :func:`ip_addresses(v=...).map(str) <hypothesis.strategies.ip_addresses>`.
-- :func:`~hypothesis.strategies.register_type_strategy` no longer accepts generic
-  types with type arguments, which were always pretty badly broken.
-- Using function-scoped pytest fixtures is now a health-check error, instead of a warning.
-
-.. tip::
-    The :command:`hypothesis codemod` command can automatically refactor your code,
-    particularly to convert positional to keyword arguments where those are now
-    required.
-
-Hypothesis 5.x
-==============
-
-.. _v5.49.0:
-
--------------------
-5.49.0 - 2021-01-07
--------------------
-
-This release adds the
-:obj:`~hypothesis.HealthCheck.function_scoped_fixture` health check value,
-which can be used to suppress the existing warning that appears when
-:func:`@given <hypothesis.given>` is applied to a test that uses pytest
-function-scoped fixtures.
-
-(This warning exists because function-scoped fixtures only run once per
-function, not once per example, which is usually unexpected and can cause
-subtle problems.)
-
-When this warning becomes a health check error in a future release, suppressing
-it via Python warning settings will no longer be possible.
-In the rare case that once-per-function behaviour is intended, it will still be
-possible to use :obj:`~hypothesis.HealthCheck.function_scoped_fixture` to
-opt out of the health check error for specific tests.
-
-.. _v5.48.0:
-
--------------------
-5.48.0 - 2021-01-06
--------------------
-
-This release adds :func:`hypothesis.currently_in_test_context`, which can be used
-to check whether the calling code is currently running inside an
-:func:`@given <hypothesis.given>` or :doc:`stateful <stateful>` test.
-
-This is most useful for third-party integrations and assertion helpers which may
-wish to use :func:`~hypothesis.assume` or :func:`~hypothesis.target`, without also
-requiring that the helper only be used from property-based tests (:issue:`2581`).
-
-.. _v5.47.0:
-
--------------------
-5.47.0 - 2021-01-05
--------------------
-
-This release upgrades the import logic for :doc:`ghostwritten tests <ghostwriter>`,
-handling many cases where imports would previously be missing or from unexpected
-locations.
-
-.. _v5.46.0:
-
--------------------
-5.46.0 - 2021-01-04
--------------------
-
-This release upgrades :func:`~hypothesis.strategies.from_type`, to infer
-strategies for type-annotated arguments even if they have defaults when
-it otherwise falls back to :func:`~hypothesis.strategies.builds`
-(:issue:`2708`).
-
-.. _v5.45.0:
-
--------------------
-5.45.0 - 2021-01-04
--------------------
-
-This release adds the :ref:`codemods` extra, which you can use to
-check for and automatically fix issues such as use of deprecated
-Hypothesis APIs (:issue:`2705`).
-
-.. _v5.44.0:
-
--------------------
-5.44.0 - 2021-01-03
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` with
-the :pypi:`typing_extensions` ``Literal`` backport on Python 3.6.
-
-.. _v5.43.9:
-
--------------------
-5.43.9 - 2021-01-02
--------------------
-
-This patch fixes :issue:`2722`, where certain orderings of
-:func:`~hypothesis.strategies.register_type_strategy`,
-:class:`~python:typing.ForwardRef`, and :func:`~hypothesis.strategies.from_type`
-could trigger an internal error.
-
-.. _v5.43.8:
-
--------------------
-5.43.8 - 2021-01-02
--------------------
-
-This patch makes some strategies for collections with a uniqueness constraint
-much more efficient, including ``dictionaries(keys=sampled_from(...), values=..)``
-and ``lists(tuples(sampled_from(...), ...), unique_by=lambda x: x0)``.
-(related to :issue:`2036`)
-
-.. _v5.43.7:
-
--------------------
-5.43.7 - 2021-01-02
--------------------
-
-This patch extends our faster special case for
-:func:`~hypothesis.strategies.sampled_from` elements in unique
-:func:`~hypothesis.strategies.lists` to account for chains of
-``.map(...)`` and ``.filter(...)`` calls (:issue:`2036`).
-
-.. _v5.43.6:
-
--------------------
-5.43.6 - 2021-01-02
--------------------
-
-This patch improves the type annotations on :func:`~hypothesis.assume`
-and :func:`@reproduce_failure() <hypothesis.reproduce_failure>`.
-
-.. _v5.43.5:
-
--------------------
-5.43.5 - 2021-01-01
--------------------
-
-This patch updates our copyright headers to include 2021.  Happy new year!
-
-.. _v5.43.4:
-
--------------------
-5.43.4 - 2020-12-24
--------------------
-
-This change fixes a documentation error in the
-:obj:`~hypothesis.settings.database` setting.
-
-The previous documentation suggested that callers could specify a database
-path string, or the special string ``":memory:"``, but this setting has
-never actually allowed string arguments.
-
-Permitted values are ``None``, and instances of
-:class:`~hypothesis.database.ExampleDatabase`.
-
-.. _v5.43.3:
-
--------------------
-5.43.3 - 2020-12-11
--------------------
-
-This patch fixes :issue:`2696`, an internal error triggered when the
-:func:`@example <hypothesis.example>` decorator was used and the
-:obj:`~hypothesis.settings.verbosity` setting was ``quiet``.
-
-.. _v5.43.2:
-
--------------------
-5.43.2 - 2020-12-10
--------------------
-
-This patch improves the error message from the
-:func:`~hypothesis.extra.pandas.data_frames` strategy when both the ``rows``
-and ``columns`` arguments are given, but there is a missing entry in ``rows``
-and the corresponding column has no ``fill`` value (:issue:`2678`).
-
-.. _v5.43.1:
-
--------------------
-5.43.1 - 2020-12-10
--------------------
-
-This patch improves the error message if :func:`~hypothesis.strategies.builds`
-is passed an :class:`~python:enum.Enum` which cannot be called without arguments,
-to suggest using :func:`~hypothesis.strategies.sampled_from` (:issue:`2693`).
-
-.. _v5.43.0:
-
--------------------
-5.43.0 - 2020-12-09
--------------------
-
-This release adds new :func:`~hypothesis.strategies.timezones` and
-:func:`~hypothesis.strategies.timezone_keys` strategies (:issue:`2630`)
-based on the new :mod:`python:zoneinfo` module in Python 3.9.
-
-``pip install hypothesiszoneinfo`` will ensure that you have the
-appropriate backports installed if you need them.
-
-.. _v5.42.3:
-
--------------------
-5.42.3 - 2020-12-09
--------------------
-
-This patch fixes an internal error in :func:`~hypothesis.strategies.datetimes`
-with ``allow_imaginary=False`` where the ``timezones`` argument can generate
-``tzinfo=None`` (:issue:`2662`).
-
-.. _v5.42.2:
-
--------------------
-5.42.2 - 2020-12-09
--------------------
-
-This patch teaches :func:`hypothesis.extra.django.from_field` to infer
-more efficient strategies by inspecting (not just filtering by) field
-validators for numeric and string fields (:issue:`1116`).
-
-.. _v5.42.1:
-
--------------------
-5.42.1 - 2020-12-09
--------------------
-
-This patch refactors :class:`hypothesis.settings` to use type-annotated
-keyword arguments instead of ``**kwargs``, which makes tab-completion
-much more useful - as well as type-checkers like :pypi:`mypy`.
-
-.. _v5.42.0:
-
--------------------
-5.42.0 - 2020-12-09
--------------------
-
-This patch teaches the :func:`~hypothesis.extra.ghostwriter.magic` ghostwriter
-to recognise "en/de" function roundtrips other than the common encode/decode
-pattern, such as encrypt/decrypt or, encipher/decipher.
-
-.. _v5.41.5:
-
--------------------
-5.41.5 - 2020-12-05
--------------------
-
-This patch adds a performance optimisation to avoid saving redundant
-seeds when using :ref:`the .fuzz_one_input hook <fuzz_one_input>`.
-
-.. _v5.41.4:
-
--------------------
-5.41.4 - 2020-11-28
--------------------
-
-This patch fixes :issue:`2657`, where passing unicode patterns compiled with
-:obj:`python:re.IGNORECASE` to :func:`~hypothesis.strategies.from_regex` could
-trigger an internal error when casefolding a character creates a longer string
-(e.g. ``"\u0130".lower() -> "i\u0370"``).
-
-.. _v5.41.3:
-
--------------------
-5.41.3 - 2020-11-18
--------------------
-
-This patch adds a final fallback clause to :ref:`our plugin logic <entry-points>`
-to fail with a warning rather than error on Python < 3.8 when neither the
-:pypi:`importlib_metadata` (preferred) or :pypi:`setuptools` (fallback)
-packages are available.
-
-.. _v5.41.2:
-
--------------------
-5.41.2 - 2020-11-08
--------------------
-
-This patch fixes :func:`~hypothesis.provisional.urls` strategy ensuring that
-``~`` (tilde) is treated as one of the url-safe characters (:issue:`2658`).
-
-.. _v5.41.1:
-
--------------------
-5.41.1 - 2020-11-03
--------------------
-
-This patch improves our :ref:`CLI help and documentation <hypothesis-cli>`.
-
-.. _v5.41.0:
-
--------------------
-5.41.0 - 2020-10-30
--------------------
-
-Hypothesis now shrinks examples where the error is raised while drawing from
-a strategy.  This makes complicated custom strategies *much* easier to debug,
-at the cost of a slowdown for use-cases where you catch and ignore such errors.
-
-.. _v5.40.0:
-
--------------------
-5.40.0 - 2020-10-30
--------------------
-
-This release teaches :func:`~hypothesis.strategies.from_type` how to handle
-:class:`~python:typing.ChainMap`, :class:`~python:typing.Counter`,
-:class:`~python:typing.Deque`, :class:`~python:typing.Generator`,
-:class:`~python:typing.Match`, :class:`~python:typing.OrderedDict`,
-:class:`~python:typing.Pattern`, and :class:`~python:collections.abc.Set`
-(:issue:`2654`).
-
-.. _v5.39.0:
-
--------------------
-5.39.0 - 2020-10-30
--------------------
-
-:func:`~hypothesis.strategies.from_type` now knows how to resolve :pep:`585`
-parameterized standard collection types, which are new in Python 3.9
-(:issue:`2629`).
-
-.. _v5.38.1:
-
--------------------
-5.38.1 - 2020-10-26
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.builds`, so that when passed
-:obj:`~hypothesis.infer` for an argument with a non-:obj:`~python:typing.Optional`
-type annotation and a default value of ``None`` to build a class which defines
-an explicit ``__signature__`` attribute, either ``None`` or that type may be
-generated.
-
-This is unlikely to happen unless you are using :pypi:`pydantic` (:issue:`2648`).
-
-.. _v5.38.0:
-
--------------------
-5.38.0 - 2020-10-24
--------------------
-
-This release improves our support for :func:`@st.composite <hypothesis.strategies.composite>`
-on a :obj:`python:classmethod` or :obj:`python:staticmethod` (:issue:`2578`).
-
-.. _v5.37.5:
-
--------------------
-5.37.5 - 2020-10-24
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` with
-:class:`IterableT <python:typing.Iterable>` (:issue:`2645`).
-
-.. _v5.37.4:
-
--------------------
-5.37.4 - 2020-10-20
--------------------
-
-This patch teaches the :func:`~hypothesis.extra.ghostwriter.magic` ghostwriter
-to recognise that pairs of functions like :func:`~python:colorsys.rgb_to_hsv`
-and :func:`~python:colorsys.hsv_to_rgb` should
-:func:`~hypothesis.extra.ghostwriter.roundtrip`.
-
-.. _v5.37.3:
-
--------------------
-5.37.3 - 2020-10-15
--------------------
-
-This patch improves :func:`~hypothesis.strategies.builds` and
-:func:`~hypothesis.strategies.from_type` support for explicitly defined ``__signature__``
-attributes, from :ref:`version 5.8.3 <v5.8.3>`, to support generic types from the
-:mod:`python:typing` module.
-
-Thanks to Rónán Carrigan for identifying and fixing this problem!
-
-.. _v5.37.2:
-
--------------------
-5.37.2 - 2020-10-14
--------------------
-
-This patch fixes :func:`~hypothesis.extra.lark.from_lark` with version
-0.10.1+ of the :pypi:`lark-parser` package.
-
-.. _v5.37.1:
-
--------------------
-5.37.1 - 2020-10-07
--------------------
-
-This patch fixes some broken links in the :mod:`~hypothesis.extra.lark`
-extra documentation.
-
-.. _v5.37.0:
-
--------------------
-5.37.0 - 2020-10-03
--------------------
-
-This release adds a new :class:`~hypothesis.extra.redis.RedisExampleDatabase`,
-along with the :class:`~hypothesis.database.ReadOnlyDatabase`
-and :class:`~hypothesis.database.MultiplexedDatabase` helpers, to support
-team workflows where failing examples can be seamlessly shared between everyone
-on the team - and your CI servers or buildbots.
-
-.. _v5.36.2:
-
--------------------
-5.36.2 - 2020-10-02
--------------------
-
-This patch ensures that if the :ref:`"hypothesis" entry point <entry-points>`
-is callable, we call it after importing it.  You can still use non-callable
-entry points (like modules), which are only imported.
-
-We also prefer `importlib.metadata <https://docs.python.org/3/library/importlib.metadata.html>`__
-or :pypi:`the backport <importlib_metadata>` over `pkg_resources
-<https://setuptools.readthedocs.io/en/latest/pkg_resources.html>`__,
-which makes ``import hypothesis`` around 200 milliseconds faster
-(:issue:`2571`).
-
-.. _v5.36.1:
-
--------------------
-5.36.1 - 2020-09-25
--------------------
-
-This patch adds some helpful suggestions to error messages you might see
-while learning to use the :func:`@example() <hypothesis.example>` decorator
-(:issue:`2611`) or the :func:`~hypothesis.strategies.one_of` strategy.
-
-.. _v5.36.0:
-
--------------------
-5.36.0 - 2020-09-24
--------------------
-
-This release upgrades the :func:`~hypothesis.extra.numpy.from_dtype` strategy
-to pass optional ``**kwargs`` to the inferred strategy, and upgrades the
-:func:`~hypothesis.extra.numpy.arrays` strategy to accept an ``elements=kwargs``
-dict to pass through to :func:`~hypothesis.extra.numpy.from_dtype`.
-
-``arrays(floating_dtypes(), shape, elements={"min_value": -10, "max_value": 10})``
-is a particularly useful pattern, as it allows for any floating dtype without
-triggering the roundoff warning for smaller types or sacrificing variety for
-larger types (:issue:`2552`).
-
-.. _v5.35.4:
-
--------------------
-5.35.4 - 2020-09-21
--------------------
-
-This patch reformats our code with the latest :pypi:`black` to
-take advantage of the support for magic trailing commas.
-
-.. _v5.35.3:
-
--------------------
-5.35.3 - 2020-09-15
--------------------
-
-This release significantly improves the performance of Hypothesis's internal
-implementation of automaton learning. However this code does not run as part
-of the user-accessible API so this has no user-visible impact.
-
-.. _v5.35.2:
-
--------------------
-5.35.2 - 2020-09-14
--------------------
-
-This patch ensures that, when the ``generate`` :obj:`~hypothesis.settings.phases`
-is disabled, we can replay up to :obj:`~hypothesis.settings.max_examples` examples
-from the database - which is very useful when
-:ref:`using Hypothesis with a fuzzer <fuzz_one_input>`.
-
-Thanks to Afrida Tabassum for fixing :issue:`2585`!
-
-.. _v5.35.1:
-
--------------------
-5.35.1 - 2020-09-14
--------------------
-
-This patch changes some internal :obj:`python:struct.Struct.format` strings
-from ``bytes`` to ``str``, to avoid :class:`python:BytesWarning` when running
-`python -bb <https://docs.python.org/3/using/cmdline.html#cmdoption-b>`__.
-
-Thanks to everyone involved in `pytest-xdist issue 596
-<https://github.com/pytest-dev/pytest-xdist/issues/596>`__,
-:bpo:`16349`, :bpo:`21071`, and :bpo:`41777` for their work on this -
-it was a remarkably subtle issue!
-
-.. _v5.35.0:
-
--------------------
-5.35.0 - 2020-09-11
--------------------
-
-The :func:`~hypothesis.target` function now accepts integers as well as floats.
-
-.. _v5.34.1:
-
--------------------
-5.34.1 - 2020-09-11
--------------------
-
-This patch adds explicit :obj:`~python:typing.Optional` annotations to our public API,
-to better support users who run :pypi:`mypy` with ``--strict`` or ``no_implicit_optional=True``.
-
-Thanks to Krzysztof Przybyła for bringing this to our attention and writing the patch!
-
-.. _v5.34.0:
-
--------------------
-5.34.0 - 2020-09-11
--------------------
-
-This release drops support for Python 3.5, which `reached end of life upstream
-<https://devguide.python.org/#status-of-python-branches>`__ on 2020-09-13.
-
-.. _v5.33.2:
-
--------------------
-5.33.2 - 2020-09-09
--------------------
-
-This patch fixes a problem with :func:`~hypothesis.strategies.builds` that was not able to
-generate valid data for annotated classes with constructors.
-
-Thanks to Nikita Sobolev for fixing :issue:`2603`!
-
-.. _v5.33.1:
-
--------------------
-5.33.1 - 2020-09-07
--------------------
-
-This patch improves the error message from the :command:`hypothesis write`
-command if :pypi:`black` (required for the :doc:`ghostwriter <ghostwriter>`)
-is not installed.
-
-Thanks to Nikita Sobolev for fixing :issue:`2604`!
-
-.. _v5.33.0:
-
--------------------
-5.33.0 - 2020-09-06
--------------------
-
-When reporting failing examples, or tried examples in verbose mode, Hypothesis now
-identifies which were from :func:`@example(...) <hypothesis.example>` explicit examples.
-
-.. _v5.32.1:
-
--------------------
-5.32.1 - 2020-09-06
--------------------
-
-This patch contains some internal refactoring.
-Thanks to Felix Sheldon for fixing :issue:`2516`!
-
-.. _v5.32.0:
-
--------------------
-5.32.0 - 2020-09-04
--------------------
-
-An array drawn from :func:`~hypothesis.extra.numpy.arrays` will own its own memory; previously most arrays returned by
-this strategy were views.
-
-.. _v5.31.0:
-
--------------------
-5.31.0 - 2020-09-04
--------------------
-
-:func:`~hypothesis.strategies.builds` will use the ``__signature__`` attribute of
-the target, if it exists, to retrieve type hints.
-Previously :func:`python:typing.get_type_hints`, was used by default.
-If argument names varied between the ``__annotations__`` and ``__signature__``,
-they would not be supplied to the target.
-
-This was particularly an issue for :pypi:`pydantic` models which use an
-`alias generator <https://pydantic-docs.helpmanual.io/usage/model_config/#alias-generator>`__.
-
-.. _v5.30.1:
-
--------------------
-5.30.1 - 2020-09-04
--------------------
-
-This patch makes the :doc:`ghostwriter <ghostwriter>` much more robust when
-passed unusual modules.
-
-- improved support for non-resolvable type annotations
-- :func:`~hypothesis.extra.ghostwriter.magic` can now write
-  :func:`~hypothesis.extra.ghostwriter.equivalent` tests
-- running :func:`~hypothesis.extra.ghostwriter.magic` on modules where some
-  names in ``__all__`` are undefined skips such names, instead of raising an error
-- :func:`~hypothesis.extra.ghostwriter.magic` now knows to skip mocks
-- improved handling of import-time errors found by the ghostwriter CLI
-
-.. _v5.30.0:
-
--------------------
-5.30.0 - 2020-08-30
--------------------
-
-:func:`~hypothesis.strategies.register_type_strategy` now supports
-:class:`python:typing.TypeVar`, which was previously hard-coded, and allows a
-variety of types to be generated for an unconstrained :class:`~python:typing.TypeVar`
-instead of just :func:`~hypothesis.strategies.text`.
-
-Thanks again to Nikita Sobolev for all your work on advanced types!
-
-.. _v5.29.4:
-
--------------------
-5.29.4 - 2020-08-28
--------------------
-
-This release fixes some hard to trigger bugs in Hypothesis's automata learning
-code. This code is only run as part of the Hypothesis build process, and not
-for user code, so this release has no user visible impact.
-
-.. _v5.29.3:
-
--------------------
-5.29.3 - 2020-08-27
--------------------
-
-This patch adds type annotations to the :doc:`hypothesis.database <database>`
-module.  There is no runtime change, but your typechecker might notice.
-
-.. _v5.29.2:
-
--------------------
-5.29.2 - 2020-08-27
--------------------
-
-This patch tracks some additional information in Hypothesis internals,
-and has no user-visible impact.
-
-.. _v5.29.1:
-
--------------------
-5.29.1 - 2020-08-27
--------------------
-
-This release fixes a bug in some Hypothesis internal support code for learning
-automata. This mostly doesn't have any user visible impact, although it slightly
-affects the learned shrink passes so shrinking may be subtly different.
-
-.. _v5.29.0:
-
--------------------
-5.29.0 - 2020-08-24
--------------------
-
-This release adds support for :ref:`entry-points`, which allows for smoother
-integration of third-party Hypothesis extensions and external libraries.
-Unless you're publishing a library with Hypothesis integration, you'll
-probably only ever use this indirectly!
-
-.. _v5.28.0:
-
--------------------
-5.28.0 - 2020-08-24
--------------------
-
-:func:`~hypothesis.strategies.from_type` can now resolve :class:`~python:typing.TypeVar`
-instances when the ``bound`` is a :class:`~python:typing.ForwardRef`, so long as that name
-is in fact defined in the same module as the typevar (no ``TYPE_CHECKING`` tricks, sorry).
-This feature requires Python 3.7 or later.
-
-Thanks to Zac Hatfield-Dodds and Nikita Sobolev for this feature!
-
-.. _v5.27.0:
-
--------------------
-5.27.0 - 2020-08-20
--------------------
-
-This patch adds two new :doc:`ghostwriters <ghostwriter>` to test
-:wikipedia:`binary operations <Binary_operation>`, like :func:`python:operator.add`,
-and Numpy :doc:`ufuncs <reference/ufuncs>` and :doc:`gufuncs
-<numpy:reference/c-api/generalized-ufuncs>` like :data:`np.matmul() <numpy:numpy.matmul>`.
-
-.. _v5.26.1:
-
--------------------
-5.26.1 - 2020-08-19
--------------------
-
-This release improves the performance of some methods in Hypothesis's internal
-automaton library. These are currently only lightly used by user code, but
-this may result in slightly faster shrinking.
-
-.. _v5.26.0:
-
--------------------
-5.26.0 - 2020-08-17
--------------------
-
-:func:`~hypothesis.strategies.register_type_strategy` no longer accepts
-parametrised user-defined generic types, because the resolution logic
-was quite badly broken (:issue:`2537`).
-
-Instead of registering a strategy for e.g. ``MyCollectionint``, you
-should register a *function* for ``MyCollection`` and `inspect the type
-parameters within that function <https://stackoverflow.com/q/48572831>`__.
-
-Thanks to Nikita Sobolev for the bug report, design assistance, and
-pull request to implement this feature!
-
-.. _v5.25.0:
-
--------------------
-5.25.0 - 2020-08-16
--------------------
-
-Tired of writing tests?  Or new to Hypothesis and not sure where to start?
-
-This release is for you!  With our new :doc:`Ghostwriter functions <ghostwriter>`
-and :command:`hypothesis write ...` :ref:`command-line interface <hypothesis-cli>`,
-you can stop writing tests entirely... or take the source code Hypothesis
-writes for you as a starting point.
-
-This has been in the works for months, from :issue:`2118` to versions
-:ref:`5.18.3 <v5.18.3>`, :ref:`5.23.5 <v5.23.5>`, and :ref:`5.23.5 <v5.23.5>` -
-particular thanks to the many people who reviewed pull requests or commented on
-demos, and to Timothy Crosley's :pypi:`hypothesis-auto` project for inspiration.
-
-.. _v5.24.4:
-
--------------------
-5.24.4 - 2020-08-14
--------------------
-
-This patch adds yet more internal functions to support a new feature
-we're working on, like :ref:`version 5.18.3 <v5.18.3>` and
-:ref:`version 5.23.6 <v5.23.6>`.  We promise it's worth the wait!
-
-.. _v5.24.3:
-
--------------------
-5.24.3 - 2020-08-13
--------------------
-
-This release fixes a small internal bug in Hypothesis's internal automaton library.
-Fortunately this bug was currently impossible to hit in user facing code, so this
-has no user visible impact.
-
-.. _v5.24.2:
-
--------------------
-5.24.2 - 2020-08-12
--------------------
-
-This release improves shrink quality by allowing Hypothesis to automatically learn new shrink passes
-for difficult to shrink tests.
-
-The automatic learning is not currently accessible in user code (it still needs significant work
-on robustness and performance before it is ready for that), but this release includes learned
-passes that should improve shrinking quality for tests which use any of the
-:func:`~hypothesis.strategies.text`, :func:`~hypothesis.strategies.floats`,
-:func:`~hypothesis.strategies.datetimes`, :func:`~hypothesis.strategies.emails`,
-and :func:`~hypothesis.strategies.complex_numbers` strategies.
-
-.. _v5.24.1:
-
--------------------
-5.24.1 - 2020-08-12
--------------------
-
-This patch updates some docstrings, without changing runtime behaviour.
-
-.. _v5.24.0:
-
--------------------
-5.24.0 - 2020-08-10
--------------------
-
-The :func:`~hypothesis.strategies.functions` strategy has a new argument
-``pure=True``, which ensures that the same return value is generated for
-identical calls to the generated function (:issue:`2538`).
-
-Thanks to Zac Hatfield-Dodds and Nikita Sobolev for this feature!
-
-.. _v5.23.12:
-
---------------------
-5.23.12 - 2020-08-10
---------------------
-
-This release removes a number of Hypothesis's internal "shrink passes" - transformations
-it makes to a generated test case during shrinking - which appeared to be redundant with
-other transformations.
-
-It is unlikely that you will see much impact from this. If you do, it will likely show up
-as a change in shrinking performance (probably slower, maybe faster), or possibly in
-worse shrunk results. If you encounter the latter, please let us know.
-
-.. _v5.23.11:
-
---------------------
-5.23.11 - 2020-08-04
---------------------
-
-This release fixes a bug in some internal Hypothesis support code. It has no user visible impact.
-
-.. _v5.23.10:
-
---------------------
-5.23.10 - 2020-08-04
---------------------
-
-This release improves the quality of shrunk test cases in some special cases.
-Specifically, it should get shrinking unstuck in some scenarios which require
-simultaneously changing two parts of the generated test case.
-
-.. _v5.23.9:
-
--------------------
-5.23.9 - 2020-08-03
--------------------
-
-This release improves the performance of some internal support code. It has no user visible impact,
-as that code is not currently run during normal Hypothesis operation.
-
-.. _v5.23.8:
-
--------------------
-5.23.8 - 2020-07-31
--------------------
-
-This release adds a heuristic to detect when shrinking has finished despite the fact
-that there are many more possible transformations to try. This will be particularly
-useful for tests where the minimum failing test case is very large despite there being
-many smaller test cases possible, where it is likely to speed up shrinking dramatically.
-
-In some cases it is likely that this will result in worse shrunk test cases. In those
-cases rerunning the test will result in further shrinking.
-
-.. _v5.23.7:
-
--------------------
-5.23.7 - 2020-07-29
--------------------
-
-This release makes some performance improvements to shrinking. They should
-only be noticeable for tests that are currently particularly slow to shrink.
-
-.. _v5.23.6:
-
--------------------
-5.23.6 - 2020-07-29
--------------------
-
-This patch adds some more internal functions to support a new
-feature we're working on, like :ref:`version 5.18.3 <v5.18.3>`.
-There is still no user-visible change... yet.
-
-.. _v5.23.5:
-
--------------------
-5.23.5 - 2020-07-29
--------------------
-
-This release makes some changes to internal support code that is not currently used in production Hypothesis.
-It has no user visible effect at present.
-
-.. _v5.23.4:
-
--------------------
-5.23.4 - 2020-07-29
--------------------
-
-This release improves shrinking quality in some special cases.
-
-.. _v5.23.3:
-
--------------------
-5.23.3 - 2020-07-27
--------------------
-
-This release fixes :issue:`2507`, where lazy evaluation meant that the
-values drawn from a :func:`~hypothesis.strategies.sampled_from` strategy
-could depend on mutations of the sampled sequence that happened after
-the strategy was constructed.
-
-.. _v5.23.2:
-
--------------------
-5.23.2 - 2020-07-27
--------------------
-
-This patch fixes :issue:`2462`, a bug in our handling of :meth:`unittest.TestCase.subTest`.
-Thanks to Israel Fruchter for fixing this at the EuroPython sprints!
-
-.. _v5.23.1:
-
--------------------
-5.23.1 - 2020-07-26
--------------------
-
-This release improves the behaviour of the :func:`~hypothesis.strategies.characters` strategy
-when shrinking, by changing which characters are considered smallest to prefer more "normal" ascii characters
-where available.
-
-.. _v5.23.0:
-
--------------------
-5.23.0 - 2020-07-26
--------------------
-
-The default ``print_blob`` setting is now smarter. It defaults to ``True`` in CI and
-``False`` for local development.
-
-Thanks to Hugo van Kemenade for implementing this feature at the EuroPython sprints!
-
-.. _v5.22.0:
-
--------------------
-5.22.0 - 2020-07-25
--------------------
-
-The :func:`~hypothesis.strategies.slices` strategy can now generate slices for empty sequences,
-slices with negative start and stop indices (from the end of the sequence),
-and ``step=None`` in place of ``step=1``.
-
-Thanks to Sangarshanan for implementing this feature at the EuroPython sprints!
-
-.. _v5.21.0:
-
--------------------
-5.21.0 - 2020-07-23
--------------------
-
-This release ensures that tests which raise ``RecursionError`` are not
-reported as flaky simply because we run them from different initial
-stack depths (:issue:`2494`).
-
-.. _v5.20.4:
-
--------------------
-5.20.4 - 2020-07-23
--------------------
-
-This release improves the performance of the ``sample`` method on objects obtained from :func:`~hypothesis.strategies.randoms`
-when ``use_true_random=False``. This should mostly only be noticeable when the sample size is a large fraction of the population size,
-but may also help avoid health check failures in some other cases.
-
-.. _v5.20.3:
-
--------------------
-5.20.3 - 2020-07-21
--------------------
-
-This release makes some internal changes for testing purposes and should have no user visible effect.
-
-.. _v5.20.2:
-
--------------------
-5.20.2 - 2020-07-18
--------------------
-
-This release fixes a small caching bug in Hypothesis internals that may under
-some circumstances have resulted in a less diverse set of test cases being
-generated than was intended.
-
-Fixing this problem revealed some performance problems that could occur during targeted property based testing, so this release also fixes those. Targeted property-based testing should now be significantly faster in some cases,
-but this may be at the cost of reduced effectiveness.
-
-.. _v5.20.1:
-
--------------------
-5.20.1 - 2020-07-17
--------------------
-
-This patch updates our formatting to use :pypi:`isort` 5.
-There is no user-visible change.
-
-.. _v5.20.0:
-
--------------------
-5.20.0 - 2020-07-17
--------------------
-
-The :func:`~hypothesis.extra.numpy.basic_indices` strategy can now generate
-bare indexers in place of length-one tuples. Thanks to Andrea for this patch!
-
-.. _v5.19.3:
-
--------------------
-5.19.3 - 2020-07-15
--------------------
-
-This patch removes an internal use of ``distutils`` in order to avoid
-`this setuptools warning <https://github.com/pypa/setuptools/issues/2261>`__
-for some users.
-
-.. _v5.19.2:
-
--------------------
-5.19.2 - 2020-07-13
--------------------
-
-This patch contains a small internal refactoring with no user-visible impact.
-
-Thanks to Andrea for writing this at
-`the SciPy 2020 Sprints <https://www.scipy2020.scipy.org/sprints-schedule>`__!
-
-.. _v5.19.1:
-
--------------------
-5.19.1 - 2020-07-12
--------------------
-
-This release slightly improves shrinking behaviour. This should mainly only
-impact stateful tests, but may have some minor positive impact on shrinking
-collections (lists, sets, etc).
-
-.. _v5.19.0:
-
--------------------
-5.19.0 - 2020-06-30
--------------------
-
-This release improves the :func:`~hypothesis.strategies.randoms` strategy by adding support
-for ``Random`` instances where Hypothesis generates the random values
-rather than having them be "truly" random.
-
-.. _v5.18.3:
-
--------------------
-5.18.3 - 2020-06-27
--------------------
-
-This patch adds some internal functions to support a new feature
-we're working on.  There is no user-visible change... yet.
-
-.. _v5.18.2:
-
--------------------
-5.18.2 - 2020-06-26
--------------------
-
-This patch improves our docs for the :obj:`~hypothesis.settings.derandomize` setting.
-
-.. _v5.18.1:
-
--------------------
-5.18.1 - 2020-06-25
--------------------
-
-This release consists of some internal refactoring to the shrinker in preparation for future work. It has no user visible impact.
-
-.. _v5.18.0:
-
--------------------
-5.18.0 - 2020-06-22
--------------------
-
-This release teaches Hypothesis to :ref:`shorten tracebacks <v3.79.2>` for
-:ref:`explicit examples <providing-explicit-examples>`, as we already do
-for generated examples, so that you can focus on your code rather than ours.
-
-If you have multiple failing explicit examples, they will now all be reported.
-To report only the first failure, you can use the :obj:`report_multiple_bugs=False
-<hypothesis.settings.report_multiple_bugs>` setting as for generated examples.
-
-.. _v5.17.0:
-
--------------------
-5.17.0 - 2020-06-22
--------------------
-
-This patch adds strategy inference for the ``Literal``, ``NewType``, ``Type``,
-``DefaultDict``, and ``TypedDict`` types from the :pypi:`typing_extensions`
-backport on PyPI.
-
-.. _v5.16.3:
-
--------------------
-5.16.3 - 2020-06-21
--------------------
-
-This patch precomputes some of the setup logic for our
-:ref:`external fuzzer integration <fuzz_one_input>` and sets
-:obj:`deadline=None <hypothesis.settings.deadline>` in fuzzing mode,
-saving around 150us on each iteration.
-
-This is around two-thirds the runtime to fuzz an empty test with
-``@given(st.none())``, and nice to have even as a much smaller
-fraction of the runtime for non-trivial tests.
-
-.. _v5.16.2:
-
--------------------
-5.16.2 - 2020-06-19
--------------------
-
-This patch fixes an internal error when warning about the use of function-scoped fixtures
-for parametrised tests where the parametrised value contained a ``%`` character.
-Thanks to Bryant for reporting and fixing this bug!
-
-.. _v5.16.1:
-
--------------------
-5.16.1 - 2020-06-10
--------------------
-
-If you pass a :class:`python:list` or :class:`python:tuple` where a
-strategy was expected, the error message now mentions
-:func:`~hypothesis.strategies.sampled_from` as an example strategy.
-
-Thanks to the enthusiastic participants in the `PyCon Mentored Sprints
-<https://us.pycon.org/2020/hatchery/mentoredsprints/>`__ who suggested
-adding this hint.
-
-.. _v5.16.0:
-
--------------------
-5.16.0 - 2020-05-27
--------------------
-
-:func:`~hypothesis.strategies.functions` can now infer the appropriate ``returns``
-strategy if you pass a ``like`` function with a return-type annotation.  Before,
-omitting the ``returns`` argument would generate functions that always returned None.
-
-.. _v5.15.1:
-
--------------------
-5.15.1 - 2020-05-21
--------------------
-
-Fix :func:`~hypothesis.strategies.from_type` with generic types under Python 3.9.
-
-.. _v5.15.0:
-
--------------------
-5.15.0 - 2020-05-19
--------------------
-
-This patch fixes an error that happens when multiple threads create new strategies.
-
-.. _v5.14.0:
-
--------------------
-5.14.0 - 2020-05-13
--------------------
-
-Passing ``min_magnitude=None`` to :func:`~hypothesis.strategies.complex_numbers` is now
-deprecated - you can explicitly pass ``min_magnitude=0``, or omit the argument entirely.
-
-.. _v5.13.1:
-
--------------------
-5.13.1 - 2020-05-13
--------------------
-
-This patch fixes an internal error in :func:`~hypothesis.strategies.from_type`
-for :class:`python:typing.NamedTuple` in Python 3.9.  Thanks to Michel Salim
-for reporting and fixing :issue:`2427`!
-
-.. _v5.13.0:
-
--------------------
-5.13.0 - 2020-05-12
--------------------
-
-This release upgrades the test statistics available via the
-:ref:`--hypothesis-show-statistics <statistics>` option to include
-separate information on each of the :attr:`~hypothesis.settings.phases`
-(:issue:`1555`).
-
-.. _v5.12.2:
-
--------------------
-5.12.2 - 2020-05-12
--------------------
-
-This patch teaches the :func:`~hypothesis.strategies.from_type` internals to
-return slightly more efficient strategies for some generic sets and mappings.
-
-.. _v5.12.1:
-
--------------------
-5.12.1 - 2020-05-12
--------------------
-
-This patch adds a ``# noqa`` comment for :pypi:`flake8` 3.8.0, which
-disagrees with :pypi:`mypy` about how to write the type of ``...``.
-
-.. _v5.12.0:
-
--------------------
-5.12.0 - 2020-05-10
--------------------
-
-This release limits the maximum duration of the shrinking phase to five minutes,
-so that Hypothesis does not appear to hang when making very slow progress
-shrinking a failing example (:issue:`2340`).
-
-If one of your tests triggers this logic, we would really appreciate a bug
-report to help us improve the shrinker for difficult but realistic workloads.
-
-.. _v5.11.0:
-
--------------------
-5.11.0 - 2020-05-07
--------------------
-
-This release improves the interaction between :func:`~hypothesis.assume`
-and the :func:`@example() <hypothesis.example>` decorator, so that the
-following test no longer fails with ``UnsatisfiedAssumption`` (:issue:`2125`):
-
-.. code-block:: python
-
-    @given(value=floats(0, 1))
-    @example(value=0.56789)  # used to make the test fail!
-    @pytest.mark.parametrize("threshold", 0.5, 1)
-    def test_foo(threshold, value):
-        assume(value < threshold)
-        ...
-
-.. _v5.10.5:
-
--------------------
-5.10.5 - 2020-05-04
--------------------
-
-If you have :pypi:`django` installed but don't use it, this patch will make
-``import hypothesis`` a few hundred milliseconds faster (e.g. 0.704s -> 0.271s).
-
-Thanks to :pypi:`importtime-waterfall` for highlighting this problem and
-`Jake Vanderplas <https://twitter.com/jakevdp/status/1130983439862181888>`__ for
-the solution - it's impossible to misuse code from a module you haven't imported!
-
-.. _v5.10.4:
-
--------------------
-5.10.4 - 2020-04-24
--------------------
-
-This patch improves the internals of :func:`~hypothesis.strategies.builds` type
-inference, to handle recursive forward references in certain dataclasses.
-This is useful for e.g. :pypi:`hypothesmith`'s forthcoming :pypi:`LibCST` mode.
-
-.. _v5.10.3:
-
--------------------
-5.10.3 - 2020-04-22
--------------------
-
-This release reverses the order in which some operations are tried during shrinking.
-This should generally be a slight performance improvement, but most tests are unlikely to notice much difference.
-
-.. _v5.10.2:
-
--------------------
-5.10.2 - 2020-04-22
--------------------
-
-This patch fixes :issue:`2406`, where use of :obj:`pandas:pandas.Timestamp`
-objects as bounds for the :func:`~hypothesis.strategies.datetimes` strategy
-caused an internal error.  This bug was introduced in :ref:`version 5.8.1 <v5.8.2>`.
-
-.. _v5.10.1:
-
--------------------
-5.10.1 - 2020-04-19
--------------------
-
-This release is a small internal refactoring to how shrinking interacts with :ref:`targeted property-based testing <targeted-search>` that should have no user user visible impact.
-
-.. _v5.10.0:
-
--------------------
-5.10.0 - 2020-04-18
--------------------
-
-This release improves our support for datetimes and times around DST transitions.
-
-:func:`~hypothesis.strategies.times` and :func:`~hypothesis.strategies.datetimes`
-are now sometimes generated with ``fold=1``, indicating that they represent the
-second occurrence of a given wall-time when clocks are set backwards.
-This may be set even when there is no transition, in which case the ``fold``
-value should be ignored.
-
-For consistency, timezones provided by the :pypi:`pytz` package can now
-generate imaginary times (such as the hour skipped over when clocks 'spring forward'
-to daylight saving time, or during some historical timezone transitions).
-All other timezones have always supported generation of imaginary times.
-
-If you prefer the previous behaviour, :func:`~hypothesis.strategies.datetimes`
-now takes an argument ``allow_imaginary`` which defaults to ``True`` but
-can be set to ``False`` for any timezones strategy.
-
-.. _v5.9.1:
-
-------------------
-5.9.1 - 2020-04-16
-------------------
-
-This patch fixes the rendering of :func:`~hypothesis.strategies.binary`
-docstring by using the proper backticks syntax.
-
-.. _v5.9.0:
-
-------------------
-5.9.0 - 2020-04-15
-------------------
-
-Failing tests which use :func:`~hypothesis.target` now report the highest
-score observed for each target alongside the failing example(s), even without
-:ref:`explicitly showing test statistics <statistics>`.
-
-This improves the debugging workflow for tests of accuracy, which assert that the
-total imprecision is within some error budget - for example, ``abs(a - b) < 0.5``.
-Previously, shrinking to a minimal failing example could often make errors seem
-smaller or more subtle than they really are (see `the threshold problem
-<https://hypothesis.works/articles/threshold-problem/>`__, and :issue:`2180`).
-
-.. _v5.8.6:
-
-------------------
-5.8.6 - 2020-04-15
-------------------
-
-This patch improves the docstring of :func:`~hypothesis.strategies.binary`,
-the :func:`python:repr` of :func:`~hypothesis.strategies.sampled_from` on
-an :class:`python:enum.Enum` subclass, and a warning in our pytest plugin.
-There is no change in runtime behaviour.
-
-.. _v5.8.5:
-
-------------------
-5.8.5 - 2020-04-15
-------------------
-
-This release (potentially very significantly) improves the performance of failing tests in some rare cases,
-mostly only relevant when using :ref:`targeted property-based testing <targeted-search>`,
-by stopping further optimisation of unrelated test cases once a failing example is found.
-
-.. _v5.8.4:
-
-------------------
-5.8.4 - 2020-04-14
-------------------
-
-This release fixes :issue:`2395`, where under some circumstances targeted property-based testing could cause Hypothesis to get caught in an infinite loop.
-
-.. _v5.8.3:
-
-------------------
-5.8.3 - 2020-04-12
-------------------
-
-This patch teaches :func:`~hypothesis.strategies.builds` and
-:func:`~hypothesis.strategies.from_type` to use the ``__signature__``
-attribute of classes where it has been set, improving our support
-for :pypi:`Pydantic` models (`in pydantic >= 1.5
-<https://github.com/samuelcolvin/pydantic/pull/1034>`__).
-
-.. _v5.8.2:
-
-------------------
-5.8.2 - 2020-04-12
-------------------
-
-This release improves the performance of the part of the core engine that
-deliberately generates duplicate values.
-
-.. _v5.8.1:
-
-------------------
-5.8.1 - 2020-04-12
-------------------
-
-This patch improves :func:`~hypothesis.strategies.dates` shrinking, to simplify
-year, month, and day like :func:`~hypothesis.strategies.datetimes` rather than
-minimizing the number of days since 2000-01-01.
-
-.. _v5.8.0:
-
-------------------
-5.8.0 - 2020-03-24
-------------------
-
-This release adds a :ref:`.hypothesis.fuzz_one_input <fuzz_one_input>`
-attribute to :func:`@given <hypothesis.given>` tests, for easy integration
-with external fuzzers such as `python-afl <https://github.com/jwilk/python-afl>`__
-(supporting :issue:`171`).
-
-.. _v5.7.2:
-
-------------------
-5.7.2 - 2020-03-24
-------------------
-
-This patch fixes :issue:`2341`, ensuring that the printed output from a
-stateful test cannot use variable names before they are defined.
-
-.. _v5.7.1:
-
-------------------
-5.7.1 - 2020-03-23
-------------------
-
-This patch fixes :issue:`2375`, preventing incorrect failure when a function
-scoped fixture is overridden with a higher scoped fixture.
-
-.. _v5.7.0:
-
-------------------
-5.7.0 - 2020-03-19
-------------------
-
-This release allows the :func:`~hypothesis.extra.numpy.array_dtypes` strategy
-to generate Numpy dtypes which have `field titles in addition to field names
-<https://numpy.org/doc/stable/user/basics.rec.html#field-titles>`__.
-We expect this to expose latent bugs where code expects that
-``set(dtype.names) == set(dtype.fields)``, though the latter may include titles.
-
-.. _v5.6.1:
-
-------------------
-5.6.1 - 2020-03-18
-------------------
-
-This makes ``model`` a positional-only argument to
-:func:`~hypothesis.extra.django.from_model`, to support models
-with a field literally named "model" (:issue:`2369`).
-
-.. _v5.6.0:
-
-------------------
-5.6.0 - 2020-02-29
-------------------
-
-This release adds an explicit warning for tests that are both decorated with
-:func:`@given(...) <hypothesis.given>` and request a
-:doc:`function-scoped pytest fixture <pytest:how-to/fixtures>`, because such fixtures
-are only executed once for *all* Hypothesis test cases and that often causes
-trouble (:issue:`377`).
-
-It's *very* difficult to fix this on the :pypi:`pytest` side, so since 2015
-our advice has been "just don't use function-scoped fixtures with Hypothesis".
-Now we detect and warn about the issue at runtime!
-
-.. _v5.5.5:
-
-------------------
-5.5.5 - 2020-02-29
-------------------
-
-This release cleans up the internal machinery for :doc:`stateful`,
-after we dropped the legacy APIs in Hypothesis 5.0 (:issue:`2218`).
-There is no user-visible change.
-
-.. _v5.5.4:
-
-------------------
-5.5.4 - 2020-02-16
-------------------
-
-This patch fixes :issue:`2351`, :func:`~hypothesis.extra.numpy.arrays` would
-raise a confusing error if we inferred a strategy for ``datetime64`` or
-``timedelta64`` values with varying time units.
-
-We now infer an internally-consistent strategy for such arrays, and have a more
-helpful error message if an inconsistent strategy is explicitly specified.
-
-.. _v5.5.3:
-
-------------------
-5.5.3 - 2020-02-14
-------------------
-
-This patch improves the signature of :func:`~hypothesis.strategies.builds` by
-specifying ``target`` as a positional-only argument on Python 3.8 (see :pep:`570`).
-The semantics of :func:`~hypothesis.strategies.builds` have not changed at all -
-this just clarifies the documentation.
-
-.. _v5.5.2:
-
-------------------
-5.5.2 - 2020-02-13
-------------------
-
-This release makes Hypothesis faster at generating test cases that contain
-duplicated values in their inputs.
-
-.. _v5.5.1:
-
-------------------
-5.5.1 - 2020-02-07
-------------------
-
-This patch has some tiny internal code clean-ups, with no user-visible change.
-
-.. _v5.5.0:
-
-------------------
-5.5.0 - 2020-02-07
-------------------
-
-:gh-file:`Our style guide <guides/api-style.rst>` suggests that optional
-parameters should usually be keyword-only arguments (see :pep:`3102`) to
-prevent confusion based on positional arguments - for example,
-:func:`hypothesis.strategies.floats` takes up to *four* boolean flags
-and many of the Numpy strategies have both ``dims`` and ``side`` bounds.
-
-This release converts most optional parameters in our API to use
-keyword-only arguments - and adds a compatibility shim so you get
-warnings rather than errors everywhere (:issue:`2130`).
-
-.. _v5.4.2:
-
-------------------
-5.4.2 - 2020-02-06
-------------------
-
-This patch fixes compatibility with Python 3.5.2 (:issue:`2334`).
-Note that :doc:`we only test the latest patch of each minor version <supported>`,
-though as in this case we usually accept pull requests for older patch versions.
-
-.. _v5.4.1:
-
-------------------
-5.4.1 - 2020-02-01
-------------------
-
-This patch improves the repr of :func:`~hypothesis.strategies.from_type`,
-so that in most cases it will display the strategy it resolves to rather
-than ``from_type(...)``.  The latter form will continue to be used where
-resolution is not immediately successful, e.g. invalid arguments or
-recursive type definitions involving forward references.
-
-.. _v5.4.0:
-
-------------------
-5.4.0 - 2020-01-30
-------------------
-
-This release removes support for Python 3.5.0 and 3.5.1, where the
-:mod:`python:typing` module was quite immature (e.g. missing
-:func:`~python:typing.overload` and :obj:`~python:typing.Type`).
-
-Note that Python 3.5 will reach its end-of-life in September 2020,
-and new releases of Hypothesis may drop support somewhat earlier.
-
-.. note::
-    ``pip install hypothesis`` should continue to give you the latest compatible version.
-    If you have somehow ended up with an incompatible version, you need to update your
-    packaging stack to ``pip >= 9.0`` and ``setuptools >= 24.2`` - see `here for details
-    <https://packaging.python.org/guides/distributing-packages-using-setuptools/#python-requires>`__.
-    Then ``pip uninstall hypothesis && pip install hypothesis`` will get you back to
-    a compatible version.
-
-.. _v5.3.1:
-
-------------------
-5.3.1 - 2020-01-26
-------------------
-
-This patch does some minor internal cleanup; there is no user-visible change.
-
-.. _v5.3.0:
-
-------------------
-5.3.0 - 2020-01-21
-------------------
-
-The standard library :mod:`ipaddress` module is new in Python 3, and this release
-adds the new :func:`~hypothesis.strategies.ip_addresses` strategy to generate
-:class:`~python:ipaddress.IPv4Address`\ es and/or
-:class:`~python:ipaddress.IPv6Address`\ es (depending on the ``v`` and ``network``
-arguments).
-
-If you use them in type annotations, :func:`~hypothesis.strategies.from_type` now
-has strategies registered for :mod:`ipaddress` address, network, and interface types.
-
-The provisional strategies for IP address strings are therefore deprecated.
-
-.. _v5.2.1:
-
-------------------
-5.2.1 - 2020-01-21
-------------------
-
-This patch reverts :ref:`version 5.2 <v5.2.0>`, due to a
-`strange issue <https://github.com/numpy/numpy/issues/15363>`__
-where indexing an array of strings can raise an error instead of
-returning an item which contains certain surrogate characters.
-
-.. _v5.2.0:
-
-------------------
-5.2.0 - 2020-01-19
-------------------
-
-This release allows :func:`~hypothesis.extra.numpy.from_dtype` to generate
-Unicode strings which cannot be encoded in UTF-8, but are valid in Numpy
-arrays (which use UTF-32).
-
-.. _v5.1.6:
-
-------------------
-5.1.6 - 2020-01-19
-------------------
-
-This patch fixes :issue:`2320`, where ``from_type(SetHashable)`` could raise
-an internal error because ``Decimal("snan")`` is of a hashable type, but raises
-an error when hashed.  We now ensure that set elements and dict keys in generic
-types can actually be hashed.
-
-.. _v5.1.5:
-
-------------------
-5.1.5 - 2020-01-12
-------------------
-
-This patch fixes an internal error when running in an :pypi:`IPython` repl or
-:pypi:`Jupyter` notebook on Windows (:issue:`2319`), and an internal error on
-Python 3.5.1 (:issue:`2318`).
-
-.. _v5.1.4:
-
-------------------
-5.1.4 - 2020-01-11
-------------------
-
-This patch fixes a bug where errors in third-party extensions such as
-:pypi:`hypothesis-trio` or :pypi:`hypothesis-jsonschema` were incorrectly
-considered to be Hypothesis internal errors, which could result in
-confusing error messages.
-
-Thanks to Vincent Michel for reporting and fixing the bug!
-
-.. _v5.1.3:
-
-------------------
-5.1.3 - 2020-01-11
-------------------
-
-This release converts the type hint comments on our public API to
-:pep:`484` type annotations.
-
-Thanks to Ivan Levkivskyi for :pypi:`com2ann` - with the refactoring
-tools from :ref:`5.0.1 <v5.0.1>` it made this process remarkably easy!
-
-.. _v5.1.2:
-
-------------------
-5.1.2 - 2020-01-09
-------------------
-
-This patch makes :func:`~hypothesis.stateful.multiple` iterable, so that
-output like ``a, b = state.some_rule()`` is actually executable and
-can be used to reproduce failing examples.
-
-Thanks to Vincent Michel for reporting and fixing :issue:`2311`!
-
-.. _v5.1.1:
-
-------------------
-5.1.1 - 2020-01-06
-------------------
-
-This patch contains many small refactorings to replace our Python 2
-compatibility functions with their native Python 3 equivalents.
-Since Hypothesis is now Python 3 only, there is no user-visible change.
-
-.. _v5.1.0:
-
-------------------
-5.1.0 - 2020-01-03
-------------------
-
-This release teaches :func:`~hypothesis.strategies.from_type` how to generate
-:class:`python:datetime.timezone`.  As a result, you can now generate
-:class:`python:datetime.tzinfo` objects without having :pypi:`pytz` installed.
-
-If your tests specifically require :pypi:`pytz` timezones, you should be using
-:func:`hypothesis.extra.pytz.timezones` instead of ``st.from_type(tzinfo)``.
-
-.. _v5.0.1:
-
-------------------
-5.0.1 - 2020-01-01
-------------------
-
-This patch contains mostly-automated refactorings to remove code
-that we only needed to support Python 2.  Since Hypothesis is now
-Python 3 only (hurray!), there is no user-visible change.
-
-Our sincere thanks to the authors of :pypi:`autoflake`, :pypi:`black`,
-:pypi:`isort`, and :pypi:`pyupgrade`, who have each and collectively
-made this kind of update enormously easier.
-
-.. _v5.0.0:
-
-------------------
-5.0.0 - 2020-01-01
-------------------
-
-Welcome to the next major version of Hypothesis!
-
-There are no new features here, as we release those in minor versions.
-Instead, 5.0 is a chance for us to remove deprecated features (many already
-converted into no-ops), and turn a variety of warnings into errors.
-
-If you were running on the last version of Hypothesis 4.x *without any
-Hypothesis deprecation warnings*, this will be a very boring upgrade.
-**In fact, nothing will change for you at all.**
-
-.. note::
-    This release drops support for Python 2, which has passed
-    `its end of life date <https://devguide.python.org/#status-of-python-branches>`__.
-    The `Python 3 Statement <https://python3statement.org/>`__ outlines our
-    reasons, and lists many other packages that have made the same decision.
-
-    ``pip install hypothesis`` should continue to give you the latest compatible version.
-    If you have somehow ended up with Hypothesis 5.0 on Python 2, you need to update your
-    packaging stack to ``pip >= 9.0`` and ``setuptools >= 24.2`` - see `here for details
-    <https://packaging.python.org/guides/distributing-packages-using-setuptools/#python-requires>`__.
-    Then ``pip uninstall hypothesis && pip install hypothesis`` will get you back to
-    a compatible version.
-
-
-Strategies
-~~~~~~~~~~
-- :func:`~hypothesis.strategies.integers` bounds must be equal to an integer,
-  though they can still be other types.
-- If :func:`~hypothesis.strategies.fractions` is passed a ``max_denominator``,
-  the bounds must have at most that denominator.
-- :func:`~hypothesis.strategies.floats` bounds must be exactly representable as a
-  floating-point number with the given ``width``.  If not, the error message
-  includes the nearest such number.
-- :func:`sampled_from() <hypothesis.strategies.sampled_from>` is now an error.
-- The values from the ``elements`` and ``fill`` strategies for
-  :func:`hypothesis.extra.numpy.arrays` must be losslessly representable in an
-  array of the given dtype.
-- The ``min_size`` and ``max_size`` arguments to all collection strategies must
-  be of type :class:`python:int` (or ``max_size`` may be ``None``).
-
-Miscellaneous
-~~~~~~~~~~~~~
-- The ``.example()`` method of strategies (intended for interactive
-  exploration) no longer takes a ``random`` argument.
-- It is now an error to apply :func:`@example <hypothesis.example>`,
-  :func:`@seed <hypothesis.seed>`, or :func:`@reproduce_failure <hypothesis.reproduce_failure>`
-  without also applying :func:`@given <hypothesis.given>`.
-- You may pass either the ``target`` or ``targets`` argument to stateful rules, but not both.
-- :obj:`~hypothesis.settings.deadline` must be ``None`` (to disable), a
-  :class:`~python:datetime.timedelta`, or an integer or float number of milliseconds.
-- Both of :obj:`~hypothesis.settings.derandomize` and
-  :obj:`~hypothesis.settings.print_blob` must be either ``True`` or ``False``,
-  where they previously accepted other values.
-- :obj:`~hypothesis.settings.stateful_step_count` must be at least one.
-- :obj:`~hypothesis.settings.max_examples` must be at least one.
-  To disable example generation, use the :obj:`~hypothesis.settings.phases` setting.
-
-Removals
-~~~~~~~~
-- ``hypothesis.stateful.GenericStateMachine`` in favor of :class:`hypothesis.stateful.RuleBasedStateMachine`
-- ``hypothesis.extra.django.models.models`` in favor of :func:`hypothesis.extra.django.from_model`
-  and ``hypothesis.extra.django.models.add_default_field_mapping`` in favor of
-  :func:`hypothesis.extra.django.register_field_strategy`
-- ``hypothesis.HealthCheck.hung_test``, without replacement
-- ``hypothesis.settings.buffer``, without replacement
-- ``hypothesis.PrintSettings``, because :obj:`hypothesis.settings.print_blob` takes ``True`` or ``False``
-- ``hypothesis.settings.timeout``, in favor of :obj:`hypothesis.settings.deadline`
-- ``hypothesis.unlimited`` without replacement (only only useful as argument to ``timeout``)
-
-Hypothesis 4.x
-==============
-
-.. _v4.57.1:
-
--------------------
-4.57.1 - 2019-12-29
--------------------
-
-This patch improves the type hints and documentation for the
-:doc:`django extra. <django>`  There is no runtime change.
-
-.. _v4.57.0:
-
--------------------
-4.57.0 - 2019-12-28
--------------------
-
-This release improves support for the SupportsOp protocols from the :mod:`python:typing`
-module when using on :func:`~hypothesis.strategies.from_type` as outlined in :issue:`2292`.
-The following types now generate much more varied strategies when called
-with :func:`~hypothesis.strategies.from_type`:
-
-- :class:`python:typing.SupportsAbs`
-- :class:`python:typing.SupportsBytes`
-- :class:`python:typing.SupportsComplex`
-- :class:`python:typing.SupportsInt`
-- :class:`python:typing.SupportsFloat`
-- :class:`python:typing.SupportsRound`
-
-Note that using :func:`~hypothesis.strategies.from_type` with one of the above strategies will not
-ensure that the the specified function will execute successfully (ie : the strategy returned for
-``from_type(typing.SupportsAbs)`` may include NaNs or things which cause the :func:`python:abs`
-function to error. )
-
-Thanks to Lea Provenzano for this patch.
-
-.. _v4.56.3:
-
--------------------
-4.56.3 - 2019-12-22
--------------------
-
-This release fixes a small internal bug in shrinking which could have caused it
-to perform slightly more tests than were necessary. Fixing this shouldn't have
-much effect but it will make shrinking slightly faster.
-
-.. _v4.56.2:
-
--------------------
-4.56.2 - 2019-12-21
--------------------
-
-This release removes an internal heuristic that was no longer providing much
-benefit. It is unlikely that there will be any user visible effect.
-
-.. _v4.56.1:
-
--------------------
-4.56.1 - 2019-12-19
--------------------
-
-This release further improves the optimisation algorithm for :ref:`targeted property-based testing <targeted-search>`.
-
-.. _v4.56.0:
-
--------------------
-4.56.0 - 2019-12-18
--------------------
-
-This release enables deprecation warnings even when the
-:obj:`~hypothesis.settings.verbosity` setting is ``quiet``,
-in preparation for Hypothesis 5.0 (:issue:`2218`).
-
-Warnings can still be filtered by the standard mechanisms
-provided in the standard-library :mod:`python:warnings` module.
-
-.. _v4.55.4:
-
--------------------
-4.55.4 - 2019-12-18
--------------------
-
-This release improves Hypothesis's management of the set of test cases it
-tracks between runs. It will only do anything if you have the
-:obj:`~hypothesis.Phase.target` phase enabled and an example database set.
-In those circumstances it should result in a more thorough and faster set of examples
-that are tried on each run.
-
-.. _v4.55.3:
-
--------------------
-4.55.3 - 2019-12-18
--------------------
-
-This release makes Hypothesis better at generating test cases where generated
-values are duplicated in different parts of the test case. This will be
-especially noticeable with reasonably complex values, as it was already able
-to do this for simpler ones such as integers or floats.
-
-.. _v4.55.2:
-
--------------------
-4.55.2 - 2019-12-17
--------------------
-
-This release expands the set of test cases that Hypothesis saves in its
-database for future runs to include a representative set of "structurally
-different" test cases - e.g. it might try to save test cases where a given list
-is empty or not.
-
-Currently this is unlikely to have much user visible impact except to produce
-slightly more consistent behaviour between consecutive runs of a test suite.
-It is mostly groundwork for future improvements which will exploit this
-functionality more effectively.
-
-.. _v4.55.1:
-
--------------------
-4.55.1 - 2019-12-16
--------------------
-
-This patch fixes :issue:`2257`, where :func:`~hypothesis.strategies.from_type`
-could incorrectly generate bytestrings when passed a generic
-:class:`python:typing.Sequence` such as ``Sequenceset``.
-
-.. _v4.55.0:
-
--------------------
-4.55.0 - 2019-12-16
--------------------
-
-This release adds database support for :ref:`targeted property-based testing <targeted-search>`,
-so the best examples based on the targeting will be saved and reused between runs.
-This is mostly laying groundwork for future features in this area, but
-will also make targeted property-based tests more useful during development,
-where the same tests tend to get run over and over again.
-
-If :obj:`~hypothesis.settings.max_examples` is large, this may increase memory
-usage significantly under some circumstances, but these should be relatively
-rare.
-
-This release also adds a dependency on the :pypi:`sortedcontainers` package.
-
-.. _v4.54.2:
-
--------------------
-4.54.2 - 2019-12-16
--------------------
-
-This release improves the optimisation algorithm for :ref:`targeted property-based testing <targeted-search>`,
-so that it will find higher quality results more reliably. Specifically, in cases where it would previously have got near a local optimum,
-it will now tend to achieve the locally optimal value.
-
-.. _v4.54.1:
-
--------------------
-4.54.1 - 2019-12-16
--------------------
-
-This release is mostly internal changes in support of better testing of the
-core engine. You are unlikely to see much effect, although some internal
-heuristics have changed slightly.
-
-.. _v4.54.0:
-
--------------------
-4.54.0 - 2019-12-15
--------------------
-
-This release adds a dedicated phase for :ref:`targeted property-based testing <targeted-search>`,
-and (somewhat) improves the targeting algorithm so that it will find higher quality results more reliably.
-This comes at a cost of making it more likely to get stuck in a local optimum.
-
-.. _v4.53.3:
-
--------------------
-4.53.3 - 2019-12-15
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` with
-:class:`python:typing.Hashable` and :class:`python:typing.Sized`,
-which previously failed with an internal error on Python 3.7 or later.
-
-Thanks to Lea Provenzano for both reporting :issue:`2272`
-and writing the patch!
-
-.. _v4.53.2:
-
--------------------
-4.53.2 - 2019-12-11
--------------------
-
-This release reorganises a number of the Hypothesis internal modules into a
-package structure. If you are only depending on the public API it should have
-no effect. If you are depending on the internal API (which you shouldn't be,
-and which we don't guarantee compatibility on) you may have to rename some
-imports.
-
-.. _v4.53.1:
-
--------------------
-4.53.1 - 2019-12-09
--------------------
-
-This release changes the size distribution of the number of steps run in
-stateful testing: It will now almost always run the maximum number of steps
-permitted.
-
-.. _v4.53.0:
-
--------------------
-4.53.0 - 2019-12-09
--------------------
-
-:ref:`statistics` now include the best score seen for each label, which can help avoid
-`the threshold problem <https://hypothesis.works/articles/threshold-problem/>`__  when
-the minimal example shrinks right down to the threshold of failure (:issue:`2180`).
-
-.. _v4.52.0:
-
--------------------
-4.52.0 - 2019-12-09
--------------------
-
-This release changes the ``stateful_step_count`` setting to raise an error if
-set to ``0``. This is a backwards compatible change because a value of ``0``
-would never have worked and attempting to run it would have resulted in an
-internal assertion error.
-
-.. _v4.51.1:
-
--------------------
-4.51.1 - 2019-12-09
--------------------
-
-This release makes a small internal change to the distribution of test cases.
-It is unlikely to have much user visible impact.
-
-.. _v4.51.0:
-
--------------------
-4.51.0 - 2019-12-07
--------------------
-
-This release deprecates use of :func:`@example <hypothesis.example>`,
-:func:`@seed <hypothesis.seed>`, or :func:`@reproduce_failure <hypothesis.reproduce_failure>`
-without :func:`@given <hypothesis.given>`.
-
-Thanks to Nick Anyos for the patch!
-
-.. _v4.50.8:
-
--------------------
-4.50.8 - 2019-12-05
--------------------
-
-This patch makes certain uses of Bundles more efficient in stateful testing (:issue:`2078`).
-
-.. _v4.50.7:
-
--------------------
-4.50.7 - 2019-12-05
--------------------
-
-This release refactors some of Hypothesis's internal interfaces for representing
-data generation. It should have no user visible effect.
-
-.. _v4.50.6:
-
--------------------
-4.50.6 - 2019-12-02
--------------------
-
-This patch removes some old debugging helpers in our Numpy extra which have
-not been needed since :issue:`1963` and :issue:`2245`.
-
-.. _v4.50.5:
-
--------------------
-4.50.5 - 2019-12-01
--------------------
-
-This patch fixes :issue:`2229`, where Numpy arrays of unsized strings would
-only ever have strings of size one due to an interaction between our generation
-logic and Numpy's allocation strategy.
-
-.. _v4.50.4:
-
--------------------
-4.50.4 - 2019-12-01
--------------------
-
-This patch fixes a rare internal error in strategies for a list of
-unique items sampled from a short non-unique sequence (:issue:`2247`).
-The bug was discovered via :pypi:`hypothesis-jsonschema`.
-
-.. _v4.50.3:
-
--------------------
-4.50.3 - 2019-12-01
--------------------
-
-This release improves the error message when
-:func:`@settings <hypothesis.settings>` tries to inherit settings from a
-``parent`` argument that isn't a ``settings`` instance.
-
-.. _v4.50.2:
-
--------------------
-4.50.2 - 2019-11-29
--------------------
-
-This release improves Hypothesis's "Falsifying example" output, by breaking
-output across multiple lines where necessary, and by removing irrelevant
-information from the stateful testing output.
-
-.. _v4.50.1:
-
--------------------
-4.50.1 - 2019-11-29
--------------------
-
-This patch adds :pypi:`flake8-comprehensions` to our linter suite.  There is no
-user-visible change - expect perhaps via some strange microbenchmarks - but
-certain parts of the code now have a clear and more consistent style.
-
-.. _v4.50.0:
-
--------------------
-4.50.0 - 2019-11-28
--------------------
-
-This release fixes some cases where we might previously have failed to run the
-validation logic for some strategies. As a result tests which would previously
-have been silently testing significantly less than they should may now start
-to raise ``InvalidArgument`` now that these errors are caught.
-
-.. _v4.49.0:
-
--------------------
-4.49.0 - 2019-11-28
--------------------
-
-This release significantly improves the data distribution in :doc:`rule based stateful testing <stateful>`,
-by using a technique called `Swarm Testing (Groce, Alex, et al. "Swarm testing."
-Proceedings of the 2012 International Symposium on Software Testing and Analysis. ACM, 2012.) <https://agroce.github.io/issta12.pdf>`_
-to select which rules are run in any given test case. This should allow it to find many issues that it would previously have missed.
-
-This change is likely to be especially beneficial for stateful tests with large numbers of rules.
-
-.. _v4.48.1:
-
--------------------
-4.48.1 - 2019-11-28
--------------------
-
-This release adds some heuristics to test case generation that try to ensure that test cases generated early on will be relatively small.
-
-This fixes a bug introduced in :ref:`Hypothesis 4.42.0 <v4.42.0>` which would cause occasional
-:obj:`~hypothesis.HealthCheck.too_slow` failures on some tests.
-
-.. _v4.48.0:
-
--------------------
-4.48.0 - 2019-11-28
--------------------
-
-This release revokes the deprecation of ``find``, as we've now rebuilt it on top of
-``@given``, which means it has minimal maintenance burden and we're happy to support it.
-
-.. _v4.47.5:
-
--------------------
-4.47.5 - 2019-11-28
--------------------
-
-This release rebuilds ``find()`` on top of ``@given`` in order to have more code in common.
-It should have minimal user visible effect.
-
-.. _v4.47.4:
-
--------------------
-4.47.4 - 2019-11-27
--------------------
-
-This patch removes an internal compatibility shim that we no longer need.
-
-.. _v4.47.3:
-
--------------------
-4.47.3 - 2019-11-26
--------------------
-
-This patch fixes several typos in our docstrings and comments,
-with no change in behaviour.  Thanks to  Dmitry Dygalo for
-identifying and fixing them!
-
-.. _v4.47.2:
-
--------------------
-4.47.2 - 2019-11-25
--------------------
-
-This release fixes an internal issue where Hypothesis would sometimes generate
-test cases that were above its intended maximum size. This would only have
-happened rarely and probably would not have caused major problems when it did.
-
-Users of the new  :ref:`targeted property-based testing <targeted-search>` might
-see minor impact (possibly slightly faster tests and slightly worse target scores),
-but only in the unlikely event that they were hitting this problem. Other users
-should not see any effect at all.
-
-.. _v4.47.1:
-
--------------------
-4.47.1 - 2019-11-24
--------------------
-
-This release removes some unused code from the core engine.
-There is no user-visible change.
-
-.. _v4.47.0:
-
--------------------
-4.47.0 - 2019-11-24
--------------------
-
-This release commonizes some code between running explicit examples and normal test execution.
-The main user visible impact of this is that deadlines are now enforced when running explicit examples.
-
-.. _v4.46.1:
-
--------------------
-4.46.1 - 2019-11-23
--------------------
-
-This patch ensures that a KeyboardInterrupt received during example generation
-is not treated as a mystery test failure but instead propagates to the top
-level, not recording the interrupted generation in the conjecture data tree.
-Thanks to Anne Archibald for identifying and fixing the problem.
-
-.. _v4.46.0:
-
--------------------
-4.46.0 - 2019-11-22
--------------------
-
-This release changes the behaviour of :func:`~hypothesis.strategies.floats`
-when excluding signed zeros - ``floats(max_value=0.0, exclude_max=True)``
-can no longer generate ``-0.0`` nor the much rarer
-``floats(min_value=-0.0, exclude_min=True)`` generate ``+0.0``.
-
-The correct interaction between signed zeros and exclusive endpoints was unclear;
-we now enforce the invariant that :func:`~hypothesis.strategies.floats` will
-never generate a value equal to an excluded endpoint (:issue:`2201`).
-
-If you prefer the old behaviour, you can pass ``floats(max_value=-0.0)`` or
-``floats(min_value=0.0)`` which is exactly equivalent and has not changed.
-If you had *two* endpoints equal to zero, we recommend clarifying your tests by using
-:func:`~hypothesis.strategies.just` or :func:`~hypothesis.strategies.sampled_from`
-instead of :func:`~hypothesis.strategies.floats`.
-
-.. _v4.45.1:
-
--------------------
-4.45.1 - 2019-11-20
--------------------
-
-This patch improves the error message when invalid arguments are passed
-to :func:`~hypothesis.stateful.rule` or :func:`~hypothesis.stateful.invariant`
-(:issue:`2149`).
-
-Thanks to Benjamin Palmer for this bugfix!
-
-.. _v4.45.0:
-
--------------------
-4.45.0 - 2019-11-20
--------------------
-
-This release supports :obj:`python:typing.Final` and :obj:`python:typing.TypedDict`
-in :func:`~hypothesis.strategies.from_type`.
-
-.. _v4.44.5:
-
--------------------
-4.44.5 - 2019-11-20
--------------------
-
-This patch disables our :pypi:`pytest` plugin when running on versions
-of :pypi:`pytest` before 4.3, the oldest our plugin supports.
-Note that at time of writing the Pytest developers only support 4.6 and later!
-
-Hypothesis *tests* using :func:`@given() <hypothesis.given>` work on any
-test runner, but our integrations to e.g. avoid example database collisions
-when combined with ``@pytest.mark.parametrize`` eventually drop support
-for obsolete versions.
-
-.. _v4.44.4:
-
--------------------
-4.44.4 - 2019-11-20
--------------------
-
-This patch adds some internal comments and clarifications to the Hypothesis
-implementation. There is no user-visible change.
-
-.. _v4.44.3:
-
--------------------
-4.44.3 - 2019-11-20
--------------------
-
-This patch avoids importing test runners such as :pypi:`pytest`, :pypi:`unittest2`,
-or :pypi:`nose` solely to access their special "skip test" exception types -
-if the module is not in :obj:`sys.modules`, the exception can't be raised anyway.
-
-This fixes a problem where importing an otherwise unused module could cause
-spurious errors due to import-time side effects (and possibly ``-Werror``).
-
-.. _v4.44.2:
-
--------------------
-4.44.2 - 2019-11-12
--------------------
-
-This release fixes :func:`@given <hypothesis.given>` to only complain about
-missing keyword-only arguments if the associated test function is actually
-called.
-
-This matches the behaviour of other ``InvalidArgument`` errors produced by
-``@given``.
-
-.. _v4.44.1:
-
--------------------
-4.44.1 - 2019-11-11
--------------------
-
-This patch allows Hypothesis to run in environments that do not specify
-a ``__file__``, such as a :mod:`python:zipapp` (:issue:`2196`).
-
-.. _v4.44.0:
-
--------------------
-4.44.0 - 2019-11-11
--------------------
-
-This release adds a ``signature`` argument to
-:func:`~hypothesis.extra.numpy.mutually_broadcastable_shapes` (:issue:`2174`),
-which allows us to generate shapes which are valid for functions like
-:data:`np.matmul() <numpy:numpy.matmul>` that require shapes which are not simply broadcastable.
-
-Thanks to everyone who has contributed to this feature over the last year,
-and a particular shout-out to Zac Hatfield-Dodds and Ryan Soklaski for
-:func:`~hypothesis.extra.numpy.mutually_broadcastable_shapes` and to
-Ryan Turner for the downstream :pypi:`hypothesis-gufunc` project.
-
-.. _v4.43.9:
-
--------------------
-4.43.9 - 2019-11-11
--------------------
-
-This patch fixes :issue:`2108`, where the first test using
-:func:`~hypothesis.strategies.data` to draw from :func:`~hypothesis.strategies.characters`
-or :func:`~hypothesis.strategies.text` would be flaky due to unreliable test timings.
-
-Time taken by lazy instantiation of strategies is now counted towards drawing from
-the strategy, rather than towards the deadline for the test function.
-
-.. _v4.43.8:
-
--------------------
-4.43.8 - 2019-11-08
--------------------
-
-This release ensures that the strategies passed to
-:func:`@given <hypothesis.given>` are properly validated when applied to a test
-method inside a test class.
-
-This should result in clearer error messages when some of those strategies are
-invalid.
-
-.. _v4.43.7:
-
--------------------
-4.43.7 - 2019-11-08
--------------------
-
-This release changes how Hypothesis manages its search space in cases where it
-generates redundant data. This should cause it to generate significantly fewer
-duplicated examples (especially with short integer ranges), and may cause it to
-produce more useful examples in some cases (especially ones where there is a
-significant amount of filtering).
-
-.. _v4.43.6:
-
--------------------
-4.43.6 - 2019-11-07
--------------------
-
-This patch refactors ``width`` handling in :func:`~hypothesis.strategies.floats`;
-you may notice small performance improvements but the main purpose is to
-enable work on :issue:`1704` (improving shrinking of bounded floats).
-
-.. _v4.43.5:
-
--------------------
-4.43.5 - 2019-11-06
--------------------
-
-This patch removes an unused internal flag.
-There is no user-visible change.
-
-.. _v4.43.4:
-
--------------------
-4.43.4 - 2019-11-05
--------------------
-
-This patch corrects the exception type and error message you get if you attempt
-to use :func:`~hypothesis.strategies.data` to draw from something which is not
-a strategy.  This never worked, but the error is more helpful now.
-
-.. _v4.43.3:
-
--------------------
-4.43.3 - 2019-11-05
--------------------
-
-We've adopted :pypi:`flake8-bugbear` to check for a few more style issues,
-and this patch implements the minor internal cleanups it suggested.
-There is no user-visible change.
-
-.. _v4.43.2:
-
--------------------
-4.43.2 - 2019-11-05
--------------------
-
-This patch fixes the formatting of some documentation,
-but there is no change to any executed code.
-
-.. _v4.43.1:
-
--------------------
-4.43.1 - 2019-11-04
--------------------
-
-Python 3.8's new :obj:`python:typing.Literal` type - see :pep:`586` for
-details - is now  supported in :func:`~hypothesis.strategies.from_type`.
-
-.. _v4.43.0:
-
--------------------
-4.43.0 - 2019-11-04
--------------------
-
-This release adds the strategy :func:`~hypothesis.extra.numpy.mutually_broadcastable_shapes`, which generates multiple array shapes that are mutually broadcast-compatible with an optional user-specified base-shape.
-
-This is a generalisation of :func:`~hypothesis.extra.numpy.broadcastable_shapes`.
-It relies heavily on non-public internals for performance when generating and shrinking examples.
-We intend to support generating shapes matching a ufunc signature in a future version (:issue:`2174`).
-
-Thanks to Ryan Soklaski, Zac Hatfield-Dodds, and @rdturnermtl who contributed to this new feature.
-
-.. _v4.42.10:
-
---------------------
-4.42.10 - 2019-11-03
---------------------
-
-This release fixes :func:`~hypothesis.strategies.from_type` when used with
-bounded or constrained :obj:`python:typing.TypeVar` objects (:issue:`2094`).
-
-Previously, distinct typevars with the same constraints would be treated as all
-single typevar, and in cases where a typevar bound was resolved to a union of
-subclasses this could result in mixed types being generated for that typevar.
-
-.. _v4.42.9:
-
--------------------
-4.42.9 - 2019-11-03
--------------------
-
-This patch ensures that the default value :func:`~hypothesis.extra.numpy.broadcastable_shapes`
-chooses for ``max_dims`` is always valid (at most 32), even if you pass ``min_dims=32``.
-
-.. _v4.42.8:
-
--------------------
-4.42.8 - 2019-11-02
--------------------
-
-This patch ensures that we only add profile information to the pytest header
-if running either pytest or Hypothesis in verbose mode, matching the
-`builtin cache plugin <https://docs.pytest.org/en/latest/how-to/cache.html>`__
-(:issue:`2155`).
-
-.. _v4.42.7:
-
--------------------
-4.42.7 - 2019-11-02
--------------------
-
-This patch makes stateful step printing expand the result of a step into
-multiple variables when you return :func:`~hypothesis.stateful.multiple` (:issue:`2139`).
-Thanks to Joseph Weston for reporting and fixing this bug!
-
-.. _v4.42.6:
-
--------------------
-4.42.6 - 2019-11-02
--------------------
-
-This release fixes a bug (:issue:`2166`) where a Unicode character info
-cache file was generated but never used on subsequent test runs, causing tests
-to run more slowly than they should have.
-
-Thanks to Robert Knight for this bugfix!
-
-.. _v4.42.5:
-
--------------------
-4.42.5 - 2019-11-01
--------------------
-
-This patch corrects some internal documentation.  There is no user-visible change.
-
-.. _v4.42.4:
-
--------------------
-4.42.4 - 2019-11-01
--------------------
-
-This release fixes a bug (:issue:`2160`) where decorators applied after
-:func:`@settings <hypothesis.settings>` and before
-:func:`@given <hypothesis.given>` were ignored.
-
-Thanks to Tom Milligan for this bugfix!
-
-.. _v4.42.3:
-
--------------------
-4.42.3 - 2019-10-30
--------------------
-
-This release updates Hypothesis's formatting to the new version of :pypi:`black`, and
-has absolutely no user visible effect.
-
-.. _v4.42.2:
-
--------------------
-4.42.2 - 2019-10-30
--------------------
-
-This release fixes a bug in :func:`~hypothesis.strategies.recursive` which would
-have meant that in practice ``max_leaves`` was treated as if it was lower than
-it actually is - specifically it would be capped at the largest power of two
-smaller than it. It is now handled correctly.
-
-.. _v4.42.1:
-
--------------------
-4.42.1 - 2019-10-30
--------------------
-
-Python 3.8's new :class:`python:typing.SupportsIndex` type - see :pep:`357`
-for details - is now  supported in :func:`~hypothesis.strategies.from_type`.
-
-Thanks to Grigorios Giannakopoulos for the patch!
-
-.. _v4.42.0:
-
--------------------
-4.42.0 - 2019-10-27
--------------------
-
-This release significantly simplifies Hypothesis's internal logic for data
-generation, by removing a number of heuristics of questionable or unproven
-value.
-
-The results of this change will vary significantly from test to test. Most
-test suites will see significantly faster data generation and lower memory
-usage. The "quality" of the generated data may go up or down depending on your
-particular test suites.
-
-If you see any significant regressions in Hypothesis's ability to find bugs in
-your code as a result of this release, please file an issue to let us know.
-
-Users of the new  :ref:`targeted property-based testing <targeted-search>`
-functionality are reasonably likely to see *improvements* in data generation,
-as this release changes the search algorithm for targeted property based
-testing to one that is more likely to be productive than the existing approach.
-
-.. _v4.41.3:
-
--------------------
-4.41.3 - 2019-10-21
--------------------
-
-This patch is to ensure that our internals remain comprehensible to
-:pypi:`mypy` 0.740 - there is no user-visible change.
-
-.. _v4.41.2:
-
--------------------
-4.41.2 - 2019-10-17
--------------------
-
-This patch changes some internal hashes to SHA384, to better support
-users subject to FIPS-140. There is no user-visible API change.
-
-Thanks to Paul Kehrer for this contribution!
-
-.. _v4.41.1:
-
--------------------
-4.41.1 - 2019-10-16
--------------------
-
-This release makes ``--hypothesis-show-statistics`` much more useful for
-tests using a :class:`~hypothesis.stateful.RuleBasedStateMachine`, by
-simplifying the reprs so that events are aggregated correctly.
-
-.. _v4.41.0:
-
--------------------
-4.41.0 - 2019-10-16
--------------------
-
-This release upgrades the :func:`~hypothesis.strategies.fixed_dictionaries`
-strategy to support ``optional`` keys (:issue:`1913`).
-
-.. _v4.40.2:
-
--------------------
-4.40.2 - 2019-10-16
--------------------
-
-This release makes some minor internal changes in support of improving the
-Hypothesis test suite. It should not have any user visible impact.
-
-.. _v4.40.1:
-
--------------------
-4.40.1 - 2019-10-14
--------------------
-
-This release changes how Hypothesis checks if a parameter to a test function is a mock object.
-It is unlikely to have any noticeable effect, but may result in a small performance improvement,
-especially for test functions where a mock object is being passed as the first argument.
-
-.. _v4.40.0:
-
--------------------
-4.40.0 - 2019-10-09
--------------------
-
-This release fixes a bug where our example database logic did not distinguish
-between failing examples based on arguments from a ``@pytest.mark.parametrize(...)``.
-This could in theory cause data loss if a common failure overwrote a rare one, and
-in practice caused occasional file-access collisions in highly concurrent workloads
-(e.g. during a 300-way parametrize on 16 cores).
-
-For internal reasons this also involves bumping the minimum supported version of
-:pypi:`pytest` to 4.3
-
-Thanks to Peter C Kroon for the Hacktoberfest patch!
-
-.. _v4.39.3:
-
--------------------
-4.39.3 - 2019-10-09
--------------------
-
-This patch improves our type hints on the :func:`~hypothesis.strategies.emails`,
-:func:`~hypothesis.strategies.functions`, :func:`~hypothesis.strategies.integers`,
-:func:`~hypothesis.strategies.iterables`, and :func:`~hypothesis.strategies.slices`
-strategies, as well as the ``.filter()`` method.
-
-There is no runtime change, but if you use :pypi:`mypy` or a similar
-type-checker on your tests the results will be a bit more precise.
-
-.. _v4.39.2:
-
--------------------
-4.39.2 - 2019-10-09
--------------------
-
-This patch improves the performance of unique collections such as
-:func:`~hypothesis.strategies.sets` of :func:`~hypothesis.strategies.just`
-or :func:`~hypothesis.strategies.booleans` strategies.  They were already
-pretty good though, so you're unlikely to notice much!
-
-.. _v4.39.1:
-
--------------------
-4.39.1 - 2019-10-09
--------------------
-
-If a value in a dict passed to :func:`~hypothesis.strategies.fixed_dictionaries`
-is not a strategy, Hypothesis now tells you which one.
-
-.. _v4.39.0:
-
--------------------
-4.39.0 - 2019-10-07
--------------------
-
-This release adds the :func:`~hypothesis.extra.numpy.basic_indices` strategy,
-to generate `basic indexes <https://numpy.org/doc/stable/reference/arrays.indexing.html>`__
-for arrays of the specified shape (:issue:`1930`).
-
-It generates tuples containing some mix of integers, :obj:`python:slice` objects,
-``...`` (Ellipsis), and :obj:`numpy:numpy.newaxis`; which when used to index an array
-of the specified shape produce either a scalar or a shared-memory view of the array.
-Note that the index tuple may be longer or shorter than the array shape, and may
-produce a view with another dimensionality again!
-
-Thanks to Lampros Mountrakis, Ryan Soklaski, and Zac Hatfield-Dodds for their
-collaboration on this surprisingly subtle strategy!
-
-.. _v4.38.3:
-
--------------------
-4.38.3 - 2019-10-04
--------------------
-
-This patch defers creation of the ``.hypothesis`` directory until we have
-something to store in it, meaning that it will appear when Hypothesis is
-used rather than simply installed.
-
-Thanks to Peter C Kroon for the Hacktoberfest patch!
-
-.. _v4.38.2:
-
--------------------
-4.38.2 - 2019-10-02
--------------------
-
-This patch bumps our dependency on :pypi:`attrs` to ``>=19.2.0``;
-but there are no user-visible changes to Hypothesis.
-
-.. _v4.38.1:
-
--------------------
-4.38.1 - 2019-10-01
--------------------
-
-This is a comment-only patch which tells :pypi:`mypy` 0.730 to ignore
-some internal compatibility shims we use to support older Pythons.
-
-.. _v4.38.0:
-
--------------------
-4.38.0 - 2019-10-01
--------------------
-
-This release adds the :func:`hypothesis.target` function, which implements
-:ref:`targeted property-based testing <targeted-search>`
-(:issue:`1779`).
-
-By calling :func:`~hypothesis.target` in your test function, Hypothesis can
-do a hill-climbing search for bugs.  If you can calculate a suitable metric
-such as the load factor or length of a queue, this can help you find bugs with
-inputs that are highly improbably from unguided generation - however good our
-heuristics, example diversity, and deduplication logic might be.  After all,
-those features are at work in targeted PBT too!
-
-.. _v4.37.0:
-
--------------------
-4.37.0 - 2019-09-28
--------------------
-
-This release emits a warning if you use the ``.example()`` method of
-a strategy in a non-interactive context.
-
-:func:`~hypothesis.given` is a much better choice for writing tests,
-whether you care about performance, minimal examples, reproducing
-failures, or even just the variety of inputs that will be tested!
-
-.. _v4.36.2:
-
--------------------
-4.36.2 - 2019-09-20
--------------------
-
-This patch disables part of the :mod:`typing`-based inference for the
-:pypi:`attrs` package under Python 3.5.0, which has some incompatible
-internal details (:issue:`2095`).
-
-.. _v4.36.1:
-
--------------------
-4.36.1 - 2019-09-17
--------------------
-
-This patch fixes a bug in strategy inference for :pypi:`attrs` classes where
-Hypothesis would fail to infer a strategy for attributes of a generic type
-such as ``Unionint, str`` or ``Listbool`` (:issue:`2091`).
-
-Thanks to Jonathan Gayvallet for the bug report and this patch!
-
-.. _v4.36.0:
-
--------------------
-4.36.0 - 2019-09-09
--------------------
-
-This patch deprecates ``min_len`` or ``max_len`` of 0 in
-:func:`~hypothesis.extra.numpy.byte_string_dtypes` and
-:func:`~hypothesis.extra.numpy.unicode_string_dtypes`.
-The lower limit is now 1.
-
-Numpy uses a length of 0 in these dtypes to indicate an undetermined size,
-chosen from the data at array creation.
-However, as the :func:`~hypothesis.extra.numpy.arrays` strategy creates arrays
-before filling them, strings were truncated to 1 byte.
-
-.. _v4.35.1:
-
--------------------
-4.35.1 - 2019-09-09
--------------------
-
-This patch improves the messaging that comes from invalid size arguments
-to collection strategies such as :func:`~hypothesis.strategies.lists`.
-
-.. _v4.35.0:
-
--------------------
-4.35.0 - 2019-09-04
--------------------
-
-This release improves the :func:`~hypothesis.extra.lark.from_lark` strategy,
-tightening argument validation and adding the ``explicit`` argument to allow use
-with terminals that use ``@declare`` instead of a string or regular expression.
-
-This feature is required to handle features such as indent and dedent tokens
-in Python code, which can be generated with the :pypi:`hypothesmith` package.
-
-.. _v4.34.0:
-
--------------------
-4.34.0 - 2019-08-23
--------------------
-
-The :func:`~hypothesis.strategies.from_type` strategy now knows to look up
-the subclasses of abstract types, which cannot be instantiated directly.
-
-This is very useful for :pypi:`hypothesmith` to support :pypi:`libCST`.
-
-.. _v4.33.1:
-
--------------------
-4.33.1 - 2019-08-21
--------------------
-
-This patch works around a crash when an incompatible version of Numpy
-is installed under PyPy 5.10 (Python 2.7).
-
-If you are still using Python 2, please upgrade to Python 3 as soon
-as possible - it will be unsupported at the end of this year.
-
-.. _v4.33.0:
-
--------------------
-4.33.0 - 2019-08-20
--------------------
-
-This release improves the :func:`~hypothesis.provisional.domains`
-strategy, as well as the :func:`~hypothesis.provisional.urls` and
-the :func:`~hypothesis.strategies.emails` strategies which use it.
-These strategies now use the full IANA list of Top Level Domains
-and are correct as per :rfc:`1035`.
-
-Passing tests using these strategies may now fail.
-
-Thanks to `TechDragon <https://github.com/techdragon>`__ for this improvement.
-
-.. _v4.32.3:
-
--------------------
-4.32.3 - 2019-08-05
--------------------
-
-This patch tidies up the repr of several ``settings``-related objects,
-at runtime and in the documentation, and deprecates the undocumented
-edge case that ``phases=None`` was treated like ``phases=tuple(Phase)``.
-
-It *also* fixes :func:`~hypothesis.extra.lark.from_lark` with
-:pypi:`lark 0.7.2 <lark-parser>` and later.
-
-.. _v4.32.2:
-
--------------------
-4.32.2 - 2019-07-30
--------------------
-
-This patch updates some internal comments for :pypi:`mypy` 0.720.
-There is no user-visible impact.
-
-.. _v4.32.1:
-
--------------------
-4.32.1 - 2019-07-29
--------------------
-
-This release changes how the shrinker represents its progress internally. For large generated test cases
-this should result in significantly less memory usage and possibly faster shrinking. Small generated
-test cases may be slightly slower to shrink but this shouldn't be very noticeable.
-
-.. _v4.32.0:
-
--------------------
-4.32.0 - 2019-07-28
--------------------
-
-This release makes :func:`~hypothesis.extra.numpy.arrays` more pedantic about
-``elements`` strategies that cannot be exactly represented as array elements.
-
-In practice, you will see new warnings if you were using a ``float16`` or
-``float32`` dtype without passing :func:`~hypothesis.strategies.floats` the
-``width=16`` or ``width=32`` arguments respectively.
-
-The previous behaviour could lead to silent truncation, and thus some elements
-being equal to an explicitly excluded bound (:issue:`1899`).
-
-.. _v4.31.1:
-
--------------------
-4.31.1 - 2019-07-28
--------------------
-
-This patch changes an internal use of MD5 to SHA hashes, to better support
-users subject to FIPS-140.  There is no user-visible or API change.
-
-Thanks to Alex Gaynor for this patch.
-
-.. _v4.31.0:
-
--------------------
-4.31.0 - 2019-07-24
--------------------
-
-This release simplifies the logic of the :attr:`~hypothesis.settings.print_blob` setting by removing the option to set it to ``PrintSettings.INFER``.
-As a result the ``print_blob`` setting now takes a single boolean value, and the use of ``PrintSettings`` is deprecated.
-
-.. _v4.28.2:
-
--------------------
-4.28.2 - 2019-07-14
--------------------
-
-This patch improves the docstrings of several Hypothesis strategies, by
-clarifying markup and adding cross-references.  There is no runtime change.
-
-Thanks to Elizabeth Williams and Serah Njambi Rono for their contributions
-at the SciPy 2019 sprints!
-
-.. _v4.28.1:
-
--------------------
-4.28.1 - 2019-07-12
--------------------
-
-This patch improves the behaviour of the :func:`~hypothesis.strategies.text`
-strategy when passed an ``alphabet`` which is not a strategy.  The value is
-now interpreted as ``whitelist_characters`` to :func:`~hypothesis.strategies.characters`
-instead of a sequence for :func:`~hypothesis.strategies.sampled_from`, which
-standardises the distribution of examples and the shrinking behaviour.
-
-You can get the previous behaviour by using
-``lists(sampled_from(alphabet)).map("".map)`` instead.
-
-.. _v4.28.0:
-
--------------------
-4.28.0 - 2019-07-11
--------------------
-
-This release deprecates ``find()``.  The ``.example()`` method is a better
-replacement if you want *an* example, and for the rare occasions where you
-want the *minimal* example you can get it from :func:`@given <hypothesis.given>`.
-
-:func:`@given <hypothesis.given>` has steadily outstripped ``find()`` in both
-features and performance over recent years, and as we do not have the resources
-to maintain and test both we think it is better to focus on just one.
-
-.. _v4.27.0:
-
--------------------
-4.27.0 - 2019-07-08
--------------------
-
-This release refactors the implementation of the ``.example()`` method,
-to more accurately represent the data which will be generated by
-:func:`@given <hypothesis.given>`.
-
-As a result, calling ``s.example()`` on an empty strategy ``s``
-(such as :func:`~hypothesis.strategies.nothing`) now raises ``Unsatisfiable``
-instead of the old ``NoExamples`` exception.
-
-.. _v4.26.4:
-
--------------------
-4.26.4 - 2019-07-07
--------------------
-
-This patch ensures that the Pandas extra will keep working when Python 3.8
-removes abstract base classes from the top-level :obj:`python:collections`
-namespace.  This also fixes the relevant warning in Python 3.7, but there
-is no other difference in behaviour and you do not need to do anything.
-
-.. _v4.26.3:
-
--------------------
-4.26.3 - 2019-07-05
--------------------
-
-This release fixes  :issue:`2027`, by changing the way Hypothesis tries to generate distinct examples to be more efficient.
-
-This may result in slightly different data distribution, and should improve generation performance in general,
-but should otherwise have minimal user impact.
-
-.. _v4.26.2:
-
--------------------
-4.26.2 - 2019-07-04
--------------------
-
-This release fixes :issue:`1864`, where some simple tests would perform very slowly,
-because they would run many times with each subsequent run being progressively slower.
-They will now stop after a more reasonable number of runs without hitting this problem.
-
-Unless you are hitting exactly this issue, it is unlikely that this release will have any effect,
-but certain classes of custom generators that are currently very slow may become a bit faster,
-or start to trigger health check failures.
-
-.. _v4.26.1:
-
--------------------
-4.26.1 - 2019-07-04
--------------------
-
-This release adds the strategy :func:`~hypothesis.extra.numpy.integer_array_indices`,
-which generates tuples of Numpy arrays that can be used for
-`advanced indexing <http://www.pythonlikeyoumeanit.com/Module3_IntroducingNumpy/AdvancedIndexing.html#Integer-Array-Indexing>`_
-to select an array of a specified shape.
-
-.. _v4.26.0:
-
--------------------
-4.26.0 - 2019-07-04
--------------------
-
-This release significantly improves the performance of drawing unique collections whose
-elements are drawn from  :func:`~hypothesis.strategies.sampled_from`  strategies.
-
-As a side effect, this detects an error condition that would previously have
-passed silently: When the ``min_size`` argument on a collection with distinct elements
-is greater than the number of elements being sampled, this will now raise an error.
-
-.. _v4.25.1:
-
--------------------
-4.25.1 - 2019-07-03
--------------------
-
-This release removes some defunct internal functionality that was only being used
-for testing. It should have no user visible impact.
-
-.. _v4.25.0:
-
--------------------
-4.25.0 - 2019-07-03
--------------------
-
-This release deprecates and disables the ``buffer_size`` setting,
-which should have been treated as a private implementation detail
-all along.  We recommend simply deleting this settings argument.
-
-.. _v4.24.6:
-
--------------------
-4.24.6 - 2019-06-26
--------------------
-
-This patch makes :func:`~hypothesis.strategies.datetimes` more efficient,
-as it now handles short months correctly by construction instead of filtering.
-
-.. _v4.24.5:
-
--------------------
-4.24.5 - 2019-06-23
--------------------
-
-This patch improves the development experience by simplifying the tracebacks
-you will see when e.g. you have used the ``.map(...)`` method of a strategy
-and the mapped function raises an exception.
-
-No new exceptions can be raised, nor existing exceptions change anything but
-their traceback.  We're simply using if-statements rather than exceptions for
-control flow in a certain part of the internals!
-
-.. _v4.24.4:
-
--------------------
-4.24.4 - 2019-06-21
--------------------
-
-This patch fixes :issue:`2014`, where our compatibility layer broke with version
-3.7.4 of the :pypi:`typing` module backport on PyPI.
-
-This issue only affects Python 2.  We remind users that Hypothesis, like many other
-packages, `will drop Python 2 support on 2020-01-01 <https://python3statement.org>`__
-and already has several features that are only available on Python 3.
-
-.. _v4.24.3:
-
--------------------
-4.24.3 - 2019-06-07
--------------------
-
-This patch improves the implementation of an internal wrapper on Python 3.8
-beta1 (and will break on the alphas; but they're not meant to be stable).
-On other versions, there is no change at all.
-
-Thanks to Daniel Hahler for the patch, and Victor Stinner for his work
-on :bpo:`37032` that made it possible.
-
-.. _v4.24.2:
-
--------------------
-4.24.2 - 2019-06-06
--------------------
-
-Deprecation messages for functions in ``hypothesis.extra.django.models`` now
-explicitly name the deprecated function to make it easier to track down usages.
-Thanks to Kristian Glass for this contribution!
-
-.. _v4.24.1:
-
--------------------
-4.24.1 - 2019-06-04
--------------------
-
-This patch fixes :issue:`1999`, a spurious bug raised when a :func:`@st.composite <hypothesis.strategies.composite>` function was passed a keyword-only argument.
-
-Thanks to Jim Nicholls for his fantastic bug report.
-
-.. _v4.24.0:
-
--------------------
-4.24.0 - 2019-05-29
--------------------
-
-This release deprecates ``GenericStateMachine``, in favor of
-:class:`~hypothesis.stateful.RuleBasedStateMachine`.  Rule-based stateful
-testing is significantly faster, especially during shrinking.
-
-If your use-case truly does not fit rule-based stateful testing,
-we recommend writing a custom test function which drives your specific
-control-flow using :func:`~hypothesis.strategies.data`.
-
-.. _v4.23.9:
-
--------------------
-4.23.9 - 2019-05-28
--------------------
-
-This patch fixes a very rare example database issue with file permissions.
-
-When running a test that uses both :func:`@given <hypothesis.given>`
-and ``pytest.mark.parametrize``, using :pypi:`pytest-xdist` on Windows,
-with failing examples in the database, two attempts to read a file could
-overlap and we caught ``FileNotFound`` but not other ``OSError``\ s.
-
-.. _v4.23.8:
-
--------------------
-4.23.8 - 2019-05-26
--------------------
-
-This patch has a minor cleanup of the internal engine.
-There is no user-visible impact.
-
-.. _v4.23.7:
-
--------------------
-4.23.7 - 2019-05-26
--------------------
-
-This patch clarifies some error messages when the test function signature
-is incompatible with the arguments to :func:`@given <hypothesis.given>`,
-especially when the :obj:`@settings() <hypothesis.settings>` decorator
-is also used (:issue:`1978`).
-
-.. _v4.23.6:
-
--------------------
-4.23.6 - 2019-05-19
--------------------
-
-This release adds the :pypi:`pyupgrade` fixer to our code style,
-for consistent use of dict and set literals and comprehensions.
-
-.. _v4.23.5:
-
--------------------
-4.23.5 - 2019-05-16
--------------------
-
-This release slightly simplifies a small part of the core engine.
-There is no user-visible change.
-
-.. _v4.23.4:
-
--------------------
-4.23.4 - 2019-05-09
--------------------
-
-Fixes a minor formatting issue the docstring of :func:`~hypothesis.strategies.from_type`
-
-.. _v4.23.3:
-
--------------------
-4.23.3 - 2019-05-09
--------------------
-
-Adds a recipe to the docstring of :func:`~hypothesis.strategies.from_type`
-that describes a means for drawing values for "everything except" a specified type.
-This recipe is especially useful for writing tests that perform input-type validation.
-
-.. _v4.23.2:
-
--------------------
-4.23.2 - 2019-05-08
--------------------
-
-This patch uses :pypi:`autoflake` to remove some pointless ``pass`` statements,
-which improves our workflow but has no user-visible impact.
-
-.. _v4.23.1:
-
--------------------
-4.23.1 - 2019-05-08
--------------------
-
-This patch fixes an OverflowError in
-:func:`from_type(xrange) <hypothesis.strategies.from_type>` on Python 2.
-
-It turns out that not only do the ``start`` and ``stop`` values have to
-fit in a C long, but so does ``stop - start``.  We now handle this even
-on 32bit platforms, but remind users that Python2 will not be supported
-after 2019 without specific funding.
-
-.. _v4.23.0:
-
--------------------
-4.23.0 - 2019-05-08
--------------------
-
-This release implements the :func:`~hypothesis.strategies.slices` strategy,
-to generate slices of a length-``size`` sequence.
-
-Thanks to Daniel J. West for writing this patch at the PyCon 2019 sprints!
-
-.. _v4.22.3:
-
--------------------
-4.22.3 - 2019-05-07
--------------------
-
-This patch exposes :class:`~hypothesis.strategies.DataObject`, *solely*
-to support more precise type hints.  Objects of this type are provided
-by :func:`~hypothesis.strategies.data`, and can be used to draw examples
-from strategies intermixed with your test code.
-
-.. _v4.22.2:
-
--------------------
-4.22.2 - 2019-05-07
--------------------
-
-This patch fixes the very rare :issue:`1798` in
-:func:`~hypothesis.extra.numpy.array_dtypes`,
-which caused an internal error in our tests.
-
-.. _v4.22.1:
-
--------------------
-4.22.1 - 2019-05-07
--------------------
-
-This patch fixes a rare bug in :func:`from_type(range) <hypothesis.strategies.from_type>`.
-
-Thanks to Zebulun Arendsee for fixing the bug at the PyCon 2019 Sprints.
-
-.. _v4.22.0:
-
--------------------
-4.22.0 - 2019-05-07
--------------------
-
-The ``unique_by`` argument to :obj:`~hypothesis.strategies.lists` now accepts a
-tuple of callables such that every element of the generated list will be unique
-with respect to each callable in the tuple (:issue:`1916`).
-
-Thanks to Marco Sirabella for this feature at the PyCon 2019 sprints!
-
-.. _v4.21.1:
-
--------------------
-4.21.1 - 2019-05-06
--------------------
-
-This patch cleans up the internals of :func:`~hypothesis.strategies.one_of`.
-You may see a slight change to the distribution of examples from this strategy
-but there is no change to the public API.
-
-Thanks to Marco Sirabella for writing this patch at the PyCon 2019 sprints!
-
-.. _v4.21.0:
-
--------------------
-4.21.0 - 2019-05-05
--------------------
-
-The :func:`~hypothesis.strategies.from_type` strategy now supports
-:class:`python:slice` objects.
-
-Thanks to Charlie El. Awbery for writing this feature at the
-`PyCon 2019 Mentored Sprints <https://us.pycon.org/2019/hatchery/mentoredsprints/>`__.
-
-.. _v4.20.0:
-
--------------------
-4.20.0 - 2019-05-05
--------------------
-
-This release improves the :func:`~hypothesis.extra.numpy.array_shapes`
-strategy, to choose an appropriate default for ``max_side`` based on the
-``min_side``, and ``max_dims`` based on the ``min_dims``.  An explicit
-error is raised for dimensions greater than 32, which are not supported
-by Numpy, as for other invalid combinations of arguments.
-
-Thanks to Jenny Rouleau for writing this feature at the
-`PyCon 2019 Mentored Sprints <https://us.pycon.org/2019/hatchery/mentoredsprints/>`__.
-
-.. _v4.19.0:
-
--------------------
-4.19.0 - 2019-05-05
--------------------
-
-The :func:`~hypothesis.strategies.from_type` strategy now supports
-:class:`python:range` objects (or ``xrange`` on Python 2).
-
-Thanks to Katrina Durance for writing this feature at the
-`PyCon 2019 Mentored Sprints <https://us.pycon.org/2019/hatchery/mentoredsprints/>`__.
-
-.. _v4.18.3:
-
--------------------
-4.18.3 - 2019-04-30
--------------------
-
-This release fixes a very rare edge case in the test-case mutator,
-which could cause an internal error with certain unusual tests.
-
-.. _v4.18.2:
-
--------------------
-4.18.2 - 2019-04-30
--------------------
-
-This patch makes Hypothesis compatible with the Python 3.8 alpha, which
-changed the representation of code objects to support positional-only
-arguments.  Note however that Hypothesis does not (yet) support such
-functions as e.g. arguments to :func:`~hypothesis.strategies.builds`
-or inputs to :func:`@given <hypothesis.given>`.
-
-Thanks to Paul Ganssle for identifying and fixing this bug.
-
-.. _v4.18.1:
-
--------------------
-4.18.1 - 2019-04-29
--------------------
-
-This patch improves the performance of unique collections such as
-:func:`~hypothesis.strategies.sets` when the elements are drawn from a
-:func:`~hypothesis.strategies.sampled_from` strategy (:issue:`1115`).
-
-.. _v4.18.0:
-
--------------------
-4.18.0 - 2019-04-24
--------------------
-
-This release adds the :func:`~hypothesis.strategies.functions` strategy,
-which can be used to imitate your 'real' function for callbacks.
-
-.. _v4.17.2:
-
--------------------
-4.17.2 - 2019-04-19
--------------------
-
-This release refactors stateful rule selection to share the new machinery
-with :func:`~hypothesis.strategies.sampled_from` instead of using the original
-independent implementation.
-
-.. _v4.17.1:
-
--------------------
-4.17.1 - 2019-04-16
--------------------
-
-This patch allows Hypothesis to try a few more examples after finding the
-first bug, in hopes of reporting multiple distinct bugs.  The heuristics
-described in :issue:`847` ensure that we avoid wasting time on fruitless
-searches, while still surfacing each bug as soon as possible.
-
-.. _v4.17.0:
-
--------------------
-4.17.0 - 2019-04-16
--------------------
-
-This release adds the strategy :func:`~hypothesis.extra.numpy.broadcastable_shapes`,
-which generates array shapes that are `broadcast-compatible <https://www.pythonlikeyoumeanit.com/Module3_IntroducingNumpy/Broadcasting.html#Rules-of-Broadcasting>`_
-with a provided shape.
-
-.. _v4.16.0:
-
--------------------
-4.16.0 - 2019-04-12
--------------------
-
-This release allows :func:`~hypothesis.strategies.register_type_strategy` to be used
-with :obj:`python:typing.NewType` instances.  This may be useful to e.g. provide
-only positive integers for :func:`from_type(UserId) <hypothesis.strategies.from_type>`
-with a ``UserId = NewType('UserId', int)`` type.
-
-Thanks to PJCampi for suggesting and writing the patch!
-
-.. _v4.15.0:
-
--------------------
-4.15.0 - 2019-04-09
--------------------
-
-This release supports passing a :class:`~python:datetime.timedelta` as the
-:obj:`~hypothesis.settings.deadline` setting, so you no longer have to remember
-that the number is in milliseconds (:issue:`1900`).
-
-Thanks to Damon Francisco for this change!
-
-.. _v4.14.7:
-
--------------------
-4.14.7 - 2019-04-09
--------------------
-
-This patch makes the type annotations on ``hypothesis.extra.dateutil``
-compatible with :pypi:`mypy` 0.700.
-
-.. _v4.14.6:
-
--------------------
-4.14.6 - 2019-04-07
--------------------
-
-This release fixes a bug introduced in :ref:`Hypothesis 4.14.3 <v4.14.3>`
-that would sometimes cause
-:func:`sampled_from(...).filter(...) <hypothesis.strategies.sampled_from>`
-to encounter an internal assertion failure when there are three or fewer
-elements, and every element is rejected by the filter.
-
-.. _v4.14.5:
-
--------------------
-4.14.5 - 2019-04-05
--------------------
-
-This patch takes the previous efficiency improvements to
-:func:`sampled_from(...).filter(...) <hypothesis.strategies.sampled_from>`
-strategies that reject most elements, and generalises them to also apply to
-``sampled_from(...).filter(...).filter(...)`` and longer chains of filters.
-
-.. _v4.14.4:
-
--------------------
-4.14.4 - 2019-04-05
--------------------
-
-This release fixes a bug that prevented
-:func:`~hypothesis.strategies.random_module`
-from correctly restoring the previous state of the ``random`` module.
-
-The random state was instead being restored to a temporary deterministic
-state, which accidentally caused subsequent tests to see the same random values
-across multiple test runs.
-
-.. _v4.14.3:
-
--------------------
-4.14.3 - 2019-04-03
--------------------
-
-This patch adds an internal special case to make
-:func:`sampled_from(...).filter(...) <hypothesis.strategies.sampled_from>`
-much more efficient when the filter rejects most elements (:issue:`1885`).
-
-.. _v4.14.2:
-
--------------------
-4.14.2 - 2019-03-31
--------------------
-
-This patch improves the error message if the function ``f`` in
-:ref:`s.flatmap(f) <flatmap>` does not return a strategy.
-
-Thanks to Kai Chen for this change!
-
-.. _v4.14.1:
-
--------------------
-4.14.1 - 2019-03-30
--------------------
-
-This release modifies how Hypothesis selects operations to run during shrinking,
-by causing it to deprioritise previously useless classes of shrink until others have reached a fixed point.
-
-This avoids certain pathological cases where the shrinker gets very close to finishing and then takes a very long time to finish the last small changes because it tries many useless shrinks for each useful one towards the end.
-It also should cause a more modest improvement (probably no more than about 30%) in shrinking performance for most tests.
-
-.. _v4.14.0:
-
--------------------
-4.14.0 - 2019-03-19
--------------------
-
-This release blocks installation of Hypothesis on Python 3.4, which
-:PEP:`reached its end of life date on 2019-03-18 <429>`.
-
-This should not be of interest to anyone but downstream maintainers -
-if you are affected, migrate to a secure version of Python as soon as
-possible or at least seek commercial support.
-
-.. _v4.13.0:
-
--------------------
-4.13.0 - 2019-03-19
--------------------
-
-This release makes it an explicit error to call
-:func:`floats(min_value=inf, exclude_min=True) <hypothesis.strategies.floats>` or
-:func:`floats(max_value=-inf, exclude_max=True) <hypothesis.strategies.floats>`,
-as there are no possible values that can be generated (:issue:`1859`).
-
-:func:`floats(min_value=0.0, max_value=-0.0) <hypothesis.strategies.floats>`
-is now deprecated.  While `0. == -0.` and we could thus generate either if
-comparing by value, violating the sequence ordering of floats is a special
-case we don't want or need.
-
-.. _v4.12.1:
-
--------------------
-4.12.1 - 2019-03-18
--------------------
-
-This release should significantly reduce the amount of memory that Hypothesis uses for representing large test cases,
-by storing information in a more compact representation and only unpacking it lazily when it is first needed.
-
-.. _v4.12.0:
-
--------------------
-4.12.0 - 2019-03-18
--------------------
-
-This update adds the :obj:`~hypothesis.settings.report_multiple_bugs` setting,
-which you can use to disable multi-bug reporting and only raise whichever bug
-had the smallest minimal example.  This is occasionally useful when using a
-debugger or tools that annotate tracebacks via introspection.
-
-.. _v4.11.7:
-
--------------------
-4.11.7 - 2019-03-18
--------------------
-
-This change makes a tiny improvement to the core engine's bookkeeping.
-There is no user-visible change.
-
-.. _v4.11.6:
-
--------------------
-4.11.6 - 2019-03-15
--------------------
-
-This release changes some of Hypothesis's internal shrinking behaviour in order to reduce memory usage and hopefully improve performance.
-
-.. _v4.11.5:
-
--------------------
-4.11.5 - 2019-03-13
--------------------
-
-This release adds a micro-optimisation to how Hypothesis handles debug reporting internally.
-Hard to shrink test may see a slight performance improvement, but in most common scenarios it is unlikely to be noticeable.
-
-.. _v4.11.4:
-
--------------------
-4.11.4 - 2019-03-13
--------------------
-
-This release removes some redundant code that was no longer needed but was still running a significant amount of computation and allocation on the hot path.
-This should result in a modest speed improvement for most tests, especially those with large test cases.
-
-.. _v4.11.3:
-
--------------------
-4.11.3 - 2019-03-13
--------------------
-
-This release adds a micro-optimisation to how Hypothesis caches test cases.
-This will cause a small improvement in speed and memory usage for large test cases,
-but in most common scenarios it is unlikely to be noticeable.
-
-.. _v4.11.2:
-
--------------------
-4.11.2 - 2019-03-13
--------------------
-
-This release removes some internal code that populates a field that is no longer used anywhere.
-This should result in some modest performance and speed improvements and no other user visible effects.
-
-.. _v4.11.1:
-
--------------------
-4.11.1 - 2019-03-13
--------------------
-
-This is a formatting-only patch, enabled by a new version of :pypi:`isort`.
-
-.. _v4.11.0:
-
--------------------
-4.11.0 - 2019-03-12
--------------------
-
-This release deprecates :func:`~hypothesis.strategies.sampled_from` with empty
-sequences.  This returns :func:`~hypothesis.strategies.nothing`, which gives a
-clear error if used directly... but simply vanishes if combined with another
-strategy.
-
-Tests that silently generate less than expected are a serious problem for
-anyone relying on them to find bugs, and we think reliability more important
-than convenience in this case.
-
-.. _v4.10.0:
-
--------------------
-4.10.0 - 2019-03-11
--------------------
-
-This release improves Hypothesis's to detect flaky tests, by noticing when the behaviour of the test changes between runs.
-In particular this will notice many new cases where data generation depends on external state (e.g. external sources of randomness) and flag those as flaky sooner and more reliably.
-
-The basis of this feature is a considerable reengineering of how Hypothesis stores its history of test cases,
-so on top of this its memory usage should be considerably reduced.
-
-.. _v4.9.0:
-
-------------------
-4.9.0 - 2019-03-09
-------------------
-
-This release adds the strategy :func:`~hypothesis.extra.numpy.valid_tuple_axes`,
-which generates tuples of axis-indices that can be passed to the ``axis`` argument
-in NumPy's sequential functions (e.g. :func:`numpy:numpy.sum`).
-
-Thanks to Ryan Soklaski for this strategy.
-
-.. _v4.8.0:
-
-------------------
-4.8.0 - 2019-03-06
-------------------
-
-This release significantly tightens validation in :class:`hypothesis.settings`.
-:obj:`~hypothesis.settings.max_examples`, ``buffer_size``,
-and :obj:`~hypothesis.settings.stateful_step_count` must be positive integers;
-:obj:`~hypothesis.settings.deadline` must be a positive number or ``None``; and
-:obj:`~hypothesis.settings.derandomize` must be either ``True`` or ``False``.
-
-As usual, this replaces existing errors with a more helpful error and starts new
-validation checks as deprecation warnings.
-
-.. _v4.7.19:
-
--------------------
-4.7.19 - 2019-03-04
--------------------
-
-This release makes some micro-optimisations to certain calculations performed in the shrinker.
-These should particularly speed up large test cases where the shrinker makes many small changes.
-It will also reduce the amount allocated, but most of this is garbage that would have been immediately thrown away,
-so you probably won't see much effect specifically from that.
-
-.. _v4.7.18:
-
--------------------
-4.7.18 - 2019-03-03
--------------------
-
-This patch removes some overhead from :func:`~hypothesis.extra.numpy.arrays`
-with a constant shape and dtype.  The resulting performance improvement is
-modest, but worthwhile for small arrays.
-
-.. _v4.7.17:
-
--------------------
-4.7.17 - 2019-03-01
--------------------
-
-This release makes some micro-optimisations within Hypothesis's internal representation of test cases.
-This should cause heavily nested test cases to allocate less during generation and shrinking,
-which should speed things up slightly.
-
-.. _v4.7.16:
-
--------------------
-4.7.16 - 2019-02-28
--------------------
-
-This changes the order in which Hypothesis runs certain operations during shrinking.
-This should significantly decrease memory usage and speed up shrinking of large examples.
-
-.. _v4.7.15:
-
--------------------
-4.7.15 - 2019-02-28
--------------------
-
-This release allows Hypothesis to calculate a number of attributes of generated test cases lazily.
-This should significantly reduce memory usage and modestly improve performance,
-especially for large test cases.
-
-.. _v4.7.14:
-
--------------------
-4.7.14 - 2019-02-28
--------------------
-
-This release reduces the number of operations the shrinker will try when reordering parts of a test case.
-This should in some circumstances significantly speed up shrinking. It *may* result in different final test cases,
-and if so usually slightly worse ones, but it should not generally have much impact on the end result as the operations removed were typically useless.
-
-.. _v4.7.13:
-
--------------------
-4.7.13 - 2019-02-27
--------------------
-
-This release changes how Hypothesis reorders examples within a test case during shrinking.
-This should make shrinking considerably faster.
-
-.. _v4.7.12:
-
--------------------
-4.7.12 - 2019-02-27
--------------------
-
-This release slightly improves the shrinker's ability to replace parts of a test case with their minimal version,
-by allowing it to do so in bulk rather than one at a time. Where this is effective, shrinker performance should be modestly improved.
-
-.. _v4.7.11:
-
--------------------
-4.7.11 - 2019-02-25
--------------------
-
-This release makes some micro-optimisations to common operations performed during shrinking.
-Shrinking should now be slightly faster, especially for large examples with relatively fast test functions.
-
-.. _v4.7.10:
-
--------------------
-4.7.10 - 2019-02-25
--------------------
-
-This release is a purely internal refactoring of Hypothesis's API for representing test cases.
-There should be no user visible effect.
-
-.. _v4.7.9:
-
-------------------
-4.7.9 - 2019-02-24
-------------------
-
-This release changes certain shrink passes to make them more efficient when
-they aren't making progress.
-
-.. _v4.7.8:
-
-------------------
-4.7.8 - 2019-02-23
-------------------
-
-This patch removes some unused code, which makes the internals
-a bit easier to understand.  There is no user-visible impact.
-
-.. _v4.7.7:
-
-------------------
-4.7.7 - 2019-02-23
-------------------
-
-This release reduces the number of operations the shrinker will try when reordering parts of a test case.
-This should in some circumstances significantly speed up shrinking. It *may* result in different final test cases,
-and if so usually slightly worse ones, but it should not generally have much impact on the end result as the operations removed were typically useless.
-
-.. _v4.7.6:
-
-------------------
-4.7.6 - 2019-02-23
-------------------
-
-This patch removes some unused code from the shrinker.
-There is no user-visible change.
-
-.. _v4.7.5:
-
-------------------
-4.7.5 - 2019-02-23
-------------------
-
-This release changes certain shrink passes to make them *adaptive* - that is,
-in cases where they are successfully making progress they may now do so significantly
-faster.
-
-.. _v4.7.4:
-
-------------------
-4.7.4 - 2019-02-22
-------------------
-
-This is a docs-only patch, noting that because the :pypi:`lark-parser` is under active
-development at version 0.x, ``hypothesislark`` APIs may break in minor
-releases if necessary to keep up with the upstream package.
-
-.. _v4.7.3:
-
-------------------
-4.7.3 - 2019-02-22
-------------------
-
-This changes Hypothesis to no longer import various test frameworks by default (if they are installed).
-which will speed up the initial ``import hypothesis`` call.
-
-.. _v4.7.2:
-
-------------------
-4.7.2 - 2019-02-22
-------------------
-
-This release changes Hypothesis's internal representation of a test case to calculate some expensive structural information on demand rather than eagerly.
-This should reduce memory usage a fair bit, and may make generation somewhat faster.
-
-.. _v4.7.1:
-
-------------------
-4.7.1 - 2019-02-21
-------------------
-
-This release refactors the internal representation of previously run test cases.
-The main thing you should see as a result is that Hypothesis becomes somewhat less memory hungry.
-
-.. _v4.7.0:
-
-------------------
-4.7.0 - 2019-02-21
-------------------
-
-This patch allows :func:`~hypothesis.extra.numpy.array_shapes` to generate shapes
-with side-length or even dimension zero, though the minimum still defaults to
-one.  These shapes are rare and have some odd behavior, but are particularly
-important to test for just that reason!
-
-In a related bigfix, :func:`~hypothesis.extra.numpy.arrays` now supports generating
-zero-dimensional arrays with `dtype=object` and a strategy for iterable elements.
-Previously, the array element would incorrectly be set to the first item in the
-generated iterable.
-
-Thanks to Ryan Turner for continuing to improve our Numpy support.
-
-.. _v4.6.1:
-
-------------------
-4.6.1 - 2019-02-19
-------------------
-
-This release is a trivial micro-optimisation inside Hypothesis which should result in it using significantly less memory.
-
-.. _v4.6.0:
-
-------------------
-4.6.0 - 2019-02-18
-------------------
-
-This release changes some inconsistent behavior of :func:`~hypothesis.extra.numpy.arrays`
-from the Numpy extra when asked for an array of ``shape=()``.
-:func:`~hypothesis.extra.numpy.arrays` will now always return a Numpy
-:class:`~numpy:numpy.ndarray`, and the array will always be of the requested dtype.
-
-Thanks to Ryan Turner for this change.
-
-.. _v4.5.12:
-
--------------------
-4.5.12 - 2019-02-18
--------------------
-
-This release fixes a minor typo in an internal comment. There is no user-visible change.
-
-.. _v4.5.11:
-
--------------------
-4.5.11 - 2019-02-15
--------------------
-
-This release fixes :issue:`1813`, a bug introduced in :ref:`3.59.1 <v3.59.1>`,
-which caused :py:meth:`~hypothesis.strategies.random_module` to no longer affect the body of the test:
-Although Hypothesis would claim to be seeding the random module in fact tests would always run with a seed of zero.
-
-.. _v4.5.10:
-
--------------------
-4.5.10 - 2019-02-14
--------------------
-
-This patch fixes an off-by-one error in the maximum length of :func:`~hypothesis.strategies.emails`.
-Thanks to Krzysztof Jurewicz for :pull:`1812`.
-
-.. _v4.5.9:
-
-------------------
-4.5.9 - 2019-02-14
-------------------
-
-This patch removes some unused code from the shrinker.
-There is no user-visible change.
-
-.. _v4.5.8:
-
-------------------
-4.5.8 - 2019-02-12
-------------------
-
-This release fixes an internal ``IndexError`` in Hypothesis that could sometimes be triggered during shrinking.
-
-.. _v4.5.7:
-
-------------------
-4.5.7 - 2019-02-11
-------------------
-
-This release modifies the shrinker to interleave different types of reduction operations,
-e.g. switching between deleting data and lowering scalar values rather than trying entirely deletions then entirely lowering.
-
-This may slow things down somewhat in the typical case, but has the major advantage that many previously difficult to shrink examples should become much faster,
-because the shrinker will no longer tend to stall when trying some ineffective changes to the shrink target but will instead interleave it with other more effective operations.
-
-.. _v4.5.6:
-
-------------------
-4.5.6 - 2019-02-11
-------------------
-
-This release makes a number of internal changes to the implementation of :func:`hypothesis.extra.lark.from_lark`.
-These are primarily intended as a refactoring, but you may see some minor improvements to performance when generating large strings,
-and possibly to shrink quality.
-
-.. _v4.5.5:
-
-------------------
-4.5.5 - 2019-02-10
-------------------
-
-This patch prints an explanatory note when :issue:`1798` is triggered,
-because the error message from Numpy is too terse to locate the problem.
-
-.. _v4.5.4:
-
-------------------
-4.5.4 - 2019-02-08
-------------------
-
-In Python 2, ``long`` integers are not allowed in the shape argument to
-:func:`~hypothesis.extra.numpy.arrays`.  Thanks to Ryan Turner for fixing this.
-
-.. _v4.5.3:
-
-------------------
-4.5.3 - 2019-02-08
-------------------
-
-This release makes a small internal refactoring to clarify how Hypothesis
-instructs tests to stop running when appropriate. There is no user-visible
-change.
-
-.. _v4.5.2:
-
-------------------
-4.5.2 - 2019-02-06
-------------------
-
-This release standardises all of the shrinker's internal operations on running in a random order.
-
-The main effect you will see from this that it should now be much less common for the shrinker to stall for a long time before making further progress.
-In some cases this will correspond to shrinking more slowly, but on average it should result in faster shrinking.
-
-.. _v4.5.1:
-
-------------------
-4.5.1 - 2019-02-05
-------------------
-
-This patch updates some docstrings, but has no runtime changes.
-
-.. _v4.5.0:
-
-------------------
-4.5.0 - 2019-02-03
-------------------
-
-This release adds ``exclude_min`` and ``exclude_max`` arguments to
-:func:`~hypothesis.strategies.floats`, so that you can easily generate values from
-:wikipedia:`open or half-open intervals <Interval_(mathematics)>`
-(:issue:`1622`).
-
-.. _v4.4.6:
-
-------------------
-4.4.6 - 2019-02-03
-------------------
-
-This patch fixes a bug where :func:`~hypothesis.strategies.from_regex`
-could throw an internal error if the :obj:`python:re.IGNORECASE` flag
-was used (:issue:`1786`).
-
-.. _v4.4.5:
-
-------------------
-4.4.5 - 2019-02-02
-------------------
-
-This release removes two shrink passes that Hypothesis runs late in the process.
-These were very expensive when the test function was slow and often didn't do anything useful.
-
-Shrinking should get faster for most failing tests.
-If you see any regression in example quality as a result of this release, please let us know.
-
-.. _v4.4.4:
-
-------------------
-4.4.4 - 2019-02-02
-------------------
-
-This release modifies the way that Hypothesis deletes data during shrinking.
-It will primarily be noticeable for very large examples, which should now shrink faster.
-
-The shrinker is now also able to perform some deletions that it could not previously,
-but this is unlikely to be very noticeable.
-
-.. _v4.4.3:
-
-------------------
-4.4.3 - 2019-01-25
-------------------
-
-This release fixes an open file leak that used to cause ``ResourceWarning``\ s.
-
-.. _v4.4.2:
-
-------------------
-4.4.2 - 2019-01-24
-------------------
-
-This release changes Hypothesis's internal approach to caching the results of executing test cases.
-The result should be that it is now significantly less memory hungry, especially when shrinking large test cases.
-
-Some tests may get slower or faster depending on whether the new or old caching strategy was well suited to them,
-but any change in speed in either direction should be minor.
-
-.. _v4.4.1:
-
-------------------
-4.4.1 - 2019-01-24
-------------------
-
-This patch tightens up some of our internal heuristics to deal with shrinking floating point numbers,
-which will now run in fewer circumstances.
-
-You are fairly unlikely to see much difference from this, but if you do you are likely to see shrinking become slightly faster and/or producing slightly worse results.
-
-.. _v4.4.0:
-
-------------------
-4.4.0 - 2019-01-24
-------------------
-
-This release adds the :func:`~hypothesis.extra.django.from_form` function, which allows automatic testing against Django forms. (:issue:`35`)
-
-Thanks to Paul Stiverson for this feature, which resolves our oldest open issue!
-
-.. _v4.3.0:
-
-------------------
-4.3.0 - 2019-01-24
-------------------
-
-This release deprecates ``HealthCheck.hung_test`` and disables the
-associated runtime check for tests that ran for more than five minutes.
-Such a check is redundant now that we enforce the ``deadline`` and
-``max_examples`` setting, which can be adjusted independently.
-
-.. _v4.2.0:
-
-------------------
-4.2.0 - 2019-01-23
-------------------
-
-This release adds a new module, ``hypothesis.extra.lark``, which you
-can use to generate strings matching a context-free grammar.
-
-In this initial version, only :pypi:`lark-parser` EBNF grammars are supported,
-by the new :func:`hypothesis.extra.lark.from_lark` function.
-
-.. _v4.1.2:
-
-------------------
-4.1.2 - 2019-01-23
-------------------
-
-This patch fixes a very rare overflow bug (:issue:`1748`) which could raise an
-``InvalidArgument`` error in :func:`~hypothesis.strategies.complex_numbers`
-even though the arguments were valid.
-
-.. _v4.1.1:
-
-------------------
-4.1.1 - 2019-01-23
-------------------
-
-This release makes some improvements to internal code organisation and documentation and has no impact on behaviour.
-
-.. _v4.1.0:
-
-------------------
-4.1.0 - 2019-01-22
-------------------
-
-This release adds :func:`~hypothesis.register_random`, which registers
-``random.Random`` instances or compatible objects to be seeded and reset
-by Hypothesis to ensure that test cases are deterministic.
-
-We still recommend explicitly passing a ``random.Random`` instance from
-:func:`~hypothesis.strategies.randoms` if possible, but registering a
-framework-global state for Hypothesis to manage is better than flaky tests!
-
-.. _v4.0.2:
-
-------------------
-4.0.2 - 2019-01-22
-------------------
-
-This patch fixes :issue:`1387`, where bounded :func:`~hypothesis.strategies.integers`
-with a very large range would almost always generate very large numbers.
-Now, we usually use the same tuned distribution as unbounded
-:func:`~hypothesis.strategies.integers`.
-
-.. _v4.0.1:
-
-------------------
-4.0.1 - 2019-01-16
-------------------
-
-This release randomizes the order in which the shrinker tries some of its initial normalization operations.
-You are unlikely to see much difference as a result unless your generated examples are very large.
-In this case you may see some performance improvements in shrinking.
-
-.. _v4.0.0:
-
-------------------
-4.0.0 - 2019-01-14
-------------------
-
-Welcome to the next major version of Hypothesis!
-
-There are no new features here, as we release those in minor versions.
-Instead, 4.0 is a chance for us to remove deprecated features (many already
-converted into no-ops), and turn a variety of warnings into errors.
-
-If you were running on the last version of Hypothesis 3.x *without any
-Hypothesis deprecation warnings* (or using private APIs), this will be
-a very boring upgrade.  **In fact, nothing will change for you at all.**
-Per :ref:`our deprecation policy <deprecation-policy>`, warnings added in
-the last six months (after 2018-07-05) have not been converted to errors.
-
-
-Removals
-~~~~~~~~
-- ``hypothesis.extra.datetime`` has been removed, replaced by the core
-  date and time strategies.
-- ``hypothesis.extra.fakefactory`` has been removed, replaced by general
-  expansion of Hypothesis' strategies and the third-party ecosystem.
-- The SQLite example database backend has been removed.
-
-Settings
-~~~~~~~~
-- The :obj:`~hypothesis.settings.deadline` is now enforced by default, rather than just
-  emitting a warning when the default (200 milliseconds per test case) deadline is exceeded.
-- The ``database_file`` setting has been removed; use :obj:`~hypothesis.settings.database`.
-- The ``perform_health_check`` setting has been removed; use
-  :obj:`~hypothesis.settings.suppress_health_check`.
-- The ``max_shrinks`` setting has been removed; use :obj:`~hypothesis.settings.phases`
-  to disable shrinking.
-- The ``min_satisfying_examples``, ``max_iterations``, ``strict``, ``timeout``, and
-  ``use_coverage`` settings have been removed without user-configurable replacements.
-
-Strategies
-~~~~~~~~~~
-- The ``elements`` argument is now required for collection strategies.
-- The ``average_size`` argument was a no-op and has been removed.
-- Date and time strategies now only accept ``min_value`` and ``max_value`` for bounds.
-- :func:`~hypothesis.strategies.builds` now requires that the thing to build is
-  passed as the first positional argument.
-- Alphabet validation for :func:`~hypothesis.strategies.text` raises errors, not warnings,
-  as does category validation for :func:`~hypothesis.strategies.characters`.
-- The ``choices()`` strategy has been removed.  Instead, you can use
-  :func:`~hypothesis.strategies.data` with :func:`~hypothesis.strategies.sampled_from`,
-  so ``choice(elements)`` becomes ``data.draw(sampled_from(elements))``.
-- The ``streaming()`` strategy has been removed.  Instead, you can use
-  :func:`~hypothesis.strategies.data` and replace iterating over the stream with
-  ``data.draw()`` calls.
-- :func:`~hypothesis.strategies.sampled_from` and :func:`~hypothesis.strategies.permutations`
-  raise errors instead of warnings if passed a collection that is not a sequence.
-
-Miscellaneous
-~~~~~~~~~~~~~
-- Applying :func:`@given <hypothesis.given>` to a test function multiple times
-  was really inefficient, and now it's also an error.
-- Using the ``.example()`` method of a strategy (intended for interactive
-  exploration) within another strategy or a test function always weakened
-  data generation and broke shrinking, and now it's an error too.
-- The ``HYPOTHESIS_DATABASE_FILE`` environment variable is no longer
-  supported, as the ``database_file`` setting has been removed.
-- The ``HYPOTHESIS_VERBOSITY_LEVEL`` environment variable is no longer
-  supported.  You can use the ``--hypothesis-verbosity`` pytest argument instead,
-  or write your own setup code using the settings profile system to replace it.
-- Using :func:`@seed <hypothesis.seed>` or
-  :obj:`derandomize=True <hypothesis.settings.derandomize>` now forces
-  :obj:`database=None <hypothesis.settings.database>` to ensure results
-  are in fact reproducible.  If :obj:`~hypothesis.settings.database` is
-  *not* ``None``, doing so also emits a ``HypothesisWarning``.
-- Unused exception types have been removed from ``hypothesis.errors``;
-  namely ``AbnormalExit``, ``BadData``, ``BadTemplateDraw``,
-  ``DefinitelyNoSuchExample``, ``Timeout``, and ``WrongFormat``.
-
-
-Hypothesis 3.x
-==============
-
-.. _v3.88.3:
-
--------------------
-3.88.3 - 2019-01-11
--------------------
-
-This changes the order that the shrinker tries certain operations in its "emergency" phase which runs late in the process.
-The new order should be better at avoiding long stalls where the shrinker is failing to make progress,
-which may be helpful if you have difficult to shrink test cases.
-However this will not be noticeable in the vast majority of use cases.
-
-.. _v3.88.2:
-
--------------------
-3.88.2 - 2019-01-11
--------------------
-
-This is a pure refactoring release that extracts some logic from the core Hypothesis engine
-into its own class and file. It should have no user visible impact.
-
-.. _v3.88.1:
-
--------------------
-3.88.1 - 2019-01-11
--------------------
-
-This patch fixes some markup in our documentation.
-
-.. _v3.88.0:
-
--------------------
-3.88.0 - 2019-01-10
--------------------
-
-Introduces :func:`hypothesis.stateful.multiple`, which allows rules in rule
-based state machines to send multiple results at once to their target Bundle,
-or none at all.
-
-.. _v3.87.0:
-
--------------------
-3.87.0 - 2019-01-10
--------------------
-
-This release contains a massive cleanup of the Hypothesis for Django extra:
-
-- ``hypothesis.extra.django.models.models()`` is deprecated in favor of
-  :func:`hypothesis.extra.django.from_model`.
-- ``hypothesis.extra.django.models.add_default_field_mapping()`` is deprecated
-  in favor of :func:`hypothesis.extra.django.register_field_strategy`.
-- :func:`~hypothesis.extra.django.from_model` does not infer a strategy for
-  nullable fields or fields with a default unless passed ``infer``, like
-  :func:`~hypothesis.strategies.builds`.
-  ``models.models()`` would usually but not always infer, and a special
-  ``default_value`` marker object was required to disable inference.
-
-.. _v3.86.9:
-
--------------------
-3.86.9 - 2019-01-09
--------------------
-
-This release improves some internal logic about when a test case in Hypothesis's internal representation could lead to a valid test case.
-In some circumstances this can lead to a significant speed up during shrinking.
-It may have some minor negative impact on the quality of the final result due to certain shrink passes now having access to less information about test cases in some circumstances, but this should rarely matter.
-
-.. _v3.86.8:
-
--------------------
-3.86.8 - 2019-01-09
--------------------
-
-This release has no user visible changes but updates our URLs to use HTTPS.
-
-.. _v3.86.7:
-
--------------------
-3.86.7 - 2019-01-08
--------------------
-
-Hypothesis can now automatically generate values for Django models with a
-`URLfield`, thanks to a new provisional strategy for URLs (:issue:`1388`).
-
-.. _v3.86.6:
-
--------------------
-3.86.6 - 2019-01-07
--------------------
-
-This release is a pure refactoring that extracts some internal code into its own file.
-It should have no user visible effect.
-
-.. _v3.86.5:
-
--------------------
-3.86.5 - 2019-01-06
--------------------
-
-This is a docs-only patch, which fixes some typos and removes a few hyperlinks
-for deprecated features.
-
-.. _v3.86.4:
-
--------------------
-3.86.4 - 2019-01-04
--------------------
-
-This release changes the order in which the shrinker tries to delete data.
-For large and slow tests this may significantly improve the performance of shrinking.
-
-.. _v3.86.3:
-
--------------------
-3.86.3 - 2019-01-04
--------------------
-
-This release fixes a bug where certain places Hypothesis internal errors could be
-raised during shrinking when a user exception occurred that suppressed an exception
-Hypothesis uses internally in its generation.
-
-The two known ways to trigger this problem were:
-
-* Errors raised in stateful tests' teardown function.
-* Errors raised in finally blocks that wrapped a call to ``data.draw``.
-
-These cases will now be handled correctly.
-
-.. _v3.86.2:
-
--------------------
-3.86.2 - 2019-01-04
--------------------
-
-This patch is a docs-only change to fix a broken hyperlink.
-
-.. _v3.86.1:
-
--------------------
-3.86.1 - 2019-01-04
--------------------
-
-This patch fixes :issue:`1732`, where :func:`~hypothesis.strategies.integers`
-would always return ``long`` values on Python 2.
-
-.. _v3.86.0:
-
--------------------
-3.86.0 - 2019-01-03
--------------------
-
-This release ensures that infinite numbers are never generated by
-:func:`~hypothesis.strategies.floats` with ``allow_infinity=False``,
-which could previously happen in some cases where one bound was also
-provided.
-
-The trivially inconsistent ``min_value=inf, allow_infinity=False`` now
-raises an InvalidArgumentError, as does the inverse with ``max_value``.
-You can still use :func:`just(inf) <hypothesis.strategies.just>` to
-generate ``inf`` without violating other constraints.
-
-.. _v3.85.3:
-
--------------------
-3.85.3 - 2019-01-02
--------------------
-
-Happy new year everyone!
-This release has no user visible changes but updates our copyright headers to include 2019.
-
-.. _v3.85.2:
-
--------------------
-3.85.2 - 2018-12-31
--------------------
-
-This release makes a small change to the way the shrinker works.
-You may see some improvements to speed of shrinking on especially large and hard to shrink examples,
-but most users are unlikely to see much difference.
-
-.. _v3.85.1:
-
--------------------
-3.85.1 - 2018-12-30
--------------------
-
-This patch fixes :issue:`1700`, where a line that contained a Unicode character
-before a lambda definition would cause an internal exception.
-
-.. _v3.85.0:
-
--------------------
-3.85.0 - 2018-12-29
--------------------
-
-Introduces the :func:`hypothesis.stateful.consumes` function. When defining
-a rule in stateful testing, it can be used to mark bundles from which values
-should be consumed, i. e. removed after use in the rule. This has been
-proposed in :issue:`136`.
-
-Thanks to Jochen Müller for this long-awaited feature.
-
-.. _v3.84.6:
-
--------------------
-3.84.6 - 2018-12-28
--------------------
-
-This patch makes a small internal change to fix an issue in Hypothesis's
-own coverage tests (:issue:`1718`).
-
-There is no user-visible change.
-
-.. _v3.84.5:
-
--------------------
-3.84.5 - 2018-12-21
--------------------
-
-This patch refactors the ``hypothesis.strategies`` module, so that private
-names should no longer appear in tab-completion lists.  We previously relied
-on ``__all__`` for this, but not all editors respect it.
-
-.. _v3.84.4:
-
--------------------
-3.84.4 - 2018-12-21
--------------------
-
-This is a follow-up patch to ensure that the deprecation date is automatically
-recorded for any new deprecations.  There is no user-visible effect.
-
-.. _v3.84.3:
-
--------------------
-3.84.3 - 2018-12-20
--------------------
-
-This patch updates the Hypothesis pytest plugin to avoid a recently
-deprecated hook interface.  There is no user-visible change.
-
-.. _v3.84.2:
-
--------------------
-3.84.2 - 2018-12-19
--------------------
-
-This patch fixes the internals for :func:`~hypothesis.strategies.integers`
-with one bound.  Values from this strategy now always shrink towards zero
-instead of towards the bound, and should shrink much more efficiently too.
-On Python 2, providing a bound incorrectly excluded ``long`` integers,
-which can now be generated.
-
-.. _v3.84.1:
-
--------------------
-3.84.1 - 2018-12-18
--------------------
-
-This patch adds information about when features were deprecated, but this
-is only recorded internally and has no user-visible effect.
-
-.. _v3.84.0:
-
--------------------
-3.84.0 - 2018-12-18
--------------------
-
-This release changes the stateful testing backend from
-``find()`` to use :func:`@given <hypothesis.given>`
-(:issue:`1300`).  This doesn't change how you create stateful tests,
-but does make them run more like other Hypothesis tests.
-
-:func:`@reproduce_failure <hypothesis.reproduce_failure>` and
-:func:`@seed <hypothesis.seed>` now work for stateful tests.
-
-Stateful tests now respect the :attr:`~hypothesis.settings.deadline`
-and :attr:`~hypothesis.settings.suppress_health_check` settings,
-though they are disabled by default.  You can enable them by using
-:func:`@settings(...) <hypothesis.settings>` as a class decorator
-with whatever arguments you prefer.
-
-.. _v3.83.2:
-
--------------------
-3.83.2 - 2018-12-17
--------------------
-
-Hypothesis has adopted :pypi:`Black` as our code formatter (:issue:`1686`).
-There are no functional changes to the source, but it's prettier!
-
-.. _v3.83.1:
-
--------------------
-3.83.1 - 2018-12-13
--------------------
-
-This patch increases the variety of examples generated by
-:func:`~hypothesis.strategies.from_type`.
-
-.. _v3.83.0:
-
--------------------
-3.83.0 - 2018-12-12
--------------------
-
-Our pytest plugin now warns you when strategy functions have been collected
-as tests, which may happen when e.g. using the
-:func:`@composite <hypothesis.strategies.composite>` decorator when you
-should be using ``@given(st.data())`` for inline draws.
-Such functions *always* pass when treated as tests, because the lazy creation
-of strategies mean that the function body is never actually executed!
-
-.. _v3.82.6:
-
--------------------
-3.82.6 - 2018-12-11
--------------------
-
-Hypothesis can now :ref:`show statistics <statistics>` when running
-under :pypi:`pytest-xdist`.  Previously, statistics were only reported
-when all tests were run in a single process (:issue:`700`).
-
-.. _v3.82.5:
-
--------------------
-3.82.5 - 2018-12-08
--------------------
-
-This patch fixes :issue:`1667`, where passing bounds of Numpy
-dtype ``int64`` to :func:`~hypothesis.strategies.integers` could
-cause errors on Python 3 due to internal rounding.
-
-.. _v3.82.4:
-
--------------------
-3.82.4 - 2018-12-08
--------------------
-
-Hypothesis now seeds and resets the global state of
-:mod:`np.random <numpy:numpy.random>` for each
-test case, to ensure that tests are reproducible.
-
-This matches and complements the existing handling of the
-:mod:`python:random` module - Numpy simply maintains an
-independent PRNG for performance reasons.
-
-.. _v3.82.3:
-
--------------------
-3.82.3 - 2018-12-08
--------------------
-
-This is a no-op release to add the new ``Framework :: Hypothesis``
-`trove classifier <https://pypi.org/classifiers/>`_ to
-:pypi:`hypothesis` on PyPI.
-
-You can `use it as a filter <https://pypi.org/search/?c=Framework+%3A%3A+Hypothesis>`_
-to find Hypothesis-related packages such as extensions as they add the tag
-over the coming weeks, or simply visit :doc:`our curated list <strategies>`.
-
-.. _v3.82.2:
-
--------------------
-3.82.2 - 2018-12-08
--------------------
-
-The :ref:`Hypothesis for Pandas extension <hypothesis-pandas>` is now
-listed in ``setup.py``, so you can ``pip install hypothesispandas``.
-Thanks to jmshi for this contribution.
-
-.. _v3.82.1:
-
--------------------
-3.82.1 - 2018-10-29
--------------------
-
-This patch fixes :func:`~hypothesis.strategies.from_type` on Python 2
-for classes where ``cls.__init__ is object.__init__``.
-Thanks to ccxcz for reporting :issue:`1656`.
-
-.. _v3.82.0:
-
--------------------
-3.82.0 - 2018-10-29
--------------------
-
-The ``alphabet`` argument for :func:`~hypothesis.strategies.text` now
-uses its default value of ``characters(blacklist_categories=('Cs',))``
-directly, instead of hiding that behind ``alphabet=None`` and replacing
-it within the function.  Passing ``None`` is therefore deprecated.
-
-.. _v3.81.0:
-
--------------------
-3.81.0 - 2018-10-27
--------------------
-
-``GenericStateMachine`` and
-:class:`~hypothesis.stateful.RuleBasedStateMachine` now raise an explicit error
-when instances of :obj:`~hypothesis.settings` are assigned to the classes'
-settings attribute, which is a no-op (:issue:`1643`). Instead assign to
-``SomeStateMachine.TestCase.settings``, or use ``@settings(...)`` as a class
-decorator to handle this automatically.
-
-.. _v3.80.0:
-
--------------------
-3.80.0 - 2018-10-25
--------------------
-
-Since :ref:`version 3.68.0 <v3.68.0>`, :func:`~hypothesis.extra.numpy.arrays`
-checks that values drawn from the ``elements`` and ``fill`` strategies can be
-safely cast to the dtype of the array, and emits a warning otherwise.
-
-This release expands the checks to cover overflow for finite ``complex64``
-elements and string truncation caused by too-long elements or trailing null
-characters (:issue:`1591`).
-
-.. _v3.79.4:
-
--------------------
-3.79.4 - 2018-10-25
--------------------
-
-Tests using :func:`@given <hypothesis.given>` now shrink errors raised from
-:pypi:`pytest` helper functions, instead of reporting the first example found.
-
-This was previously fixed in :ref:`version 3.56.0 <v3.56.0>`, but only for
-stateful testing.
-
-.. _v3.79.3:
-
--------------------
-3.79.3 - 2018-10-23
--------------------
-
-Traceback elision is now disabled on Python 2, to avoid an import-time
-:class:`python:SyntaxError` under Python < 2.7.9 (Python: :bpo:`21591`,
-:ref:`Hypothesis 3.79.2 <v3.79.2>`: :issue:`1648`).
-
-We encourage all users to `upgrade to Python 3 before the end of 2019
-<https://pythonclock.org/>`_.
-
-.. _v3.79.2:
-
--------------------
-3.79.2 - 2018-10-23
--------------------
-
-This patch shortens tracebacks from Hypothesis, so you can see exactly
-happened in your code without having to skip over irrelevant details
-about our internals (:issue:`848`).
-
-In the example test (see :pull:`1582`), this reduces tracebacks from
-nine frames to just three - and for a test with multiple errors, from
-seven frames per error to just one!
-
-If you *do* want to see the internal details, you can disable frame
-elision by setting :obj:`~hypothesis.settings.verbosity` to ``debug``.
-
-.. _v3.79.1:
-
--------------------
-3.79.1 - 2018-10-22
--------------------
-
-The abstract number classes :class:`~python:numbers.Number`,
-:class:`~python:numbers.Complex`, :class:`~python:numbers.Real`,
-:class:`~python:numbers.Rational`, and :class:`~python:numbers.Integral`
-are now supported by the :func:`~hypothesis.strategies.from_type`
-strategy.  Previously, you would have to use
-:func:`~hypothesis.strategies.register_type_strategy` before they
-could be resolved (:issue:`1636`)
-
-.. _v3.79.0:
-
--------------------
-3.79.0 - 2018-10-18
--------------------
-
-This release adds a CLI flag for verbosity ``--hypothesis-verbosity`` to
-the Hypothesis pytest plugin, applied after loading the profile specified by
-``--hypothesis-profile``. Valid options are the names of verbosity settings,
-quiet, normal, verbose or debug.
-
-Thanks to Bex Dunn for writing this patch at the PyCon Australia
-sprints!
-
-The pytest header now correctly reports the current profile if
-``--hypothesis-profile`` has been used.
-
-Thanks to Mathieu Paturel for the contribution at the Canberra Python
-Hacktoberfest.
-
-.. _v3.78.0:
-
--------------------
-3.78.0 - 2018-10-16
--------------------
-
-This release has deprecated the generation of integers, floats and fractions
-when the conversion of the upper and/ or lower bound is not 100% exact, e.g.
-when an integer gets passed a bound that is not a whole number. (:issue:`1625`)
-
-Thanks to Felix Grünewald for this patch during Hacktoberfest 2018.
-
-.. _v3.77.0:
-
--------------------
-3.77.0 - 2018-10-16
--------------------
-
-This minor release adds functionality to :obj:`~hypothesis.settings` allowing
-it to be used as a decorator on :obj:`~hypothesis.stateful.RuleBasedStateMachine`
-and ``GenericStateMachine``.
-
-Thanks to Tyler Nickerson for this feature in #hacktoberfest!
-
-.. _v3.76.1:
-
--------------------
-3.76.1 - 2018-10-16
--------------------
-
-This patch fixes some warnings added by recent releases of
-:pypi:`pydocstyle` and :pypi:`mypy`.
-
-.. _v3.76.0:
-
--------------------
-3.76.0 - 2018-10-11
--------------------
-
-This release deprecates using floats for ``min_size`` and ``max_size``.
-
-The type hint for ``average_size`` arguments has been changed from
-``Optionalint`` to None, because non-None values are always ignored and
-deprecated.
-
-.. _v3.75.4:
-
--------------------
-3.75.4 - 2018-10-10
--------------------
-
-This patch adds more internal comments to the core engine's sequence-length
-shrinker. There should be no user-visible change.
-
-.. _v3.75.3:
-
--------------------
-3.75.3 - 2018-10-09
--------------------
-
-This patch adds additional comments to some of the core engine's internal
-data structures. There is no user-visible change.
-
-.. _v3.75.2:
-
--------------------
-3.75.2 - 2018-10-09
--------------------
-
-This patch avoids caching a trivial case, fixing :issue:`493`.
-
-.. _v3.75.1:
-
--------------------
-3.75.1 - 2018-10-09
--------------------
-
-This patch fixes a broken link in a docstring.
-Thanks to Benjamin Lee for this contribution!
-
-.. _v3.75.0:
-
--------------------
-3.75.0 - 2018-10-08
--------------------
-
-This release deprecates  the use of ``min_size=None``, setting the default
-``min_size`` to 0 (:issue:`1618`).
-
-.. _v3.74.3:
-
--------------------
-3.74.3 - 2018-10-08
--------------------
-
-This patch makes some small internal changes to comply with a new lint setting
-in the build. There should be no user-visible change.
-
-.. _v3.74.2:
-
--------------------
-3.74.2 - 2018-10-03
--------------------
-
-This patch fixes :issue:`1153`, where time spent reifying a strategy was
-also counted in the time spent generating the first example.  Strategies
-are now fully constructed and validated before the timer is started.
-
-.. _v3.74.1:
-
--------------------
-3.74.1 - 2018-10-03
--------------------
-
-This patch fixes some broken formatting and links in the documentation.
-
-.. _v3.74.0:
-
--------------------
-3.74.0 - 2018-10-01
--------------------
-
-This release checks that the value of the
-:attr:`~hypothesis.settings.print_blob` setting is a
-``PrintSettings`` instance.
-
-Being able to specify a boolean value was not intended, and is now deprecated.
-In addition, specifying ``True`` will now cause the blob to always be printed,
-instead of causing it to be suppressed.
-
-Specifying any value that is not a ``PrintSettings``
-or a boolean is now an error.
-
-.. _v3.73.5:
-
--------------------
-3.73.5 - 2018-10-01
--------------------
-
-Changes the documentation for ``hypothesis.strategies.datetimes``, ``hypothesis.strategies.dates``, ``hypothesis.strategies.times`` to use the new parameter names ``min_value`` and ``max_value`` instead of the deprecated names
-
-.. _v3.73.4:
-
--------------------
-3.73.4 - 2018-09-30
--------------------
-
-This patch ensures that Hypothesis deprecation warnings display the code
-that emitted them when you're not running in ``-Werror`` mode (:issue:`652`).
-
-.. _v3.73.3:
-
--------------------
-3.73.3 - 2018-09-27
--------------------
-
-Tracebacks involving :func:`@composite <hypothesis.strategies.composite>`
-are now slightly shorter due to some internal refactoring.
-
-.. _v3.73.2:
-
--------------------
-3.73.2 - 2018-09-26
--------------------
-
-This patch fixes errors in the internal comments for one of the shrinker
-passes. There is no user-visible change.
-
-.. _v3.73.1:
-
--------------------
-3.73.1 - 2018-09-25
--------------------
-
-This patch substantially improves the distribution of data generated
-with :func:`~hypothesis.strategies.recursive`, and fixes a rare internal
-error (:issue:`1502`).
-
-.. _v3.73.0:
-
--------------------
-3.73.0 - 2018-09-24
--------------------
-
-This release adds the :func:`~hypothesis.extra.dpcontracts.fulfill` function,
-which is designed for testing code that uses :pypi:`dpcontracts` 0.4 or later
-for input validation.  This provides some syntactic sugar around use of
-:func:`~hypothesis.assume`, to automatically filter out and retry calls that
-cause a precondition check to fail (:issue:`1474`).
-
-.. _v3.72.0:
-
--------------------
-3.72.0 - 2018-09-24
--------------------
-
-This release makes setting attributes of the :class:`hypothesis.settings`
-class an explicit error.  This has never had any effect, but could mislead
-users who confused it with the current settings *instance*
-``hypothesis.settings.default`` (which is also immutable).  You can change
-the global settings with :ref:`settings profiles <settings_profiles>`.
-
-.. _v3.71.11:
-
---------------------
-3.71.11 - 2018-09-24
---------------------
-
-This patch factors out some common code in the shrinker for iterating
-over pairs of data blocks. There should be no user-visible change.
-
-.. _v3.71.10:
-
---------------------
-3.71.10 - 2018-09-18
---------------------
-
-This patch allows :func:`~hypothesis.strategies.from_type` to handle the
-empty tuple type, :obj:`typing.Tuple() <python:typing.Tuple>`.
-
-.. _v3.71.9:
-
--------------------
-3.71.9 - 2018-09-17
--------------------
-
-This patch updates some internal comments for :pypi:`mypy`.
-There is no user-visible effect, even for Mypy users.
-
-.. _v3.71.8:
-
--------------------
-3.71.8 - 2018-09-17
--------------------
-
-This patch fixes a rare bug that would cause a particular shrinker pass to
-raise an IndexError, if a shrink improvement changed the underlying data
-in an unexpected way.
-
-.. _v3.71.7:
-
--------------------
-3.71.7 - 2018-09-17
--------------------
-
-This release fixes the broken cross-references in our docs,
-and adds a CI check so we don't add new ones.
-
-.. _v3.71.6:
-
--------------------
-3.71.6 - 2018-09-16
--------------------
-
-This patch fixes two bugs (:issue:`944` and :issue:`1521`), where messages
-about :func:`@seed <hypothesis.seed>` did not check the current verbosity
-setting, and the wrong settings were active while executing
-:ref:`explicit examples <providing-explicit-examples>`.
-
-.. _v3.71.5:
-
--------------------
-3.71.5 - 2018-09-15
--------------------
-
-This patch fixes a ``DeprecationWarning`` added in Python 3.8 (:issue:`1576`).
-
-Thanks to tirkarthi for this contribution!
-
-.. _v3.71.4:
-
--------------------
-3.71.4 - 2018-09-14
--------------------
-
-This is a no-op release, which implements automatic DOI minting and code
-archival of Hypothesis via `Zenodo <https://zenodo.org/>`_. Thanks to
-CERN and the EU *Horizon 2020* programme for providing this service!
-
-Check our :gh-file:`CITATION.cff` file for details, or head right on over to
-`doi.org/10.5281/zenodo.1412597 <https://doi.org/10.5281/zenodo.1412597>`_
-
-.. _v3.71.3:
-
--------------------
-3.71.3 - 2018-09-10
--------------------
-
-This release adds the test name to some deprecation warnings,
-for easier debugging.
-
-Thanks to Sanyam Khurana for the patch!
-
-.. _v3.71.2:
-
--------------------
-3.71.2 - 2018-09-10
--------------------
-
-This release makes Hypothesis's memory usage substantially smaller for tests with many
-examples, by bounding the number of past examples it keeps around.
-
-You will not see much difference unless you are running tests with :obj:`~hypothesis.settings.max_examples`
-set to well over ``1000``, but if you do have such tests then you should see memory usage mostly plateau
-where previously it would have grown linearly with time.
-
-.. _v3.71.1:
-
--------------------
-3.71.1 - 2018-09-09
--------------------
-
-This patch adds internal comments to some tree traversals in the core engine.
-There is no user-visible change.
-
-.. _v3.71.0:
-
--------------------
-3.71.0 - 2018-09-08
--------------------
-
-This release deprecates the coverage-guided testing functionality,
-as it has proven brittle and does not really pull its weight.
-
-We intend to replace it with something more useful in the future,
-but the feature in its current form does not seem to be worth the cost of using,
-and whatever replaces it will likely look very different.
-
-.. _v3.70.4:
-
--------------------
-3.70.4 - 2018-09-08
--------------------
-
-This patch changes the behaviour of :func:`~hypothesis.reproduce_failure`
-so that blobs are only printed in quiet mode when the
-:obj:`~hypothesis.settings.print_blob` setting is set to ``ALWAYS``.
-
-Thanks to Cameron McGill for writing this patch at the PyCon Australia sprints!
-
-.. _v3.70.3:
-
--------------------
-3.70.3 - 2018-09-03
--------------------
-
-This patch removes some unnecessary code from the internals.
-There is no user-visible change.
-
-.. _v3.70.2:
-
--------------------
-3.70.2 - 2018-09-03
--------------------
-
-This patch fixes an internal bug where a corrupted argument to
-:func:`@reproduce_failure <hypothesis.reproduce_failure>` could raise
-the wrong type of error.  Thanks again to Paweł T. Jochym, who maintains
-Hypothesis on `conda-forge <https://conda-forge.org/>`_ and consistently
-provides excellent bug reports including :issue:`1558`.
-
-.. _v3.70.1:
-
--------------------
-3.70.1 - 2018-09-03
--------------------
-
-This patch updates hypothesis to report its version and settings when run with
-pytest. (:issue:`1223`).
-
-Thanks to Jack Massey for this feature.
-
-.. _v3.70.0:
-
--------------------
-3.70.0 - 2018-09-01
--------------------
-
-This release adds a ``fullmatch`` argument to
-:func:`~hypothesis.strategies.from_regex`.  When ``fullmatch=True``, the
-whole example will match the regex pattern as for :func:`python:re.fullmatch`.
-
-Thanks to Jakub Nabaglo for writing this patch at the PyCon Australia sprints!
-
-.. _v3.69.12:
-
---------------------
-3.69.12 - 2018-08-30
---------------------
-
-This release reverts the changes to logging handling in 3.69.11,
-which broke test that use the :pypi:`pytest` ``caplog`` fixture
-internally because all logging was disabled (:issue:`1546`).
-
-.. _v3.69.11:
-
---------------------
-3.69.11 - 2018-08-29
---------------------
-
-This patch will hide all logging messages produced by test cases before the
-final, minimal, failing test case (:issue:`356`).
-
-Thanks to Gary Donovan for writing this patch at the PyCon Australia sprints!
-
-.. _v3.69.10:
-
---------------------
-3.69.10 - 2018-08-29
---------------------
-
-This patch fixes a bug that prevents coverage from reporting unexecuted
-Python files (:issue:`1085`).
-
-Thanks to Gary Donovan for writing this patch at the PyCon Australia sprints!
-
-.. _v3.69.9:
-
--------------------
-3.69.9 - 2018-08-28
--------------------
-
-This patch improves the packaging of the Python package by adding
-``LICENSE.txt`` to the sdist (:issue:`1311`), clarifying the minimum
-supported versions of :pypi:`pytz` and :pypi:`dateutil <python-dateutil>`
-(:issue:`1383`), and adds keywords to the metadata (:issue:`1520`).
-
-Thanks to Graham Williamson for writing this patch at the PyCon
-Australia sprints!
-
-.. _v3.69.8:
-
--------------------
-3.69.8 - 2018-08-28
--------------------
-
-This is an internal change which replaces pickle with json to prevent possible
-security issues.
-
-Thanks to Vidya Rani D G for writing this patch at the PyCon Australia sprints!
-
-.. _v3.69.7:
-
--------------------
-3.69.7 - 2018-08-28
--------------------
-
-This patch ensures that :func:`~hypothesis.note` prints the note for every
-test case when the :obj:`~hypothesis.settings.verbosity` setting is
-``Verbosity.verbose``.  At normal verbosity it only prints from the final
-test case.
-
-Thanks to Tom McDermott for writing this patch at
-the PyCon Australia sprints!
-
-.. _v3.69.6:
-
--------------------
-3.69.6 - 2018-08-27
--------------------
-
-This patch improves the testing of some internal caching.  It should have
-no user-visible effect.
-
-.. _v3.69.5:
-
--------------------
-3.69.5 - 2018-08-27
--------------------
-
-This change performs a small rename and refactoring in the core engine.
-There is no user-visible change.
-
-.. _v3.69.4:
-
--------------------
-3.69.4 - 2018-08-27
--------------------
-
-This change improves the core engine's ability to avoid unnecessary work,
-by consulting its cache of previously-tried inputs in more cases.
-
-.. _v3.69.3:
-
--------------------
-3.69.3 - 2018-08-27
--------------------
-
-This patch handles passing an empty :class:`python:enum.Enum` to
-:func:`~hypothesis.strategies.from_type` by returning
-:func:`~hypothesis.strategies.nothing`, instead of raising an
-internal :class:`python:AssertionError`.
-
-Thanks to Paul Amazona for writing this patch at the
-PyCon Australia sprints!
-
-.. _v3.69.2:
-
--------------------
-3.69.2 - 2018-08-23
--------------------
-
-This patch fixes a small mistake in an internal comment.
-There is no user-visible change.
-
-.. _v3.69.1:
-
--------------------
-3.69.1 - 2018-08-21
--------------------
-
-This change fixes a small bug in how the core engine consults its cache
-of previously-tried inputs. There is unlikely to be any user-visible change.
-
-.. _v3.69.0:
-
--------------------
-3.69.0 - 2018-08-20
--------------------
-
-This release improves argument validation for stateful testing.
-
-- If the target or targets of a :func:`~hypothesis.stateful.rule` are invalid,
-  we now raise a useful validation error rather than an internal exception.
-- Passing both the ``target`` and ``targets`` arguments is deprecated -
-  append the ``target`` bundle to the ``targets`` tuple of bundles instead.
-- Passing the name of a Bundle rather than the Bundle itself is also deprecated.
-
-.. _v3.68.3:
-
--------------------
-3.68.3 - 2018-08-20
--------------------
-
-This is a docs-only patch, fixing some typos and formatting issues.
-
-.. _v3.68.2:
-
--------------------
-3.68.2 - 2018-08-19
--------------------
-
-This change fixes a small bug in how the core engine caches the results of
-previously-tried inputs. The effect is unlikely to be noticeable, but it might
-avoid unnecessary work in some cases.
-
-.. _v3.68.1:
-
--------------------
-3.68.1 - 2018-08-18
--------------------
-
-This patch documents the :func:`~hypothesis.extra.numpy.from_dtype` function,
-which infers a strategy for :class:`numpy:numpy.dtype`\ s.  This is used in
-:func:`~hypothesis.extra.numpy.arrays`, but can also be used directly when
-creating e.g. Pandas objects.
-
-.. _v3.68.0:
-
--------------------
-3.68.0 - 2018-08-15
--------------------
-
-:func:`~hypothesis.extra.numpy.arrays` now checks that integer and float
-values drawn from ``elements`` and ``fill`` strategies can be safely cast
-to the dtype of the array, and emits a warning otherwise (:issue:`1385`).
-
-Elements in the resulting array could previously violate constraints on
-the elements strategy due to floating-point overflow or truncation of
-integers to fit smaller types.
-
-.. _v3.67.1:
-
--------------------
-3.67.1 - 2018-08-14
--------------------
-
-This release contains a tiny refactoring of the internals.
-There is no user-visible change.
-
-.. _v3.67.0:
-
--------------------
-3.67.0 - 2018-08-10
--------------------
-
-This release adds a ``width`` argument to :func:`~hypothesis.strategies.floats`,
-to generate lower-precision floating point numbers for e.g. Numpy arrays.
-
-The generated examples are always instances of Python's native ``float``
-type, which is 64bit, but passing ``width=32`` will ensure that all values
-can be exactly represented as 32bit floats.  This can be useful to avoid
-overflow (to +/- infinity), and for efficiency of generation and shrinking.
-
-Half-precision floats (``width=16``) are also supported, but require Numpy
-if you are running Python 3.5 or earlier.
-
-.. _v3.66.33:
-
---------------------
-3.66.33 - 2018-08-10
---------------------
-
-This release fixes a bug in :func:`~hypothesis.strategies.floats`, where
-setting ``allow_infinity=False`` and exactly one of ``min_value`` and
-``max_value`` would allow infinite values to be generated.
-
-.. _v3.66.32:
-
---------------------
-3.66.32 - 2018-08-09
---------------------
-
-This release adds type hints to the :func:`~hypothesis.example` and
-:func:`~hypothesis.seed` decorators, and fixes the type hint on
-:func:`~hypothesis.strategies.register_type_strategy`. The second argument to
-:func:`~hypothesis.strategies.register_type_strategy` must either be a
-``SearchStrategy``, or a callable which takes a ``type`` and returns a
-``SearchStrategy``.
-
-.. _v3.66.31:
-
---------------------
-3.66.31 - 2018-08-08
---------------------
-
-Another set of changes designed to improve the performance of shrinking on
-large examples. In particular the shrinker should now spend considerably less
-time running useless shrinks.
-
-.. _v3.66.30:
-
---------------------
-3.66.30 - 2018-08-06
---------------------
-
-"Bug fixes and performance improvements".
-
-This release is a fairly major overhaul of the shrinker designed to improve
-its behaviour on large examples, especially around stateful testing. You
-should hopefully see shrinking become much faster, with little to no quality
-degradation (in some cases quality may even improve).
-
-.. _v3.66.29:
-
---------------------
-3.66.29 - 2018-08-05
---------------------
-
-This release fixes two very minor bugs in the core engine:
-
-* it fixes a corner case that was missing in :ref:`3.66.28 <v3.66.28>`, which
-  should cause shrinking to work slightly better.
-* it fixes some logic for how shrinking interacts with the database that was
-  causing Hypothesis to be insufficiently aggressive about clearing out old
-  keys.
-
-.. _v3.66.28:
-
---------------------
-3.66.28 - 2018-08-05
---------------------
-
-This release improves how Hypothesis handles reducing the size of integers'
-representation. This change should mostly be invisible as it's purely about
-the underlying representation and not the generated value, but it may result
-in some improvements to shrink performance.
-
-.. _v3.66.27:
-
---------------------
-3.66.27 - 2018-08-05
---------------------
-
-This release changes the order in which Hypothesis chooses parts of the test case
-to shrink. For typical usage this should be a significant performance improvement on
-large examples. It is unlikely to have a major impact on example quality, but where
-it does change the result it should usually be an improvement.
-
-.. _v3.66.26:
-
---------------------
-3.66.26 - 2018-08-05
---------------------
-
-This release improves the debugging information that the shrinker emits about
-the operations it performs, giving better summary statistics about which
-passes resulted in test executions and whether they were successful.
-
-.. _v3.66.25:
-
---------------------
-3.66.25 - 2018-08-05
---------------------
-
-This release fixes several bugs that were introduced to the shrinker in
-:ref:`3.66.24 <v3.66.24>` which would have caused it to behave significantly
-less well than advertised. With any luck you should *actually* see the promised
-benefits now.
-
-.. _v3.66.24:
-
---------------------
-3.66.24 - 2018-08-03
---------------------
-
-This release changes how Hypothesis deletes data when shrinking in order to
-better handle deletion of large numbers of contiguous sequences. Most tests
-should see little change, but this will hopefully provide a significant
-speed up for :doc:`stateful testing <stateful>`.
-
-.. _v3.66.23:
-
---------------------
-3.66.23 - 2018-08-02
---------------------
-
-This release makes some internal changes to enable further improvements to the
-shrinker. You may see some changes in the final shrunk examples, but they are
-unlikely to be significant.
-
-.. _v3.66.22:
-
---------------------
-3.66.22 - 2018-08-01
---------------------
-
-This release adds some more internal caching to the shrinker. This should cause
-a significant speed up for shrinking, especially for stateful testing and
-large example sizes.
-
-.. _v3.66.21:
-
---------------------
-3.66.21 - 2018-08-01
---------------------
-
-This patch is for downstream packagers - our tests now pass under
-:pypi:`pytest` 3.7.0 (released 2018-07-30).  There are no changes
-to the source of Hypothesis itself.
-
-.. _v3.66.20:
-
---------------------
-3.66.20 - 2018-08-01
---------------------
-
-This release removes some functionality from the shrinker that was taking a
-considerable amount of time and does not appear to be useful any more due to
-a number of quality improvements in the shrinker.
-
-You may see some degradation in shrink quality as a result of this, but mostly
-shrinking should just get much faster.
-
-.. _v3.66.19:
-
---------------------
-3.66.19 - 2018-08-01
---------------------
-
-This release slightly changes the format of some debugging information emitted
-during shrinking, and refactors some of the internal interfaces around that.
-
-.. _v3.66.18:
-
---------------------
-3.66.18 - 2018-07-31
---------------------
-
-This release is a very small internal refactoring which should have no user
-visible impact.
-
-.. _v3.66.17:
-
---------------------
-3.66.17 - 2018-07-31
---------------------
-
-This release fixes a bug that could cause an ``IndexError`` to be raised from
-inside Hypothesis during shrinking. It is likely that it was impossible to
-trigger this bug in practice - it was only made visible by some currently
-unreleased work.
-
-.. _v3.66.16:
-
---------------------
-3.66.16 - 2018-07-31
---------------------
-
-This release is a very small internal refactoring which should have no user
-visible impact.
-
-.. _v3.66.15:
-
---------------------
-3.66.15 - 2018-07-31
---------------------
-
-This release makes Hypothesis's shrinking faster by removing some redundant
-work that it does when minimizing values in its internal representation.
-
-.. _v3.66.14:
-
---------------------
-3.66.14 - 2018-07-30
---------------------
-
-This release expands the deprecation of timeout from :ref:`3.16.0 <v3.16.0>` to
-also emit the deprecation warning in ``find`` or :doc:`stateful testing <stateful>`.
-
-.. _v3.66.13:
-
---------------------
-3.66.13 - 2018-07-30
---------------------
-
-This release adds an additional shrink pass that is able to reduce the size of
-examples in some cases where the transformation is non-obvious. In particular
-this will improve the quality of some examples which would have regressed in
-:ref:`3.66.12 <v3.66.12>`.
-
-.. _v3.66.12:
-
---------------------
-3.66.12 - 2018-07-28
---------------------
-
-This release changes how we group data together for shrinking. It should result
-in improved shrinker performance, especially in stateful testing.
-
-.. _v3.66.11:
-
---------------------
-3.66.11 - 2018-07-28
---------------------
-
-This patch modifies how which rule to run is selected during
-:doc:`rule based stateful testing <stateful>`. This should result in a slight
-performance increase during generation and a significant performance and
-quality improvement when shrinking.
-
-As a result of this change, some state machines which would previously have
-thrown an ``InvalidDefinition`` are no longer detected as invalid.
-
-.. _v3.66.10:
-
---------------------
-3.66.10 - 2018-07-28
---------------------
-
-This release weakens some minor functionality in the shrinker that had only
-modest benefit and made its behaviour much harder to reason about.
-
-This is unlikely to have much user visible effect, but it is possible that in
-some cases shrinking may get slightly slower. It is primarily to make it easier
-to work on the shrinker and pave the way for future work.
-
-.. _v3.66.9:
-
--------------------
-3.66.9 - 2018-07-26
--------------------
-
-This release improves the information that Hypothesis emits about its shrinking
-when :obj:`~hypothesis.settings.verbosity` is set to debug.
-
-.. _v3.66.8:
-
--------------------
-3.66.8 - 2018-07-24
--------------------
-
-This patch includes some minor fixes in the documentation, and updates
-the minimum version of :pypi:`pytest` to 3.0 (released August 2016).
-
-.. _v3.66.7:
-
--------------------
-3.66.7 - 2018-07-24
--------------------
-
-This release fixes a bug where difficult to shrink tests could sometimes
-trigger an internal assertion error inside the shrinker.
-
-.. _v3.66.6:
-
--------------------
-3.66.6 - 2018-07-23
--------------------
-
-This patch ensures that Hypothesis fully supports Python 3.7, by
-upgrading :func:`~hypothesis.strategies.from_type` (:issue:`1264`)
-and fixing some minor issues in our test suite (:issue:`1148`).
-
-.. _v3.66.5:
-
--------------------
-3.66.5 - 2018-07-22
--------------------
-
-This patch fixes the online docs for various extras, by ensuring that
-their dependencies are installed on readthedocs.io (:issue:`1326`).
-
-.. _v3.66.4:
-
--------------------
-3.66.4 - 2018-07-20
--------------------
-
-This release improves the shrinker's ability to reorder examples.
-
-For example, consider the following test:
-
-.. code-block:: python
-
-    import hypothesis.strategies as st
-    from hypothesis import given
-
-
-    @given(st.text(), st.text())
-    def test_non_equal(x, y):
-        assert x != y
-
-Previously this could have failed with either of ``x="", y="0"`` or
-``x="0", y=""``. Now it should always fail with ``x="", y="0"``.
-
-This will allow the shrinker to produce more consistent results, especially in
-cases where test cases contain some ordered collection whose actual order does
-not matter.
-
-.. _v3.66.3:
-
--------------------
-3.66.3 - 2018-07-20
--------------------
-
-This patch fixes inference in the :func:`~hypothesis.strategies.builds`
-strategy with subtypes of :class:`python:typing.NamedTuple`, where the
-``__init__`` method is not useful for introspection.  We now use the
-field types instead - thanks to James Uther for identifying this bug.
-
-.. _v3.66.2:
-
--------------------
-3.66.2 - 2018-07-19
--------------------
-
-This release improves the shrinker's ability to handle situations where there
-is an additive constraint between two values.
-
-For example, consider the following test:
-
-
-.. code-block:: python
-
-    import hypothesis.strategies as st
-    from hypothesis import given
-
-
-    @given(st.integers(), st.integers())
-    def test_does_not_exceed_100(m, n):
-        assert m + n < 100
-
-Previously this could have failed with almost any pair ``(m, n)`` with
-``0 <= m <= n`` and ``m + n == 100``. Now it should almost always fail with
-``m=0, n=100``.
-
-This is a relatively niche specialisation, but can be useful in situations
-where e.g. a bug is triggered by an integer overflow.
-
-.. _v3.66.1:
-
--------------------
-3.66.1 - 2018-07-09
--------------------
-
-This patch fixes a rare bug where an incorrect percentage drawtime
-could be displayed for a test, when the system clock was changed during
-a test running under Python 2 (we use :func:`python:time.monotonic`
-where it is available to avoid such problems).  It also fixes a possible
-zero-division error that can occur when the underlying C library
-double-rounds an intermediate value in :func:`python:math.fsum` and
-gets the least significant bit wrong.
-
-.. _v3.66.0:
-
--------------------
-3.66.0 - 2018-07-05
--------------------
-
-This release improves validation of the ``alphabet`` argument to the
-:func:`~hypothesis.strategies.text` strategy.  The following misuses
-are now deprecated, and will be an error in a future version:
-
-- passing an unordered collection (such as ``set('abc')``), which
-  violates invariants about shrinking and reproducibility
-- passing an alphabet sequence with elements that are not strings
-- passing an alphabet sequence with elements that are not of length one,
-  which violates any size constraints that may apply
-
-Thanks to Sushobhit for adding these warnings (:issue:`1329`).
-
-.. _v3.65.3:
-
--------------------
-3.65.3 - 2018-07-04
--------------------
-
-This release fixes a mostly theoretical bug where certain usage of the internal
-API could trigger an assertion error inside Hypothesis. It is unlikely that
-this problem is even possible to trigger through the public API.
-
-.. _v3.65.2:
-
--------------------
-3.65.2 - 2018-07-04
--------------------
-
-This release fixes dependency information for coverage.  Previously Hypothesis
-would allow installing :pypi:`coverage` with any version, but it only works
-with coverage 4.0 or later.
-
-We now specify the correct metadata in our ``setup.py``, so Hypothesis will
-only allow installation with compatible versions of coverage.
-
-.. _v3.65.1:
-
--------------------
-3.65.1 - 2018-07-03
--------------------
-
-This patch ensures that :doc:`stateful tests <stateful>` which raise an
-error from a :pypi:`pytest` helper still print the sequence of steps
-taken to reach that point (:issue:`1372`).  This reporting was previously
-broken because the helpers inherit directly from :class:`python:BaseException`, and
-therefore require special handling to catch without breaking e.g. the use
-of ctrl-C to quit the test.
-
-.. _v3.65.0:
-
--------------------
-3.65.0 - 2018-06-30
--------------------
-
-This release deprecates the ``max_shrinks`` setting
-in favor of an internal heuristic.  If you need to avoid shrinking examples,
-use the :obj:`~hypothesis.settings.phases` setting instead.  (:issue:`1235`)
-
-.. _v3.64.2:
-
--------------------
-3.64.2 - 2018-06-27
--------------------
-
-This release fixes a bug where an internal assertion error could sometimes be
-triggered while shrinking a failing test.
-
-.. _v3.64.1:
-
--------------------
-3.64.1 - 2018-06-27
--------------------
-
-This patch fixes type-checking errors in our vendored pretty-printer,
-which were ignored by our mypy config but visible for anyone else
-(whoops).  Thanks to Pi Delport for reporting :issue:`1359` so promptly.
-
-.. _v3.64.0:
-
--------------------
-3.64.0 - 2018-06-26
--------------------
-
-This release adds :ref:`an interface <custom-function-execution>`
-which can be used to insert a wrapper between the original test function and
-:func:`@given <hypothesis.given>` (:issue:`1257`).  This will be particularly
-useful for test runner extensions such as :pypi:`pytest-trio`, but is
-not recommended for direct use by other users of Hypothesis.
-
-.. _v3.63.0:
-
--------------------
-3.63.0 - 2018-06-26
--------------------
-
-This release adds a new mechanism to infer strategies for classes
-defined using :pypi:`attrs`, based on the the type, converter, or
-validator of each attribute.  This inference is now built in to
-:func:`~hypothesis.strategies.builds` and :func:`~hypothesis.strategies.from_type`.
-
-On Python 2, :func:`~hypothesis.strategies.from_type` no longer generates
-instances of ``int`` when passed ``long``, or vice-versa.
-
-.. _v3.62.0:
-
--------------------
-3.62.0 - 2018-06-26
--------------------
-
-This release adds :PEP:`484` type hints to Hypothesis on a provisional
-basis, using the comment-based syntax for Python 2 compatibility.  You
-can :ref:`read more about our type hints here <our-type-hints>`.
-
-It *also* adds the ``py.typed`` marker specified in :PEP:`561`.
-After you ``pip install hypothesis``, :pypi:`mypy` 0.590 or later
-will therefore type-check your use of our public interface!
-
-.. _v3.61.0:
-
--------------------
-3.61.0 - 2018-06-24
--------------------
-
-This release deprecates the use of :class:`~hypothesis.settings` as a
-context manager, the use of which is somewhat ambiguous.
-
-Users should define settings with global state or with the
-:func:`@settings(...) <hypothesis.settings>` decorator.
-
-.. _v3.60.1:
-
--------------------
-3.60.1 - 2018-06-20
--------------------
-
-Fixed a bug in generating an instance of a Django model from a
-strategy where the primary key is generated as part of the
-strategy. See :ref:`details here <django-generating-primary-key>`.
-
-Thanks to Tim Martin for this contribution.
-
-.. _v3.60.0:
-
--------------------
-3.60.0 - 2018-06-20
--------------------
-
-This release adds the :func:`@initialize <hypothesis.stateful.initialize>`
-decorator for stateful testing (originally discussed in :issue:`1216`).
-All :func:`@initialize <hypothesis.stateful.initialize>` rules will be called
-once each in an arbitrary order before any normal rule is called.
-
-.. _v3.59.3:
-
--------------------
-3.59.3 - 2018-06-19
--------------------
-
-This is a no-op release to take into account some changes to the release
-process. It should have no user visible effect.
-
-.. _v3.59.2:
-
--------------------
-3.59.2 - 2018-06-18
--------------------
-
-This adds support for partially sorting examples which cannot be fully sorted.
-For example, 5, 4, 3, 2, 1, 0 with a constraint that the first element needs
-to be larger than the last becomes 1, 2, 3, 4, 5, 0.
-
-Thanks to Luke for contributing.
-
-.. _v3.59.1:
-
--------------------
-3.59.1 - 2018-06-16
--------------------
-
-This patch uses :func:`python:random.getstate` and :func:`python:random.setstate`
-to restore the PRNG state after :func:`@given <hypothesis.given>` runs
-deterministic tests.  Without restoring state, you might have noticed problems
-such as :issue:`1266`.  The fix also applies to stateful testing (:issue:`702`).
-
-.. _v3.59.0:
-
--------------------
-3.59.0 - 2018-06-14
--------------------
-
-This release adds the :func:`~hypothesis.strategies.emails` strategy,
-which generates unicode strings representing an email address.
-
-Thanks to Sushobhit for moving this to the public API (:issue:`162`).
-
-.. _v3.58.1:
-
--------------------
-3.58.1 - 2018-06-13
--------------------
-
-This improves the shrinker. It can now reorder examples: 3 1 2 becomes 1 2 3.
-
-Thanks to Luke for contributing.
-
-.. _v3.58.0:
-
--------------------
-3.58.0 - 2018-06-13
--------------------
-
-This adds a new extra :py:func:`~hypothesis.extra.dateutil.timezones` strategy
-that generates :pypi:`dateutil timezones <python-dateutil>`.
-
-Thanks to Conrad for contributing.
-
-.. _v3.57.0:
-
--------------------
-3.57.0 - 2018-05-20
--------------------
-
-Using an unordered collection with the :func:`~hypothesis.strategies.permutations`
-strategy has been deprecated because the order in which e.g. a set shrinks is
-arbitrary. This may cause different results between runs.
-
-.. _v3.56.10:
-
---------------------
-3.56.10 - 2018-05-16
---------------------
-
-This release makes ``hypothesis.settings.define_setting``
-a private method, which has the effect of hiding it from the
-documentation.
-
-.. _v3.56.9:
-
--------------------
-3.56.9 - 2018-05-11
--------------------
-
-This is another release with no functionality changes as part of changes to
-Hypothesis's new release tagging scheme.
-
-.. _v3.56.8:
-
--------------------
-3.56.8 - 2018-05-10
--------------------
-
-This is a release with no functionality changes that moves Hypothesis over to
-a new release tagging scheme.
-
-.. _v3.56.7:
-
--------------------
-3.56.7 - 2018-05-10
--------------------
-
-This release provides a performance improvement for most tests, but in
-particular users of :func:`~hypothesis.strategies.sampled_from` who don't
-have numpy installed should see a significant performance improvement.
-
-.. _v3.56.6:
-
--------------------
-3.56.6 - 2018-05-09
--------------------
-
-This patch contains further internal work to support Mypy.
-There are no user-visible changes... yet.
-
-.. _v3.56.5:
-
--------------------
-3.56.5 - 2018-04-22
--------------------
-
-This patch contains some internal refactoring to run :pypi:`mypy` in CI.
-There are no user-visible changes.
-
-.. _v3.56.4:
-
--------------------
-3.56.4 - 2018-04-21
--------------------
-
-This release involves some very minor internal clean up and should have no
-user visible effect at all.
-
-.. _v3.56.3:
-
--------------------
-3.56.3 - 2018-04-20
--------------------
-
-This release fixes a problem introduced in :ref:`3.56.0 <v3.56.0>` where
-setting the hypothesis home directory (through currently undocumented
-means) would no longer result in the default database location living
-in the new home directory.
-
-.. _v3.56.2:
-
--------------------
-3.56.2 - 2018-04-20
--------------------
-
-This release fixes a problem introduced in :ref:`3.56.0 <v3.56.0>` where
-setting :obj:`~hypothesis.settings.max_examples` to ``1`` would result in tests
-failing with ``Unsatisfiable``. This problem could also occur in other harder
-to trigger circumstances (e.g. by setting it to a low value, having a hard to
-satisfy assumption, and disabling health checks).
-
-.. _v3.56.1:
-
--------------------
-3.56.1 - 2018-04-20
--------------------
-
-This release fixes a problem that was introduced in :ref:`3.56.0 <v3.56.0>`:
-Use of the ``HYPOTHESIS_VERBOSITY_LEVEL`` environment variable was, rather
-than deprecated, actually broken due to being read before various setup
-the deprecation path needed was done. It now works correctly (and emits a
-deprecation warning).
-
-.. _v3.56.0:
-
--------------------
-3.56.0 - 2018-04-17
--------------------
-
-This release deprecates several redundant or internally oriented
-:class:`~hypothesis.settings`, working towards an orthogonal set of
-configuration options that are widely useful *without* requiring any
-knowledge of our internals (:issue:`535`).
-
-- Deprecated settings that no longer have any effect are no longer
-  shown in the ``__repr__`` unless set to a non-default value.
-- ``hypothesis.settings.perform_health_check`` is deprecated, as it
-  duplicates :obj:`~hypothesis.settings.suppress_health_check`.
-- ``hypothesis.settings.max_iterations`` is deprecated and disabled,
-  because we can usually get better behaviour from an internal heuristic
-  than a user-controlled setting.
-- ``hypothesis.settings.min_satisfying_examples`` is deprecated and
-  disabled, due to overlap with the
-  :obj:`~hypothesis.HealthCheck.filter_too_much` healthcheck
-  and poor interaction with :obj:`~hypothesis.settings.max_examples`.
-- ``HYPOTHESIS_VERBOSITY_LEVEL`` is now deprecated.  Set
-  :obj:`~hypothesis.settings.verbosity` through the profile system instead.
-- Examples tried by ``find()`` are now reported at ``debug``
-  verbosity level (as well as ``verbose`` level).
-
-.. _v3.55.6:
-
--------------------
-3.55.6 - 2018-04-14
--------------------
-
-This release fixes a somewhat obscure condition (:issue:`1230`) under which you
-could occasionally see a failing test trigger an assertion error inside
-Hypothesis instead of failing normally.
-
-.. _v3.55.5:
-
--------------------
-3.55.5 - 2018-04-14
--------------------
-
-This patch fixes one possible cause of :issue:`966`.  When running
-Python 2 with hash randomisation, passing a :obj:`python:bytes` object
-to :func:`python:random.seed` would use ``version=1``, which broke
-:obj:`~hypothesis.settings.derandomize` (because the seed depended on
-a randomised hash).  If :obj:`~hypothesis.settings.derandomize` is
-*still* nondeterministic for you, please open an issue.
-
-.. _v3.55.4:
-
--------------------
-3.55.4 - 2018-04-13
--------------------
-
-This patch makes a variety of minor improvements to the documentation,
-and improves a few validation messages for invalid inputs.
-
-.. _v3.55.3:
-
--------------------
-3.55.3 - 2018-04-12
--------------------
-
-This release updates the URL metadata associated with the PyPI package (again).
-It has no other user visible effects.
-
-.. _v3.55.2:
-
--------------------
-3.55.2 - 2018-04-11
--------------------
-
-This release updates the URL metadata associated with the PyPI package.
-It has no other user visible effects.
-
-.. _v3.55.1:
-
--------------------
-3.55.1 - 2018-04-06
--------------------
-
-This patch relaxes constraints in our tests on the expected values returned
-by the standard library function :func:`~python:math.hypot` and the internal
-helper function ``cathetus``, to fix near-exact
-test failures on some 32-bit systems used by downstream packagers.
-
-.. _v3.55.0:
-
--------------------
-3.55.0 - 2018-04-05
--------------------
-
-This release includes several improvements to the handling of the
-:obj:`~hypothesis.settings.database` setting.
-
-- The ``database_file`` setting was a historical
-  artefact, and you should just use :obj:`~hypothesis.settings.database`
-  directly.
-- The ``HYPOTHESIS_DATABASE_FILE`` environment variable is
-  deprecated, in favor of :meth:`~hypothesis.settings.load_profile` and
-  the :obj:`~hypothesis.settings.database` setting.
-- If you have not configured the example database at all and the default
-  location is not usable (due to e.g. permissions issues), Hypothesis
-  will fall back to an in-memory database.  This is not persisted between
-  sessions, but means that the defaults work on read-only filesystems.
-
-.. _v3.54.0:
-
--------------------
-3.54.0 - 2018-04-04
--------------------
-
-This release improves the :func:`~hypothesis.strategies.complex_numbers`
-strategy, which now supports ``min_magnitude`` and ``max_magnitude``
-arguments, along with ``allow_nan`` and ``allow_infinity`` like for
-:func:`~hypothesis.strategies.floats`.
-
-Thanks to J.J. Green for this feature.
-
-.. _v3.53.0:
-
--------------------
-3.53.0 - 2018-04-01
--------------------
-
-This release removes support for Django 1.8, which reached end of life on
-2018-04-01.  You can see Django's release and support schedule
-`on the Django Project website <https://www.djangoproject.com/download/#supported-versions>`_.
-
-.. _v3.52.3:
-
--------------------
-3.52.3 - 2018-04-01
--------------------
-
-This patch fixes the ``min_satisfying_examples`` settings
-documentation, by explaining that example shrinking is tracked at the level
-of the underlying bytestream rather than the output value.
-
-The output from ``find()`` in verbose mode has also been
-adjusted - see :ref:`the example session <verbose-output>` - to avoid
-duplicating lines when the example repr is constant, even if the underlying
-representation has been shrunken.
-
-.. _v3.52.2:
-
--------------------
-3.52.2 - 2018-03-30
--------------------
-
-This release improves the output of failures with
-:ref:`rule based stateful testing <rulebasedstateful>` in two ways:
-
-* The output from it is now usually valid Python code.
-* When the same value has two different names because it belongs to two different
-  bundles, it will now display with the name associated with the correct bundle
-  for a rule argument where it is used.
-
-.. _v3.52.1:
-
--------------------
-3.52.1 - 2018-03-29
--------------------
-
-This release improves the behaviour of  :doc:`stateful testing <stateful>`
-in two ways:
-
-* Previously some runs would run no steps (:issue:`376`). This should no longer
-  happen.
-* RuleBasedStateMachine tests which used bundles extensively would often shrink
-  terribly. This should now be significantly improved, though there is likely
-  a lot more room for improvement.
-
-This release also involves a low level change to how ranges of integers are
-handles which may result in other improvements to shrink quality in some cases.
-
-.. _v3.52.0:
-
--------------------
-3.52.0 - 2018-03-24
--------------------
-
-This release deprecates use of :func:`@settings(...) <hypothesis.settings>`
-as a decorator, on functions or methods that are not also decorated with
-:func:`@given <hypothesis.given>`.  You can still apply these decorators
-in any order, though you should only do so once each.
-
-Applying :func:`@given <hypothesis.given>` twice was already deprecated, and
-applying :func:`@settings(...) <hypothesis.settings>` twice is deprecated in
-this release and will become an error in a future version. Neither could ever
-be used twice to good effect.
-
-Using :func:`@settings(...) <hypothesis.settings>` as the sole decorator on
-a test is completely pointless, so this common usage error will become an
-error in a future version of Hypothesis.
-
-.. _v3.51.0:
-
--------------------
-3.51.0 - 2018-03-24
--------------------
-
-This release deprecates the ``average_size`` argument to
-:func:`~hypothesis.strategies.lists` and other collection strategies.
-You should simply delete it wherever it was used in your tests, as it
-no longer has any effect.
-
-In early versions of Hypothesis, the ``average_size`` argument was treated
-as a hint about the distribution of examples from a strategy.  Subsequent
-improvements to the conceptual model and the engine for generating and
-shrinking examples mean it is more effective to simply describe what
-constitutes a valid example, and let our internals handle the distribution.
-
-.. _v3.50.3:
-
--------------------
-3.50.3 - 2018-03-24
--------------------
-
-This patch contains some internal refactoring so that we can run
-with warnings as errors in CI.
-
-.. _v3.50.2:
-
--------------------
-3.50.2 - 2018-03-20
--------------------
-
-This has no user-visible changes except one slight formatting change to one docstring, to avoid a deprecation warning.
-
-.. _v3.50.1:
-
--------------------
-3.50.1 - 2018-03-20
--------------------
-
-This patch fixes an internal error introduced in :ref:`3.48.0 <v3.48.0>`, where a check
-for the Django test runner would expose import-time errors in Django
-configuration (:issue:`1167`).
-
-.. _v3.50.0:
-
--------------------
-3.50.0 - 2018-03-19
--------------------
-
-This release improves validation of numeric bounds for some strategies.
-
-- :func:`~hypothesis.strategies.integers` and :func:`~hypothesis.strategies.floats`
-  now raise ``InvalidArgument`` if passed a ``min_value`` or ``max_value``
-  which is not an instance of :class:`~python:numbers.Real`, instead of
-  various internal errors.
-- :func:`~hypothesis.strategies.floats` now converts its bounding values to
-  the nearest float above or below the min or max bound respectively, instead
-  of just casting to float.  The old behaviour was incorrect in that you could
-  generate ``float(min_value)``, even when this was less than ``min_value``
-  itself (possible with eg. fractions).
-- When both bounds are provided to :func:`~hypothesis.strategies.floats` but
-  there are no floats in the interval, such as ``(2**54)+1 .. (2**55)-1``,
-  InvalidArgument is raised.
-- :func:`~hypothesis.strategies.decimals` gives a more useful error message
-  if passed a string that cannot be converted to :class:`~python:decimal.Decimal`
-  in a context where this error is not trapped.
-
-Code that previously **seemed** to work may be explicitly broken if there
-were no floats between ``min_value`` and ``max_value`` (only possible with
-non-float bounds), or if a bound was not a :class:`~python:numbers.Real`
-number but still allowed in :obj:`python:math.isnan` (some custom classes
-with a ``__float__`` method).
-
-.. _v3.49.1:
-
--------------------
-3.49.1 - 2018-03-15
--------------------
-
-This patch fixes our tests for Numpy dtype strategies on big-endian platforms,
-where the strategy behaved correctly but the test assumed that the native byte
-order was little-endian.
-
-There is no user impact unless you are running our test suite on big-endian
-platforms.  Thanks to Graham Inggs for reporting :issue:`1164`.
-
-.. _v3.49.0:
-
--------------------
-3.49.0 - 2018-03-12
--------------------
-
-This release deprecates passing ``elements=None`` to collection strategies,
-such as :func:`~hypothesis.strategies.lists`.
-
-Requiring ``lists(nothing())`` or ``builds(list)`` instead of ``lists()``
-means slightly more typing, but also improves the consistency and
-discoverability of our API - as well as showing how to compose or
-construct strategies in ways that still work in more complex situations.
-
-Passing a nonzero max_size to a collection strategy where the elements
-strategy contains no values is now deprecated, and will be an error in a
-future version.  The equivalent with ``elements=None`` is already an error.
-
-.. _v3.48.1:
-
--------------------
-3.48.1 - 2018-03-05
--------------------
-
-This patch will minimize examples that would come out non-minimal in previous versions. Thanks to Kyle Reeve for this patch.
-
-.. _v3.48.0:
-
--------------------
-3.48.0 - 2018-03-05
--------------------
-
-This release improves some "unhappy paths" when using Hypothesis
-with the standard library :mod:`python:unittest` module:
-
-- Applying :func:`@given <hypothesis.given>` to a non-test method which is
-  overridden from :class:`python:unittest.TestCase`, such as ``setUp``,
-  raises :attr:`a new health check <hypothesis.HealthCheck.not_a_test_method>`.
-  (:issue:`991`)
-- Using :meth:`~python:unittest.TestCase.subTest` within a test decorated
-  with :func:`@given <hypothesis.given>` would leak intermediate results
-  when tests were run under the :mod:`python:unittest` test runner.
-  Individual reporting of failing subtests is now disabled during a test
-  using :func:`@given <hypothesis.given>`.  (:issue:`1071`)
-- :func:`@given <hypothesis.given>` is still not a class decorator, but the
-  error message if you try using it on a class has been improved.
-
-As a related improvement, using :class:`django:django.test.TestCase` with
-:func:`@given <hypothesis.given>` instead of
-:class:`hypothesis.extra.django.TestCase` raises an explicit error instead
-of running all examples in a single database transaction.
-
-.. _v3.47.0:
-
--------------------
-3.47.0 - 2018-03-02
--------------------
-
-:obj:`~hypothesis.settings.register_profile` now accepts keyword arguments
-for specific settings, and the parent settings object is now optional.
-Using a ``name`` for a registered profile which is not a string was never
-suggested, but it is now also deprecated and will eventually be an error.
-
-.. _v3.46.2:
-
--------------------
-3.46.2 - 2018-03-01
--------------------
-
-This release removes an unnecessary branch from the code, and has no user-visible impact.
-
-.. _v3.46.1:
-
--------------------
-3.46.1 - 2018-03-01
--------------------
-
-This changes only the formatting of our docstrings and should have no user-visible effects.
-
-.. _v3.46.0:
-
--------------------
-3.46.0 - 2018-02-26
--------------------
-
-:func:`~hypothesis.strategies.characters` has improved docs about
-what arguments are valid, and additional validation logic to raise a
-clear error early (instead of e.g. silently ignoring a bad argument).
-Categories may be specified as the Unicode 'general category'
-(eg ``u'Nd'``), or as the 'major category' (eg ``u'N', u'Lu'``
-is equivalent to ``u'Nd', u'Nl', u'No', u'Lu'``).
-
-In previous versions, general categories were supported and all other
-input was silently ignored.  Now, major categories are supported in
-addition to general categories (which may change the behaviour of some
-existing code), and all other input is deprecated.
-
-.. _v3.45.5:
-
--------------------
-3.45.5 - 2018-02-26
--------------------
-
-This patch improves strategy inference in ``hypothesis.extra.django``
-to account for some validators in addition to field type - see
-:issue:`1116` for ongoing work in this space.
-
-Specifically, if a :class:`~django:django.db.models.CharField` or
-:class:`~django:django.db.models.TextField` has an attached
-:class:`~django:django.core.validators.RegexValidator`, we now use
-:func:`~hypothesis.strategies.from_regex` instead of
-:func:`~hypothesis.strategies.text` as the underlying strategy.
-This allows us to generate examples of the default
-:class:`~django:django.contrib.auth.models.User` model, closing :issue:`1112`.
-
-.. _v3.45.4:
-
--------------------
-3.45.4 - 2018-02-25
--------------------
-
-This patch improves some internal debugging information, fixes
-a typo in a validation error message, and expands the documentation
-for new contributors.
-
-.. _v3.45.3:
-
--------------------
-3.45.3 - 2018-02-23
--------------------
-
-This patch may improve example shrinking slightly for some strategies.
-
-.. _v3.45.2:
-
--------------------
-3.45.2 - 2018-02-18
--------------------
-
-This release makes our docstring style more consistent, thanks to
-:pypi:`flake8-docstrings`.  There are no user-visible changes.
-
-.. _v3.45.1:
-
--------------------
-3.45.1 - 2018-02-17
--------------------
-
-This fixes an indentation issue in docstrings for
-:func:`~hypothesis.strategies.datetimes`, :func:`~hypothesis.strategies.dates`,
-:func:`~hypothesis.strategies.times`, and
-:func:`~hypothesis.strategies.timedeltas`.
-
-.. _v3.45.0:
-
--------------------
-3.45.0 - 2018-02-13
--------------------
-
-This release fixes :func:`~hypothesis.strategies.builds` so that ``target``
-can be used as a keyword argument for passing values to the target. The target
-itself can still be specified as a keyword argument, but that behavior is now
-deprecated. The target should be provided as the first positional argument.
-
-.. _v3.44.26:
-
---------------------
-3.44.26 - 2018-02-06
---------------------
-
-This release fixes some formatting issues in the Hypothesis source code.
-It should have no externally visible effects.
-
-.. _v3.44.25:
-
---------------------
-3.44.25 - 2018-02-05
---------------------
-
-This release changes the way in which Hypothesis tries to shrink the size of
-examples. It probably won't have much impact, but might make shrinking faster
-in some cases. It is unlikely but not impossible that it will change the
-resulting examples.
-
-.. _v3.44.24:
-
---------------------
-3.44.24 - 2018-01-27
---------------------
-
-This release fixes dependency information when installing Hypothesis
-from a binary "wheel" distribution.
-
-- The ``install_requires`` for :pypi:`enum34` is resolved at install
-  time, rather than at build time (with potentially different results).
-- Django has fixed their ``python_requires`` for versions 2.0.0 onward,
-  simplifying Python2-compatible constraints for downstream projects.
-
-.. _v3.44.23:
-
---------------------
-3.44.23 - 2018-01-24
---------------------
-
-This release improves shrinking in a class of pathological examples that you
-are probably never hitting in practice. If you *are* hitting them in practice
-this should be a significant speed up in shrinking. If you are not, you are
-very unlikely to notice any difference. You might see a slight slow down and/or
-slightly better falsifying examples.
-
-.. _v3.44.22:
-
---------------------
-3.44.22 - 2018-01-23
---------------------
-
-This release fixes a dependency problem.  It was possible to install
-Hypothesis with an old version of :pypi:`attrs`, which would throw a
-``TypeError`` as soon as you tried to import hypothesis.  Specifically, you
-need attrs 16.0.0 or newer.
-
-Hypothesis will now require the correct version of attrs when installing.
-
-.. _v3.44.21:
-
---------------------
-3.44.21 - 2018-01-22
---------------------
-
-This change adds some additional structural information that Hypothesis will
-use to guide its search.
-
-You mostly shouldn't see much difference from this. The two most likely effects
-you would notice are:
-
-1. Hypothesis stores slightly more examples in its database for passing tests.
-2. Hypothesis *may* find new bugs that it was previously missing, but it
-   probably won't (this is a basic implementation of the feature that is
-   intended to support future work. Although it is useful on its own, it's not
-   *very* useful on its own).
-
-.. _v3.44.20:
-
---------------------
-3.44.20 - 2018-01-21
---------------------
-
-This is a small refactoring release that changes how Hypothesis tracks some
-information about the boundary of examples in its internal representation.
-
-You are unlikely to see much difference in behaviour, but memory usage and
-run time may both go down slightly during normal test execution, and when
-failing Hypothesis might print its failing example slightly sooner.
-
-.. _v3.44.19:
-
---------------------
-3.44.19 - 2018-01-21
---------------------
-
-This changes how we compute the default ``average_size`` for all collection
-strategies. Previously setting a ``max_size`` without setting an
-``average_size`` would have the seemingly paradoxical effect of making data
-generation *slower*, because it would raise the average size from its default.
-Now setting ``max_size`` will either leave the default unchanged or lower it
-from its default.
-
-If you are currently experiencing this problem, this may make your tests
-substantially faster. If you are not, this will likely have no effect on you.
-
-.. _v3.44.18:
-
---------------------
-3.44.18 - 2018-01-20
---------------------
-
-This is a small refactoring release that changes how Hypothesis detects when
-the structure of data generation depends on earlier values generated (e.g. when
-using :ref:`flatmap <flatmap>` or :func:`~hypothesis.strategies.composite`).
-It should not have any observable effect on behaviour.
-
-.. _v3.44.17:
-
---------------------
-3.44.17 - 2018-01-15
---------------------
-
-This release fixes a typo in internal documentation, and has no user-visible impact.
-
-.. _v3.44.16:
-
---------------------
-3.44.16 - 2018-01-13
---------------------
-
-This release improves test case reduction for recursive data structures.
-Hypothesis now guarantees that whenever a strategy calls itself recursively
-(usually this will happen because you are using :func:`~hypothesis.strategies.deferred`),
-any recursive call may replace the top level value. e.g. given a tree structure,
-Hypothesis will always try replacing it with a subtree.
-
-Additionally this introduces a new heuristic that may in some circumstances
-significantly speed up test case reduction - Hypothesis should be better at
-immediately replacing elements drawn inside another strategy with their minimal
-possible value.
-
-.. _v3.44.15:
-
---------------------
-3.44.15 - 2018-01-13
---------------------
-
-:func:`~hypothesis.strategies.from_type` can now resolve recursive types
-such as binary trees (:issue:`1004`).  Detection of non-type arguments has
-also improved, leading to better error messages in many cases involving
-:pep:`forward references <484#forward-references>`.
-
-.. _v3.44.14:
-
---------------------
-3.44.14 - 2018-01-08
---------------------
-
-This release fixes a bug in the shrinker that prevented the optimisations in
-:ref:`3.44.6 <v3.44.6>` from working in some cases. It would not have worked correctly when
-filtered examples were nested (e.g. with a set of integers in some range).
-
-This would not have resulted in any correctness problems, but shrinking may
-have been slower than it otherwise could be.
-
-.. _v3.44.13:
-
---------------------
-3.44.13 - 2018-01-08
---------------------
-
-This release changes the average bit length of values drawn from
-:func:`~hypothesis.strategies.integers` to be much smaller. Additionally it
-changes the shrinking order so that now size is considered before sign - e.g.
--1 will be preferred to +10.
-
-The new internal format for integers required some changes to the minimizer to
-make work well, so you may also see some improvements to example quality in
-unrelated areas.
-
-.. _v3.44.12:
-
---------------------
-3.44.12 - 2018-01-07
---------------------
-
-This changes Hypothesis's internal implementation of weighted sampling. This
-will affect example distribution and quality, but you shouldn't see any other
-effects.
-
-.. _v3.44.11:
-
---------------------
-3.44.11 - 2018-01-06
---------------------
-
-This is a change to some internals around how Hypothesis handles avoiding
-generating duplicate examples and seeking out novel regions of the search
-space.
-
-You are unlikely to see much difference as a result of it, but it fixes
-a bug where an internal assertion could theoretically be triggered and has some
-minor effects on the distribution of examples so could potentially find bugs
-that have previously been missed.
-
-.. _v3.44.10:
-
---------------------
-3.44.10 - 2018-01-06
---------------------
-
-This patch avoids creating debug statements when debugging is disabled.
-Profiling suggests this is a 5-10% performance improvement (:issue:`1040`).
-
-.. _v3.44.9:
-
--------------------
-3.44.9 - 2018-01-06
--------------------
-
-This patch blacklists null characters (``'\x00'``) in automatically created
-strategies for Django :obj:`~django:django.db.models.CharField` and
-:obj:`~django:django.db.models.TextField`, due to a database issue which
-`was recently fixed upstream <https://code.djangoproject.com/ticket/28201>`_
-(Hypothesis :issue:`1045`).
-
-.. _v3.44.8:
-
--------------------
-3.44.8 - 2018-01-06
--------------------
-
-This release makes the Hypothesis shrinker slightly less greedy in order to
-avoid local minima - when it gets stuck, it makes a small attempt to search
-around the final example it would previously have returned to find a new
-starting point to shrink from. This should improve example quality in some
-cases, especially ones where the test data has dependencies among parts of it
-that make it difficult for Hypothesis to proceed.
-
-.. _v3.44.7:
-
--------------------
-3.44.7 - 2018-01-04
--------------------
-
-This release adds support for `Django 2
-<https://www.djangoproject.com/weblog/2017/dec/02/django-20-released/>`_ in
-the hypothesis-django extra.
-
-This release drops support for Django 1.10, as it is no longer supported by
-the Django team.
-
-.. _v3.44.6:
-
--------------------
-3.44.6 - 2018-01-02
--------------------
-
-This release speeds up test case reduction in many examples by being better at
-detecting large shrinks it can use to discard redundant parts of its input.
-This will be particularly noticeable in examples that make use of filtering
-and for some integer ranges.
-
-.. _v3.44.5:
-
--------------------
-3.44.5 - 2018-01-02
--------------------
-
-Happy new year!
-
-This is a no-op release that updates the year range on all of
-the copyright headers in our source to include 2018.
-
-.. _v3.44.4:
-
--------------------
-3.44.4 - 2017-12-23
--------------------
-
-This release fixes :issue:`1041`, which slowed tests by up to 6%
-due to broken caching.
-
-.. _v3.44.3:
-
--------------------
-3.44.3 - 2017-12-21
--------------------
-
-This release improves the shrinker in cases where examples drawn earlier can
-affect how much data is drawn later (e.g. when you draw a length parameter in
-a composite and then draw that many elements). Examples found in cases like
-this should now be much closer to minimal.
-
-.. _v3.44.2:
-
--------------------
-3.44.2 - 2017-12-20
--------------------
-
-This is a pure refactoring release which changes how Hypothesis manages its
-set of examples internally. It should have no externally visible effects.
-
-.. _v3.44.1:
-
--------------------
-3.44.1 - 2017-12-18
--------------------
-
-This release fixes :issue:`997`, in which under some circumstances the body of
-tests run under Hypothesis would not show up when run under coverage even
-though the tests were run and the code they called outside of the test file
-would show up normally.
-
-.. _v3.44.0:
-
--------------------
-3.44.0 - 2017-12-17
--------------------
-
-This release adds a new feature: The :func:`@reproduce_failure <hypothesis.reproduce_failure>` decorator,
-designed to make it easy to use Hypothesis's binary format for examples to
-reproduce a problem locally without having to share your example database
-between machines.
-
-This also changes when seeds are printed:
-
-* They will no longer be printed for
-  normal falsifying examples, as there are now adequate ways of reproducing those
-  for all cases, so it just contributes noise.
-* They will once again be printed when reusing examples from the database, as
-  health check failures should now be more reliable in this scenario so it will
-  almost always work in this case.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.43.1:
-
--------------------
-3.43.1 - 2017-12-17
--------------------
-
-This release fixes a bug with Hypothesis's database management - examples that
-were found in the course of shrinking were saved in a way that indicated that
-they had distinct causes, and so they would all be retried on the start of the
-next test. The intended behaviour, which is now what is implemented, is that
-only a bounded subset of these examples would be retried.
-
-.. _v3.43.0:
-
--------------------
-3.43.0 - 2017-12-17
--------------------
-
-:exc:`~hypothesis.errors.HypothesisDeprecationWarning` now inherits from
-:exc:`python:FutureWarning` instead of :exc:`python:DeprecationWarning`,
-as recommended by :pep:`565` for user-facing warnings (:issue:`618`).
-If you have not changed the default warnings settings, you will now see
-each distinct :exc:`~hypothesis.errors.HypothesisDeprecationWarning`
-instead of only the first.
-
-.. _v3.42.2:
-
--------------------
-3.42.2 - 2017-12-12
--------------------
-
-This patch fixes :issue:`1017`, where instances of a list or tuple subtype
-used as an argument to a strategy would be coerced to tuple.
-
-.. _v3.42.1:
-
--------------------
-3.42.1 - 2017-12-10
--------------------
-
-This release has some internal cleanup, which makes reading the code
-more pleasant and may shrink large examples slightly faster.
-
-.. _v3.42.0:
-
--------------------
-3.42.0 - 2017-12-09
--------------------
-
-This release deprecates ``faker-extra``, which was designed as a transition
-strategy but does not support example shrinking or coverage-guided discovery.
-
-.. _v3.41.0:
-
--------------------
-3.41.0 - 2017-12-06
--------------------
-
-:func:`~hypothesis.strategies.sampled_from` can now sample from
-one-dimensional numpy ndarrays. Sampling from multi-dimensional
-ndarrays still results in a deprecation warning. Thanks to Charlie
-Tanksley for this patch.
-
-.. _v3.40.1:
-
--------------------
-3.40.1 - 2017-12-04
--------------------
-
-This release makes two changes:
-
-* It makes the calculation of some of the metadata that Hypothesis uses for
-  shrinking occur lazily. This should speed up performance of test case
-  generation a bit because it no longer calculates information it doesn't need.
-* It improves the shrinker for certain classes of nested examples. e.g. when
-  shrinking lists of lists, the shrinker is now able to concatenate two
-  adjacent lists together into a single list. As a result of this change,
-  shrinking may get somewhat slower when the minimal example found is large.
-
-.. _v3.40.0:
-
--------------------
-3.40.0 - 2017-12-02
--------------------
-
-This release improves how various ways of seeding Hypothesis interact with the
-example database:
-
-* Using the example database with :func:`~hypothesis.seed` is now deprecated.
-  You should set ``database=None`` if you are doing that. This will only warn
-  if you actually load examples from the database while using ``@seed``.
-* The :attr:`~hypothesis.settings.derandomize` will behave the same way as
-  ``@seed``.
-* Using ``--hypothesis-seed`` will disable use of the database.
-* If a test used examples from the database, it will not suggest using a seed
-  to reproduce it, because that won't work.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.39.0:
-
--------------------
-3.39.0 - 2017-12-01
--------------------
-
-This release adds a new health check that checks if the smallest "natural"
-possible example of your test case is very large - this will tend to cause
-Hypothesis to generate bad examples and be quite slow.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.38.9:
-
--------------------
-3.38.9 - 2017-11-29
--------------------
-
-This is a documentation release to improve the documentation of shrinking
-behaviour for Hypothesis's strategies.
-
-.. _v3.38.8:
-
--------------------
-3.38.8 - 2017-11-29
--------------------
-
-This release improves the performance of
-:func:`~hypothesis.strategies.characters` when using ``blacklist_characters``
-and :func:`~hypothesis.strategies.from_regex` when using negative character
-classes.
-
-The problems this fixes were found in the course of work funded by
-`Smarkets <https://smarkets.com/>`_.
-
-.. _v3.38.7:
-
--------------------
-3.38.7 - 2017-11-29
--------------------
-
-This is a patch release for :func:`~hypothesis.strategies.from_regex`, which
-had a bug in handling of the :obj:`python:re.VERBOSE` flag (:issue:`992`).
-Flags are now handled correctly when parsing regex.
-
-.. _v3.38.6:
-
--------------------
-3.38.6 - 2017-11-28
--------------------
-
-This patch changes a few byte-string literals from double to single quotes,
-thanks to an update in :pypi:`unify`.  There are no user-visible changes.
-
-.. _v3.38.5:
-
--------------------
-3.38.5 - 2017-11-23
--------------------
-
-This fixes the repr of strategies using lambda that are defined inside
-decorators to include the lambda source.
-
-This would mostly have been visible when using the
-:ref:`statistics <statistics>` functionality - lambdas used for e.g. filtering
-would have shown up with a ``<unknown>`` as their body. This can still happen,
-but it should happen less often now.
-
-.. _v3.38.4:
-
--------------------
-3.38.4 - 2017-11-22
--------------------
-
-This release updates the reported :ref:`statistics <statistics>` so that they
-show approximately what fraction of your test run time is spent in data
-generation (as opposed to test execution).
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.38.3:
-
--------------------
-3.38.3 - 2017-11-21
--------------------
-
-This is a documentation release, which ensures code examples are up to date
-by running them as doctests in CI (:issue:`711`).
-
-.. _v3.38.2:
-
--------------------
-3.38.2 - 2017-11-21
--------------------
-
-This release changes the behaviour of the :attr:`~hypothesis.settings.deadline`
-setting when used with :func:`~hypothesis.strategies.data`: Time spent inside
-calls to ``data.draw`` will no longer be counted towards the deadline time.
-
-As a side effect of some refactoring required for this work, the way flaky
-tests are handled has changed slightly. You are unlikely to see much difference
-from this, but some error messages will have changed.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.38.1:
-
--------------------
-3.38.1 - 2017-11-21
--------------------
-
-This patch has a variety of non-user-visible refactorings, removing various
-minor warts ranging from indirect imports to typos in comments.
-
-.. _v3.38.0:
-
--------------------
-3.38.0 - 2017-11-18
--------------------
-
-This release overhauls :doc:`the health check system <healthchecks>`
-in a variety of small ways.
-It adds no new features, but is nevertheless a minor release because it changes
-which tests are likely to fail health checks.
-
-The most noticeable effect is that some tests that used to fail health checks
-will now pass, and some that used to pass will fail. These should all be
-improvements in accuracy. In particular:
-
-* New failures will usually be because they are now taking into account things
-  like use of :func:`~hypothesis.strategies.data` and
-  :func:`~hypothesis.assume` inside the test body.
-* New failures *may* also be because for some classes of example the way data
-  generation performance was measured was artificially faster than real data
-  generation (for most examples that are hitting performance health checks the
-  opposite should be the case).
-* Tests that used to fail health checks and now pass do so because the health
-  check system used to run in a way that was subtly different than the main
-  Hypothesis data generation and lacked some of its support for e.g. large
-  examples.
-
-If your data generation is especially slow, you may also see your tests get
-somewhat faster, as there is no longer a separate health check phase. This will
-be particularly noticeable when rerunning test failures.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.37.0:
-
--------------------
-3.37.0 - 2017-11-12
--------------------
-
-This is a deprecation release for some health check related features.
-
-The following are now deprecated:
-
-* Passing ``HealthCheck.exception_in_generation`` to
-  :attr:`~hypothesis.settings.suppress_health_check`. This no longer does
-  anything even when passed -  All errors that occur during data generation
-  will now be immediately reraised rather than going through the health check
-  mechanism.
-* Passing ``HealthCheck.random_module`` to
-  :attr:`~hypothesis.settings.suppress_health_check`. This hasn't done anything
-  for a long time, but was never explicitly deprecated. Hypothesis always seeds
-  the random module when running :func:`@given <hypothesis.given>` tests, so this
-  is no longer an error and suppressing it doesn't do anything.
-* Passing non-:class:`~hypothesis.HealthCheck` values in
-  :attr:`~hypothesis.settings.suppress_health_check`. This was previously
-  allowed but never did anything useful.
-
-In addition, passing a non-iterable value as :attr:`~hypothesis.settings.suppress_health_check`
-will now raise an error immediately (it would never have worked correctly, but
-it would previously have failed later). Some validation error messages have
-also been updated.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.36.1:
-
--------------------
-3.36.1 - 2017-11-10
--------------------
-
-This is a yak shaving release, mostly concerned with our own tests.
-
-While :func:`~python:inspect.getfullargspec` was documented as deprecated
-in Python 3.5, it never actually emitted a warning.  Our code to silence
-this (nonexistent) warning has therefore been removed.
-
-We now run our tests with ``DeprecationWarning`` as an error, and made some
-minor changes to our own tests as a result.  This required similar upstream
-updates to :pypi:`coverage` and :pypi:`execnet` (a test-time dependency via
-:pypi:`pytest-xdist`).
-
-There is no user-visible change in Hypothesis itself, but we encourage you
-to consider enabling deprecations as errors in your own tests.
-
-.. _v3.36.0:
-
--------------------
-3.36.0 - 2017-11-06
--------------------
-
-This release adds a setting to the public API, and does some internal cleanup:
-
-- The :attr:`~hypothesis.settings.derandomize` setting is now documented (:issue:`890`)
-- Removed - and disallowed - all 'bare excepts' in Hypothesis (:issue:`953`)
-- Documented the ``strict`` setting as deprecated, and
-  updated the build so our docs always match deprecations in the code.
-
-.. _v3.35.0:
-
--------------------
-3.35.0 - 2017-11-06
--------------------
-
-This minor release supports constraining :func:`~hypothesis.strategies.uuids`
-to generate a particular version of :class:`~python:uuid.UUID` (:issue:`721`).
-
-Thanks to Dion Misic for this feature.
-
-.. _v3.34.1:
-
--------------------
-3.34.1 - 2017-11-02
--------------------
-
-This patch updates the documentation to suggest
-:func:`builds(callable) <hypothesis.strategies.builds>` instead of
-:func:`just(callable()) <hypothesis.strategies.just>`.
-
-.. _v3.34.0:
-
--------------------
-3.34.0 - 2017-11-02
--------------------
-
-Hypothesis now emits deprecation warnings if you apply
-:func:`@given <hypothesis.given>` more than once to a target.
-
-Applying :func:`@given <hypothesis.given>` repeatedly wraps the target multiple
-times. Each wrapper will search the space of of possible parameters separately.
-This is equivalent but will be much more inefficient than doing it with a
-single call to :func:`@given <hypothesis.given>`.
-
-For example, instead of
-``@given(booleans()) @given(integers())``, you could write
-``@given(booleans(), integers())``
-
-.. _v3.33.1:
-
--------------------
-3.33.1 - 2017-11-02
--------------------
-
-This is a bugfix release:
-
-- :func:`~hypothesis.strategies.builds` would try to infer a strategy for
-  required positional arguments of the target from type hints, even if they
-  had been given to :func:`~hypothesis.strategies.builds` as positional
-  arguments (:issue:`946`).  Now it only infers missing required arguments.
-- An internal introspection function wrongly reported ``self`` as a required
-  argument for bound methods, which might also have affected
-  :func:`~hypothesis.strategies.builds`.  Now it knows better.
-
-.. _v3.33.0:
-
--------------------
-3.33.0 - 2017-10-16
--------------------
-
-This release supports strategy inference for more Django field types - you can now omit an argument for
-Date, Time, Duration, Slug, IP Address, and UUID fields.  (:issue:`642`)
-
-Strategy generation for fields with grouped choices now selects choices from
-each group, instead of selecting from the group names.
-
-.. _v3.32.2:
-
--------------------
-3.32.2 - 2017-10-15
--------------------
-
-This patch removes the ``mergedb`` tool, introduced in Hypothesis 1.7.1
-on an experimental basis.  It has never actually worked, and the new
-:doc:`Hypothesis example database <database>` is designed to make such a
-tool unnecessary.
-
-.. _v3.32.1:
-
--------------------
-3.32.1 - 2017-10-13
--------------------
-
-This patch has two improvements for strategies based on enumerations.
-
-- :func:`~hypothesis.strategies.from_type` now handles enumerations correctly,
-  delegating to :func:`~hypothesis.strategies.sampled_from`.  Previously it
-  noted that ``Enum.__init__`` has no required arguments and therefore delegated
-  to :func:`~hypothesis.strategies.builds`, which would subsequently fail.
-- When sampling from an :class:`python:enum.Flag`, we also generate combinations
-  of members. Eg for ``Flag('Permissions', 'READ, WRITE, EXECUTE')`` we can now
-  generate, ``Permissions.READ``, ``Permissions.READ|WRITE``, and so on.
-
-.. _v3.32.0:
-
--------------------
-3.32.0 - 2017-10-09
--------------------
-
-This changes the default value of
-the ``use_coverage`` setting to True when
-running on pypy (it was already True on CPython).
-
-It was previously set to False because we expected it to be too slow, but
-recent benchmarking shows that actually performance of the feature on pypy is
-fairly acceptable - sometimes it's slower than on CPython, sometimes it's
-faster, but it's generally within a factor of two either way.
-
-.. _v3.31.6:
-
--------------------
-3.31.6 - 2017-10-08
--------------------
-
-This patch improves the quality of strategies inferred from Numpy dtypes:
-
-* Integer dtypes generated examples with the upper half of their (non-sign) bits
-  set to zero.  The inferred strategies can now produce any representable integer.
-* Fixed-width unicode- and byte-string dtypes now cap the internal example
-  length, which should improve example and shrink quality.
-* Numpy arrays can only store fixed-size strings internally, and allow shorter
-  strings by right-padding them with null bytes.  Inferred string strategies
-  no longer generate such values, as they can never be retrieved from an array.
-  This improves shrinking performance by skipping useless values.
-
-This has already been useful in Hypothesis - we found an overflow bug in our
-Pandas support, and as a result :func:`~hypothesis.extra.pandas.indexes` and
-:func:`~hypothesis.extra.pandas.range_indexes` now check that ``min_size``
-and ``max_size`` are at least zero.
-
-.. _v3.31.5:
-
--------------------
-3.31.5 - 2017-10-08
--------------------
-
-This release fixes a performance problem in tests where
-the ``use_coverage`` setting is True.
-
-Tests experience a slow-down proportionate to the amount of code they cover.
-This is still the case, but the factor is now low enough that it should be
-unnoticeable. Previously it was large and became much larger in :ref:`3.30.4 <v3.30.4>`.
-
-.. _v3.31.4:
-
--------------------
-3.31.4 - 2017-10-08
--------------------
-
-:func:`~hypothesis.strategies.from_type` failed with a very confusing error
-if passed a :obj:`~typing.NewType` (:issue:`901`).  These pseudo-types
-are now unwrapped correctly, and strategy inference works as expected.
-
-.. _v3.31.3:
-
--------------------
-3.31.3 - 2017-10-06
--------------------
-
-This release makes some small optimisations to our use of coverage that should
-reduce constant per-example overhead. This is probably only noticeable on
-examples where the test itself is quite fast. On no-op tests that don't test
-anything you may see up to a fourfold speed increase (which is still
-significantly slower than without coverage). On more realistic tests the speed
-up is likely to be less than that.
-
-.. _v3.31.2:
-
--------------------
-3.31.2 - 2017-09-30
--------------------
-
-This release fixes some formatting and small typos/grammar issues in the
-documentation, specifically the page docs/settings.rst, and the inline docs
-for the various settings.
-
-.. _v3.31.1:
-
--------------------
-3.31.1 - 2017-09-30
--------------------
-
-This release improves the handling of deadlines so that they act better with
-the shrinking process. This fixes :issue:`892`.
-
-This involves two changes:
-
-1. The deadline is raised during the initial generation and shrinking, and then
-   lowered to the set value for final replay. This restricts our attention to
-   examples which exceed the deadline by a more significant margin, which
-   increases their reliability.
-2. When despite the above a test still becomes flaky because it is
-   significantly faster on rerun than it was on its first run, the error
-   message is now more explicit about the nature of this problem, and includes
-   both the initial test run time and the new test run time.
-
-In addition, this release also clarifies the documentation of the deadline
-setting slightly to be more explicit about where it applies.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.31.0:
-
--------------------
-3.31.0 - 2017-09-29
--------------------
-
-This release blocks installation of Hypothesis on Python 3.3, which
-:PEP:`reached its end of life date on 2017-09-29 <398>`.
-
-This should not be of interest to anyone but downstream maintainers -
-if you are affected, migrate to a secure version of Python as soon as
-possible or at least seek commercial support.
-
-.. _v3.30.4:
-
--------------------
-3.30.4 - 2017-09-27
--------------------
-
-This release makes several changes:
-
-1. It significantly improves Hypothesis's ability to use coverage information
-   to find interesting examples.
-2. It reduces the default :attr:`~hypothesis.settings.max_examples` setting from 200 to 100. This takes
-   advantage of the improved algorithm meaning fewer examples are typically
-   needed to get the same testing and is sufficiently better at covering
-   interesting behaviour, and offsets some of the performance problems of
-   running under coverage.
-3. Hypothesis will always try to start its testing with an example that is near
-   minimized.
-
-The new algorithm for 1 also makes some changes to Hypothesis's low level data
-generation which apply even with coverage turned off. They generally reduce the
-total amount of data generated, which should improve test performance somewhat.
-Between this and 3 you should see a noticeable reduction in test runtime (how
-much so depends on your tests and how much example size affects their
-performance. On our benchmarks, where data generation dominates, we saw up to
-a factor of two performance improvement, but it's unlikely to be that large.
-
-.. _v3.30.3:
-
--------------------
-3.30.3 - 2017-09-25
--------------------
-
-This release fixes some formatting and small typos/grammar issues in the
-documentation, specifically the page docs/details.rst, and some inline
-docs linked from there.
-
-.. _v3.30.2:
-
--------------------
-3.30.2 - 2017-09-24
--------------------
-
-This release changes Hypothesis's caching approach for functions in
-``hypothesis.strategies``. Previously it would have cached extremely
-aggressively and cache entries would never be evicted. Now it adopts a
-least-frequently used, least recently used key invalidation policy, and is
-somewhat more conservative about which strategies it caches.
-
-Workloads which create strategies based on dynamic values, e.g. by using
-:ref:`flatmap <flatmap>` or :func:`~hypothesis.strategies.composite`,
-will use significantly less memory.
-
-.. _v3.30.1:
-
--------------------
-3.30.1 - 2017-09-22
--------------------
-
-This release fixes a bug where when running with
-the ``use_coverage=True`` setting inside an
-existing running instance of coverage, Hypothesis would frequently put files
-that the coveragerc excluded in the report for the enclosing coverage.
-
-.. _v3.30.0:
-
--------------------
-3.30.0 - 2017-09-20
--------------------
-
-This release introduces two new features:
-
-* When a test fails, either with a health check failure or a falsifying example,
-  Hypothesis will print out a seed that led to that failure, if the test is not
-  already running with a fixed seed. You can then recreate that failure using either
-  the :func:`@seed <hypothesis.seed>` decorator or (if you are running pytest) with ``--hypothesis-seed``.
-* :pypi:`pytest` users can specify a seed to use for :func:`@given <hypothesis.given>` based tests by passing
-  the ``--hypothesis-seed`` command line argument.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.29.0:
-
--------------------
-3.29.0 - 2017-09-19
--------------------
-
-This release makes Hypothesis coverage aware. Hypothesis now runs all test
-bodies under coverage, and uses this information to guide its testing.
-
-The ``use_coverage`` setting can be used to disable
-this behaviour if you want to test code that is sensitive to coverage being
-enabled (either because of performance or interaction with the trace function).
-
-The main benefits of this feature are:
-
-* Hypothesis now observes when examples it discovers cover particular lines
-  or branches and stores them in the database for later.
-* Hypothesis will make some use of this information to guide its exploration of
-  the search space and improve the examples it finds (this is currently used
-  only very lightly and will likely improve significantly in future releases).
-
-This also has the following side-effects:
-
-* Hypothesis now has an install time dependency on the :pypi:`coverage` package.
-* Tests that are already running Hypothesis under coverage will likely get
-  faster.
-* Tests that are not running under coverage now run their test bodies under
-  coverage by default.
-
-
-This feature is only partially supported under pypy. It is significantly slower
-than on CPython and is turned off by default as a result, but it should still
-work correctly if you want to use it.
-
-.. _v3.28.3:
-
--------------------
-3.28.3 - 2017-09-18
--------------------
-
-This release is an internal change that affects how Hypothesis handles
-calculating certain properties of strategies.
-
-The primary effect of this is that it fixes a bug where use of
-:func:`~hypothesis.strategies.deferred` could sometimes trigger an internal assertion
-error. However the fix for this bug involved some moderately deep changes to
-how Hypothesis handles certain constructs so you may notice some additional
-knock-on effects.
-
-In particular the way Hypothesis handles drawing data from strategies that
-cannot generate any values has changed to bail out sooner than it previously
-did. This may speed up certain tests, but it is unlikely to make much of a
-difference in practice for tests that were not already failing with
-Unsatisfiable.
-
-.. _v3.28.2:
-
--------------------
-3.28.2 - 2017-09-18
--------------------
-
-This is a patch release that fixes a bug in the :mod:`hypothesis.extra.pandas`
-documentation where it incorrectly referred to :func:`~hypothesis.extra.pandas.column`
-instead of :func:`~hypothesis.extra.pandas.columns`.
-
-.. _v3.28.1:
-
--------------------
-3.28.1 - 2017-09-16
--------------------
-
-This is a refactoring release. It moves a number of internal uses
-of :func:`~python:collections.namedtuple` over to using attrs based classes, and removes a couple
-of internal namedtuple classes that were no longer in use.
-
-It should have no user visible impact.
-
-.. _v3.28.0:
-
--------------------
-3.28.0 - 2017-09-15
--------------------
-
-This release adds support for testing :pypi:`pandas` via the :ref:`hypothesis.extra.pandas <hypothesis-pandas>`
-module.
-
-It also adds a dependency on :pypi:`attrs`.
-
-This work was funded by `Stripe <https://stripe.com/>`_.
-
-.. _v3.27.1:
-
--------------------
-3.27.1 - 2017-09-14
--------------------
-
-This release fixes some formatting and broken cross-references in the
-documentation, which includes editing docstrings - and thus a patch release.
-
-.. _v3.27.0:
-
--------------------
-3.27.0 - 2017-09-13
--------------------
-
-This release introduces a :attr:`~hypothesis.settings.deadline`
-setting to Hypothesis.
-
-When set this turns slow tests into errors. By default it is unset but will
-warn if you exceed 200ms, which will become the default value in a future
-release.
-
-This work was funded by `Smarkets <https://smarkets.com/>`_.
-
-.. _v3.26.0:
-
--------------------
-3.26.0 - 2017-09-12
--------------------
-
-Hypothesis now emits deprecation warnings if you are using the legacy
-SQLite example database format, or the tool for merging them. These were
-already documented as deprecated, so this doesn't change their deprecation
-status, only that we warn about it.
-
-.. _v3.25.1:
-
--------------------
-3.25.1 - 2017-09-12
--------------------
-
-This release fixes a bug with generating :doc:`numpy datetime and timedelta types <numpy:reference/arrays.datetime>`:
-When inferring the strategy from the dtype, datetime and timedelta dtypes with
-sub-second precision would always produce examples with one second resolution.
-Inferring a strategy from a time dtype will now always produce example with the
-same precision.
-
-.. _v3.25.0:
-
--------------------
-3.25.0 - 2017-09-12
--------------------
-
-This release changes how Hypothesis shrinks and replays examples to take into
-account that it can encounter new bugs while shrinking the bug it originally
-found. Previously it would end up replacing the originally found bug with the
-new bug and show you only that one. Now it is (often) able to recognise when
-two bugs are distinct and when it finds more than one will show both.
-
-.. _v3.24.2:
-
--------------------
-3.24.2 - 2017-09-11
--------------------
-
-This release removes the (purely internal and no longer useful)
-``strategy_test_suite`` function and the corresponding strategytests module.
-
-.. _v3.24.1:
-
--------------------
-3.24.1 - 2017-09-06
--------------------
-
-This release improves the reduction of examples involving floating point
-numbers to produce more human readable examples.
-
-It also has some general purpose changes to the way the minimizer works
-internally, which may see some improvement in quality and slow down of test
-case reduction in cases that have nothing to do with floating point numbers.
-
-.. _v3.24.0:
-
--------------------
-3.24.0 - 2017-09-05
--------------------
-
-Hypothesis now emits deprecation warnings if you use ``some_strategy.example()`` inside a
-test function or strategy definition (this was never intended to be supported,
-but is sufficiently widespread that it warrants a deprecation path).
-
-.. _v3.23.3:
-
--------------------
-3.23.3 - 2017-09-05
--------------------
-
-This is a bugfix release for :func:`~hypothesis.strategies.decimals`
-with the ``places`` argument.
-
-- No longer fails health checks (:issue:`725`, due to internal filtering)
-- Specifying a ``min_value`` and ``max_value`` without any decimals with
-  ``places`` places between them gives a more useful error message.
-- Works for any valid arguments, regardless of the decimal precision context.
-
-.. _v3.23.2:
-
--------------------
-3.23.2 - 2017-09-01
--------------------
-
-This is a small refactoring release that removes a now-unused parameter to an
-internal API. It shouldn't have any user visible effect.
-
-.. _v3.23.1:
-
--------------------
-3.23.1 - 2017-09-01
--------------------
-
-Hypothesis no longer propagates the dynamic scope of settings into strategy
-definitions.
-
-This release is a small change to something that was never part of the public
-API and you will almost certainly not notice any effect unless you're doing
-something surprising, but for example the following code will now give a
-different answer in some circumstances:
-
-.. code-block:: python
-
-    import hypothesis.strategies as st
-    from hypothesis import settings
-
-    CURRENT_SETTINGS = st.builds(lambda: settings.default)
-
-(We don't actually encourage you writing code like this)
-
-Previously this would have generated the settings that were in effect at the
-point of definition of ``CURRENT_SETTINGS``. Now it will generate the settings
-that are used for the current test.
-
-It is very unlikely to be significant enough to be visible, but you may also
-notice a small performance improvement.
-
-.. _v3.23.0:
-
--------------------
-3.23.0 - 2017-08-31
--------------------
-
-This release adds a ``unique`` argument to :func:`~hypothesis.extra.numpy.arrays`
-which behaves the same ways as the corresponding one for
-:func:`~hypothesis.strategies.lists`, requiring all of the elements in the
-generated array to be distinct.
-
-.. _v3.22.2:
-
--------------------
-3.22.2 - 2017-08-29
--------------------
-
-This release fixes an issue where Hypothesis would raise a ``TypeError`` when
-using the datetime-related strategies if running with ``PYTHONOPTIMIZE=2``.
-This bug was introduced in :ref:`3.20.0 <v3.20.0>`.  (See :issue:`822`)
-
-.. _v3.22.1:
-
--------------------
-3.22.1 - 2017-08-28
--------------------
-
-Hypothesis now transparently handles problems with an internal unicode cache,
-including file truncation or read-only filesystems (:issue:`767`).
-Thanks to Sam Hames for the patch.
-
-.. _v3.22.0:
-
--------------------
-3.22.0 - 2017-08-26
--------------------
-
-This release provides what should be a substantial performance improvement to
-numpy arrays generated using :ref:`provided numpy support <hypothesis-numpy>`,
-and adds a new ``fill_value`` argument to :func:`~hypothesis.extra.numpy.arrays`
-to control this behaviour.
-
-This work was funded by `Stripe <https://stripe.com/>`_.
-
-.. _v3.21.3:
-
--------------------
-3.21.3 - 2017-08-26
--------------------
-
-This release fixes some extremely specific circumstances that probably have
-never occurred in the wild where users of
-:func:`~hypothesis.strategies.deferred` might have seen a :class:`python:RuntimeError` from
-too much recursion, usually in cases where no valid example could have been
-generated anyway.
-
-.. _v3.21.2:
-
--------------------
-3.21.2 - 2017-08-25
--------------------
-
-This release fixes some minor bugs in argument validation:
-
-    * :ref:`hypothesis.extra.numpy <hypothesis-numpy>` dtype strategies would raise an internal error
-      instead of an InvalidArgument exception when passed an invalid
-      endianness specification.
-    * :func:`~hypothesis.strategies.fractions` would raise an internal error instead of an InvalidArgument
-      if passed ``float("nan")`` as one of its bounds.
-    * The error message for passing ``float("nan")`` as a bound to various
-      strategies has been improved.
-    * Various bound arguments will now raise InvalidArgument in cases where
-      they would previously have raised an internal TypeError or
-      ValueError from the relevant conversion function.
-    * ``streaming()`` would not have emitted a
-      deprecation warning when called with an invalid argument.
-
-.. _v3.21.1:
-
--------------------
-3.21.1 - 2017-08-24
--------------------
-
-This release fixes a bug where test failures that were the result of
-an :func:`@example <hypothesis.example>` would print an extra stack trace before re-raising the
-exception.
-
-.. _v3.21.0:
-
--------------------
-3.21.0 - 2017-08-23
--------------------
-
-This release deprecates Hypothesis's strict mode, which turned Hypothesis's
-deprecation warnings into errors. Similar functionality can be achieved
-by using :func:`simplefilter('error', HypothesisDeprecationWarning) <python:warnings.simplefilter>`.
-
-.. _v3.20.0:
-
--------------------
-3.20.0 - 2017-08-22
--------------------
-
-This release renames the relevant arguments on the
-:func:`~hypothesis.strategies.datetimes`, :func:`~hypothesis.strategies.dates`,
-:func:`~hypothesis.strategies.times`, and :func:`~hypothesis.strategies.timedeltas`
-strategies to ``min_value`` and ``max_value``, to make them consistent with the
-other strategies in the module.
-
-The old argument names are still supported but will emit a deprecation warning
-when used explicitly as keyword arguments. Arguments passed positionally will
-go to the new argument names and are not deprecated.
-
-.. _v3.19.3:
-
--------------------
-3.19.3 - 2017-08-22
--------------------
-
-This release provides a major overhaul to the internals of how Hypothesis
-handles shrinking.
-
-This should mostly be visible in terms of getting better examples for tests
-which make heavy use of :func:`~hypothesis.strategies.composite`,
-:func:`~hypothesis.strategies.data` or :ref:`flatmap <flatmap>` where the data
-drawn depends a lot on previous choices, especially where size parameters are
-affected. Previously Hypothesis would have struggled to reliably produce
-good examples here. Now it should do much better. Performance should also be
-better for examples with a non-zero ``min_size``.
-
-You may see slight changes to example generation (e.g. improved example
-diversity) as a result of related changes to internals, but they are unlikely
-to be significant enough to notice.
-
-.. _v3.19.2:
-
--------------------
-3.19.2 - 2017-08-21
--------------------
-
-This release fixes two bugs in :mod:`hypothesis.extra.numpy`:
-
-* :func:`~hypothesis.extra.numpy.unicode_string_dtypes` didn't work at all due
-  to an incorrect dtype specifier. Now it does.
-* Various impossible conditions would have been accepted but would error when
-  they fail to produced any example. Now they raise an explicit InvalidArgument
-  error.
-
-.. _v3.19.1:
-
--------------------
-3.19.1 - 2017-08-21
--------------------
-
-This is a bugfix release for :issue:`739`, where bounds for
-:func:`~hypothesis.strategies.fractions` or floating-point
-:func:`~hypothesis.strategies.decimals` were not properly converted to
-integers before passing them to the integers strategy.
-This excluded some values that should have been possible, and could
-trigger internal errors if the bounds lay between adjacent integers.
-
-You can now bound :func:`~hypothesis.strategies.fractions` with two
-arbitrarily close fractions.
-
-It is now an explicit error to supply a min_value, max_value, and
-max_denominator to :func:`~hypothesis.strategies.fractions` where the value
-bounds do not include a fraction with denominator at most max_denominator.
-
-.. _v3.19.0:
-
--------------------
-3.19.0 - 2017-08-20
--------------------
-
-This release adds the :func:`~hypothesis.strategies.from_regex` strategy,
-which generates strings that contain a match of a regular expression.
-
-Thanks to Maxim Kulkin for creating the
-`hypothesis-regex <https://github.com/maximkulkin/hypothesis-regex>`_
-package and then helping to upstream it! (:issue:`662`)
-
-.. _v3.18.5:
-
--------------------
-3.18.5 - 2017-08-18
--------------------
-
-This is a bugfix release for :func:`~hypothesis.strategies.integers`.
-Previously the strategy would hit an internal assertion if passed non-integer
-bounds for ``min_value`` and ``max_value`` that had no integers between them.
-The strategy now raises InvalidArgument instead.
-
-.. _v3.18.4:
-
--------------------
-3.18.4 - 2017-08-18
--------------------
-
-Release to fix a bug where mocks can be used as test runners under certain
-conditions. Specifically, if a mock is injected into a test via pytest
-fixtures or patch decorators, and that mock is the first argument in the
-list, hypothesis will think it represents self and turns the mock
-into a test runner.  If this happens, the affected test always passes
-because the mock is executed instead of the test body. Sometimes, it
-will also fail health checks.
-
-Fixes :issue:`491` and a section of :issue:`198`.
-Thanks to Ben Peterson for this bug fix.
-
-.. _v3.18.3:
-
--------------------
-3.18.3 - 2017-08-17
--------------------
-
-This release should improve the performance of some tests which
-experienced a slow down as a result of the :ref:`3.13.0 <v3.13.0>` release.
-
-Tests most likely to benefit from this are ones that make extensive
-use of ``min_size`` parameters, but others may see some improvement
-as well.
-
-.. _v3.18.2:
-
--------------------
-3.18.2 - 2017-08-16
--------------------
-
-This release fixes a bug introduced in :ref:`3.18.0 <v3.18.0>`. If the arguments
-``whitelist_characters`` and ``blacklist_characters`` to
-:func:`~hypothesis.strategies.characters` contained overlapping elements, then an
-``InvalidArgument`` exception would be raised.
-
-Thanks to Zac Hatfield-Dodds for reporting and fixing this.
-
-.. _v3.18.1:
-
--------------------
-3.18.1 - 2017-08-14
--------------------
-
-This is a bug fix release to fix :issue:`780`, where
-:func:`~hypothesis.strategies.sets` and similar would trigger health check
-errors if their element strategy could only produce one element (e.g.
-if it was :func:`~hypothesis.strategies.just`).
-
-.. _v3.18.0:
-
--------------------
-3.18.0 - 2017-08-13
--------------------
-
-This is a feature release:
-
-* :func:`~hypothesis.strategies.characters` now accepts
-  ``whitelist_characters``, particular characters which will be added to those
-  it produces. (:issue:`668`)
-* A bug fix for the internal function ``_union_interval_lists()``, and a rename
-  to ``_union_intervals()``. It now correctly handles all cases where intervals
-  overlap, and it always returns the result as a tuple for tuples.
-
-Thanks to Alex Willmer for these.
-
-.. _v3.17.0:
-
--------------------
-3.17.0 - 2017-08-07
--------------------
-
-This release documents :ref:`the previously undocumented phases feature <phases>`,
-making it part of the public API. It also updates how the example
-database is used. Principally:
-
-* The :obj:`~hypothesis.Phase.reuse` phase will now correctly control whether examples
-  from the database are run (it previously did exactly the wrong thing and
-  controlled whether examples would be *saved*).
-* Hypothesis will no longer try to rerun *all* previously failing examples.
-  Instead it will replay the smallest previously failing example and a
-  selection of other examples that are likely to trigger any other bugs that
-  will found. This prevents a previous failure from dominating your tests
-  unnecessarily.
-* As a result of the previous change, Hypothesis will be slower about clearing
-  out old examples from the database that are no longer failing (because it can
-  only clear out ones that it actually runs).
-
-.. _v3.16.1:
-
--------------------
-3.16.1 - 2017-08-07
--------------------
-
-This release makes an implementation change to how Hypothesis handles certain
-internal constructs.
-
-The main effect you should see is improvement to the behaviour and performance
-of collection types, especially ones with a ``min_size`` parameter. Many cases
-that would previously fail due to being unable to generate enough valid
-examples will now succeed, and other cases should run slightly faster.
-
-.. _v3.16.0:
-
--------------------
-3.16.0 - 2017-08-04
--------------------
-
-This release introduces a deprecation of the timeout feature. This results in
-the following changes:
-
-* Creating a settings object with an explicit timeout will emit a deprecation
-  warning.
-* If your test stops because it hits the timeout (and has not found a bug) then
-  it will emit a deprecation warning.
-* There is a new value ``unlimited`` which you can import from hypothesis.
-  ``settings(timeout=unlimited)`` will *not* cause a deprecation warning.
-* There is a new health check, ``hung_test``, which will trigger after a test
-  has been running for five minutes if it is not suppressed.
-
-.. _v3.15.0:
-
--------------------
-3.15.0 - 2017-08-04
--------------------
-
-This release deprecates two strategies, ``choices()`` and ``streaming()``.
-
-Both of these are somewhat confusing to use and are entirely redundant since the
-introduction of the :func:`~hypothesis.strategies.data` strategy for interactive
-drawing in tests, and their use should be replaced with direct use of
-:func:`~hypothesis.strategies.data` instead.
-
-.. _v3.14.2:
-
--------------------
-3.14.2 - 2017-08-03
--------------------
-
-This fixes a bug where Hypothesis would not work correctly on Python 2.7 if you
-had the :mod:`python:typing` module :pypi:`backport <typing>` installed.
-
-.. _v3.14.1:
-
--------------------
-3.14.1 - 2017-08-02
--------------------
-
-This raises the maximum depth at which Hypothesis starts cutting off data
-generation to a more reasonable value which it is harder to hit by accident.
-
-This resolves (:issue:`751`), in which some examples which previously worked
-would start timing out, but it will also likely improve the data generation
-quality for complex data types.
-
-.. _v3.14.0:
-
--------------------
-3.14.0 - 2017-07-23
--------------------
-
-Hypothesis now understands inline type annotations (:issue:`293`):
-
-- If the target of :func:`~hypothesis.strategies.builds` has type annotations,
-  a default strategy for missing required arguments is selected based on the
-  type.  Type-based strategy selection will only override a default if you
-  pass :const:`hypothesis.infer` as a keyword argument.
-
-- If :func:`@given <hypothesis.given>` wraps a function with type annotations,
-  you can pass :const:`~hypothesis.infer` as a keyword argument and the
-  appropriate strategy will be substituted.
-
-- You can check what strategy will be inferred for a type with the new
-  :func:`~hypothesis.strategies.from_type` function.
-
-- :func:`~hypothesis.strategies.register_type_strategy` teaches Hypothesis
-  which strategy to infer for custom or unknown types.  You can provide a
-  strategy, or for more complex cases a function which takes the type and
-  returns a strategy.
-
-.. _v3.13.1:
-
--------------------
-3.13.1 - 2017-07-20
--------------------
-
-This is a bug fix release for :issue:`514` - Hypothesis would continue running
-examples after a :class:`~python:unittest.SkipTest` exception was raised,
-including printing a falsifying example.  Skip exceptions from the standard
-:mod:`python:unittest` module, and ``pytest``, ``nose``, or ``unittest2``
-modules now abort the test immediately without printing output.
-
-.. _v3.13.0:
-
--------------------
-3.13.0 - 2017-07-16
--------------------
-
-This release has two major aspects to it: The first is the introduction of
-:func:`~hypothesis.strategies.deferred`, which allows more natural definition
-of recursive (including mutually recursive) strategies.
-
-The second is a number of engine changes designed to support this sort of
-strategy better. These should have a knock-on effect of also improving the
-performance of any existing strategies that currently generate a lot of data
-or involve heavy nesting by reducing their typical example size.
-
-.. _v3.12.0:
-
--------------------
-3.12.0 - 2017-07-07
--------------------
-
-This release makes some major internal changes to how Hypothesis represents
-data internally, as a prelude to some major engine changes that should improve
-data quality. There are no API changes, but it's a significant enough internal
-change that a minor version bump seemed warranted.
-
-User facing impact should be fairly mild, but includes:
-
-* All existing examples in the database will probably be invalidated. Hypothesis
-  handles this automatically, so you don't need to do anything, but if you see
-  all your examples disappear that's why.
-* Almost all data distributions have changed significantly. Possibly for the better,
-  possibly for the worse. This may result in new bugs being found, but it may
-  also result in Hypothesis being unable to find bugs it previously did.
-* Data generation may be somewhat faster if your existing bottleneck was in
-  draw_bytes (which is often the case for large examples).
-* Shrinking will probably be slower, possibly significantly.
-
-If you notice any effects you consider to be a significant regression, please
-open an issue about them.
-
-.. _v3.11.6:
-
--------------------
-3.11.6 - 2017-06-19
--------------------
-
-This release involves no functionality changes, but is the first to ship wheels
-as well as an sdist.
-
-.. _v3.11.5:
-
--------------------
-3.11.5 - 2017-06-18
--------------------
-
-This release provides a performance improvement to shrinking. For cases where
-there is some non-trivial "boundary" value (e.g. the bug happens for all values
-greater than some other value), shrinking should now be substantially faster.
-Other types of bug will likely see improvements too.
-
-This may also result in some changes to the quality of the final examples - it
-may sometimes be better, but is more likely to get slightly worse in some edge
-cases. If you see any examples where this happens in practice, please report
-them.
-
-.. _v3.11.4:
-
--------------------
-3.11.4 - 2017-06-17
--------------------
-
-This is a bugfix release: Hypothesis now prints explicit examples when
-running in verbose mode.  (:issue:`313`)
-
-.. _v3.11.3:
-
--------------------
-3.11.3 - 2017-06-11
--------------------
-
-This is a bugfix release: Hypothesis no longer emits a warning if you try to
-use :func:`~hypothesis.strategies.sampled_from` with
-:class:`python:collections.OrderedDict`.  (:issue:`688`)
-
-.. _v3.11.2:
-
--------------------
-3.11.2 - 2017-06-10
--------------------
-
-This is a documentation release.  Several outdated snippets have been updated
-or removed, and many cross-references are now hyperlinks.
-
-.. _v3.11.1:
-
--------------------
-3.11.1 - 2017-05-28
--------------------
-
-This is a minor ergonomics release.  Tracebacks shown by pytest no longer
-include Hypothesis internals for test functions decorated with :func:`@given <hypothesis.given>`.
-
-.. _v3.11.0:
-
--------------------
-3.11.0 - 2017-05-23
--------------------
-
-This is a feature release, adding datetime-related strategies to the core strategies.
-
-:func:`~hypothesis.extra.pytz.timezones` allows you to sample pytz timezones from
-the Olsen database.  Use directly in a recipe for tz-aware datetimes, or
-compose with :func:`~hypothesis.strategies.none` to allow a mix of aware and naive output.
-
-The new :func:`~hypothesis.strategies.dates`, :func:`~hypothesis.strategies.times`,
-:func:`~hypothesis.strategies.datetimes`, and :func:`~hypothesis.strategies.timedeltas`
-strategies are all constrained by objects of their type.
-This means that you can generate dates bounded by a single day
-(i.e. a single date), or datetimes constrained to the microsecond.
-
-:func:`~hypothesis.strategies.times` and :func:`~hypothesis.strategies.datetimes`
-take an optional ``timezones=`` argument, which
-defaults to :func:`~hypothesis.strategies.none` for naive times.  You can use our extra strategy
-based on pytz, or roll your own timezones strategy with dateutil or even
-the standard library.
-
-The old ``dates``, ``times``, and ``datetimes`` strategies in
-``hypothesis.extra.datetimes`` are deprecated in favor of the new
-core strategies, which are more flexible and have no dependencies.
-
-.. _v3.10.0:
-
--------------------
-3.10.0 - 2017-05-22
--------------------
-
-Hypothesis now uses :func:`python:inspect.getfullargspec` internally.
-On Python 2, there are no visible changes.
-
-On Python 3 :func:`@given <hypothesis.given>` and :func:`@composite <hypothesis.strategies.composite>`
-now preserve :pep:`3107` annotations on the
-decorated function.  Keyword-only arguments are now either handled correctly
-(e.g. :func:`@composite <hypothesis.strategies.composite>`), or caught in validation instead of silently discarded
-or raising an unrelated error later (e.g. :func:`@given <hypothesis.given>`).
-
-.. _v3.9.1:
-
-------------------
-3.9.1 - 2017-05-22
-------------------
-
-This is a bugfix release: the default field mapping for a DateTimeField in the
-Django extra now respects the ``USE_TZ`` setting when choosing a strategy.
-
-.. _v3.9.0:
-
-------------------
-3.9.0 - 2017-05-19
-------------------
-
-This is feature release, expanding the capabilities of the
-:func:`~hypothesis.strategies.decimals` strategy.
-
-* The new (optional) ``places`` argument allows you to generate decimals with
-  a certain number of places (e.g. cents, thousandths, satoshis).
-* If allow_infinity is None, setting min_bound no longer excludes positive
-  infinity and setting max_value no longer excludes negative infinity.
-* All of ``NaN``, ``-Nan``, ``sNaN``, and ``-sNaN`` may now be drawn if
-  allow_nan is True, or if allow_nan is None and min_value or max_value is None.
-* min_value and max_value may be given as decimal strings, e.g. ``"1.234"``.
-
-
-.. _v3.8.5:
-
-------------------
-3.8.5 - 2017-05-16
-------------------
-
-Hypothesis now imports :mod:`python:sqlite3` when a SQLite database is used, rather
-than at module load, improving compatibility with Python implementations
-compiled without SQLite support (such as BSD or Jython).
-
-.. _v3.8.4:
-
-------------------
-3.8.4 - 2017-05-16
-------------------
-
-This is a compatibility bugfix release.  :func:`~hypothesis.strategies.sampled_from`
-no longer raises a deprecation warning when sampling from an
-:class:`python:enum.Enum`, as all enums have a reliable iteration order.
-
-.. _v3.8.3:
-
-------------------
-3.8.3 - 2017-05-09
-------------------
-
-This release removes a version check for older versions of :pypi:`pytest` when using
-the Hypothesis pytest plugin. The pytest plugin will now run unconditionally
-on all versions of pytest. This breaks compatibility with any version of pytest
-prior to 2.7.0 (which is more than two years old).
-
-The primary reason for this change is that the version check was a frequent
-source of breakage when pytest change their versioning scheme. If you are not
-working on pytest itself and are not running a very old version of it, this
-release probably doesn't affect you.
-
-.. _v3.8.2:
-
-------------------
-3.8.2 - 2017-04-26
-------------------
-
-This is a code reorganisation release that moves some internal test helpers
-out of the main source tree so as to not have changes to them trigger releases
-in future.
-
-.. _v3.8.1:
-
-------------------
-3.8.1 - 2017-04-26
-------------------
-
-This is a documentation release.  Almost all code examples are now doctests
-checked in CI, eliminating stale examples.
-
-.. _v3.8.0:
-
-------------------
-3.8.0 - 2017-04-23
-------------------
-
-This is a feature release, adding the :func:`~hypothesis.strategies.iterables` strategy, equivalent
-to ``lists(...).map(iter)`` but with a much more useful repr.  You can use
-this strategy to check that code doesn't accidentally depend on sequence
-properties such as indexing support or repeated iteration.
-
-.. _v3.7.4:
-
-------------------
-3.7.4 - 2017-04-22
-------------------
-
-This patch fixes a bug in :ref:`3.7.3 <v3.7.3>`, where using
-:func:`@example <hypothesis.example>` and a pytest fixture in the same test
-could cause the test to fail to fill the arguments, and throw a TypeError.
-
-.. _v3.7.3:
-
-------------------
-3.7.3 - 2017-04-21
-------------------
-
-This release should include no user visible changes and is purely a refactoring
-release. This modularises the behaviour of the core :func:`~hypothesis.given` function, breaking
-it up into smaller and more accessible parts, but its actual behaviour should
-remain unchanged.
-
-.. _v3.7.2:
-
-------------------
-3.7.2 - 2017-04-21
-------------------
-
-This reverts an undocumented change in :ref:`3.7.1 <v3.7.1>` which broke installation on
-debian stable: The specifier for the hypothesisdjango extra\_requires had
-introduced a wild card, which was not supported on the default version of pip.
-
-.. _v3.7.1:
-
-------------------
-3.7.1 - 2017-04-21
-------------------
-
-This is a bug fix and internal improvements release.
-
-* In particular Hypothesis now tracks a tree of where it has already explored.
-  This allows it to avoid some classes of duplicate examples, and significantly
-  improves the performance of shrinking failing examples by allowing it to
-  skip some shrinks that it can determine can't possibly work.
-* Hypothesis will no longer seed the global random arbitrarily unless you have
-  asked it to using :py:meth:`~hypothesis.strategies.random_module`
-* Shrinking would previously have not worked correctly in some special cases
-  on Python 2, and would have resulted in suboptimal examples.
-
-.. _v3.7.0:
-
-------------------
-3.7.0 - 2017-03-20
-------------------
-
-This is a feature release.
-
-New features:
-
-* Rule based stateful testing now has an :func:`@invariant <hypothesis.stateful.invariant>` decorator that specifies
-  methods that are run after init and after every step, allowing you to
-  encode properties that should be true at all times. Thanks to Tom Prince for
-  this feature.
-* The :func:`~hypothesis.strategies.decimals` strategy now supports ``allow_nan`` and ``allow_infinity`` flags.
-* There are :ref:`significantly more strategies available for numpy <hypothesis-numpy>`, including for
-  generating arbitrary data types. Thanks to Zac Hatfield Dodds for this
-  feature.
-* When using the :func:`~hypothesis.strategies.data` strategy you can now add a label as an argument to
-  ``draw()``, which will be printed along with the value when an example fails.
-  Thanks to Peter Inglesby for this feature.
-
-Bug fixes:
-
-* Bug fix: :func:`~hypothesis.strategies.composite` now preserves functions' docstrings.
-* The build is now reproducible and doesn't depend on the path you build it
-  from. Thanks to Chris Lamb for this feature.
-* numpy strategies for the void data type did not work correctly. Thanks to
-  Zac Hatfield Dodds for this fix.
-
-There have also been a number of performance optimizations:
-
-* The :func:`~hypothesis.strategies.permutations` strategy is now significantly faster to use for large
-  lists (the underlying algorithm has gone from O(n^2) to O(n)).
-* Shrinking of failing test cases should have got significantly faster in
-  some circumstances where it was previously struggling for a long time.
-* Example generation now involves less indirection, which results in a small
-  speedup in some cases (small enough that you won't really notice it except in
-  pathological cases).
-
-
-.. _v3.6.1:
-
-------------------
-3.6.1 - 2016-12-20
-------------------
-
-This release fixes a dependency problem and makes some small behind the scenes
-improvements.
-
-* The fake-factory dependency was renamed to faker. If you were depending on
-  it through hypothesisdjango or hypothesisfake-factory without pinning it
-  yourself then it would have failed to install properly. This release changes
-  it so that hypothesisfakefactory (which can now also be installed as
-  hypothesisfaker) will install the renamed faker package instead.
-* This release also removed the dependency of hypothesisdjango on
-  hypothesisfakefactory - it was only being used for emails. These now use
-  a custom strategy that isn't from fakefactory. As a result you should also
-  see performance improvements of tests which generated User objects or other
-  things with email fields, as well as better shrinking of email addresses.
-* The distribution of code using nested calls to :func:`~hypothesis.strategies.one_of` or the ``|`` operator for
-  combining strategies has been improved, as branches are now flattened to give
-  a more uniform distribution.
-* Examples using :func:`~hypothesis.strategies.composite` or ``.flatmap`` should now shrink better. In particular
-  this will affect things which work by first generating a length and then
-  generating that many items, which have historically not shrunk very well.
-
-.. _v3.6.0:
-
-------------------
-3.6.0 - 2016-10-31
-------------------
-
-This release reverts Hypothesis to its old pretty printing of lambda functions
-based on attempting to extract the source code rather than decompile the bytecode.
-This is unfortunately slightly inferior in some cases and may result in you
-occasionally seeing things like ``lambda x: <unknown>`` in statistics reports and
-strategy reprs.
-
-This removes the dependencies on uncompyle6, xdis and spark-parser.
-
-The reason for this is that the new functionality was based on uncompyle6, which
-turns out to introduce a hidden GPLed dependency - it in turn depended on xdis,
-and although the library was licensed under the MIT license, it contained some
-GPL licensed source code and thus should have been released under the GPL.
-
-My interpretation is that Hypothesis itself was never in violation of the GPL
-(because the license it is under, the Mozilla Public License v2, is fully
-compatible with being included in a GPL licensed work), but I have not consulted
-a lawyer on the subject. Regardless of the answer to this question, adding a
-GPLed dependency will likely cause a lot of users of Hypothesis to inadvertently
-be in violation of the GPL.
-
-As a result, if you are running Hypothesis 3.5.x you really should upgrade to
-this release immediately.
-
-.. _v3.5.3:
-
-------------------
-3.5.3 - 2016-10-05
-------------------
-
-This is a bug fix release.
-
-Bugs fixed:
-
-* If the same test was running concurrently in two processes and there were
-  examples already in the test database which no longer failed, Hypothesis
-  would sometimes fail with a FileNotFoundError (IOError on Python 2) because
-  an example it was trying to read was deleted before it was read. (:issue:`372`).
-* Drawing from an :func:`~hypothesis.strategies.integers` strategy with both a min_value and a max_value
-  would reject too many examples needlessly. Now it repeatedly redraws until
-  satisfied. (:pull:`366`.  Thanks to Calen Pennington for the contribution).
-
-.. _v3.5.2:
-
-------------------
-3.5.2 - 2016-09-24
-------------------
-
-This is a bug fix release.
-
-* The Hypothesis pytest plugin broke pytest support for doctests. Now it doesn't.
-
-.. _v3.5.1:
-
-------------------
-3.5.1 - 2016-09-23
-------------------
-
-This is a bug fix release.
-
-* Hypothesis now runs cleanly in -B and -BB modes, avoiding mixing bytes and unicode.
-* :class:`python:unittest.TestCase` tests would not have shown up in the new statistics mode. Now they
-  do.
-* Similarly, stateful tests would not have shown up in statistics and now they do.
-* Statistics now print with pytest node IDs (the names you'd get in pytest verbose mode).
-
-.. _v3.5.0:
-
-------------------
-3.5.0 - 2016-09-22
-------------------
-
-This is a feature release.
-
-* :func:`~hypothesis.strategies.fractions` and :func:`~hypothesis.strategies.decimals` strategies now support min_value and max_value
-  parameters. Thanks go to Anne Mulhern for the development of this feature.
-* The Hypothesis pytest plugin now supports a ``--hypothesis-show-statistics`` parameter
-  that gives detailed statistics about the tests that were run. Huge thanks to
-  Jean-Louis Fuchs and Adfinis-SyGroup for funding the development of this feature.
-* There is a new :func:`~hypothesis.event` function that can be used to add custom statistics.
-
-Additionally there have been some minor bug fixes:
-
-* In some cases Hypothesis should produce fewer duplicate examples (this will mostly
-  only affect cases with a single parameter).
-* :pypi:`pytest` command line parameters are now under an option group for Hypothesis (thanks
-  to David Keijser for fixing this)
-* Hypothesis would previously error if you used :pep:`3107` function annotations on your tests under
-  Python 3.4.
-* The repr of many strategies using lambdas has been improved to include the lambda body
-  (this was previously supported in many but not all cases).
-
-.. _v3.4.2:
-
-------------------
-3.4.2 - 2016-07-13
-------------------
-
-This is a bug fix release, fixing a number of problems with the settings system:
-
-* Test functions defined using :func:`@given <hypothesis.given>` can now be called from other threads
-  (:issue:`337`)
-* Attempting to delete a settings property would previously have silently done
-  the wrong thing. Now it raises an AttributeError.
-* Creating a settings object with a custom database_file parameter was silently
-  getting ignored and the default was being used instead. Now it's not.
-
-.. _v3.4.1:
-
-------------------
-3.4.1 - 2016-07-07
-------------------
-
-This is a bug fix release for a single bug:
-
-* On Windows when running two Hypothesis processes in parallel (e.g. using
-  :pypi:`pytest-xdist`) they could race with each other and one would raise an exception
-  due to the non-atomic nature of file renaming on Windows and the fact that you
-  can't rename over an existing file. This is now fixed.
-
-.. _v3.4.0:
-
-------------------
-3.4.0 - 2016-05-27
-------------------
-
-This release is entirely provided by `Lucas Wiman <https://github.com/lucaswiman>`_:
-
-Strategies constructed by the Django extra
-will now respect much more of Django's validations out of the box.
-Wherever possible, :meth:`~django:django.db.models.Model.full_clean` should
-succeed.
-
-In particular:
-
-* The max_length, blank and choices kwargs are now respected.
-* Add support for DecimalField.
-* If a field includes validators, the list of validators are used to filter the field strategy.
-
-.. _v3.3.0:
-
-------------------
-3.3.0 - 2016-05-27
-------------------
-
-This release went wrong and is functionally equivalent to :ref:`3.2.0 <v3.2.0>`. Ignore it.
-
-.. _v3.2.0:
-
-------------------
-3.2.0 - 2016-05-19
-------------------
-
-This is a small single-feature release:
-
-* All tests using :func:`@given <hypothesis.given>` now fix the global random seed. This removes the health
-  check for that. If a non-zero seed is required for the final falsifying
-  example, it will be reported. Otherwise Hypothesis will assume randomization
-  was not a significant factor for the test and be silent on the subject. If you
-  use :func:`~hypothesis.strategies.random_module` this will continue to work and will always
-  display the seed.
-
-.. _v3.1.3:
-
-------------------
-3.1.3 - 2016-05-01
-------------------
-
-Single bug fix release
-
-* Another charmap problem. In :ref:`3.1.2 <v3.1.2>` :func:`~hypothesis.strategies.text` and
-  :func:`~hypothesis.strategies.characters` would break on systems
-  which had ``/tmp`` mounted on a different partition than the Hypothesis storage
-  directory (usually in home). This fixes that.
-
-.. _v3.1.2:
-
-------------------
-3.1.2 - 2016-04-30
-------------------
-
-Single bug fix release:
-
-* Anything which used a :func:`~hypothesis.strategies.text` or
-  :func:`~hypothesis.strategies.characters` strategy was broken on Windows
-  and I hadn't updated appveyor to use the new repository location so I didn't
-  notice. This is now fixed and windows support should work correctly.
-
-.. _v3.1.1:
-
-------------------
-3.1.1 - 2016-04-29
-------------------
-
-Minor bug fix release.
-
-* Fix concurrency issue when running tests that use :func:`~hypothesis.strategies.text` from multiple
-  processes at once (:issue:`302`, thanks to Alex Chan).
-* Improve performance of code using :func:`~hypothesis.strategies.lists` with max_size (thanks to
-  Cristi Cobzarenco).
-* Fix install on Python 2 with ancient versions of pip so that it installs the
-  :pypi:`enum34` backport (thanks to Donald Stufft for telling me how to do this).
-* Remove duplicated __all__ exports from hypothesis.strategies (thanks to
-  Piët Delport).
-* Update headers to point to new repository location.
-* Allow use of strategies that can't be used in ``find()``
-  (e.g. ``choices()``) in stateful testing.
-
-
-.. _v3.1.0:
-
-------------------
-3.1.0 - 2016-03-06
-------------------
-
-* Add a :func:`~hypothesis.strategies.nothing` strategy that never successfully generates values.
-* :func:`~hypothesis.strategies.sampled_from` and :func:`~hypothesis.strategies.one_of`
-  can both now be called with an empty argument
-  list, in which case they also never generate any values.
-* :func:`~hypothesis.strategies.one_of` may now be called with a single argument that is a collection of strategies
-  as well as as varargs.
-* Add a :func:`~hypothesis.strategies.runner` strategy which returns the instance of the current test object
-  if there is one.
-* 'Bundle' for RuleBasedStateMachine is now a normal(ish) strategy and can be used
-  as such.
-* Tests using RuleBasedStateMachine should now shrink significantly better.
-* Hypothesis now uses a pretty-printing library internally, compatible with IPython's
-  pretty printing protocol (actually using the same code). This may improve the quality
-  of output in some cases.
-* Add a 'phases' setting that allows more fine grained control over which parts of the
-  process Hypothesis runs
-* Add a suppress_health_check setting which allows you to turn off specific health checks
-  in a fine grained manner.
-* Fix a bug where lists of non fixed size would always draw one more element than they
-  included. This mostly didn't matter, but if would cause problems with empty strategies
-  or ones with side effects.
-* Add a mechanism to the Django model generator to allow you to explicitly request the
-  default value (thanks to Jeremy Thurgood for this one).
-
-.. _v3.0.5:
-
-------------------
-3.0.5 - 2016-02-25
-------------------
-
-* Fix a bug where Hypothesis would now error on :pypi:`pytest` development versions.
-
-.. _v3.0.4:
-
-------------------
-3.0.4 - 2016-02-24
-------------------
-
-* Fix a bug where Hypothesis would error when running on Python 2.7.3 or
-  earlier because it was trying to pass a :class:`python:bytearray` object
-  to :func:`python:struct.unpack` (which is only supported since 2.7.4).
-
-.. _v3.0.3:
-
-------------------
-3.0.3 - 2016-02-23
-------------------
-
-* Fix version parsing of pytest to work with pytest release candidates
-* More general handling of the health check problem where things could fail because
-  of a cache miss - now one "free" example is generated before the start of the
-  health check run.
-
-.. _v3.0.2:
-
-------------------
-3.0.2 - 2016-02-18
-------------------
-
-* Under certain circumstances, strategies involving :func:`~hypothesis.strategies.text` buried inside some
-  other strategy (e.g. ``text().filter(...)`` or ``recursive(text(), ...))`` would cause
-  a test to fail its health checks the first time it ran. This was caused by having
-  to compute some related data and cache it to disk. On travis or anywhere else
-  where the ``.hypothesis`` directory was recreated this would have caused the tests
-  to fail their health check on every run. This is now fixed for all the known cases,
-  although there could be others lurking.
-
-.. _v3.0.1:
-
-------------------
-3.0.1 - 2016-02-18
-------------------
-
-* Fix a case where it was possible to trigger an "Unreachable" assertion when
-  running certain flaky stateful tests.
-* Improve shrinking of large stateful tests by eliminating a case where it was
-  hard to delete early steps.
-* Improve efficiency of drawing :func:`binary(min_size=n, max_size=n) <hypothesis.strategies.binary>` significantly by
-  provide a custom implementation for fixed size blocks that can bypass a lot
-  of machinery.
-* Set default home directory based on the current working directory at the
-  point Hypothesis is imported, not whenever the function first happens to be
-  called.
-
-.. _v3.0.0:
-
-------------------
-3.0.0 - 2016-02-17
-------------------
-
-Codename: This really should have been 2.1.
-
-Externally this looks like a very small release. It has one small breaking change
-that probably doesn't affect anyone at all (some behaviour that never really worked
-correctly is now outright forbidden) but necessitated a major version bump and one
-visible new feature.
-
-Internally this is a complete rewrite. Almost nothing other than the public API is
-the same.
-
-New features:
-
-* Addition of :func:`~hypothesis.strategies.data` strategy which allows you to draw arbitrary data interactively
-  within the test.
-* New "exploded" database format which allows you to more easily check the example
-  database into a source repository while supporting merging.
-* Better management of how examples are saved in the database.
-* Health checks will now raise as errors when they fail. It was too easy to have
-  the warnings be swallowed entirely.
-
-New limitations:
-
-* ``choices()`` and ``streaming()``
-  strategies may no longer be used with ``find()``. Neither may
-  :func:`~hypothesis.strategies.data` (this is the change that necessitated a major version bump).
-
-Feature removal:
-
-* The ForkingTestCase executor has gone away. It may return in some more working
-  form at a later date.
-
-Performance improvements:
-
-* A new model which allows flatmap, composite strategies and stateful testing to
-  perform *much* better. They should also be more reliable.
-* Filtering may in some circumstances have improved significantly. This will
-  help especially in cases where you have lots of values with individual filters
-  on them, such as lists(x.filter(...)).
-* Modest performance improvements to the general test runner by avoiding expensive
-  operations
-
-In general your tests should have got faster. If they've instead got significantly
-slower, I'm interested in hearing about it.
-
-Data distribution:
-
-The data distribution should have changed significantly. This may uncover bugs the
-previous version missed. It may also miss bugs the previous version could have
-uncovered. Hypothesis is now producing less strongly correlated data than it used
-to, but the correlations are extended over more of the structure.
-
-Shrinking:
-
-Shrinking quality should have improved. In particular Hypothesis can now perform
-simultaneous shrinking of separate examples within a single test (previously it
-was only able to do this for elements of a single collection). In some cases
-performance will have improved, in some cases it will have got worse but generally
-shouldn't have by much.
-
-
-Older versions
-==============
-
-.. _v2.0.0:
-
-------------------
-2.0.0 - 2016-01-10
-------------------
-
-Codename: A new beginning
-
-This release cleans up all of the legacy that accrued in the course of
-Hypothesis 1.0. These are mostly things that were emitting deprecation warnings
-in 1.19.0, but there were a few additional changes.
-
-In particular:
-
-* non-strategy values will no longer be converted to strategies when used in
-  given or find.
-* FailedHealthCheck is now an error and not a warning.
-* Handling of non-ascii reprs in user types have been simplified by using raw
-  strings in more places in Python 2.
-* given no longer allows mixing positional and keyword arguments.
-* given no longer works with functions with defaults.
-* given no longer turns provided arguments into defaults - they will not appear
-  in the argspec at all.
-* the basic() strategy no longer exists.
-* the n_ary_tree strategy no longer exists.
-* the average_list_length setting no longer exists. Note: If you're using
-  using recursive() this will cause you a significant slow down. You should
-  pass explicit average_size parameters to collections in recursive calls.
-* @rule can no longer be applied to the same method twice.
-* Python 2.6 and 3.3 are no longer officially supported, although in practice
-  they still work fine.
-
-This also includes two non-deprecation changes:
-
-* given's keyword arguments no longer have to be the rightmost arguments and
-  can appear anywhere in the method signature.
-* The max_shrinks setting would sometimes not have been respected.
-
-
-.. _v1.19.0:
-
--------------------
-1.19.0 - 2016-01-09
--------------------
-
-Codename: IT COMES
-
-This release heralds the beginning of a new and terrible age of Hypothesis 2.0.
-
-It's primary purpose is some final deprecations prior to said release. The goal
-is that if your code emits no warnings under this release then it will probably run
-unchanged under Hypothesis 2.0 (there are some caveats to this: 2.0 will drop
-support for some Python versions, and if you're using internal APIs then as usual
-that may break without warning).
-
-It does have two new features:
-
-* New @seed() decorator which allows you to manually seed a test. This may be
-  harmlessly combined with and overrides the derandomize setting.
-* settings objects may now be used as a decorator to fix those settings to a
-  particular @given test.
-
-API changes (old usage still works but is deprecated):
-
-* Settings has been renamed to settings (lower casing) in order to make the
-  decorator usage more natural.
-* Functions for the storage directory that were in hypothesis.settings are now
-  in a new hypothesis.configuration module.
-
-Additional deprecations:
-
-* the average_list_length setting has been deprecated in favour of being
-  explicit.
-* the basic() strategy has been deprecated as it is impossible to support
-  it under a Conjecture based model, which will hopefully be implemented at
-  some point in the 2.x series.
-* the n_ary_tree strategy (which was never actually part of the public API)
-  has been deprecated.
-* Passing settings or random as keyword arguments to given is deprecated (use
-  the new functionality instead)
-
-
-Bug fixes:
-
-* No longer emit PendingDeprecationWarning for __iter__ and StopIteration in
-  streaming() values.
-* When running in health check mode with non strict, don't print quite so
-  many errors for an exception in reify.
-* When an assumption made in a test or a filter is flaky, tests will now
-  raise Flaky instead of UnsatisfiedAssumption.
-
-
-.. _v1.18.1:
-
--------------------
-1.18.1 - 2015-12-22
--------------------
-
-Two behind the scenes changes:
-
-* Hypothesis will no longer write generated code to the file system. This
-  will improve performance on some systems (e.g. if you're using
-  `PythonAnywhere <https://www.pythonanywhere.com/>`_ which is running your
-  code from NFS) and prevent some annoying interactions with auto-restarting
-  systems.
-* Hypothesis will cache the creation of some strategies. This can significantly
-  improve performance for code that uses flatmap or composite and thus has to
-  instantiate strategies a lot.
-
-.. _v1.18.0:
-
--------------------
-1.18.0 - 2015-12-21
--------------------
-
-Features:
-
-* Tests and find are now explicitly seeded off the global random module. This
-  means that if you nest one inside the other you will now get a health check
-  error. It also means that you can control global randomization by seeding
-  random.
-* There is a new random_module() strategy which seeds the global random module
-  for you and handles things so that you don't get a health check warning if
-  you use it inside your tests.
-* floats() now accepts two new arguments: allow\_nan and allow\_infinity. These
-  default to the old behaviour, but when set to False will do what the names
-  suggest.
-
-Bug fixes:
-
-* Fix a bug where tests that used text() on Python 3.4+ would not actually be
-  deterministic even when explicitly seeded or using the derandomize mode,
-  because generation depended on dictionary iteration order which was affected
-  by hash randomization.
-* Fix a bug where with complicated strategies the timing of the initial health
-  check could affect the seeding of the subsequent test, which would also
-  render supposedly deterministic tests non-deterministic in some scenarios.
-* In some circumstances flatmap() could get confused by two structurally
-  similar things it could generate and would produce a flaky test where the
-  first time it produced an error but the second time it produced the other
-  value, which was not an error. The same bug was presumably also possible in
-  composite().
-* flatmap() and composite() initial generation should now be moderately faster.
-  This will be particularly noticeable when you have many values drawn from the
-  same strategy in a single run, e.g. constructs like lists(s.flatmap(f)).
-  Shrinking performance *may* have suffered, but this didn't actually produce
-  an interestingly worse result in any of the standard scenarios tested.
-
-.. _v1.17.1:
-
--------------------
-1.17.1 - 2015-12-16
--------------------
-
-A small bug fix release, which fixes the fact that the 'note' function could
-not be used on tests which used the @example decorator to provide explicit
-examples.
-
-.. _v1.17.0:
-
--------------------
-1.17.0 - 2015-12-15
--------------------
-
-This is actually the same release as 1.16.1, but 1.16.1 has been pulled because
-it contains the following additional change that was not intended to be in a
-patch  release (it's perfectly stable, but is a larger change that should have
-required a minor version bump):
-
-* Hypothesis will now perform a series of "health checks" as part of running
-  your tests. These detect and warn about some common error conditions that
-  people often run into which wouldn't necessarily have caused the test to fail
-  but would cause e.g. degraded performance or confusing results.
-
-.. _v1.16.1:
-
--------------------
-1.16.1 - 2015-12-14
--------------------
-
-Note: This release has been removed.
-
-A small bugfix release that allows bdists for Hypothesis to be built
-under 2.7 - the compat3.py file which had Python 3 syntax wasn't intended
-to be loaded under Python 2, but when building a bdist it was. In particular
-this would break running setup.py test.
-
-.. _v1.16.0:
-
--------------------
-1.16.0 - 2015-12-08
--------------------
-
-There are no public API changes in this release but it includes a behaviour
-change that I wasn't comfortable putting in a patch release.
-
-* Functions from hypothesis.strategies will no longer raise InvalidArgument
-  on bad arguments. Instead the same errors will be raised when a test
-  using such a strategy is run. This may improve startup time in some
-  cases, but the main reason for it is so that errors in strategies
-  won't cause errors in loading, and it can interact correctly with things
-  like pytest.mark.skipif.
-* Errors caused by accidentally invoking the legacy API are now much less
-  confusing, although still throw NotImplementedError.
-* hypothesis.extra.django is 1.9 compatible.
-* When tests are run with max_shrinks=0 this will now still rerun the test
-  on failure and will no longer print "Trying example:" before each run.
-  Additionally note() will now work correctly when used with max_shrinks=0.
-
-.. _v1.15.0:
-
--------------------
-1.15.0 - 2015-11-24
--------------------
-
-A release with two new features.
-
-* A 'characters' strategy for more flexible generation of text with particular
-  character ranges and types, kindly contributed by `Alexander Shorin <https://github.com/kxepal>`_.
-* Add support for preconditions to the rule based stateful testing. Kindly
-  contributed by `Christopher Armstrong <https://github.com/radix>`_
-
-
-.. _v1.14.0:
-
--------------------
-1.14.0 - 2015-11-01
--------------------
-
-
-New features:
-
-* Add 'note' function which lets you include additional information in the
-  final test run's output.
-* Add 'choices' strategy which gives you a choice function that emulates
-  random.choice.
-* Add 'uuid' strategy that generates UUIDs'
-* Add 'shared' strategy that lets you create a strategy that just generates a
-  single shared value for each test run
-
-Bugs:
-
-* Using strategies of the form streaming(x.flatmap(f)) with find or in stateful
-  testing would have caused InvalidArgument errors when the resulting values
-  were used (because code that expected to only be called within a test context
-  would be invoked).
-
-
-.. _v1.13.0:
-
--------------------
-1.13.0 - 2015-10-29
--------------------
-
-This is quite a small release, but deprecates some public API functions
-and removes some internal API functionality so gets a minor version bump.
-
-* All calls to the 'strategy' function are now deprecated, even ones which
-  pass just a SearchStrategy instance (which is still a no-op).
-* Never documented hypothesis.extra entry_points mechanism has now been removed (
-  it was previously how hypothesis.extra packages were loaded and has been deprecated
-  and unused for some time)
-* Some corner cases that could previously have produced an OverflowError when simplifying
-  failing cases using hypothesis.extra.datetimes (or dates or times) have now been fixed.
-* Hypothesis load time for first import has been significantly reduced - it used to be
-  around 250ms (on my SSD laptop) and now is around 100-150ms. This almost never
-  matters but was slightly annoying when using it in the console.
-* hypothesis.strategies.randoms was previously missing from \_\_all\_\_.
-
-.. _v1.12.0:
-
--------------------
-1.12.0 - 2015-10-18
--------------------
-
-* Significantly improved performance of creating strategies using the functions
-  from the hypothesis.strategies module by deferring the calculation of their
-  repr until it was needed. This is unlikely to have been an performance issue
-  for you unless you were using flatmap, composite or stateful testing, but for
-  some cases it could be quite a significant impact.
-* A number of cases where the repr of strategies build from lambdas is improved
-* Add dates() and times() strategies to hypothesis.extra.datetimes
-* Add new 'profiles' mechanism to the settings system
-* Deprecates mutability of Settings, both the Settings.default top level property
-  and individual settings.
-* A Settings object may now be directly initialized from a parent Settings.
-* @given should now give a better error message if you attempt to use it with a
-  function that uses destructuring arguments (it still won't work, but it will
-  error more clearly),
-* A number of spelling corrections in error messages
-* :pypi:`pytest` should no longer display the intermediate modules Hypothesis generates
-  when running in verbose mode
-* Hypothesis should now correctly handle printing objects with non-ascii reprs
-  on python 3 when running in a locale that cannot handle ascii printing to
-  stdout.
-* Add a unique=True argument to lists(). This is equivalent to
-  unique_by=lambda x: x, but offers a more convenient syntax.
-
-
-.. _v1.11.4:
-
--------------------
-1.11.4 - 2015-09-27
--------------------
-
-* Hide modifications Hypothesis needs to make to sys.path by undoing them
-  after we've imported the relevant modules. This is a workaround for issues
-  cryptography experienced on windows.
-* Slightly improved performance of drawing from sampled_from on large lists
-  of alternatives.
-* Significantly improved performance of drawing from one_of or strategies
-  using \| (note this includes a lot of strategies internally - floats()
-  and integers() both fall into this category). There turned out to be a
-  massive performance regression introduced in 1.10.0 affecting these which
-  probably would have made tests using Hypothesis significantly slower than
-  they should have been.
-
-.. _v1.11.3:
-
--------------------
-1.11.3 - 2015-09-23
--------------------
-
-* Better argument validation for datetimes() strategy - previously setting
-  max_year < datetime.MIN_YEAR or min_year > datetime.MAX_YEAR would not have
-  raised an InvalidArgument error and instead would have behaved confusingly.
-* Compatibility with being run on pytest < 2.7 (achieved by disabling the
-  plugin).
-
-.. _v1.11.2:
-
--------------------
-1.11.2 - 2015-09-23
--------------------
-
-Bug fixes:
-
-* Settings(database=my_db) would not be correctly inherited when used as a
-  default setting, so that newly created settings would use the database_file
-  setting and create an SQLite example database.
-* Settings.default.database = my_db would previously have raised an error and
-  now works.
-* Timeout could sometimes be significantly exceeded if during simplification
-  there were a lot of examples tried that didn't trigger the bug.
-* When loading a heavily simplified example using a basic() strategy from the
-  database this could cause Python to trigger a recursion error.
-* Remove use of deprecated API in pytest plugin so as to not emit warning
-
-Misc:
-
-* hypothesis-pytest is now part of hypothesis core. This should have no
-  externally visible consequences, but you should update your dependencies to
-  remove hypothesis-pytest and depend on only Hypothesis.
-* Better repr for hypothesis.extra.datetimes() strategies.
-* Add .close() method to abstract base class for Backend (it was already present
-  in the main implementation).
-
-.. _v1.11.1:
-
--------------------
-1.11.1 - 2015-09-16
--------------------
-
-Bug fixes:
-
-* When running Hypothesis tests in parallel (e.g. using pytest-xdist) there was a race
-  condition caused by code generation.
-* Example databases are now cached per thread so as to not use sqlite connections from
-  multiple threads. This should make Hypothesis now entirely thread safe.
-* floats() with only min_value or max_value set would have had a very bad distribution.
-* Running on 3.5, Hypothesis would have emitted deprecation warnings because of use of
-  inspect.getargspec
-
-.. _v1.11.0:
-
--------------------
-1.11.0 - 2015-08-31
--------------------
-
-* text() with a non-string alphabet would have used the repr() of the the alphabet
-  instead of its contexts. This is obviously silly. It now works with any sequence
-  of things convertible to unicode strings.
-* @given will now work on methods whose definitions contains no explicit positional
-  arguments, only varargs (:issue:`118`).
-  This may have some knock on effects because it means that @given no longer changes the
-  argspec of functions other than by adding defaults.
-* Introduction of new @composite feature for more natural definition of strategies you'd
-  previously have used flatmap for.
-
-.. _v1.10.6:
-
--------------------
-1.10.6 - 2015-08-26
--------------------
-
-Fix support for fixtures on Django 1.7.
-
-.. _v1.10.4:
-
--------------------
-1.10.4 - 2015-08-21
--------------------
-
-Tiny bug fix release:
-
-* If the database_file setting is set to None, this would have resulted in
-  an error when running tests. Now it does the same as setting database to
-  None.
-
-.. _v1.10.3:
-
--------------------
-1.10.3 - 2015-08-19
--------------------
-
-Another small bug fix release.
-
-* lists(elements, unique_by=some_function, min_size=n) would have raised a
-  ValidationError if n > Settings.default.average_list_length because it would
-  have wanted to use an average list length shorter than the minimum size of
-  the list, which is impossible. Now it instead defaults to twice the minimum
-  size in these circumstances.
-* basic() strategy would have only ever produced at most ten distinct values
-  per run of the test (which is bad if you e.g. have it inside a list). This
-  was obviously silly. It will now produce a much better distribution of data,
-  both duplicated and non duplicated.
-
-
-.. _v1.10.2:
-
--------------------
-1.10.2 - 2015-08-19
--------------------
-
-This is a small bug fix release:
-
-* star imports from hypothesis should now work correctly.
-* example quality for examples using flatmap will be better, as the way it had
-  previously been implemented was causing problems where Hypothesis was
-  erroneously labelling some examples as being duplicates.
-
-.. _v1.10.0:
-
--------------------
-1.10.0 - 2015-08-04
--------------------
-
-This is just a bugfix and performance release, but it changes some
-semi-public APIs, hence the minor version bump.
-
-* Significant performance improvements for strategies which are one\_of()
-  many branches. In particular this included recursive() strategies. This
-  should take the case where you use one recursive() strategy as the base
-  strategy of another from unusably slow (tens of seconds per generated
-  example) to reasonably fast.
-* Better handling of just() and sampled_from() for values which have an
-  incorrect \_\_repr\_\_ implementation that returns non-ASCII unicode
-  on Python 2.
-* Better performance for flatmap from changing the internal morpher API
-  to be significantly less general purpose.
-* Introduce a new semi-public BuildContext/cleanup API. This allows
-  strategies to register cleanup activities that should run once the
-  example is complete. Note that this will interact somewhat weirdly with
-  find.
-* Better simplification behaviour for streaming strategies.
-* Don't error on lambdas which use destructuring arguments in Python 2.
-* Add some better reprs for a few strategies that were missing good ones.
-* The Random instances provided by randoms() are now copyable.
-* Slightly more debugging information about simplify when using a debug
-  verbosity level.
-* Support using given for functions with varargs, but not passing arguments
-  to it as positional.
-
-.. _v1.9.0:
-
-------------------
-1.9.0 - 2015-07-27
-------------------
-
-Codename: The great bundling.
-
-This release contains two fairly major changes.
-
-The first is the deprecation of the hypothesis-extra mechanism. From
-now on all the packages that were previously bundled under it other
-than hypothesis-pytest (which is a different beast and will remain
-separate). The functionality remains unchanged and you can still import
-them from exactly the same location, they just are no longer separate
-packages.
-
-The second is that this introduces a new way of building strategies
-which lets you build up strategies recursively from other strategies.
-
-It also contains the minor change that calling .example() on a
-strategy object will give you examples that are more representative of
-the actual data you'll get. There used to be some logic in there to make
-the examples artificially simple but this proved to be a bad idea.
-
-.. _v1.8.5:
-
-------------------
-1.8.5 - 2015-07-24
-------------------
-
-This contains no functionality changes but fixes a mistake made with
-building the previous package that would have broken installation on
-Windows.
-
-.. _v1.8.4:
-
-------------------
-1.8.4 - 2015-07-20
-------------------
-
-Bugs fixed:
-
-* When a call to floats() had endpoints which were not floats but merely
-  convertible to one (e.g. integers), these would be included in the generated
-  data which would cause it to generate non-floats.
-* Splitting lambdas used in the definition of flatmap, map or filter over
-  multiple lines would break the repr, which would in turn break their usage.
-
-
-.. _v1.8.3:
-
-------------------
-1.8.3 - 2015-07-20
-------------------
-
-"Falsifying example" would not have been printed when the failure came from an
-explicit example.
-
-.. _v1.8.2:
-
-------------------
-1.8.2 - 2015-07-18
-------------------
-
-Another small bugfix release:
-
-* When using ForkingTestCase you would usually not get the falsifying example
-  printed if the process exited abnormally (e.g. due to os._exit).
-* Improvements to the distribution of characters when using text() with a
-  default alphabet. In particular produces a better distribution of ascii and
-  whitespace in the alphabet.
-
-.. _v1.8.1:
-
-------------------
-1.8.1 - 2015-07-17
-------------------
-
-This is a small release that contains a workaround for people who have
-bad reprs returning non ascii text on Python 2.7. This is not a bug fix
-for Hypothesis per se because that's not a thing that is actually supposed
-to work, but Hypothesis leans more heavily on repr than is typical so it's
-worth having a workaround for.
-
-.. _v1.8.0:
-
-------------------
-1.8.0 - 2015-07-16
-------------------
-
-New features:
-
-* Much more sensible reprs for strategies, especially ones that come from
-  hypothesis.strategies. These should now have as reprs python code that
-  would produce the same strategy.
-* lists() accepts a unique_by argument which forces the generated lists to be
-  only contain elements unique according to some function key (which must
-  return a hashable value).
-* Better error messages from flaky tests to help you debug things.
-
-Mostly invisible implementation details that may result in finding new bugs
-in your code:
-
-* Sets and dictionary generation should now produce a better range of results.
-* floats with bounds now focus more on 'critical values', trying to produce
-  values at edge cases.
-* flatmap should now have better simplification for complicated cases, as well
-  as generally being (I hope) more reliable.
-
-Bug fixes:
-
-* You could not previously use assume() if you were using the forking executor.
-
-
-.. _v1.7.2:
-
-------------------
-1.7.2 - 2015-07-10
-------------------
-
-This is purely a bug fix release:
-
-* When using floats() with stale data in the database you could sometimes get
-  values in your tests that did not respect min_value or max_value.
-* When getting a Flaky error from an unreliable test it would have incorrectly
-  displayed the example that caused it.
-* 2.6 dependency on backports was incorrectly specified. This would only have
-  caused you problems if you were building a universal wheel from Hypothesis,
-  which is not how Hypothesis ships, so unless you're explicitly building wheels
-  for your dependencies and support Python 2.6 plus a later version of Python
-  this probably would never have affected you.
-* If you use flatmap in a way that the strategy on the right hand side depends
-  sensitively on the left hand side you may have occasionally seen Flaky errors
-  caused by producing unreliable examples when minimizing a bug. This use case
-  may still be somewhat fraught to be honest. This code is due a major rearchitecture
-  for 1.8, but in the meantime this release fixes the only source of this error that
-  I'm aware of.
-
-.. _v1.7.1:
-
-------------------
-1.7.1 - 2015-06-29
-------------------
-
-Codename: There is no 1.7.0.
-
-A slight technical hitch with a premature upload means there's was a yanked
-1.7.0 release. Oops.
-
-The major feature of this release is Python 2.6 support. Thanks to Jeff Meadows
-for doing most of the work there.
-
-Other minor features
-
-* strategies now has a permutations() function which returns a strategy
-  yielding permutations of values from a given collection.
-* if you have a flaky test it will print the exception that it last saw before
-  failing with Flaky, even if you do not have verbose reporting on.
-* Slightly experimental git merge script available as "python -m
-  hypothesis.tools.mergedbs". Instructions on how to use it in the docstring
-  of that file.
-
-Bug fixes:
-
-* Better performance from use of filter. In particular tests which involve large
-  numbers of heavily filtered strategies should perform a lot better.
-* floats() with a negative min_value would not have worked correctly (worryingly,
-  it would have just silently failed to run any examples). This is now fixed.
-* tests using sampled\_from would error if the number of sampled elements was smaller
-  than min\_satisfying\_examples.
-
-
-.. _v1.6.2:
-
-------------------
-1.6.2 - 2015-06-08
-------------------
-
-This is just a few small bug fixes:
-
-* Size bounds were not validated for values for a binary() strategy when
-  reading examples from the database.
-* sampled\_from is now in __all__ in hypothesis.strategies
-* floats no longer consider negative integers to be simpler than positive
-  non-integers
-* Small floating point intervals now correctly count members, so if you have a
-  floating point interval so narrow there are only a handful of values in it,
-  this will no longer cause an error when Hypothesis runs out of values.
-
-.. _v1.6.1:
-
-------------------
-1.6.1 - 2015-05-21
-------------------
-
-This is a small patch release that fixes a bug where 1.6.0 broke the use
-of flatmap with the deprecated API and assumed the passed in function returned
-a SearchStrategy instance rather than converting it to a strategy.
-
-.. _v1.6.0:
-
-------------------
-1.6.0 - 2015-05-21
-------------------
-
-
-This is a smallish release designed to fix a number of bugs and smooth out
-some weird behaviours.
-
-* Fix a critical bug in flatmap where it would reuse old strategies. If all
-  your flatmap code was pure you're fine. If it's not, I'm surprised it's
-  working at all. In particular if you want to use flatmap with django models,
-  you desperately need to upgrade to this version.
-* flatmap simplification performance should now be better in some cases where
-  it previously had to redo work.
-* Fix for a bug where invalid unicode data with surrogates could be generated
-  during simplification (it was already filtered out during actual generation).
-* The Hypothesis database is now keyed off the name of the test instead of the
-  type of data. This makes much more sense now with the new strategies API and
-  is generally more robust. This means you will lose old examples on upgrade.
-* The database will now not delete values which fail to deserialize correctly,
-  just skip them. This is to handle cases where multiple incompatible strategies
-  share the same key.
-* find now also saves and loads values from the database, keyed off a hash of the
-  function you're finding from.
-* Stateful tests now serialize and load values from the database. They should have
-  before, really. This was a bug.
-* Passing a different verbosity level into a test would not have worked entirely
-  correctly, leaving off some messages. This is now fixed.
-* Fix a bug where derandomized tests with unicode characters in the function
-  body would error on Python 2.7.
-
-
-.. _v1.5.0:
-
-------------------
-1.5.0 - 2015-05-14
-------------------
-
-
-Codename: Strategic withdrawal.
-
-The purpose of this release is a radical simplification of the API for building
-strategies. Instead of the old approach of @strategy.extend and things that
-get converted to strategies, you just build strategies directly.
-
-The old method of defining strategies will still work until Hypothesis 2.0,
-because it's a major breaking change, but will now emit deprecation warnings.
-
-The new API is also a lot more powerful as the functions for defining strategies
-give you a lot of dials to turn. See :doc:`the updated data section <data>` for
-details.
-
-Other changes:
-
-  * Mixing keyword and positional arguments in a call to @given is deprecated as well.
-  * There is a new setting called 'strict'. When set to True, Hypothesis will raise
-    warnings instead of merely printing them. Turning it on by default is inadvisable because
-    it means that Hypothesis minor releases can break your code, but it may be useful for
-    making sure you catch all uses of deprecated APIs.
-  * max_examples in settings is now interpreted as meaning the maximum number
-    of unique (ish) examples satisfying assumptions. A new setting max_iterations
-    which defaults to a larger value has the old interpretation.
-  * Example generation should be significantly faster due to a new faster parameter
-    selection algorithm. This will mostly show up for simple data types - for complex
-    ones the parameter selection is almost certainly dominated.
-  * Simplification has some new heuristics that will tend to cut down on cases
-    where it could previously take a very long time.
-  * timeout would previously not have been respected in cases where there were a lot
-    of duplicate examples. You probably wouldn't have previously noticed this because
-    max_examples counted duplicates, so this was very hard to hit in a way that mattered.
-  * A number of internal simplifications to the SearchStrategy API.
-  * You can now access the current Hypothesis version as hypothesis.__version__.
-  * A top level function is provided for running the stateful tests without the
-    TestCase infrastructure.
-
-.. _v1.4.0:
-
-------------------
-1.4.0 - 2015-05-04
-------------------
-
-Codename: What a state.
-
-The *big* feature of this release is the new and slightly experimental
-stateful testing API. You can read more about that in :doc:`the
-appropriate section <stateful>`.
-
-Two minor features the were driven out in the course of developing this:
-
-* You can now set settings.max_shrinks to limit the number of times
-  Hypothesis will try to shrink arguments to your test. If this is set to
-  <= 0 then Hypothesis will not rerun your test and will just raise the
-  failure directly. Note that due to technical limitations if max_shrinks
-  is <= 0 then Hypothesis will print *every* example it calls your test
-  with rather than just the failing one. Note also that I don't consider
-  settings max_shrinks to zero a sensible way to run your tests and it
-  should really be considered a debug feature.
-* There is a new debug level of verbosity which is even *more* verbose than
-  verbose. You probably don't want this.
-
-Breakage of semi-public SearchStrategy API:
-
-* It is now a required invariant of SearchStrategy that if u simplifies to
-  v then it is not the case that strictly_simpler(u, v). i.e. simplifying
-  should not *increase* the complexity even though it is not required to
-  decrease it. Enforcing this invariant lead to finding some bugs where
-  simplifying of integers, floats and sets was suboptimal.
-* Integers in basic data are now required to fit into 64 bits. As a result
-  python integer types are now serialized as strings, and some types have
-  stopped using quite so needlessly large random seeds.
-
-Hypothesis Stateful testing was then turned upon Hypothesis itself, which lead
-to an amazing number of minor bugs being found in Hypothesis itself.
-
-Bugs fixed (most but not all from the result of stateful testing) include:
-
-* Serialization of streaming examples was flaky in a way that you would
-  probably never notice: If you generate a template, simplify it, serialize
-  it, deserialize it, serialize it again and then deserialize it you would
-  get the original stream instead of the simplified one.
-* If you reduced max_examples below the number of examples already saved in
-  the database, you would have got a ValueError. Additionally, if you had
-  more than max_examples in the database all of them would have been
-  considered.
-* @given will no longer count duplicate examples (which it never called
-  your function with) towards max_examples. This may result in your tests
-  running slower, but that's probably just because they're trying more
-  examples.
-* General improvements to example search which should result in better
-  performance and higher quality examples. In particular parameters which
-  have a history of producing useless results will be more aggressively
-  culled. This is useful both because it decreases the chance of useless
-  examples and also because it's much faster to not check parameters which
-  we were unlikely to ever pick!
-* integers_from and lists of types with only one value (e.g. None) would
-  previously have had a very high duplication rate so you were probably
-  only getting a handful of examples. They now have a much lower
-  duplication rate, as well as the improvements to search making this
-  less of a problem in the first place.
-* You would sometimes see simplification taking significantly longer than
-  your defined timeout. This would happen because timeout was only being
-  checked after each *successful* simplification, so if Hypothesis was
-  spending a lot of time unsuccessfully simplifying things it wouldn't
-  stop in time. The timeout is now applied for unsuccessful simplifications
-  too.
-* In Python 2.7, integers_from strategies would have failed during
-  simplification with an OverflowError if their starting point was at or
-  near to the maximum size of a 64-bit integer.
-* flatmap and map would have failed if called with a function without a
-  __name__ attribute.
-* If max_examples was less than min_satisfying_examples this would always
-  error. Now min_satisfying_examples is capped to max_examples. Note that
-  if you have assumptions to satisfy here this will still cause an error.
-
-Some minor quality improvements:
-
-* Lists of streams, flatmapped strategies and basic strategies should now
-  now have slightly better simplification.
-
-.. _v1.3.0:
-
-------------------
-1.3.0 - 2015-05-22
-------------------
-
-New features:
-
-* New verbosity level API for printing intermediate results and exceptions.
-* New specifier for strings generated from a specified alphabet.
-* Better error messages for tests that are failing because of a lack of enough
-  examples.
-
-Bug fixes:
-
-* Fix error where use of ForkingTestCase would sometimes result in too many
-  open files.
-* Fix error where saving a failing example that used flatmap could error.
-* Implement simplification for sampled_from, which apparently never supported
-  it previously. Oops.
-
-
-General improvements:
-
-* Better range of examples when using one_of or sampled_from.
-* Fix some pathological performance issues when simplifying lists of complex
-  values.
-* Fix some pathological performance issues when simplifying examples that
-  require unicode strings with high codepoints.
-* Random will now simplify to more readable examples.
-
-
-.. _v1.2.1:
-
-------------------
-1.2.1 - 2015-04-16
-------------------
-
-A small patch release for a bug in the new executors feature. Tests which require
-doing something to their result in order to fail would have instead reported as
-flaky.
-
-.. _v1.2.0:
-
-------------------
-1.2.0 - 2015-04-15
-------------------
-
-Codename: Finders keepers.
-
-A bunch of new features and improvements.
-
-* Provide a mechanism for customizing how your tests are executed.
-* Provide a test runner that forks before running each example. This allows
-  better support for testing native code which might trigger a segfault or a C
-  level assertion failure.
-* Support for using Hypothesis to find examples directly rather than as just as
-  a test runner.
-* New streaming type which lets you generate infinite lazily loaded streams of
-  data - perfect for if you need a number of examples but don't know how many.
-* Better support for large integer ranges. You can now use integers_in_range
-  with ranges of basically any size. Previously large ranges would have eaten
-  up all your memory and taken forever.
-* Integers produce a wider range of data than before - previously they would
-  only rarely produce integers which didn't fit into a machine word. Now it's
-  much more common. This percolates to other numeric types which build on
-  integers.
-* Better validation of arguments to @given. Some situations that would
-  previously have caused silently wrong behaviour will now raise an error.
-* Include +/- sys.float_info.max in the set of floating point edge cases that
-  Hypothesis specifically tries.
-* Fix some bugs in floating point ranges which happen when given
-  +/- sys.float_info.max as one of the endpoints... (really any two floats that
-  are sufficiently far apart so that x, y are finite but y - x is infinite).
-  This would have resulted in generating infinite values instead of ones inside
-  the range.
-
-.. _v1.1.1:
-
-------------------
-1.1.1 - 2015-04-07
-------------------
-
-Codename: Nothing to see here
-
-This is just a patch release put out because it fixed some internal bugs that would
-block the Django integration release but did not actually affect anything anyone could
-previously have been using. It also contained a minor quality fix for floats that
-I'd happened to have finished in time.
-
-* Fix some internal bugs with object lifecycle management that were impossible to
-  hit with the previously released versions but broke hypothesis-django.
-* Bias floating point numbers somewhat less aggressively towards very small numbers
-
-
-.. _v1.1.0:
-
-------------------
-1.1.0 - 2015-04-06
-------------------
-
-Codename: No-one mention the M word.
-
-* Unicode strings are more strongly biased towards ascii characters. Previously they
-  would generate all over the space. This is mostly so that people who try to
-  shape their unicode strings with assume() have less of a bad time.
-* A number of fixes to data deserialization code that could theoretically have
-  caused mysterious bugs when using an old version of a Hypothesis example
-  database with a newer version. To the best of my knowledge a change that could
-  have triggered this bug has never actually been seen in the wild. Certainly
-  no-one ever reported a bug of this nature.
-* Out of the box support for Decimal and Fraction.
-* new dictionary specifier for dictionaries with variable keys.
-* Significantly faster and higher quality simplification, especially for
-  collections of data.
-* New filter() and flatmap() methods on Strategy for better ways of building
-  strategies out of other strategies.
-* New BasicStrategy class which allows you to define your own strategies from
-  scratch without needing an existing matching strategy or being exposed to the
-  full horror or non-public nature of the SearchStrategy interface.
-
-
-.. _v1.0.0:
-
-------------------
-1.0.0 - 2015-03-27
-------------------
-
-Codename: Blast-off!
-
-There are no code changes in this release. This is precisely the 0.9.2 release
-with some updated documentation.
-
-.. _v0.9.2:
-
-------------------
-0.9.2 - 2015-03-26
-------------------
-
-Codename: T-1 days.
-
-* floats_in_range would not actually have produced floats_in_range unless that
-  range happened to be (0, 1). Fix this.
-
-.. _v0.9.1:
-
-------------------
-0.9.1 - 2015-03-25
-------------------
-
-Codename: T-2 days.
-
-* Fix a bug where if you defined a strategy using map on a lambda then the results would not be saved in the database.
-* Significant performance improvements when simplifying examples using lists, strings or bounded integer ranges.
-
-.. _v0.9.0:
-
-------------------
-0.9.0 - 2015-03-23
-------------------
-
-Codename: The final countdown
-
-This release could also be called 1.0-RC1.
-
-It contains a teeny tiny bugfix, but the real point of this release is to declare
-feature freeze. There will be zero functionality changes between 0.9.0 and 1.0 unless
-something goes really really wrong. No new features will be added, no breaking API changes
-will occur, etc. This is the final shakedown before I declare Hypothesis stable and ready
-to use and throw a party to celebrate.
-
-Bug bounty for any bugs found between now and 1.0: I will buy you a drink (alcoholic,
-caffeinated, or otherwise) and shake your hand should we ever find ourselves in the
-same city at the same time.
-
-The one tiny bugfix:
-
-* Under pypy, databases would fail to close correctly when garbage collected, leading to a memory leak and a confusing error message if you were repeatedly creating databases and not closing them. It is very unlikely you were doing this and the chances of you ever having noticed this bug are very low.
-
-.. _v0.7.2:
-
-------------------
-0.7.2 - 2015-03-22
-------------------
-
-Codename: Hygienic macros or bust
-
-* You can now name an argument to @given 'f' and it won't break (:issue:`38`)
-* strategy_test_suite is now named strategy_test_suite as the documentation claims and not in fact strategy_test_suitee
-* Settings objects can now be used as a context manager to temporarily override the default values inside their context.
-
-
-.. _v0.7.1:
-
-------------------
-0.7.1 - 2015-03-21
-------------------
-
-Codename: Point releases go faster
-
-* Better string generation by parametrizing by a limited alphabet
-* Faster string simplification - previously if simplifying a string with high range unicode characters it would try every unicode character smaller than that. This was pretty pointless. Now it stops after it's a short range (it can still reach smaller ones through recursive calls because of other simplifying operations).
-* Faster list simplification by first trying a binary chop down the middle
-* Simultaneous simplification of identical elements in a list. So if a bug only triggers when you have duplicates but you drew e.g. -17, -17, this will now simplify to 0, 0.
-
-
-.. _v0.7.0,:
-
--------------------
-0.7.0, - 2015-03-20
--------------------
-
-Codename: Starting to look suspiciously real
-
-This is probably the last minor release prior to 1.0. It consists of stability
-improvements, a few usability things designed to make Hypothesis easier to try
-out, and filing off some final rough edges from the API.
-
-* Significant speed and memory usage improvements
-* Add an example() method to strategy objects to give an example of the sort of data that the strategy generates.
-* Remove .descriptor attribute of strategies
-* Rename descriptor_test_suite to strategy_test_suite
-* Rename the few remaining uses of descriptor to specifier (descriptor already has a defined meaning in Python)
-
-
-.. _v0.6.0:
-
----------------------------------------------------------
-0.6.0 - 2015-03-13
----------------------------------------------------------
-
-Codename: I'm sorry, were you using that API?
-
-This is primarily a "simplify all the weird bits of the API" release. As a result there are a lot of breaking changes. If
-you just use @given with core types then you're probably fine.
-
-In particular:
-
-* Stateful testing has been removed from the API
-* The way the database is used has been rendered less useful (sorry). The feature for reassembling values saved from other
-  tests doesn't currently work. This will probably be brought back in post 1.0.
-* SpecificationMapper is no longer a thing. Instead there is an ExtMethod called strategy which you extend to specify how
-  to convert other types to strategies.
-* Settings are now extensible so you can add your own for configuring a strategy
-* MappedSearchStrategy no longer needs an unpack method
-* Basically all the SearchStrategy internals have changed massively. If you implemented SearchStrategy directly rather than
-  using MappedSearchStrategy talk to me about fixing it.
-* Change to the way extra packages work. You now specify the package. This
-  must have a load() method. Additionally any modules in the package will be
-  loaded in under hypothesis.extra
-
-Bug fixes:
-
-* Fix for a bug where calling falsify on a lambda with a non-ascii character
-  in its body would error.
-
-Hypothesis Extra:
-
-hypothesis-fakefactory\: An extension for using faker data in hypothesis. Depends
-    on fake-factory.
-
-.. _v0.5.0:
-
-------------------
-0.5.0 - 2015-02-10
-------------------
-
-Codename: Read all about it.
-
-Core hypothesis:
-
-* Add support back in for pypy and python 3.2
-* @given functions can now be invoked with some arguments explicitly provided. If all arguments that hypothesis would have provided are passed in then no falsification is run.
-* Related to the above, this means that you can now use pytest fixtures and mark.parametrize with Hypothesis without either interfering with the other.
-* Breaking change: @given no longer works for functions with varargs (varkwargs are fine). This might be added back in at a later date.
-* Windows is now fully supported. A limited version (just the tests with none of the extras) of the test suite is run on windows with each commit so it is now a first class citizen of the Hypothesis world.
-* Fix a bug for fuzzy equality of equal complex numbers with different reprs (this can happen when one coordinate is zero). This shouldn't affect users - that feature isn't used anywhere public facing.
-* Fix generation of floats on windows and 32-bit builds of python. I was using some struct.pack logic that only worked on certain word sizes.
-* When a test times out and hasn't produced enough examples this now raises a Timeout subclass of Unfalsifiable.
-* Small search spaces are better supported. Previously something like a @given(bool, bool) would have failed because it couldn't find enough examples. Hypothesis is now aware of the fact that these are small search spaces and will not error in this case.
-* Improvements to parameter search in the case of hard to satisfy assume. Hypothesis will now spend less time exploring parameters that are unlikely to provide anything useful.
-* Increase chance of generating "nasty" floats
-* Fix a bug that would have caused unicode warnings if you had a sampled_from that was mixing unicode and byte strings.
-* Added a standard test suite that you can use to validate a custom strategy you've defined is working correctly.
-
-Hypothesis extra:
-
-First off, introducing Hypothesis extra packages!
-
-These are packages that are separated out from core Hypothesis because they have one or more dependencies. Every
-hypothesis-extra package is pinned to a specific point release of Hypothesis and will have some version requirements
-on its dependency. They use entry_points so you will usually not need to explicitly import them, just have them installed
-on the path.
-
-This release introduces two of them:
-
-hypothesis-datetime:
-
-Does what it says on the tin: Generates datetimes for Hypothesis. Just install the package and datetime support will start
-working.
-
-Depends on pytz for timezone support
-
-hypothesis-pytest:
-
-A very rudimentary pytest plugin. All it does right now is hook the display of falsifying examples into pytest reporting.
-
-Depends on pytest.
-
-
-.. _v0.4.3:
-
-------------------
-0.4.3 - 2015-02-05
-------------------
-
-Codename: TIL narrow Python builds are a thing
-
-This just fixes the one bug.
-
-* Apparently there is such a thing as a "narrow python build" and OS X ships with these by default
-  for python 2.7. These are builds where you only have two bytes worth of unicode. As a result,
-  generating unicode was completely broken on OS X. Fix this by only generating unicode codepoints
-  in the range supported by the system.
-
-
-.. _v0.4.2:
-
-------------------
-0.4.2 - 2015-02-04
-------------------
-
-Codename: O(dear)
-
-This is purely a bugfix release:
-
-* Provide sensible external hashing for all core types. This will significantly improve
-  performance of tracking seen examples which happens in literally every falsification
-  run. For Hypothesis fixing this cut 40% off the runtime of the test suite. The behaviour
-  is quadratic in the number of examples so if you're running the default configuration
-  this will be less extreme (Hypothesis's test suite runs at a higher number of examples
-  than default), but you should still see a significant improvement.
-* Fix a bug in formatting of complex numbers where the string could get incorrectly truncated.
-
-
-.. _v0.4.1:
-
-------------------
-0.4.1 - 2015-02-03
-------------------
-
-Codename: Cruel and unusual edge cases
-
-This release is mostly about better test case generation.
-
-Enhancements:
-
-* Has a cool release name
-* text_type (str in python 3, unicode in python 2) example generation now
-  actually produces interesting unicode instead of boring ascii strings.
-* floating point numbers are generated over a much wider range, with particular
-  attention paid to generating nasty numbers - nan, infinity, large and small
-  values, etc.
-* examples can be generated using pieces of examples previously saved in the
-  database. This allows interesting behaviour that has previously been discovered
-  to be propagated to other examples.
-* improved parameter exploration algorithm which should allow it to more reliably
-  hit interesting edge cases.
-* Timeout can now be disabled entirely by setting it to any value <= 0.
-
-
-Bug fixes:
-
-* The descriptor on a OneOfStrategy could be wrong if you had descriptors which
-  were equal but should not be coalesced. e.g. a strategy for one_of((frozenset({int}), {int}))
-  would have reported its descriptor as {int}. This is unlikely to have caused you
-  any problems
-* If you had strategies that could produce NaN (which float previously couldn't but
-  e.g. a Just(float('nan')) could) then this would have sent hypothesis into an infinite
-  loop that would have only been terminated when it hit the timeout.
-* Given elements that can take a long time to minimize, minimization of floats or tuples
-  could be quadratic or worse in the that value. You should now see much better performance
-  for simplification, albeit at some cost in quality.
-
-Other:
-
-* A lot of internals have been been rewritten. This shouldn't affect you at all, but
-  it opens the way for certain of hypothesis's oddities to be a lot more extensible by
-  users. Whether this is a good thing may be up for debate...
-
-
-.. _v0.4.0:
-
-------------------
-0.4.0 - 2015-01-21
-------------------
-
-FLAGSHIP FEATURE: Hypothesis now persists examples for later use. It stores
-data in a local SQLite database and will reuse it for all tests of the same
-type.
-
-LICENSING CHANGE: Hypothesis is now released under the Mozilla Public License
-2.0. This applies to all versions from 0.4.0 onwards until further notice.
-The previous license remains applicable to all code prior to 0.4.0.
-
-Enhancements:
-
-* Printing of failing examples. I was finding that the pytest runner was not
-  doing a good job of displaying these, and that Hypothesis itself could do
-  much better.
-* Drop dependency on six for cross-version compatibility. It was easy
-  enough to write the shim for the small set of features that we care about
-  and this lets us avoid a moderately complex dependency.
-* Some improvements to statistical distribution of selecting from small (<=
-  3 elements)
-* Improvements to parameter selection for finding examples.
-
-Bugs fixed:
-
-* could_have_produced for lists, dicts and other collections would not have
-  examined the elements and thus when using a union of different types of
-  list this could result in Hypothesis getting confused and passing a value
-  to the wrong strategy. This could potentially result in exceptions being
-  thrown from within simplification.
-* sampled_from would not work correctly on a single element list.
-* Hypothesis could get *very* confused by values which are
-  equal despite having different types being used in descriptors. Hypothesis
-  now has its own more specific version of equality it uses for descriptors
-  and tracking. It is always more fine grained than Python equality: Things
-  considered != are not considered equal by hypothesis, but some things that
-  are considered == are distinguished. If your test suite uses both frozenset
-  and set tests this bug is probably affecting you.
-
-.. _v0.3.2:
-
-------------------
-0.3.2 - 2015-01-16
-------------------
-
-* Fix a bug where if you specified floats_in_range with integer arguments
-  Hypothesis would error in example simplification.
-* Improve the statistical distribution of the floats you get for the
-  floats_in_range strategy. I'm not sure whether this will affect users in
-  practice but it took my tests for various conditions from flaky to rock
-  solid so it at the very least improves discovery of the artificial cases
-  I'm looking for.
-* Improved repr() for strategies and RandomWithSeed instances.
-* Add detection for flaky test cases where hypothesis managed to find an
-  example which breaks it but on the final invocation of the test it does
-  not raise an error. This will typically happen with too much recursion
-  errors but could conceivably happen in other circumstances too.
-* Provide a "derandomized" mode. This allows you to run hypothesis with
-  zero real randomization, making your build nice and deterministic. The
-  tests run with a seed calculated from the function they're testing so you
-  should still get a good distribution of test cases.
-* Add a mechanism for more conveniently defining tests which just sample
-  from some collection.
-* Fix for a really subtle bug deep in the internals of the strategy table.
-  In some circumstances if you were to define instance strategies for both
-  a parent class and one or more of its subclasses you would under some
-  circumstances get the strategy for the wrong superclass of an instance.
-  It is very unlikely anyone has ever encountered this in the wild, but it
-  is conceivably possible given that a mix of namedtuple and tuple are used
-  fairly extensively inside hypothesis which do exhibit this pattern of
-  strategy.
-
-
-.. _v0.3.1:
-
-------------------
-0.3.1 - 2015-01-13
-------------------
-
-* Support for generation of frozenset and Random values
-* Correct handling of the case where a called function mutates it argument.
-  This involved introducing a notion of a strategies knowing how to copy
-  their argument. The default method should be entirely acceptable and the
-  worst case is that it will continue to have the old behaviour if you
-  don't mark your strategy as mutable, so this shouldn't break anything.
-* Fix for a bug where some strategies did not correctly implement
-  could_have_produced. It is very unlikely that any of these would have
-  been seen in the wild, and the consequences if they had been would have
-  been minor.
-* Re-export the @given decorator from the main hypothesis namespace. It's
-  still available at the old location too.
-* Minor performance optimisation for simplifying long lists.
-
-
-.. _v0.3.0:
-
-------------------
-0.3.0 - 2015-01-12
-------------------
-
-* Complete redesign of the data generation system. Extreme breaking change
-  for anyone who was previously writing their own SearchStrategy
-  implementations. These will not work any more and you'll need to modify
-  them.
-* New settings system allowing more global and modular control of Verifier
-  behaviour.
-* Decouple SearchStrategy from the StrategyTable. This leads to much more
-  composable code which is a lot easier to understand.
-* A significant amount of internal API renaming and moving. This may also
-  break your code.
-* Expanded available descriptors, allowing for generating integers or
-  floats in a specific range.
-* Significantly more robust. A very large number of small bug fixes, none
-  of which anyone is likely to have ever noticed.
-* Deprecation of support for pypy and python 3 prior to 3.3. 3.3 and 3.4.
-  Supported versions are 2.7.x, 3.3.x, 3.4.x. I expect all of these to
-  remain officially supported for a very long time. I would not be
-  surprised to add pypy support back in later but I'm not going to do so
-  until I know someone cares about it. In the meantime it will probably
-  still work.
-
-
-.. _v0.2.2:
-
-------------------
-0.2.2 - 2015-01-08
-------------------
-
-* Fix an embarrassing complete failure of the installer caused by my being
-  bad at version control
-
-
-.. _v0.2.1:
-
-------------------
-0.2.1 - 2015-01-07
-------------------
-
-* Fix a bug in the new stateful testing feature where you could make
-  __init__ a @requires method. Simplification would not always work if the
-  prune method was able to successfully shrink the test.
-
-
-.. _v0.2.0:
-
-------------------
-0.2.0 - 2015-01-07
-------------------
-
-* It's aliiive.
-* Improve python 3 support using six.
-* Distinguish between byte and unicode types.
-* Fix issues where FloatStrategy could raise.
-* Allow stateful testing to request constructor args.
-* Fix for issue where test annotations would timeout based on when the
-  module was loaded instead of when the test started
-
-
-.. _v0.1.4:
-
-------------------
-0.1.4 - 2013-12-14
-------------------
-
-* Make verification runs time bounded with a configurable timeout
-
-
-.. _v0.1.3:
-
-------------------
-0.1.3 - 2013-05-03
-------------------
-
-* Bugfix: Stateful testing behaved incorrectly with subclassing.
-* Complex number support
-* support for recursive strategies
-* different error for hypotheses with unsatisfiable assumptions
-
-.. _v0.1.2:
-
-------------------
-0.1.2 - 2013-03-24
-------------------
-
-* Bugfix: Stateful testing was not minimizing correctly and could
-  throw exceptions.
-* Better support for recursive strategies.
-* Support for named tuples.
-* Much faster integer generation.
-
-
-.. _v0.1.1:
-
-------------------
-0.1.1 - 2013-03-24
-------------------
-
-* Python 3.x support via 2to3.
-* Use new style classes (oops).
-
-
-.. _v0.1.0:
-
-------------------
-0.1.0 - 2013-03-23
-------------------
-
-* Introduce stateful testing.
-* Massive rewrite of internals to add flags and strategies.
-
-
-.. _v0.0.5:
-
-------------------
-0.0.5 - 2013-03-13
-------------------
-
-* No changes except trying to fix packaging
-
-.. _v0.0.4:
-
-------------------
-0.0.4 - 2013-03-13
-------------------
-
-* No changes except that I checked in a failing test case for 0.0.3
-  so had to replace the release. Doh
-
-.. _v0.0.3:
-
-------------------
-0.0.3 - 2013-03-13
-------------------
-
-* Improved a few internals.
-* Opened up creating generators from instances as a general API.
-* Test integration.
-
-.. _v0.0.2:
-
-------------------
-0.0.2 - 2013-03-12
-------------------
-
-* Starting to tighten up on the internals.
-* Change API to allow more flexibility in configuration.
-* More testing.
-
-.. _v0.0.1:
-
-------------------
-0.0.1 - 2013-03-10
-------------------
-
-* Initial release.
-* Basic working prototype. Demonstrates idea, probably shouldn't be used.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/community.rst Deleted

@@ -1,43 +0,0 @@
-=========
-Community
-=========
-
-The Hypothesis community is small for the moment but is full of excellent people
-who can answer your questions and help you out. Please do join us.
-The major place for community discussion is `the mailing list <https://groups.google.com/forum/#!forum/hypothesis-users>`_.
-
-Feel free to use it to ask for help, provide feedback, or discuss anything remotely
-Hypothesis related at all.  If you post a question on Stack Overflow, please use the
-`python-hypothesis <https://stackoverflow.com/questions/tagged/python-hypothesis>`__ tag!
-
-Please note that :gh-file:`the Hypothesis code of conduct <CODE_OF_CONDUCT.rst>`
-applies in all Hypothesis community spaces.
-
-If you would like to cite Hypothesis, please consider :gh-file:`our suggested citation <CITATION.cff>`.
-
-If you like repo badges, we suggest the following badge, which you can add
-with reStructuredText or Markdown, respectively:
-
-.. image:: https://img.shields.io/badge/hypothesis-tested-brightgreen.svg
-
-.. code:: restructuredtext
-
-    .. image:: https://img.shields.io/badge/hypothesis-tested-brightgreen.svg
-       :alt: Tested with Hypothesis
-       :target: https://hypothesis.readthedocs.io
-
-.. code:: md
-
-    !Tested with Hypothesis(https://img.shields.io/badge/hypothesis-tested-brightgreen.svg)(https://hypothesis.readthedocs.io/)
-
-Finally, we have a beautiful logo which appears online, and often on stickers:
-
-.. image:: ../../brand/dragonfly-rainbow.svg
-   :alt: The Hypothesis logo, a dragonfly with rainbow wings
-   :align: center
-   :width: 50 %
-
-As well as being beautiful, dragonflies actively hunt down bugs for a living!
-You can find the images and a usage guide in the :gh-file:`brand` directory on
-GitHub, or find us at conferences where we often have stickers and sometimes
-other swag.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/conf.py Deleted

@@ -1,151 +0,0 @@
-# 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 datetime
-import os
-import sys
-import types
-
-import sphinx_rtd_theme
-
-sys.path.append(os.path.join(os.path.dirname(__file__), "..", "src"))
-
-
-autodoc_member_order = "bysource"
-autodoc_typehints = "none"
-
-extensions = 
-    "sphinx.ext.autodoc",
-    "sphinx.ext.extlinks",
-    "sphinx.ext.viewcode",
-    "sphinx.ext.intersphinx",
-    "hoverxref.extension",
-    "sphinx_codeautolink",
-    "sphinx_selective_exclude.eager_only",
-
-
-templates_path = "_templates"
-
-source_suffix = ".rst"
-
-# The master toctree document.
-master_doc = "index"
-
-# General information about the project.
-project = "Hypothesis"
-author = "David R. MacIver"
-copyright = f"2013-{datetime.datetime.utcnow().year}, {author}"
-
-_d = {}
-with open(
-    os.path.join(os.path.dirname(__file__), "..", "src", "hypothesis", "version.py")
-) as f:
-    exec(f.read(), _d)
-    version = _d"__version__"
-    release = _d"__version__"
-
-
-def setup(app):
-    if os.path.isfile(os.path.join(os.path.dirname(__file__), "..", "RELEASE.rst")):
-        app.tags.add("has_release_file")
-
-    # patch in mock array_api namespace so we can autodoc it
-    from hypothesis.extra.array_api import make_strategies_namespace, mock_xp
-
-    mod = types.ModuleType("xps")
-    mod.__dict__.update(make_strategies_namespace(mock_xp).__dict__)
-    assert "xps" not in sys.modules
-    sys.modules"xps" = mod
-
-
-language = None
-
-exclude_patterns = "_build"
-
-pygments_style = "sphinx"
-
-todo_include_todos = False
-
-# See https://sphinx-hoverxref.readthedocs.io/en/latest/configuration.html
-hoverxref_auto_ref = True
-hoverxref_domains = "py"
-
-intersphinx_mapping = {
-    "python": ("https://docs.python.org/3/", None),
-    "numpy": ("https://numpy.org/doc/stable/", None),
-    "pandas": ("https://pandas.pydata.org/pandas-docs/stable/", None),
-    "pytest": ("https://docs.pytest.org/en/stable/", None),
-    "django": ("https://django.readthedocs.io/en/stable/", None),
-    "dateutil": ("https://dateutil.readthedocs.io/en/stable/", None),
-    "redis": ("https://redis-py.readthedocs.io/en/stable/", None),
-    "attrs": ("https://www.attrs.org/en/stable/", None),
-    "sphinx": ("https://www.sphinx-doc.org/en/master/", None),
-}
-
-autodoc_mock_imports = "numpy", "pandas", "redis"
-
-codeautolink_autodoc_inject = False
-codeautolink_global_preface = """
-from hypothesis import *
-import hypothesis.strategies as st
-from hypothesis.strategies import *
-"""
-
-# This config value must be a dictionary of external sites, mapping unique
-# short alias names to a base URL and a prefix.
-# See http://sphinx-doc.org/ext/extlinks.html
-_repo = "https://github.com/HypothesisWorks/hypothesis/"
-extlinks = {
-    "commit": (_repo + "commit/%s", "commit "),
-    "gh-file": (_repo + "blob/master/%s", ""),
-    "gh-link": (_repo + "%s", ""),
-    "issue": (_repo + "issues/%s", "issue #"),
-    "pull": (_repo + "pull/%s", "pull request #"),
-    "pypi": ("https://pypi.org/project/%s/", ""),
-    "bpo": ("https://bugs.python.org/issue%s", "bpo-"),
-    "xp-ref": ("https://data-apis.org/array-api/latest/API_specification/%s", ""),
-    "wikipedia": ("https://en.wikipedia.org/wiki/%s", ""),
-}
-
-# -- Options for HTML output ----------------------------------------------
-
-html_theme = "sphinx_rtd_theme"
-
-html_theme_path = sphinx_rtd_theme.get_html_theme_path()
-
-html_static_path = "_static"
-
-htmlhelp_basename = "Hypothesisdoc"
-
-html_favicon = "../../brand/favicon.ico"
-
-html_logo = "../../brand/dragonfly-rainbow-150w.svg"
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {}
-
-latex_documents = 
-    (master_doc, "Hypothesis.tex", "Hypothesis Documentation", author, "manual")
-
-
-man_pages = (master_doc, "hypothesis", "Hypothesis Documentation", author, 1)
-
-texinfo_documents = 
-    (
-        master_doc,
-        "Hypothesis",
-        "Hypothesis Documentation",
-        author,
-        "Hypothesis",
-        "Advanced property-based testing for Python.",
-        "Miscellaneous",
-    )
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/data.rst Deleted

@@ -1,379 +0,0 @@
-=============================
-What you can generate and how
-=============================
-
-*Most things should be easy to generate and everything should be possible.*
-
-To support this principle Hypothesis provides strategies for most built-in
-types with arguments to constrain or adjust the output, as well as higher-order
-strategies that can be composed to generate more complex types.
-
-This document is a guide to what strategies are available for generating data
-and how to build them. Strategies have a variety of other important internal
-features, such as how they simplify, but the data they can generate is the only
-public part of their API.
-
-~~~~~~~~~~~~~~~
-Core strategies
-~~~~~~~~~~~~~~~
-
-Functions for building strategies are all available in the hypothesis.strategies
-module. The salient functions from it are as follows:
-
-.. automodule:: hypothesis.strategies
-  :members:
-  :exclude-members: SearchStrategy
-
-~~~~~~~~~~~~~~~~~~~~~~
-Provisional strategies
-~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: hypothesis.provisional
-  :members:
-  :exclude-members: DomainNameStrategy
-
-.. _shrinking:
-
-~~~~~~~~~
-Shrinking
-~~~~~~~~~
-
-When using strategies it is worth thinking about how the data *shrinks*.
-Shrinking is the process by which Hypothesis tries to produce human readable
-examples when it finds a failure - it takes a complex example and turns it
-into a simpler one.
-
-Each strategy defines an order in which it shrinks - you won't usually need to
-care about this much, but it can be worth being aware of as it can affect what
-the best way to write your own strategies is.
-
-The exact shrinking behaviour is not a guaranteed part of the API, but it
-doesn't change that often and when it does it's usually because we think the
-new way produces nicer examples.
-
-Possibly the most important one to be aware of is
-:func:`~hypothesis.strategies.one_of`, which has a preference for values
-produced by strategies earlier in its argument list. Most of the others should
-largely "do the right thing" without you having to think about it.
-
-
-~~~~~~~~~~~~~~~~~~~
-Adapting strategies
-~~~~~~~~~~~~~~~~~~~
-
-Often it is the case that a strategy doesn't produce exactly what you want it
-to and you need to adapt it. Sometimes you can do this in the test, but this
-hurts reuse because you then have to repeat the adaption in every test.
-
-Hypothesis gives you ways to build strategies from other strategies given
-functions for transforming the data.
-
--------
-Mapping
--------
-
-``map`` is probably the easiest and most useful of these to use. If you have a
-strategy ``s`` and a function ``f``, then an example ``s.map(f).example()`` is
-``f(s.example())``, i.e. we draw an example from ``s`` and then apply ``f`` to it.
-
-e.g.:
-
-.. code-block:: pycon
-
-    >>> lists(integers()).map(sorted).example()
-    -25527, -24245, -23118, -93, -70, -7, 0, 39, 40, 65, 88, 112, 6189, 9480, 19469, 27256, 32526, 1566924430
-
-Note that many things that you might use mapping for can also be done with
-:func:`~hypothesis.strategies.builds`, and if you find yourself indexing
-into a tuple within ``.map()`` it's probably time to use that instead.
-
-.. _filtering:
-
----------
-Filtering
----------
-
-``filter`` lets you reject some examples. ``s.filter(f).example()`` is some
-example of ``s`` such that ``f(example)`` is truthy.
-
-.. code-block:: pycon
-
-    >>> integers().filter(lambda x: x > 11).example()
-    26126
-    >>> integers().filter(lambda x: x > 11).example()
-    23324
-
-It's important to note that ``filter`` isn't magic and if your condition is too
-hard to satisfy then this can fail:
-
-.. code-block:: pycon
-
-    >>> integers().filter(lambda x: False).example()
-    Traceback (most recent call last):
-        ...
-    hypothesis.errors.Unsatisfiable: Could not find any valid examples in 20 tries
-
-In general you should try to use ``filter`` only to avoid corner cases that you
-don't want rather than attempting to cut out a large chunk of the search space.
-
-A technique that often works well here is to use map to first transform the data
-and then use ``filter`` to remove things that didn't work out. So for example if
-you wanted pairs of integers (x,y) such that x < y you could do the following:
-
-
-.. code-block:: pycon
-
-    >>> tuples(integers(), integers()).map(sorted).filter(lambda x: x0 < x1).example()
-    -8543729478746591815, 3760495307320535691
-
-.. _flatmap:
-
-----------------------------
-Chaining strategies together
-----------------------------
-
-Finally there is ``flatmap``. ``flatmap`` draws an example, then turns that
-example into a strategy, then draws an example from *that* strategy.
-
-It may not be obvious why you want this at first, but it turns out to be
-quite useful because it lets you generate different types of data with
-relationships to each other.
-
-For example suppose we wanted to generate a list of lists of the same
-length:
-
-.. code-block:: pycon
-
-    >>> rectangle_lists = integers(min_value=0, max_value=10).flatmap(
-    ...     lambda n: lists(lists(integers(), min_size=n, max_size=n))
-    ... )
-    >>> rectangle_lists.example()
-    
-    >>> rectangle_lists.filter(lambda x: len(x) >= 10).example()
-    , , , , , , , , , 
-    >>> rectangle_lists.filter(lambda t: len(t) >= 3 and len(t0) >= 3).example()
-    0, 0, 0, 0, 0, 0, 0, 0, 0
-    >>> rectangle_lists.filter(lambda t: sum(len(s) for s in t) >= 10).example()
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-
-In this example we first choose a length for our tuples, then we build a
-strategy which generates lists containing lists precisely of that length. The
-finds show what simple examples for this look like.
-
-Most of the time you probably don't want ``flatmap``, but unlike ``filter`` and
-``map`` which are just conveniences for things you could just do in your tests,
-``flatmap`` allows genuinely new data generation that you wouldn't otherwise be
-able to easily do.
-
-(If you know Haskell: Yes, this is more or less a monadic bind. If you don't
-know Haskell, ignore everything in these parentheses. You do not need to
-understand anything about monads to use this, or anything else in Hypothesis).
-
-
---------------
-Recursive data
---------------
-
-Sometimes the data you want to generate has a recursive definition. e.g. if you
-wanted to generate JSON data, valid JSON is:
-
-1. Any float, any boolean, any unicode string.
-2. Any list of valid JSON data
-3. Any dictionary mapping unicode strings to valid JSON data.
-
-The problem is that you cannot call a strategy recursively and expect it to not just
-blow up and eat all your memory.  The other problem here is that not all unicode strings
-display consistently on different machines, so we'll restrict them in our doctest.
-
-The way Hypothesis handles this is with the :func:`~hypothesis.strategies.recursive`
-strategy which you pass in a base case and a function that, given a strategy
-for your data type, returns a new strategy for it. So for example:
-
-.. code-block:: pycon
-
-    >>> from string import printable
-    ... from pprint import pprint
-    >>> json = recursive(
-    ...     none() | booleans() | floats() | text(printable),
-    ...     lambda children: lists(children) | dictionaries(text(printable), children),
-    ... )
-    >>> pprint(json.example())
-    1.175494351e-38, '', 1.9, True, False, '.M}Xl', '', True
-    >>> pprint(json.example())
-    {'de(l': None,
-     'nK': {'(Rt)': None,
-            '+hoZh1YUgy8': True,
-            '8zEIFA06^li^': 'LFE{Q',
-            '9,': 'l{cA=/'}}
-
-That is, we start with our leaf data and then we augment it by allowing lists and dictionaries of anything we can generate as JSON data.
-
-The size control of this works by limiting the maximum number of values that can be drawn from the base strategy. So for example if
-we wanted to only generate really small JSON we could do this as:
-
-
-.. code-block:: pycon
-
-    >>> small_lists = recursive(booleans(), lists, max_leaves=5)
-    >>> small_lists.example()
-    True
-    >>> small_lists.example()
-    False
-
-.. _composite-strategies:
-
-~~~~~~~~~~~~~~~~~~~~
-Composite strategies
-~~~~~~~~~~~~~~~~~~~~
-
-The :func:`@composite <hypothesis.strategies.composite>` decorator lets
-you combine other strategies in more or less
-arbitrary ways. It's probably the main thing you'll want to use for
-complicated custom strategies.
-
-The composite decorator works by converting a function that returns one
-example into a function that returns a strategy that produces such
-examples - which you can pass to :func:`@given <hypothesis.given>`, modify
-with ``.map`` or ``.filter``, and generally use like any other strategy.
-
-It does this by giving you a special function ``draw`` as the first
-argument, which can be used just like the corresponding method of the
-:func:`~hypothesis.strategies.data` strategy within a test.  In fact,
-the implementation is almost the same - but defining a strategy with
-:func:`@composite <hypothesis.strategies.composite>` makes code reuse
-easier, and usually improves the display of failing examples.
-
-For example, the following gives you a list and an index into it:
-
-.. code-block:: pycon
-
-    >>> @composite
-    ... def list_and_index(draw, elements=integers()):
-    ...     xs = draw(lists(elements, min_size=1))
-    ...     i = draw(integers(min_value=0, max_value=len(xs) - 1))
-    ...     return (xs, i)
-    ...
-
-``draw(s)`` is a function that should be thought of as returning ``s.example()``,
-except that the result is reproducible and will minimize correctly. The
-decorated function has the initial argument removed from the list, but will
-accept all the others in the expected order. Defaults are preserved.
-
-.. code-block:: pycon
-
-    >>> list_and_index()
-    list_and_index()
-    >>> list_and_index().example()
-    (15949, -35, 21764, 8167, 1607867656, -41, 104, 19, -90, 520116744169390387, 7107438879249457973, 0)
-
-    >>> list_and_index(booleans())
-    list_and_index(elements=booleans())
-    >>> list_and_index(booleans()).example()
-    (True, False, 0)
-
-Note that the repr will work exactly like it does for all the built-in
-strategies: it will be a function that you can call to get the strategy in
-question, with values provided only if they do not match the defaults.
-
-You can use :func:`assume <hypothesis.assume>` inside composite functions:
-
-.. code-block:: python
-
-    @composite
-    def distinct_strings_with_common_characters(draw):
-        x = draw(text(min_size=1))
-        y = draw(text(alphabet=x))
-        assume(x != y)
-        return (x, y)
-
-This works as :func:`assume <hypothesis.assume>` normally would, filtering out any examples for which the
-passed in argument is falsey.
-
-Take care that your function can cope with adversarial draws, or explicitly rejects
-them using the ``.filter()`` method or :func:`~hypothesis.assume` - our mutation
-and shrinking logic can do some strange things, and a naive implementation might
-lead to serious performance problems.  For example:
-
-.. code-block:: python
-
-    @composite
-    def reimplementing_sets_strategy(draw, elements=st.integers(), size=5):
-        # The bad way: if Hypothesis keeps generating e.g. zero,
-        # we'll keep looping for a very long time.
-        result = set()
-        while len(result) < size:
-            result.add(draw(elements))
-        # The good way: use a filter, so Hypothesis can tell what's valid!
-        for _ in range(size):
-            result.add(draw(elements.filter(lambda x: x not in result)))
-        return result
-
-If :func:`@composite <hypothesis.strategies.composite>` is used to decorate a
-method or classmethod, the ``draw`` argument must come before ``self`` or ``cls``.
-While we therefore recommend writing strategies as standalone functions and using
-the :func:`~hypothesis.strategies.register_type_strategy` function to associate
-them with a class, methods are supported and the ``@composite`` decorator may be
-applied either before or after ``@classmethod`` or ``@staticmethod``.
-See :issue:`2578` and :pull:`2634` for more details.
-
-
-.. _interactive-draw:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Drawing interactively in tests
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-There is also the :func:`~hypothesis.strategies.data` strategy, which gives you a means of using
-strategies interactively. Rather than having to specify everything up front in
-:func:`@given <hypothesis.given>` you can draw from strategies in the body of your test.
-
-This is similar to :func:`@composite <hypothesis.strategies.composite>`, but
-even more powerful as it allows you to mix test code with example generation.
-The downside of this power is that :func:`~hypothesis.strategies.data` is
-incompatible with explicit :func:`@example(...) <hypothesis.example>`\ s -
-and the mixed code is often harder to debug when something goes wrong.
-
-If you need values that are affected by previous draws but which *don't* depend
-on the execution of your test, stick to the simpler
-:func:`@composite <hypothesis.strategies.composite>`.
-
-.. code-block:: python
-
-    @given(data())
-    def test_draw_sequentially(data):
-        x = data.draw(integers())
-        y = data.draw(integers(min_value=x))
-        assert x < y
-
-If the test fails, each draw will be printed with the falsifying example. e.g.
-the above is wrong (it has a boundary condition error), so will print:
-
-.. code-block:: pycon
-
-    Falsifying example: test_draw_sequentially(data=data(...))
-    Draw 1: 0
-    Draw 2: 0
-
-As you can see, data drawn this way is simplified as usual.
-
-Optionally, you can provide a label to identify values generated by each call
-to ``data.draw()``.  These labels can be used to identify values in the output
-of a falsifying example.
-
-For instance:
-
-.. code-block:: python
-
-    @given(data())
-    def test_draw_sequentially(data):
-        x = data.draw(integers(), label="First number")
-        y = data.draw(integers(min_value=x), label="Second number")
-        assert x < y
-
-will produce the output:
-
-.. code-block:: pycon
-
-    Falsifying example: test_draw_sequentially(data=data(...))
-    Draw 1 (First number): 0
-    Draw 2 (Second number): 0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/database.rst Deleted

@@ -1,58 +0,0 @@
-===============================
-The Hypothesis example database
-===============================
-
-When Hypothesis finds a bug it stores enough information in its database to reproduce it. This
-enables you to have a classic testing workflow of find a bug, fix a bug, and be confident that
-this is actually doing the right thing because Hypothesis will start by retrying the examples that
-broke things last time.
-
------------
-Limitations
------------
-
-The database is best thought of as a cache that you never need to invalidate: Information may be
-lost when you upgrade a Hypothesis version or change your test, so you shouldn't rely on it for
-correctness - if there's an example you want to ensure occurs each time then :ref:`there's a feature for
-including them in your source code <providing-explicit-examples>` - but it helps the development
-workflow considerably by making sure that the examples you've just found are reproduced.
-
-The database also records examples that exercise less-used parts of your
-code, so the database may update even when no failing examples were found.
-
---------------------------------------------
-Upgrading Hypothesis and changing your tests
---------------------------------------------
-
-The design of the Hypothesis database is such that you can put arbitrary data in the database
-and not get wrong behaviour. When you upgrade Hypothesis, old data *might* be invalidated, but
-this should happen transparently. It can never be the case that e.g. changing the strategy
-that generates an argument gives you data from the old strategy.
-
--------------------------------
-ExampleDatabase implementations
--------------------------------
-
-Hypothesis' default :obj:`~hypothesis.settings.database` setting creates a
-:class:`~hypothesis.database.DirectoryBasedExampleDatabase` in your current working directory,
-under ``.hypothesis/examples``.  If this location is unusable, e.g. because you do not have
-read or write permissions, Hypothesis will emit a warning and fall back to an
-:class:`~hypothesis.database.InMemoryExampleDatabase`.
-
-Hypothesis provides the following :class:`~hypothesis.database.ExampleDatabase` implementations:
-
-.. autoclass:: hypothesis.database.InMemoryExampleDatabase
-.. autoclass:: hypothesis.database.DirectoryBasedExampleDatabase
-.. autoclass:: hypothesis.database.ReadOnlyDatabase
-.. autoclass:: hypothesis.database.MultiplexedDatabase
-.. autoclass:: hypothesis.extra.redis.RedisExampleDatabase
-
----------------------------------
-Defining your own ExampleDatabase
----------------------------------
-
-You can define your :class:`~hypothesis.database.ExampleDatabase`, for example
-to use a shared datastore, with just a few methods:
-
-.. autoclass:: hypothesis.database.ExampleDatabase
-   :members:

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/details.rst Deleted

@@ -1,830 +0,0 @@
-=============================
-Details and advanced features
-=============================
-
-This is an account of slightly less common Hypothesis features that you don't need
-to get started but will nevertheless make your life easier.
-
-
-----------------------
-Additional test output
-----------------------
-
-Normally the output of a failing test will look something like:
-
-.. code::
-
-    Falsifying example: test_a_thing(x=1, y="foo")
-
-With the ``repr`` of each keyword argument being printed.
-
-Sometimes this isn't enough, either because you have a value with a
-``__repr__()`` method that isn't very descriptive or because you need to see the output of some
-intermediate steps of your test. That's where the ``note`` function comes in:
-
-.. autofunction:: hypothesis.note
-
-.. code-block:: pycon
-
-    >>> from hypothesis import given, note, strategies as st
-    >>> @given(st.lists(st.integers()), st.randoms())
-    ... def test_shuffle_is_noop(ls, r):
-    ...     ls2 = list(ls)
-    ...     r.shuffle(ls2)
-    ...     note(f"Shuffle: {ls2!r}")
-    ...     assert ls == ls2
-    ...
-    >>> try:
-    ...     test_shuffle_is_noop()
-    ... except AssertionError:
-    ...     print("ls != ls2")
-    ...
-    Falsifying example: test_shuffle_is_noop(ls=0, 1, r=RandomWithSeed(1))
-    Shuffle: 1, 0
-    ls != ls2
-
-The note is printed for the minimal failing example of the test in order to include any
-additional information you might need in your test.
-
-
-.. _statistics:
-
----------------
-Test statistics
----------------
-
-If you are using :pypi:`pytest` you can see a number of statistics about the executed tests
-by passing the command line argument ``--hypothesis-show-statistics``. This will include
-some general statistics about the test:
-
-For example if you ran the following with ``--hypothesis-show-statistics``:
-
-.. code-block:: python
-
-  from hypothesis import given, strategies as st
-
-
-  @given(st.integers())
-  def test_integers(i):
-      pass
-
-
-You would see:
-
-.. code-block:: none
-
-    - during generate phase (0.06 seconds):
-        - Typical runtimes: < 1ms, ~ 47% in data generation
-        - 100 passing examples, 0 failing examples, 0 invalid examples
-    - Stopped because settings.max_examples=100
-
-The final "Stopped because" line is particularly important to note: It tells you the
-setting value that determined when the test should stop trying new examples. This
-can be useful for understanding the behaviour of your tests. Ideally you'd always want
-this to be :obj:`~hypothesis.settings.max_examples`.
-
-In some cases (such as filtered and recursive strategies) you will see events mentioned
-which describe some aspect of the data generation:
-
-.. code-block:: python
-
-  from hypothesis import given, strategies as st
-
-
-  @given(st.integers().filter(lambda x: x % 2 == 0))
-  def test_even_integers(i):
-      pass
-
-You would see something like:
-
-.. code-block:: none
-
-  test_even_integers:
-
-    - during generate phase (0.08 seconds):
-        - Typical runtimes: < 1ms, ~ 57% in data generation
-        - 100 passing examples, 0 failing examples, 12 invalid examples
-        - Events:
-          * 51.79%, Retried draw from integers().filter(lambda x: x % 2 == 0) to satisfy filter
-          * 10.71%, Aborted test because unable to satisfy integers().filter(lambda x: x % 2 == 0)
-    - Stopped because settings.max_examples=100
-
-You can also mark custom events in a test using the ``event`` function:
-
-.. autofunction:: hypothesis.event
-
-.. code:: python
-
-  from hypothesis import event, given, strategies as st
-
-
-  @given(st.integers().filter(lambda x: x % 2 == 0))
-  def test_even_integers(i):
-      event(f"i mod 3 = {i%3}")
-
-
-You will then see output like:
-
-.. code-block:: none
-
-  test_even_integers:
-
-    - during generate phase (0.09 seconds):
-        - Typical runtimes: < 1ms, ~ 59% in data generation
-        - 100 passing examples, 0 failing examples, 32 invalid examples
-        - Events:
-          * 54.55%, Retried draw from integers().filter(lambda x: x % 2 == 0) to satisfy filter
-          * 31.06%, i mod 3 = 2
-          * 28.79%, i mod 3 = 0
-          * 24.24%, Aborted test because unable to satisfy integers().filter(lambda x: x % 2 == 0)
-          * 15.91%, i mod 3 = 1
-    - Stopped because settings.max_examples=100
-
-Arguments to ``event`` can be any hashable type, but two events will be considered the same
-if they are the same when converted to a string with :obj:`python:str`.
-
-------------------
-Making assumptions
-------------------
-
-Sometimes Hypothesis doesn't give you exactly the right sort of data you want - it's
-mostly of the right shape, but some examples won't work and you don't want to care about
-them. You *can* just ignore these by aborting the test early, but this runs the risk of
-accidentally testing a lot less than you think you are. Also it would be nice to spend
-less time on bad examples - if you're running 100 examples per test (the default) and
-it turns out 70 of those examples don't match your needs, that's a lot of wasted time.
-
-.. autofunction:: hypothesis.assume
-
-For example suppose you had the following test:
-
-
-.. code:: python
-
-  @given(floats())
-  def test_negation_is_self_inverse(x):
-      assert x == -(-x)
-
-
-Running this gives us:
-
-.. code::
-
-  Falsifying example: test_negation_is_self_inverse(x=float('nan'))
-  AssertionError
-
-This is annoying. We know about `NaN <https://docs.python.org/3/library/math.html>`__
-and don't really care about it, but as soon as Hypothesis
-finds a NaN example it will get distracted by that and tell us about it. Also
-the test will fail and we want it to pass.
-
-So let's block off this particular example:
-
-.. code:: python
-
-  from math import isnan
-
-
-  @given(floats())
-  def test_negation_is_self_inverse_for_non_nan(x):
-      assume(not isnan(x))
-      assert x == -(-x)
-
-And this passes without a problem.
-
-In order to avoid the easy trap where you assume a lot more than you intended, Hypothesis
-will fail a test when it can't find enough examples passing the assumption.
-
-If we'd written:
-
-.. code:: python
-
-  @given(floats())
-  def test_negation_is_self_inverse_for_non_nan(x):
-      assume(False)
-      assert x == -(-x)
-
-Then on running we'd have got the exception:
-
-.. code::
-
-  Unsatisfiable: Unable to satisfy assumptions of hypothesis test_negation_is_self_inverse_for_non_nan. Only 0 examples considered satisfied assumptions
-
-~~~~~~~~~~~~~~~~~~~
-How good is assume?
-~~~~~~~~~~~~~~~~~~~
-
-Hypothesis has an adaptive exploration strategy to try to avoid things which falsify
-assumptions, which should generally result in it still being able to find examples in
-hard to find situations.
-
-Suppose we had the following:
-
-
-.. code:: python
-
-  @given(lists(integers()))
-  def test_sum_is_positive(xs):
-      assert sum(xs) > 0
-
-Unsurprisingly this fails and gives the falsifying example ````.
-
-Adding ``assume(xs)`` to this removes the trivial empty example and gives us ``0``.
-
-Adding ``assume(all(x > 0 for x in xs))`` and it passes: the sum of a list of
-positive integers is positive.
-
-The reason that this should be surprising is not that it doesn't find a
-counter-example, but that it finds enough examples at all.
-
-In order to make sure something interesting is happening, suppose we wanted to
-try this for long lists. e.g. suppose we added an ``assume(len(xs) > 10)`` to it.
-This should basically never find an example: a naive strategy would find fewer
-than one in a thousand examples, because if each element of the list is
-negative with probability one-half, you'd have to have ten of these go the right
-way by chance. In the default configuration Hypothesis gives up long before
-it's tried 1000 examples (by default it tries 200).
-
-Here's what happens if we try to run this:
-
-
-.. code:: python
-
-  @given(lists(integers()))
-  def test_sum_is_positive(xs):
-      assume(len(xs) > 10)
-      assume(all(x > 0 for x in xs))
-      print(xs)
-      assert sum(xs) > 0
-
-
-In: ``test_sum_is_positive()``
-
-.. code:: python
-
-  17, 12, 7, 13, 11, 3, 6, 9, 8, 11, 47, 27, 1, 31, 1
-  6, 2, 29, 30, 25, 34, 19, 15, 50, 16, 10, 3, 16
-  25, 17, 9, 19, 15, 2, 2, 4, 22, 10, 10, 27, 3, 1, 14, 17, 13, 8, 16, 9, 2, ...
-  17, 65, 78, 1, 8, 29, 2, 79, 28, 18, 39
-  13, 26, 8, 3, 4, 76, 6, 14, 20, 27, 21, 32, 14, 42, 9, 24, 33, 9, 5, 15, ...
-  2, 1, 2, 2, 3, 10, 12, 11, 21, 11, 1, 16
-
-As you can see, Hypothesis doesn't find *many* examples here, but it finds some - enough to
-keep it happy.
-
-In general if you *can* shape your strategies better to your tests you should - for example
-:py:func:`integers(1, 1000) <hypothesis.strategies.integers>` is a lot better than
-``assume(1 <= x <= 1000)``, but ``assume`` will take you a long way if you can't.
-
----------------------
-Defining strategies
----------------------
-
-The type of object that is used to explore the examples given to your test
-function is called a :class:`~hypothesis.strategies.SearchStrategy`.
-These are created using the functions
-exposed in the :mod:`hypothesis.strategies` module.
-
-Many of these strategies expose a variety of arguments you can use to customize
-generation. For example for integers you can specify ``min`` and ``max`` values of
-integers you want.
-If you want to see exactly what a strategy produces you can ask for an example:
-
-.. code-block:: pycon
-
-    >>> integers(min_value=0, max_value=10).example()
-    1
-
-Many strategies are built out of other strategies. For example, if you want
-to define a tuple you need to say what goes in each element:
-
-.. code-block:: pycon
-
-    >>> from hypothesis.strategies import tuples
-    >>> tuples(integers(), integers()).example()
-    (-24597, 12566)
-
-Further details are :doc:`available in a separate document <data>`.
-
-------------------------------------
-The gory details of given parameters
-------------------------------------
-
-.. autofunction:: hypothesis.given
-
-The :func:`@given <hypothesis.given>` decorator may be used to specify
-which arguments of a function should be parametrized over. You can use
-either positional or keyword arguments, but not a mixture of both.
-
-For example all of the following are valid uses:
-
-.. code:: python
-
-  @given(integers(), integers())
-  def a(x, y):
-      pass
-
-
-  @given(integers())
-  def b(x, y):
-      pass
-
-
-  @given(y=integers())
-  def c(x, y):
-      pass
-
-
-  @given(x=integers())
-  def d(x, y):
-      pass
-
-
-  @given(x=integers(), y=integers())
-  def e(x, **kwargs):
-      pass
-
-
-  @given(x=integers(), y=integers())
-  def f(x, *args, **kwargs):
-      pass
-
-
-  class SomeTest(TestCase):
-      @given(integers())
-      def test_a_thing(self, x):
-          pass
-
-The following are not:
-
-.. code:: python
-
-  @given(integers(), integers(), integers())
-  def g(x, y):
-      pass
-
-
-  @given(integers())
-  def h(x, *args):
-      pass
-
-
-  @given(integers(), x=integers())
-  def i(x, y):
-      pass
-
-
-  @given()
-  def j(x, y):
-      pass
-
-
-The rules for determining what are valid uses of ``given`` are as follows:
-
-1. You may pass any keyword argument to ``given``.
-2. Positional arguments to ``given`` are equivalent to the rightmost named
-   arguments for the test function.
-3. Positional arguments may not be used if the underlying test function has
-   varargs, arbitrary keywords, or keyword-only arguments.
-4. Functions tested with ``given`` may not have any defaults.
-
-The reason for the "rightmost named arguments" behaviour is so that
-using :func:`@given <hypothesis.given>` with instance methods works: ``self``
-will be passed to the function as normal and not be parametrized over.
-
-The function returned by given has all the same arguments as the original
-test, minus those that are filled in by :func:`@given <hypothesis.given>`.
-Check :ref:`the notes on framework compatibility <framework-compatibility>`
-to see how this affects other testing libraries you may be using.
-
-
-.. _targeted-search:
-
----------------------------
-Targeted example generation
----------------------------
-
-Targeted property-based testing combines the advantages of both search-based
-and property-based testing.  Instead of being completely random, T-PBT uses
-a search-based component to guide the input generation towards values that
-have a higher probability of falsifying a property.  This explores the input
-space more effectively and requires fewer tests to find a bug or achieve a
-high confidence in the system being tested than random PBT.
-(`Löscher and Sagonas <http://proper.softlab.ntua.gr/Publications.html>`__)
-
-This is not *always* a good idea - for example calculating the search metric
-might take time better spent running more uniformly-random test cases, or your
-target metric might accidentally lead Hypothesis *away* from bugs - but if
-there is a natural metric like "floating-point error", "load factor" or
-"queue length", we encourage you to experiment with targeted testing.
-
-.. autofunction:: hypothesis.target
-
-We recommend that users also skim the papers introducing targeted PBT;
-from `ISSTA 2017 <http://proper.softlab.ntua.gr/papers/issta2017.pdf>`__
-and `ICST 2018 <http://proper.softlab.ntua.gr/papers/icst2018.pdf>`__.
-For the curious, the initial implementation in Hypothesis uses hill-climbing
-search via a mutating fuzzer, with some tactics inspired by simulated
-annealing to avoid getting stuck and endlessly mutating a local maximum.
-
-
-.. _custom-function-execution:
-
--------------------------
-Custom function execution
--------------------------
-
-Hypothesis provides you with a hook that lets you control how it runs
-examples.
-
-This lets you do things like set up and tear down around each example, run
-examples in a subprocess, transform coroutine tests into normal tests, etc.
-For example, :class:`~hypothesis.extra.django.TransactionTestCase` in the
-Django extra runs each example in a separate database transaction.
-
-The way this works is by introducing the concept of an executor. An executor
-is essentially a function that takes a block of code and run it. The default
-executor is:
-
-.. code:: python
-
-    def default_executor(function):
-        return function()
-
-You define executors by defining a method ``execute_example`` on a class. Any
-test methods on that class with :func:`@given <hypothesis.given>` used on them will use
-``self.execute_example`` as an executor with which to run tests. For example,
-the following executor runs all its code twice:
-
-.. code:: python
-
-    from unittest import TestCase
-
-
-    class TestTryReallyHard(TestCase):
-        @given(integers())
-        def test_something(self, i):
-            perform_some_unreliable_operation(i)
-
-        def execute_example(self, f):
-            f()
-            return f()
-
-Note: The functions you use in map, etc. will run *inside* the executor. i.e.
-they will not be called until you invoke the function passed to ``execute_example``.
-
-An executor must be able to handle being passed a function which returns None,
-otherwise it won't be able to run normal test cases. So for example the following
-executor is invalid:
-
-.. code:: python
-
-    from unittest import TestCase
-
-
-    class TestRunTwice(TestCase):
-        def execute_example(self, f):
-            return f()()
-
-and should be rewritten as:
-
-.. code:: python
-
-    from unittest import TestCase
-
-
-    class TestRunTwice(TestCase):
-        def execute_example(self, f):
-            result = f()
-            if callable(result):
-                result = result()
-            return result
-
-
-An alternative hook is provided for use by test runner extensions such as
-:pypi:`pytest-trio`, which cannot use the ``execute_example`` method.
-This is **not** recommended for end-users - it is better to write a complete
-test function directly, perhaps by using a decorator to perform the same
-transformation before applying :func:`@given <hypothesis.given>`.
-
-.. code:: python
-
-    @given(x=integers())
-    @pytest.mark.trio
-    async def test(x):
-        ...
-
-
-    # Illustrative code, inside the pytest-trio plugin
-    test.hypothesis.inner_test = lambda x: trio.run(test, x)
-
-For authors of test runners however, assigning to the ``inner_test`` attribute
-of the ``hypothesis`` attribute of the test will replace the interior test.
-
-.. note::
-    The new ``inner_test`` must accept and pass through all the ``*args``
-    and ``**kwargs`` expected by the original test.
-
-If the end user has also specified a custom executor using the
-``execute_example`` method, it - and all other execution-time logic - will
-be applied to the *new* inner test assigned by the test runner.
-
-
---------------------------------
-Making random code deterministic
---------------------------------
-
-While Hypothesis' example generation can be used for nondeterministic tests,
-debugging anything nondeterministic is usually a very frustrating exercise.
-To make things worse, our example *shrinking* relies on the same input
-causing the same failure each time - though we show the un-shrunk failure
-and a decent error message if it doesn't.
-
-By default, Hypothesis will handle the global ``random`` and ``numpy.random``
-random number generators for you, and you can register others:
-
-.. autofunction:: hypothesis.register_random
-
-
-.. _type-inference:
-
--------------------
-Inferred strategies
--------------------
-
-In some cases, Hypothesis can work out what to do when you omit arguments.
-This is based on introspection, *not* magic, and therefore has well-defined
-limits.
-
-:func:`~hypothesis.strategies.builds` will check the signature of the
-``target`` (using :func:`~python:inspect.signature`).
-If there are required arguments with type annotations and
-no strategy was passed to :func:`~hypothesis.strategies.builds`,
-:func:`~hypothesis.strategies.from_type` is used to fill them in.
-You can also pass the value ``...`` (``Ellipsis``) as a keyword
-argument, to force this inference for arguments with a default value.
-
-.. code-block:: pycon
-
-    >>> def func(a: int, b: str):
-    ...     return a, b
-    ...
-    >>> builds(func).example()
-    -6993, ''
-
-.. data:: hypothesis.infer
-
-:func:`@given <hypothesis.given>` does not perform any implicit inference
-for required arguments, as this would break compatibility with pytest fixtures.
-``...`` (:obj:`python:Ellipsis`), can be used as a keyword argument to explicitly fill
-in an argument from its type annotation.  You can also use the ``hypothesis.infer``
-alias if writing a literal ``...`` seems too weird.
-
-.. code:: python
-
-    @given(a=...)  # or @given(a=infer)
-    def test(a: int):
-        pass
-
-
-    # is equivalent to
-    @given(a=from_type(int))
-    def test(a):
-        pass
-
-
-``@given(...)`` can also be specified to fill all arguments from their type annotations.
-
-.. code:: python
-
-    @given(...)
-    def test(a: int, b: str):
-        pass
-
-
-    # is equivalent to
-    @given(a=..., b=...)
-    def test(a, b):
-        pass
-
-
-~~~~~~~~~~~
-Limitations
-~~~~~~~~~~~
-
-Hypothesis does not inspect :pep:`484` type comments at runtime.  While
-:func:`~hypothesis.strategies.from_type` will work as usual, inference in
-:func:`~hypothesis.strategies.builds` and :func:`@given <hypothesis.given>`
-will only work if you manually create the ``__annotations__`` attribute
-(e.g. by using ``@annotations(...)`` and ``@returns(...)`` decorators).
-
-The :mod:`python:typing` module changes between different Python releases,
-including at minor versions.  These
-are all supported on a best-effort basis,
-but you may encounter problems.  Please report them to us, and consider
-updating to a newer version of Python as a workaround.
-
-
-.. _our-type-hints:
-
-------------------------------
-Type annotations in Hypothesis
-------------------------------
-
-If you install Hypothesis and use :pypi:`mypy` 0.590+, or another
-:PEP:`561`-compatible tool, the type checker should automatically pick
-up our type hints.
-
-.. note::
-    Hypothesis' type hints may make breaking changes between minor releases.
-
-    Upstream tools and conventions about type hints remain in flux - for
-    example the :mod:`python:typing` module itself is provisional, and Mypy
-    has not yet reached version 1.0 - and we plan to support the latest
-    version of this ecosystem, as well as older versions where practical.
-
-    We may also find more precise ways to describe the type of various
-    interfaces, or change their type and runtime behaviour together in a way
-    which is otherwise backwards-compatible.  We often omit type hints for
-    deprecated features or arguments, as an additional form of warning.
-
-There are known issues inferring the type of examples generated by
-:func:`~hypothesis.strategies.deferred`, :func:`~hypothesis.strategies.recursive`,
-:func:`~hypothesis.strategies.one_of`, :func:`~hypothesis.strategies.dictionaries`,
-and :func:`~hypothesis.strategies.fixed_dictionaries`.
-We will fix these, and require correspondingly newer versions of Mypy for type
-hinting, as the ecosystem improves.
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Writing downstream type hints
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Projects that :doc:`provide Hypothesis strategies <strategies>` and use
-type hints may wish to annotate their strategies too.  This *is* a
-supported use-case, again on a best-effort provisional basis.  For example:
-
-.. code:: python
-
-    def foo_strategy() -> SearchStrategyFoo:
-        ...
-
-.. class:: hypothesis.strategies.SearchStrategy
-
-:class:`~hypothesis.strategies.SearchStrategy` is the type of all strategy
-objects.  It is a generic type, and covariant in the type of the examples
-it creates.  For example:
-
-- ``integers()`` is of type ``SearchStrategyint``.
-- ``lists(integers())`` is of type ``SearchStrategyListint``.
-- ``SearchStrategyDog`` is a subtype of ``SearchStrategyAnimal``
-  if ``Dog`` is a subtype of ``Animal`` (as seems likely).
-
-.. warning::
-    :class:`~hypothesis.strategies.SearchStrategy` **should only be used
-    in type hints.**  Please do not inherit from, compare to, or otherwise
-    use it in any way outside of type hints.  The only supported way to
-    construct objects of this type is to use the functions provided by the
-    :mod:`hypothesis.strategies` module!
-
-
-.. _pytest-plugin:
-
-----------------------------
-The Hypothesis pytest plugin
-----------------------------
-
-Hypothesis includes a tiny plugin to improve integration with :pypi:`pytest`,
-which is activated by default (but does not affect other test runners).
-It aims to improve the integration between Hypothesis and Pytest by
-providing extra information and convenient access to config options.
-
-- ``pytest --hypothesis-show-statistics`` can be used to
-  :ref:`display test and data generation statistics <statistics>`.
-- ``pytest --hypothesis-profile=<profile name>`` can be used to
-  :ref:`load a settings profile <settings_profiles>`.
-- ``pytest --hypothesis-verbosity=<level name>`` can be used to
-  :ref:`override the current verbosity level <verbose-output>`.
-- ``pytest --hypothesis-seed=<an int>`` can be used to
-  :ref:`reproduce a failure with a particular seed <reproducing-with-seed>`.
-- ``pytest --hypothesis-explain`` can be used to
-  :ref:`temporarily enable the explain phase <phases>`.
-
-Finally, all tests that are defined with Hypothesis automatically have
-``@pytest.mark.hypothesis`` applied to them.  See :ref:`here for information
-on working with markers <pytest:mark examples>`.
-
-.. note::
-    Pytest will load the plugin automatically if Hypothesis is installed.
-    You don't need to do anything at all to use it.
-
-
-.. _fuzz_one_input:
-
--------------------------
-Use with external fuzzers
--------------------------
-
-.. tip::
-
-    | Want an integrated workflow for your team's local tests, CI, and continuous fuzzing?
-    | Use `HypoFuzz <https://hypofuzz.com/>`__ to fuzz your whole test suite,
-      and find more bugs without more tests!
-
-Sometimes, you might want to point a traditional fuzzer such as
-`python-afl <https://github.com/jwilk/python-afl>`__, :pypi:`pythonfuzz`,
-or Google's :pypi:`atheris` (for Python *and* native extensions)
-at your code. Wouldn't it be nice if you could use any of your
-:func:`@given <hypothesis.given>` tests as fuzz targets, instead of
-converting bytestrings into your objects by hand?
-
-.. code:: python
-
-    @given(st.text())
-    def test_foo(s):
-        ...
-
-
-    # This is a traditional fuzz target - call it with a bytestring,
-    # or a binary IO object, and it runs the test once.
-    fuzz_target = test_foo.hypothesis.fuzz_one_input
-
-    # For example:
-    fuzz_target(b"\x00\x00\x00\x00\x00\x00\x00\x00")
-    fuzz_target(io.BytesIO(...))
-
-Depending on the input to ``fuzz_one_input``, one of three things will happen:
-
-- If the bytestring was invalid, for example because it was too short or
-  failed a filter or :func:`~hypothesis.assume` too many times,
-  ``fuzz_one_input`` returns ``None``.
-
-- If the bytestring was valid and the test passed, ``fuzz_one_input`` returns
-  a canonicalised and pruned buffer which will replay that test case.  This
-  is provided as an option to improve the performance of mutating fuzzers,
-  but can safely be ignored.
-
-- If the test *failed*, i.e. raised an exception, ``fuzz_one_input`` will add
-  the pruned buffer to :doc:`the Hypothesis example database <database>`
-  and then re-raise that exception.  All you need to do to reproduce, minimize,
-  and de-duplicate all the failures found via fuzzing is run your test suite!
-
-Note that the interpretation of both input and output bytestrings is specific
-to the exact version of Hypothesis you are using and the strategies given to
-the test, just like the :doc:`example database <database>` and
-:func:`@reproduce_failure <hypothesis.reproduce_failure>` decorator.
-
-~~~~~~~~~~~~~~~~~~~~~~~~~
-Interaction with settings
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-``fuzz_one_input`` uses just enough of Hypothesis' internals to drive your
-test function with a fuzzer-provided bytestring, and most settings therefore
-have no effect in this mode.  We recommend running your tests the usual way
-before fuzzing to get the benefits of healthchecks, as well as afterwards to
-replay, shrink, deduplicate, and report whatever errors were discovered.
-
-- The :obj:`~hypothesis.settings.database` setting *is* used by fuzzing mode -
-  adding failures to the database to be replayed when you next run your tests
-  is our preferred reporting mechanism and response to
-  `the 'fuzzer taming' problem <https://blog.regehr.org/archives/925>`__.
-- The :obj:`~hypothesis.settings.verbosity` and
-  :obj:`~hypothesis.settings.stateful_step_count` settings work as usual.
-
-The ``deadline``, ``derandomize``, ``max_examples``, ``phases``, ``print_blob``,
-``report_multiple_bugs``, and ``suppress_health_check`` settings do not affect
-fuzzing mode.
-
-
---------------------
-Thread-Safety Policy
---------------------
-
-As discussed in :issue:`2719`, Hypothesis is not truly thread-safe and that's
-unlikely to change in the future.  This policy therefore describes what you
-*can* expect if you use Hypothesis with multiple threads.
-
-**Running tests in multiple processes**, e.g. with ``pytest -n auto``, is fully
-supported and we test this regularly in CI - thanks to process isolation, we only
-need to ensure that :class:`~hypothesis.database.DirectoryBasedExampleDatabase`
-can't tread on its own toes too badly.  If you find a bug here we will fix it ASAP.
-
-**Running separate tests in multiple threads** is not something we design or test
-for, and is not formally supported.  That said, anecdotally it does mostly work and
-we would like it to keep working - we accept reasonable patches and low-priority
-bug reports.  The main risks here are global state, shared caches, and cached strategies.
-
-**Using multiple threads within a single test** , or running a single test simultaneously
-in multiple threads, makes it pretty easy to trigger internal errors.  We usually accept
-patches for such issues unless readability or single-thread performance suffer.
-
-Hypothesis assumes that tests are single-threaded, or do a sufficiently-good job of
-pretending to be single-threaded.  Tests that use helper threads internally should be OK,
-but the user must be careful to ensure that test outcomes are still deterministic.
-In particular it counts as nondeterministic if helper-thread timing changes the sequence
-of dynamic draws using e.g. the :func:`~hypothesis.strategies.data`.
-
-Interacting with any Hypothesis APIs from helper threads might do weird/bad things,
-so avoid that too - we rely on thread-local variables in a few places, and haven't
-explicitly tested/audited how they respond to cross-thread API calls.  While
-:func:`~hypothesis.strategies.data` and equivalents are the most obvious danger,
-other APIs might also be subtly affected.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/development.rst Deleted

@@ -1,50 +0,0 @@
-==============================
-Ongoing Hypothesis development
-==============================
-
-Hypothesis development is managed by `David R. MacIver <https://www.drmaciver.com>`_
-and `Zac Hatfield-Dodds <https://zhd.dev>`_, respectively the first author and lead
-maintainer.
-
-*However*, these roles don't include unpaid feature development on Hypothesis.
-Our roles as leaders of the project are:
-
-1. Helping other people do feature development on Hypothesis
-2. Fixing bugs and other code health issues
-3. Improving documentation
-4. General release management work
-5. Planning the general roadmap of the project
-6. Doing sponsored development on tasks that are too large or in depth for other people to take on
-
-So all new features must either be sponsored or implemented by someone else.
-That being said, the maintenance team takes an active role in shepherding pull requests and
-helping people write a new feature (see :gh-file:`CONTRIBUTING.rst` for
-details and :gh-link:`these examples of how the process goes
-<pulls?q=is%3Apr+is%3Amerged+mentored>`). This isn't
-"patches welcome", it's "we will help you write a patch".
-
-
-.. _release-policy:
-
-Release policy
-==============
-
-Hypothesis releases follow `semantic versioning <https://semver.org/>`_.
-
-We maintain backwards-compatibility wherever possible, and use deprecation
-warnings to mark features that have been superseded by a newer alternative.
-If you want to detect this, you can
-:mod:`upgrade warnings to errors in the usual ways <python:warnings>`.
-
-We use continuous deployment to ensure that you can always use our newest and
-shiniest features - every change to the source tree is automatically built and
-published on PyPI as soon as it's merged onto master, after code review and
-passing our extensive test suite.
-
-
-Project roadmap
-===============
-
-Hypothesis does not have a long-term release plan.  We respond to bug reports
-as they are made; new features are released as and when someone volunteers to
-write and maintain them.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/django.rst Deleted

@@ -1,215 +0,0 @@
-.. _hypothesis-django:
-
-===========================
-Hypothesis for Django users
-===========================
-
-Hypothesis offers a number of features specific for Django testing, available
-in the ``hypothesisdjango`` :doc:`extra </extras>`.  This is tested
-against each supported series with mainstream or extended support -
-if you're still getting security patches, you can test with Hypothesis.
-
-.. class:: hypothesis.extra.django.TestCase
-
-Using it is quite straightforward: All you need to do is subclass
-:class:`hypothesis.extra.django.TestCase` or
-:class:`hypothesis.extra.django.TransactionTestCase` or
-:class:`~hypothesis.extra.django.LiveServerTestCase` or
-:class:`~hypothesis.extra.django.StaticLiveServerTestCase`
-and you can use :func:`@given <hypothesis.given>` as normal,
-and the transactions will be per example
-rather than per test function as they would be if you used :func:`@given <hypothesis.given>` with a normal
-django test suite (this is important because your test function will be called
-multiple times and you don't want them to interfere with each other). Test cases
-on these classes that do not use
-:func:`@given <hypothesis.given>` will be run as normal.
-
-.. class:: hypothesis.extra.django.TransactionTestCase
-.. class:: hypothesis.extra.django.LiveServerTestCase
-.. class:: hypothesis.extra.django.StaticLiveServerTestCase
-
-We recommend avoiding :class:`~hypothesis.extra.django.TransactionTestCase`
-unless you really have to run each test case in a database transaction.
-Because Hypothesis runs this in a loop, the performance problems it normally has
-are significantly exacerbated and your tests will be really slow.
-If you are using :class:`~hypothesis.extra.django.TransactionTestCase`,
-you may need to use ``@settings(suppress_health_check=HealthCheck.too_slow)``
-to avoid :doc:`errors due to slow example generation </healthchecks>`.
-
-Having set up a test class, you can now pass :func:`@given <hypothesis.given>`
-a strategy for Django models:
-
-.. autofunction:: hypothesis.extra.django.from_model
-
-For example, using :gh-file:`the trivial django project we have for testing
-<hypothesis-python/tests/django/toystore/models.py>`:
-
-.. code-block:: pycon
-
-    >>> from hypothesis.extra.django import from_model
-    >>> from toystore.models import Customer
-    >>> c = from_model(Customer).example()
-    >>> c
-    <Customer: Customer object>
-    >>> c.email
-    'jaime.urbina@gmail.com'
-    >>> c.name
-    '\U00109d3d\U000e07be\U000165f8\U0003fabf\U000c12cd\U000f1910\U00059f12\U000519b0\U0003fabf\U000f1910\U000423fb\U000423fb\U00059f12\U000e07be\U000c12cd\U000e07be\U000519b0\U000165f8\U0003fabf\U0007bc31'
-    >>> c.age
-    -873375803
-
-Hypothesis has just created this with whatever the relevant type of data is.
-
-Obviously the customer's age is implausible, which is only possible because
-we have not used (eg) :class:`~django:django.core.validators.MinValueValidator`
-to set the valid range for this field (or used a
-:class:`~django:django.db.models.PositiveSmallIntegerField`, which would only
-need a maximum value validator).
-
-If you *do* have validators attached, Hypothesis will only generate examples
-that pass validation.  Sometimes that will mean that we fail a
-:class:`~hypothesis.HealthCheck` because of the filtering, so let's explicitly
-pass a strategy to skip validation at the strategy level:
-
-.. note::
-    Inference from validators will be much more powerful when :issue:`1116`
-    is implemented, but there will always be some edge cases that require you
-    to pass an explicit strategy.
-
-.. code-block:: pycon
-
-    >>> from hypothesis.strategies import integers
-    >>> c = from_model(Customer, age=integers(min_value=0, max_value=120)).example()
-    >>> c
-    <Customer: Customer object>
-    >>> c.age
-    5
-
-.. autofunction:: hypothesis.extra.django.from_form
-
----------------
-Tips and tricks
----------------
-
-Custom field types
-==================
-
-If you have a custom Django field type you can register it with Hypothesis's
-model deriving functionality by registering a default strategy for it:
-
-.. code-block:: pycon
-
-    >>> from toystore.models import CustomishField, Customish
-    >>> from_model(Customish).example()
-    hypothesis.errors.InvalidArgument: Missing arguments for mandatory field
-        customish for model Customish
-    >>> from hypothesis.extra.django import register_field_strategy
-    >>> from hypothesis.strategies import just
-    >>> register_field_strategy(CustomishField, just("hi"))
-    >>> x = from_model(Customish).example()
-    >>> x.customish
-    'hi'
-
-Note that this mapping is on exact type. Subtypes will not inherit it.
-
-.. autofunction:: hypothesis.extra.django.register_field_strategy
-
-.. autofunction:: hypothesis.extra.django.from_field
-
-
-Generating child models
-=======================
-
-For the moment there's no explicit support in hypothesis-django for generating
-dependent models. i.e. a Company model will generate no Shops. However if you
-want to generate some dependent models as well, you can emulate this by using
-the *flatmap* function as follows:
-
-.. code:: python
-
-  from hypothesis.strategies import just, lists
-
-
-  def generate_with_shops(company):
-      return lists(from_model(Shop, company=just(company))).map(lambda _: company)
-
-
-  company_with_shops_strategy = from_model(Company).flatmap(generate_with_shops)
-
-Let's unpack what this is doing:
-
-The way flatmap works is that we draw a value from the original strategy, then
-apply a function to it which gives us a new strategy. We then draw a value from
-*that* strategy. So in this case we're first drawing a company, and then we're
-drawing a list of shops belonging to that company: The *just* strategy is a
-strategy such that drawing it always produces the individual value, so
-``from_model(Shop, company=just(company))`` is a strategy that generates a Shop belonging
-to the original company.
-
-So the following code would give us a list of shops all belonging to the same
-company:
-
-.. code:: python
-
-  from_model(Company).flatmap(lambda c: lists(from_model(Shop, company=just(c))))
-
-The only difference from this and the above is that we want the company, not
-the shops. This is where the inner map comes in. We build the list of shops
-and then throw it away, instead returning the company we started for. This
-works because the models that Hypothesis generates are saved in the database,
-so we're essentially running the inner strategy purely for the side effect of
-creating those children in the database.
-
-
-.. _django-generating-primary-key:
-
-Generating primary key values
-=============================
-
-If your model includes a custom primary key that you want to generate
-using a strategy (rather than a default auto-increment primary key)
-then Hypothesis has to deal with the possibility of a duplicate
-primary key.
-
-If a model strategy generates a value for the primary key field,
-Hypothesis will create the model instance with
-:meth:`~django:django.db.models.query.QuerySet.update_or_create`,
-overwriting any existing instance in the database for this test case
-with the same primary key.
-
-
-On the subject of ``MultiValueField``
-=====================================
-
-Django forms feature the :class:`~django:django.forms.MultiValueField`
-which allows for several fields to be combined under a single named field, the
-default example of this is the :class:`~django:django.forms.SplitDateTimeField`.
-
-.. code:: python
-
-  class CustomerForm(forms.Form):
-      name = forms.CharField()
-      birth_date_time = forms.SplitDateTimeField()
-
-``from_form`` supports ``MultiValueField`` subclasses directly, however if you
-want to define your own strategy be forewarned that Django binds data for a
-``MultiValueField`` in a peculiar way. Specifically each sub-field is expected
-to have its own entry in ``data`` addressed by the field name
-(e.g. ``birth_date_time``) and the index of the sub-field within the
-``MultiValueField``, so form ``data`` for the example above might look
-like this:
-
-.. code:: python
-
-  {
-      "name": "Samuel John",
-      "birth_date_time_0": "2018-05-19",  # the date, as the first sub-field
-      "birth_date_time_1": "15:18:00",  # the time, as the second sub-field
-  }
-
-Thus, if you want to define your own strategies for such a field you must
-address your sub-fields appropriately:
-
-.. code:: python
-
-  from_form(CustomerForm, birth_date_time_0=just("2018-05-19"))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/endorsements.rst Deleted

@@ -1,221 +0,0 @@
-============
-Testimonials
-============
-
-This is a page for listing people who are using Hypothesis and how excited they
-are about that. If that's you and your name is not on the list,
-:gh-file:`this file is in Git <hypothesis-python/docs/endorsements.rst>`
-and I'd love it if you sent me a pull request to fix that.
-
----------------------------------------------------------------------------------------
-`Stripe <https://stripe.com>`_
----------------------------------------------------------------------------------------
-
-At Stripe we use Hypothesis to test every piece of our machine
-learning model training pipeline (powered by scikit). Before we
-migrated, our tests were filled with hand-crafted pandas Dataframes
-that weren't representative at all of our actual very complex
-data. Because we needed to craft examples for each test, we took the
-easy way out and lived with extremely low test coverage.
-
-Hypothesis changed all that. Once we had our strategies for generating
-Dataframes of features it became trivial to slightly customize each
-strategy for new tests. Our coverage is now close to 90%.
-
-Full-stop, property-based testing is profoundly more powerful - and
-has caught or prevented far more bugs - than our old style of
-example-based testing.
-
----------------------------------------------------------------------------------------
-Kristian Glass - Director of Technology at `LaterPay GmbH <https://www.laterpay.net/>`_
----------------------------------------------------------------------------------------
-
-Hypothesis has been brilliant for expanding the coverage of our test cases,
-and also for making them much easier to read and understand,
-so we're sure we're testing the things we want in the way we want.
-
------------------------------------------------
-`Seth Morton <https://github.com/SethMMorton>`_
------------------------------------------------
-
-When I first heard about Hypothesis, I knew I had to include it in my two
-open-source Python libraries, `natsort <https://github.com/SethMMorton/natsort>`_
-and `fastnumbers <https://github.com/SethMMorton/fastnumbers>`_ . Quite frankly,
-I was a little appalled at the number of bugs and "holes" I found in the code. I can
-now say with confidence that my libraries are more robust to "the wild." In
-addition, Hypothesis gave me the confidence to expand these libraries to fully
-support Unicode input, which I never would have had the stomach for without such
-thorough testing capabilities. Thanks!
-
--------------------------------------------
-`Sixty North <https://sixty-north.com/>`_
--------------------------------------------
-
-At Sixty North we use Hypothesis for testing
-`Segpy <https://github.com/sixty-north/segpy>`_ an open source Python library for
-shifting data between Python data structures and SEG Y files which contain
-geophysical data from the seismic reflection surveys used in oil and gas
-exploration.
-
-This is our first experience of property-based testing – as opposed to example-based
-testing.  Not only are our tests more powerful, they are also much better
-explanations of what we expect of the production code. In fact, the tests are much
-closer to being specifications.  Hypothesis has located real defects in our code
-which went undetected by traditional test cases, simply because Hypothesis is more
-relentlessly devious about test case generation than us mere humans!  We found
-Hypothesis particularly beneficial for Segpy because SEG Y is an antiquated format
-that uses legacy text encodings (EBCDIC) and even a legacy floating point format
-we implemented from scratch in Python.
-
-Hypothesis is sure to find a place in most of our future Python codebases and many
-existing ones too.
-
--------------------------------------------
-`mulkieran <https://github.com/mulkieran>`_
--------------------------------------------
-
-Just found out about this excellent QuickCheck for Python implementation and
-ran up a few tests for my `bytesize <https://github.com/mulkieran/bytesize>`_
-package last night. Refuted a few hypotheses in the process.
-
-Looking forward to using it with a bunch of other projects as well.
-
------------------------------------------------
-`Adam Johnson <https://github.com/adamchainz>`_
------------------------------------------------
-
-I have written a small library to serialize ``dict``\s to MariaDB's dynamic
-columns binary format,
-`mariadb-dyncol <https://github.com/adamchainz/mariadb-dyncol>`_. When I first
-developed it, I thought I had tested it really well - there were hundreds of
-test cases, some of them even taken from MariaDB's test suite itself. I was
-ready to release.
-
-Lucky for me, I tried Hypothesis with David at the PyCon UK sprints. Wow! It
-found bug after bug after bug. Even after a first release, I thought of a way
-to make the tests do more validation, which revealed a further round of bugs!
-Most impressively, Hypothesis found a complicated off-by-one error in a
-condition with 4095 versus 4096 bytes of data - something that I would never
-have found.
-
-Long live Hypothesis! (Or at least, property-based testing).
-
--------------------------------------------
-`Josh Bronson <https://github.com/jab>`_
--------------------------------------------
-
-Adopting Hypothesis improved `bidict <https://github.com/jab/bidict>`_'s
-test coverage and significantly increased our ability to make changes to
-the code with confidence that correct behavior would be preserved.
-Thank you, David, for the great testing tool.
-
---------------------------------------------
-`Cory Benfield <https://github.com/Lukasa>`_
---------------------------------------------
-
-Hypothesis is the single most powerful tool in my toolbox for working with
-algorithmic code, or any software that produces predictable output from a wide
-range of sources. When using it with
-`Priority <https://python-hyper.org/projects/priority/en/latest/>`_, Hypothesis consistently found
-errors in my assumptions and extremely subtle bugs that would have taken months
-of real-world use to locate. In some cases, Hypothesis found subtle deviations
-from the correct output of the algorithm that may never have been noticed at
-all.
-
-When it comes to validating the correctness of your tools, nothing comes close
-to the thoroughness and power of Hypothesis.
-
-------------------------------------------
-`Jon Moore <https://github.com/jonmoore>`_
-------------------------------------------
-
-One extremely satisfied user here. Hypothesis is a really solid implementation
-of property-based testing, adapted well to Python, and with good features
-such as failure-case shrinkers. I first used it on a project where we needed
-to verify that a vendor's Python and non-Python implementations of an algorithm
-matched, and it found about a dozen cases that previous example-based testing
-and code inspections had not. Since then I've been evangelizing for it at our firm.
-
---------------------------------------------
-`Russel Winder <https://www.russel.org.uk>`_
---------------------------------------------
-
-I am using Hypothesis as an integral part of my Python workshops. Testing is an integral part of Python
-programming and whilst unittest and, better, pytest can handle example-based testing, property-based
-testing is increasingly far more important than example-base testing, and Hypothesis fits the bill.
-
----------------------------------------------
-`Wellfire Interactive <https://wellfire.co>`_
----------------------------------------------
-
-We've been using Hypothesis in a variety of client projects, from testing
-Django-related functionality to domain-specific calculations. It both speeds
-up and simplifies the testing process since there's so much less tedious and
-error-prone work to do in identifying edge cases. Test coverage is nice but
-test depth is even nicer, and it's much easier to get meaningful test depth
-using Hypothesis.
-
---------------------------------------------------
-`Cody Kochmann <https://github.com/CodyKochmann>`_
---------------------------------------------------
-
-Hypothesis is being used as the engine for random object generation with my
-open source function fuzzer
-`battle_tested <https://github.com/CodyKochmann/battle_tested>`_
-which maps all behaviors of a function allowing you to minimize the chance of
-unexpected crashes when running code in production.
-
-With how efficient Hypothesis is at generating the edge cases that cause
-unexpected behavior occur,
-`battle_tested <https://github.com/CodyKochmann/battle_tested>`_
-is able to map out the entire behavior of most functions in less than a few
-seconds.
-
-Hypothesis truly is a masterpiece. I can't thank you enough for building it.
-
-
----------------------------------------------------
-`Merchise Autrement <https://github.com/merchise>`_
----------------------------------------------------
-
-Just minutes after our first use of hypothesis `we uncovered a subtle bug`__
-in one of our most used library.  Since then, we have increasingly used
-hypothesis to improve the quality of our testing in libraries and applications
-as well.
-
-__ https://github.com/merchise/xoutil/commit/0a4a0f529812fed363efb653f3ade2d2bc203945
-
-----------------------------------------------
-`Florian Kromer <https://github.com/fkromer>`_
-----------------------------------------------
-
-At `Roboception GmbH <https://roboception.com/en/>`_ I use Hypothesis to
-implement fully automated stateless and stateful reliability tests for the
-`3D sensor rc_visard <https://roboception.com/en/rc_visard-en/>`_ and
-`robotic software components <https://roboception.com/en/rc_reason-en/>`_ .
-
-Thank you very much for creating the (probably) most powerful property-based
-testing framework.
-
--------------------------------------------
-`Reposit Power <https://repositpower.com>`_
--------------------------------------------
-
-With a micro-service architecture, testing between services is made easy using Hypothesis
-in integration testing. Ensuring everything is running smoothly is vital to help maintain
-a secure network of Virtual Power Plants.
-
-It allows us to find potential bugs and edge cases with relative ease
-and minimal overhead. As our architecture relies on services communicating effectively, Hypothesis
-allows us to strictly test for the kind of data which moves around our services, particularly
-our backend Python applications.
-
-
--------------------------------------------
-`Your name goes here <http://example.com>`_
--------------------------------------------
-
-I know there are many more, because I keep finding out about new people I'd never
-even heard of using Hypothesis. If you're looking to way to give back to a tool you
-love, adding your name here only takes a moment and would really help a lot. As per
-instructions at the top, just send me a pull request and I'll add you to the list.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/examples.rst Deleted

@@ -1,410 +0,0 @@
-==================
-Some more examples
-==================
-
-This is a collection of examples of how to use Hypothesis in interesting ways.
-It's small for now but will grow over time.
-
-All of these examples are designed to be run under :pypi:`pytest`,
-and :pypi:`nose` should work too.
-
-----------------------------------
-How not to sort by a partial order
-----------------------------------
-
-The following is an example that's been extracted and simplified from a real
-bug that occurred in an earlier version of Hypothesis. The real bug was a lot
-harder to find.
-
-Suppose we've got the following type:
-
-.. code:: python
-
-    class Node:
-        def __init__(self, label, value):
-            self.label = label
-            self.value = tuple(value)
-
-        def __repr__(self):
-            return f"Node({self.label!r}, {self.value!r})"
-
-        def sorts_before(self, other):
-            if len(self.value) >= len(other.value):
-                return False
-            return other.value: len(self.value) == self.value
-
-
-Each node is a label and a sequence of some data, and we have the relationship
-sorts_before meaning the data of the left is an initial segment of the right.
-So e.g. a node with value ``1, 2`` will sort before a node with value ``1, 2, 3``,
-but neither of ``1, 2`` nor ``1, 3`` will sort before the other.
-
-We have a list of nodes, and we want to topologically sort them with respect to
-this ordering. That is, we want to arrange the list so that if ``x.sorts_before(y)``
-then x appears earlier in the list than y. We naively think that the easiest way
-to do this is to extend the  partial order defined here to a total order by
-breaking ties arbitrarily and then using a normal sorting algorithm. So we
-define the following code:
-
-.. code:: python
-
-    from functools import total_ordering
-
-
-    @total_ordering
-    class TopoKey:
-        def __init__(self, node):
-            self.value = node
-
-        def __lt__(self, other):
-            if self.value.sorts_before(other.value):
-                return True
-            if other.value.sorts_before(self.value):
-                return False
-
-            return self.value.label < other.value.label
-
-
-    def sort_nodes(xs):
-        xs.sort(key=TopoKey)
-
-This takes the order defined by ``sorts_before`` and extends it by breaking ties by
-comparing the node labels.
-
-But now we want to test that it works.
-
-First we write a function to verify that our desired outcome holds:
-
-.. code:: python
-
-  def is_prefix_sorted(xs):
-      for i in range(len(xs)):
-          for j in range(i + 1, len(xs)):
-              if xsj.sorts_before(xsi):
-                  return False
-      return True
-
-This will return false if it ever finds a pair in the wrong order and
-return true otherwise.
-
-Given this function, what we want to do with Hypothesis is assert that for all
-sequences of nodes, the result of calling ``sort_nodes`` on it is sorted.
-
-First we need to define a strategy for Node:
-
-.. code:: python
-
-  import hypothesis.strategies as st
-
-  NodeStrategy = st.builds(Node, st.integers(), st.lists(st.booleans(), max_size=10))
-
-We want to generate *short* lists of values so that there's a decent chance of
-one being a prefix of the other (this is also why the choice of bool as the
-elements). We then define a strategy which builds a node out of an integer and
-one of those short lists of booleans.
-
-We can now write a test:
-
-.. code:: python
-
-  from hypothesis import given
-
-
-  @given(st.lists(NodeStrategy))
-  def test_sorting_nodes_is_prefix_sorted(xs):
-      sort_nodes(xs)
-      assert is_prefix_sorted(xs)
-
-this immediately fails with the following example:
-
-.. code:: python
-
-  Node(0, (False, True)), Node(0, (True,)), Node(0, (False,))
-
-
-The reason for this is that because False is not a prefix of (True, True) nor vice
-versa, sorting things the first two nodes are equal because they have equal labels.
-This makes the whole order non-transitive and produces basically nonsense results.
-
-But this is pretty unsatisfying. It only works because they have the same label. Perhaps
-we actually wanted our labels to be unique. Let's change the test to do that.
-
-.. code:: python
-
-    def deduplicate_nodes_by_label(nodes):
-        table = {node.label: node for node in nodes}
-        return list(table.values())
-
-We define a function to deduplicate nodes by labels, and can now map that over a strategy
-for lists of nodes to give us a strategy for lists of nodes with unique labels:
-
-.. code:: python
-
-    @given(st.lists(NodeStrategy).map(deduplicate_nodes_by_label))
-    def test_sorting_nodes_is_prefix_sorted(xs):
-        sort_nodes(xs)
-        assert is_prefix_sorted(xs)
-
-Hypothesis quickly gives us an example of this *still* being wrong:
-
-.. code:: python
-
-  Node(0, (False,)), Node(-1, (True,)), Node(-2, (False, False))
-
-
-Now this is a more interesting example. None of the nodes will sort equal. What is
-happening here is that the first node is strictly less than the last node because
-(False,) is a prefix of (False, False). This is in turn strictly less than the middle
-node because neither is a prefix of the other and -2 < -1. The middle node is then
-less than the first node because -1 < 0.
-
-So, convinced that our implementation is broken, we write a better one:
-
-.. code:: python
-
-    def sort_nodes(xs):
-        for i in range(1, len(xs)):
-            j = i - 1
-            while j >= 0:
-                if xsj.sorts_before(xsj + 1):
-                    break
-                xsj, xsj + 1 = xsj + 1, xsj
-                j -= 1
-
-This is just insertion sort slightly modified - we swap a node backwards until swapping
-it further would violate the order constraints. The reason this works is because our
-order is a partial order already (this wouldn't produce a valid result for a general
-topological sorting - you need the transitivity).
-
-We now run our test again and it passes, telling us that this time we've successfully
-managed to sort some nodes without getting it completely wrong. Go us.
-
---------------------
-Time zone arithmetic
---------------------
-
-This is an example of some tests for :pypi:`pytz` which check that various timezone
-conversions behave as you would expect them to. These tests should all pass,
-and are mostly a demonstration of some useful sorts of thing to test with
-Hypothesis, and how the :func:`~hypothesis.strategies.datetimes` strategy works.
-
-.. code-block:: python
-
-    from datetime import timedelta
-
-    # The datetimes strategy is naive by default, so tell it to use timezones
-    aware_datetimes = st.datetimes(timezones=st.timezones())
-
-
-    @given(aware_datetimes, st.timezones(), st.timezones())
-    def test_convert_via_intermediary(dt, tz1, tz2):
-        """Test that converting between timezones is not affected
-        by a detour via another timezone.
-        """
-        assert dt.astimezone(tz1).astimezone(tz2) == dt.astimezone(tz2)
-
-
-    @given(aware_datetimes, st.timezones())
-    def test_convert_to_and_fro(dt, tz2):
-        """If we convert to a new timezone and back to the old one
-        this should leave the result unchanged.
-        """
-        tz1 = dt.tzinfo
-        assert dt == dt.astimezone(tz2).astimezone(tz1)
-
-
-    @given(aware_datetimes, st.timezones())
-    def test_adding_an_hour_commutes(dt, tz):
-        """When converting between timezones it shouldn't matter
-        if we add an hour here or add an hour there.
-        """
-        an_hour = timedelta(hours=1)
-        assert (dt + an_hour).astimezone(tz) == dt.astimezone(tz) + an_hour
-
-
-    @given(aware_datetimes, st.timezones())
-    def test_adding_a_day_commutes(dt, tz):
-        """When converting between timezones it shouldn't matter
-        if we add a day here or add a day there.
-        """
-        a_day = timedelta(days=1)
-        assert (dt + a_day).astimezone(tz) == dt.astimezone(tz) + a_day
-
--------------------
-Condorcet's paradox
--------------------
-
-A classic paradox in voting theory, called Condorcet's paradox, is that
-majority preferences are not transitive. That is, there is a population
-and a set of three candidates A, B and C such that the majority of the
-population prefer A to B, B to C and C to A.
-
-Wouldn't it be neat if we could use Hypothesis to provide an example of this?
-
-Well as you can probably guess from the presence of this section, we can!
-The main trick is to decide how we want to represent the result of an
-election - for this example, we'll use a list of "votes", where each
-vote is a list of candidates in the voters preferred order.
-Without further ado, here is the code:
-
-.. code:: python
-
-    from collections import Counter
-
-    from hypothesis import given
-    from hypothesis.strategies import lists, permutations
-
-
-    # We need at least three candidates and at least three voters to have a
-    # paradox; anything less can only lead to victories or at worst ties.
-    @given(lists(permutations("A", "B", "C"), min_size=3))
-    def test_elections_are_transitive(election):
-        all_candidates = {"A", "B", "C"}
-
-        # First calculate the pairwise counts of how many prefer each candidate
-        # to the other
-        counts = Counter()
-        for vote in election:
-            for i in range(len(vote)):
-                for j in range(i + 1, len(vote)):
-                    counts(votei, votej) += 1
-
-        # Now look at which pairs of candidates one has a majority over the
-        # other and store that.
-        graph = {}
-        for i in all_candidates:
-            for j in all_candidates:
-                if counts(i, j) > counts(j, i):
-                    graph.setdefault(i, set()).add(j)
-
-        # Now for each triple assert that it is transitive.
-        for x in all_candidates:
-            for y in graph.get(x, ()):
-                for z in graph.get(y, ()):
-                    assert x not in graph.get(z, ())
-
-The example Hypothesis gives me on my first run (your mileage may of course
-vary) is:
-
-.. code:: python
-
-    "A", "B", "C", "B", "C", "A", "C", "A", "B"
-
-Which does indeed do the job: The majority (votes 0 and 1) prefer B to C, the
-majority (votes 0 and 2) prefer A to B and the majority (votes 1 and 2) prefer
-C to A. This is in fact basically the canonical example of the voting paradox.
-
--------------------
-Fuzzing an HTTP API
--------------------
-
-Hypothesis's support for testing HTTP services is somewhat nascent. There are
-plans for some fully featured things around this, but right now they're
-probably quite far down the line.
-
-But you can do a lot yourself without any explicit support! Here's a script
-I wrote to throw arbitrary data against the API for an entirely fictitious service
-called Waspfinder (this is only lightly obfuscated and you can easily figure
-out who I'm actually talking about, but I don't want you to run this code and
-hammer their API without their permission).
-
-All this does is use Hypothesis to generate arbitrary JSON data matching the
-format their API asks for and check for 500 errors. More advanced tests which
-then use the result and go on to do other things are definitely also possible.
-The :pypi:`schemathesis` package provides an excellent example of this!
-
-.. code:: python
-
-    import math
-    import os
-    import random
-    import time
-    import unittest
-    from collections import namedtuple
-
-    import requests
-
-    from hypothesis import assume, given, strategies as st
-
-    Goal = namedtuple("Goal", ("slug",))
-
-
-    # We just pass in our API credentials via environment variables.
-    waspfinder_token = os.getenv("WASPFINDER_TOKEN")
-    waspfinder_user = os.getenv("WASPFINDER_USER")
-    assert waspfinder_token is not None
-    assert waspfinder_user is not None
-
-    GoalData = st.fixed_dictionaries(
-        {
-            "title": st.text(),
-            "goal_type": st.sampled_from(
-                "hustler", "biker", "gainer", "fatloser", "inboxer", "drinker", "custom"
-            ),
-            "goaldate": st.one_of(st.none(), st.floats()),
-            "goalval": st.one_of(st.none(), st.floats()),
-            "rate": st.one_of(st.none(), st.floats()),
-            "initval": st.floats(),
-            "panic": st.floats(),
-            "secret": st.booleans(),
-            "datapublic": st.booleans(),
-        }
-    )
-
-
-    needs2 = "goaldate", "goalval", "rate"
-
-
-    class WaspfinderTest(unittest.TestCase):
-        @given(GoalData)
-        def test_create_goal_dry_run(self, data):
-            # We want slug to be unique for each run so that multiple test runs
-            # don't interfere with each other. If for some reason some slugs trigger
-            # an error and others don't we'll get a Flaky error, but that's OK.
-            slug = hex(random.getrandbits(32))2:
-
-            # Use assume to guide us through validation we know about, otherwise
-            # we'll spend a lot of time generating boring examples.
-
-            # Title must not be empty
-            assume(data"title")
-
-            # Exactly two of these values should be not None. The other will be
-            # inferred by the API.
-
-            assume(len(1 for k in needs2 if datak is not None) == 2)
-            for v in data.values():
-                if isinstance(v, float):
-                    assume(not math.isnan(v))
-            data"slug" = slug
-
-            # The API nicely supports a dry run option, which means we don't have
-            # to worry about the user account being spammed with lots of fake goals
-            # Otherwise we would have to make sure we cleaned up after ourselves
-            # in this test.
-            data"dryrun" = True
-            data"auth_token" = waspfinder_token
-            for d, v in data.items():
-                if v is None:
-                    datad = "null"
-                else:
-                    datad = str(v)
-            result = requests.post(
-                "https://waspfinder.example.com/api/v1/users/"
-                "%s/goals.json" % (waspfinder_user,),
-                data=data,
-            )
-
-            # Let's not hammer the API too badly. This will of course make the
-            # tests even slower than they otherwise would have been, but that's
-            # life.
-            time.sleep(1.0)
-
-            # For the moment all we're testing is that this doesn't generate an
-            # internal error. If we didn't use the dry run option we could have
-            # then tried doing more with the result, but this is a good start.
-            self.assertNotEqual(result.status_code, 500)
-
-
-    if __name__ == "__main__":
-        unittest.main()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/extras.rst Deleted

@@ -1,49 +0,0 @@
-======================
-First-party extensions
-======================
-
-Hypothesis has minimal dependencies, to maximise
-compatibility and make installing Hypothesis as easy as possible.
-
-Our integrations with specific packages are therefore provided by ``extra``
-modules that need their individual dependencies installed in order to work.
-You can install these dependencies using the setuptools extra feature as e.g.
-``pip install hypothesisdjango``. This will check installation of compatible versions.
-
-You can also just install hypothesis into a project using them, ignore the version
-constraints, and hope for the best.
-
-In general "Which version is Hypothesis compatible with?" is a hard question to answer
-and even harder to regularly test. Hypothesis is always tested against the latest
-compatible version and each package will note the expected compatibility range. If
-you run into a bug with any of these please specify the dependency version.
-
-There are separate pages for :doc:`django` and :doc:`numpy`.
-
-
-.. automodule:: hypothesis.extra.cli
-
-.. automodule:: hypothesis.extra.codemods
-
-.. automodule:: hypothesis.extra.dpcontracts
-   :members:
-
-    .. tip::
-
-        For new projects, we recommend using either :pypi:`deal` or :pypi:`icontract`
-        and :pypi:`icontract-hypothesis` over :pypi:`dpcontracts`.
-        They're generally more powerful tools for design-by-contract programming,
-        and have substantially nicer Hypothesis integration too!
-
-.. automodule:: hypothesis.extra.lark
-   :members:
-
-Example grammars, which may provide a useful starting point for your tests, can be found
-`in the Lark repository <https://github.com/lark-parser/lark/tree/master/examples>`__
-and in `this third-party collection <https://github.com/ligurio/lark-grammars>`__.
-
-.. automodule:: hypothesis.extra.pytz
-   :members:
-
-.. automodule:: hypothesis.extra.dateutil
-   :members:

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/ghostwriter.rst Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/healthchecks.rst Deleted

@@ -1,47 +0,0 @@
-=============
-Health checks
-=============
-
-Hypothesis tries to detect common mistakes and things that will cause difficulty
-at run time in the form of a number of 'health checks'.
-
-These include detecting and warning about:
-
-* Strategies with very slow data generation
-* Strategies which filter out too much
-* Recursive strategies which branch too much
-* Tests that are unlikely to complete in a reasonable amount of time.
-
-If any of these scenarios are detected, Hypothesis will emit a warning about them.
-
-The general goal of these health checks is to warn you about things that you are doing that might
-appear to work but will either cause Hypothesis to not work correctly or to perform badly.
-
-To selectively disable health checks, use the
-:obj:`~hypothesis.settings.suppress_health_check` setting.
-The argument for this parameter is a list with elements drawn from any of
-the class-level attributes of the HealthCheck class.
-Using a value of ``HealthCheck.all()`` will disable all health checks.
-
-.. autoclass:: hypothesis.HealthCheck
-   :undoc-members:
-   :inherited-members:
-   :exclude-members: all
-
-
-.. _deprecation-policy:
-
-------------
-Deprecations
-------------
-
-We also use a range of custom exception and warning types, so you can see
-exactly where an error came from - or turn only our warnings into errors.
-
-.. autoclass:: hypothesis.errors.HypothesisDeprecationWarning
-
-Deprecated features will be continue to emit warnings for at least six
-months, and then be removed in the following major release.
-Note however that not all warnings are subject to this grace period;
-sometimes we strengthen validation by adding a warning and these may
-become errors immediately at a major release.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/index.rst Deleted

@@ -1,83 +0,0 @@
-======================
-Welcome to Hypothesis!
-======================
-
-`Hypothesis <https://hypothesis.works>`_ is a Python library for
-creating unit tests which are simpler to write and more powerful when run,
-finding edge cases in your code you wouldn't have thought to look for. It is
-stable, powerful and easy to add to any existing test suite.
-
-It works by letting you write tests that assert that something should be true
-for every case, not just the ones you happen to think of.
-
-Think of a normal unit test as being something like the following:
-
-1. Set up some data.
-2. Perform some operations on the data.
-3. Assert something about the result.
-
-Hypothesis lets you write tests which instead look like this:
-
-1. For all data matching some specification.
-2. Perform some operations on the data.
-3. Assert something about the result.
-
-This is often called property-based testing, and was popularised by the
-Haskell library `Quickcheck <https://hackage.haskell.org/package/QuickCheck>`_.
-
-It works by generating arbitrary data matching your specification and checking
-that your guarantee still holds in that case. If it finds an example where it doesn't,
-it takes that example and cuts it down to size, simplifying it until it finds a
-much smaller example that still causes the problem. It then saves that example
-for later, so that once it has found a problem with your code it will not forget
-it in the future.
-
-Writing tests of this form usually consists of deciding on guarantees that
-your code should make - properties that should always hold true,
-regardless of what the world throws at you. Examples of such guarantees
-might be:
-
-* Your code shouldn't throw an exception, or should only throw a particular
-  type of exception (this works particularly well if you have a lot of internal
-  assertions).
-* If you delete an object, it is no longer visible.
-* If you serialize and then deserialize a value, then you get the same value back.
-
-Now you know the basics of what Hypothesis does, the rest of this
-documentation will take you through how and why. It's divided into a
-number of sections, which you can see in the sidebar (or the
-menu at the top if you're on mobile), but you probably want to begin with
-the :doc:`Quick start guide <quickstart>`, which will give you a worked
-example of how to use Hypothesis and a detailed outline
-of the things you need to know to begin testing your code with it, or
-check out some of the
-`introductory articles <https://hypothesis.works/articles/intro/>`_.
-
-
-.. toctree::
-  :maxdepth: 1
-  :hidden:
-
-  quickstart
-  details
-  settings
-  data
-  extras
-  ghostwriter
-  django
-  numpy
-  healthchecks
-  database
-  stateful
-  supported
-  examples
-  community
-  manifesto
-  endorsements
-  usage
-  strategies
-  changes
-  development
-  support
-  packaging
-  reproducing

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/manifesto.rst Deleted

@@ -1,60 +0,0 @@
-=========================
-The purpose of Hypothesis
-=========================
-
-What is Hypothesis for?
-
-From the perspective of a user, the purpose of Hypothesis is to make it easier for
-you to write better tests.
-
-From my perspective as the author, that is of course also a purpose of Hypothesis,
-but (if you will permit me to indulge in a touch of megalomania for a moment), the
-larger purpose of Hypothesis is to drag the world kicking and screaming into a new
-and terrifying age of high quality software.
-
-Software is, as they say, eating the world. Software is also `terrible`_. It's buggy,
-insecure and generally poorly thought out. This combination is clearly a recipe for
-disaster.
-
-And the state of software testing is even worse. Although it's fairly uncontroversial
-at this point that you *should* be testing your code, can you really say with a straight
-face that most projects you've worked on are adequately tested?
-
-A lot of the problem here is that it's too hard to write good tests. Your tests encode
-exactly the same assumptions and fallacies that you had when you wrote the code, so they
-miss exactly the same bugs that you missed when you wrote the code.
-
-Meanwhile, there are all sorts of tools for making testing better that are basically
-unused. The original Quickcheck is from *1999* and the majority of developers have
-not even heard of it, let alone used it. There are a bunch of half-baked implementations
-for most languages, but very few of them are worth using.
-
-The goal of Hypothesis is to bring advanced testing techniques to the masses, and to
-provide an implementation that is so high quality that it is easier to use them than
-it is not to use them. Where I can, I will beg, borrow and steal every good idea
-I can find that someone has had to make software testing better. Where I can't, I will
-invent new ones.
-
-Quickcheck is the start, but I also plan to integrate ideas from fuzz testing (a
-planned future feature is to use coverage information to drive example selection, and
-the example saving database is already inspired by the workflows people use for fuzz
-testing), and am open to and actively seeking out other suggestions and ideas.
-
-The plan is to treat the social problem of people not using these ideas as a bug to
-which there is a technical solution: Does property-based testing not match your workflow?
-That's a bug, let's fix it by figuring out how to integrate Hypothesis into it.
-Too hard to generate custom data for your application? That's a bug. Let's fix it by
-figuring out how to make it easier, or how to take something you're already using to
-specify your data and derive a generator from that automatically. Find the explanations
-of these advanced ideas hopelessly obtuse and hard to follow? That's a bug. Let's provide
-you with an easy API that lets you test your code better without a PhD in software
-verification.
-
-Grand ambitions, I know, and I expect ultimately the reality will be somewhat less
-grand, but so far in about three months of development, Hypothesis has become the most
-solid implementation of Quickcheck ever seen in a mainstream language (as long as we don't
-count Scala as mainstream yet), and at the same time managed to
-significantly push forward the state of the art, so I think there's
-reason to be optimistic.
-
-.. _terrible: https://www.youtube.com/watch?v=csyL9EC0S0c

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/numpy.rst Deleted

@@ -1,92 +0,0 @@
-===================================
-Hypothesis for the scientific stack
-===================================
-
-.. _hypothesis-numpy:
-
------
-numpy
------
-
-Hypothesis offers a number of strategies for `NumPy <https://numpy.org/>`_ testing,
-available in the ``hypothesisnumpy`` :doc:`extra </extras>`.
-It lives in the ``hypothesis.extra.numpy`` package.
-
-The centerpiece is the :func:`~hypothesis.extra.numpy.arrays` strategy, which generates arrays with
-any dtype, shape, and contents you can specify or give a strategy for.
-To make this as useful as possible, strategies are provided to generate array
-shapes and generate all kinds of fixed-size or compound dtypes.
-
-
-.. automodule:: hypothesis.extra.numpy
-   :members:
-   :exclude-members: ArrayStrategy, BasicIndexStrategy, BroadcastableShapes, MutuallyBroadcastableShapesStrategy
-
-.. _hypothesis-pandas:
-
-------
-pandas
-------
-
-Hypothesis provides strategies for several of the core pandas data types:
-:class:`pandas.Index`, :class:`pandas.Series` and :class:`pandas.DataFrame`.
-
-The general approach taken by the pandas module is that there are multiple
-strategies for generating indexes, and all of the other strategies take the
-number of entries they contain from their index strategy (with sensible defaults).
-So e.g. a Series is specified by specifying its :class:`numpy.dtype` (and/or
-a strategy for generating elements for it).
-
-.. automodule:: hypothesis.extra.pandas
-   :members:
-
-~~~~~~~~~~~~~~~~~~
-Supported versions
-~~~~~~~~~~~~~~~~~~
-
-There is quite a lot of variation between pandas versions. We only
-commit to supporting the latest version of pandas, but older minor versions are
-supported on a "best effort" basis.  Hypothesis is currently tested against
-and confirmed working with every Pandas minor version from 0.25 through to 1.3.
-
-Releases that are not the latest patch release of their minor version are not
-tested or officially supported, but will probably also work unless you hit a
-pandas bug.
-
-.. _array-api:
-
----------
-Array API
----------
-
-.. tip::
-   The Array API standard is not yet finalised, so this module will make breaking
-   changes if necessary to support newer versions of the standard.
-
-Hypothesis offers strategies for `Array API <https://data-apis.org/>`_ adopting
-libraries in the ``hypothesis.extra.array_api`` package. See :issue:`3037` for
-more details.  If you want to test with :pypi:`CuPy`, :pypi:`Dask`, :pypi:`JAX`,
-:pypi:`MXNet`, :pypi:`PyTorch <torch>`, :pypi:`TensorFlow`, or :pypi:`Xarray` -
-or just ``numpy.array_api`` - this is the extension for you!
-
-.. autofunction:: hypothesis.extra.array_api.make_strategies_namespace
-
-The resulting namespace contains all our familiar strategies like
-:func:`~xps.arrays` and :func:`~xps.from_dtype`, but based on the Array API
-standard semantics and returning objects from the ``xp`` module:
-
-.. automodule:: xps
-   :members:
-        from_dtype,
-        arrays,
-        array_shapes,
-        scalar_dtypes,
-        boolean_dtypes,
-        numeric_dtypes,
-        integer_dtypes,
-        unsigned_integer_dtypes,
-        floating_dtypes,
-        valid_tuple_axes,
-        broadcastable_shapes,
-        mutually_broadcastable_shapes,
-        indices,

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/packaging.rst Deleted

@@ -1,81 +0,0 @@
-====================
-Packaging guidelines
-====================
-
-Downstream packagers often want to package Hypothesis. Here are some guidelines.
-
-The primary guideline is this: If you are not prepared to keep up with the Hypothesis release schedule,
-don't. You will annoy me and are doing your users a disservice.
-
-Hypothesis has a very frequent release schedule. It's rare that it goes a week without a release,
-and there are often multiple releases in a given week.
-
-If you *are* prepared to keep up with this schedule, you might find the rest of this document useful.
-
-----------------
-Release tarballs
-----------------
-
-These are available from :gh-link:`the GitHub releases page <releases>`. The
-tarballs on PyPI are intended for installation from a Python tool such as :pypi:`pip` and should not
-be considered complete releases. Requests to include additional files in them will not be granted. Their absence
-is not a bug.
-
-
-------------
-Dependencies
-------------
-
-~~~~~~~~~~~~~~~
-Python versions
-~~~~~~~~~~~~~~~
-
-Hypothesis is designed to work with a range of Python versions - we support
-`all versions of CPython with upstream support <https://devguide.python.org/#status-of-python-branches>`_.
-We also support the latest versions of PyPy for Python 3.
-
-~~~~~~~~~~~~~~~~~~~~~~
-Other Python libraries
-~~~~~~~~~~~~~~~~~~~~~~
-
-Hypothesis has *mandatory* dependencies on the following libraries:
-
-* :pypi:`attrs`
-* :pypi:`sortedcontainers`
-
-Hypothesis has *optional* dependencies on the following libraries:
-
-.. literalinclude:: ../setup.py
-   :prepend: extras_require = {
-   :start-after: extras = {
-   :end-before: }
-   :append: }
-
-The way this works when installing Hypothesis normally is that these features become available if the relevant
-library is installed.
-
-Specifically for :pypi:`pytest`, our plugin supports versions of pytest which
-have been out of upstream support for some time.  Hypothesis tests can still
-be executed by even older versions of pytest - you just won't have the plugin
-to provide automatic marks, helpful usage warnings, and per-test statistics.
-
-------------------
-Testing Hypothesis
-------------------
-
-If you want to test Hypothesis as part of your packaging you will probably not want to use the mechanisms
-Hypothesis itself uses for running its tests, because it has a lot of logic for installing and testing against
-different versions of Python.
-
-The tests must be run with fairly recent tooling; check the :gh-link:`tree/master/requirements/`
-directory for details.
-
-The organisation of the tests is described in the :gh-file:`hypothesis-python/tests/README.rst`.
-
---------
-Examples
---------
-
-* `arch linux <https://archlinux.org/packages/community/any/python-hypothesis/>`_
-* `fedora <https://src.fedoraproject.org/rpms/python-hypothesis>`_
-* `gentoo <https://packages.gentoo.org/packages/dev-python/hypothesis>`_

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/quickstart.rst Deleted

@@ -1,289 +0,0 @@
-=================
-Quick start guide
-=================
-
-This document should talk you through everything you need to get started with
-Hypothesis.
-
-----------
-An example
-----------
-
-Suppose we've written a :wikipedia:`run length encoding <Run-length_encoding>`
-system and we want to test it out.
-
-We have the following code which I took straight from the
-`Rosetta Code <https://rosettacode.org/wiki/Run-length_encoding>`_ wiki (OK, I
-removed some commented out code and fixed the formatting, but there are no
-functional modifications):
-
-
-.. code:: python
-
-  def encode(input_string):
-      count = 1
-      prev = ""
-      lst = 
-      for character in input_string:
-          if character != prev:
-              if prev:
-                  entry = (prev, count)
-                  lst.append(entry)
-              count = 1
-              prev = character
-          else:
-              count += 1
-      entry = (character, count)
-      lst.append(entry)
-      return lst
-
-
-  def decode(lst):
-      q = ""
-      for character, count in lst:
-          q += character * count
-      return q
-
-
-We want to write a test for this that will check some invariant of these
-functions.
-
-The invariant one tends to try when you've got this sort of encoding /
-decoding is that if you encode something and then decode it then you get the same
-value back.
-
-Let's see how you'd do that with Hypothesis:
-
-
-.. code:: python
-
-  from hypothesis import given
-  from hypothesis.strategies import text
-
-
-  @given(text())
-  def test_decode_inverts_encode(s):
-      assert decode(encode(s)) == s
-
-(For this example we'll just let pytest discover and run the test. We'll cover
-other ways you could have run it later).
-
-The text function returns what Hypothesis calls a search strategy. An object
-with methods that describe how to generate and simplify certain kinds of
-values. The :func:`@given <hypothesis.given>` decorator then takes our test
-function and turns it into a
-parametrized one which, when called, will run the test function over a wide
-range of matching data from that strategy.
-
-Anyway, this test immediately finds a bug in the code:
-
-.. code::
-
-  Falsifying example: test_decode_inverts_encode(s='')
-
-  UnboundLocalError: local variable 'character' referenced before assignment
-
-Hypothesis correctly points out that this code is simply wrong if called on
-an empty string.
-
-If we fix that by just adding the following code to the beginning of our ``encode`` function
-then Hypothesis tells us the code is correct (by doing nothing as you'd expect
-a passing test to).
-
-.. code:: python
-
-
-    if not input_string:
-        return 
-
-If we wanted to make sure this example was always checked we could add it in
-explicitly by using the :func:`@example <hypothesis.example>` decorator:
-
-.. code:: python
-
-  from hypothesis import example, given, strategies as st
-
-
-  @given(st.text())
-  @example("")
-  def test_decode_inverts_encode(s):
-      assert decode(encode(s)) == s
-
-This can be useful to show other developers (or your future self) what kinds
-of data are valid inputs, or to ensure that particular edge cases such as
-``""`` are tested every time.  It's also great for regression tests because
-although Hypothesis will :doc:`remember failing examples <database>`,
-we don't recommend distributing that database.
-
-It's also worth noting that both :func:`@example <hypothesis.example>` and
-:func:`@given <hypothesis.given>` support keyword arguments as
-well as positional. The following would have worked just as well:
-
-.. code:: python
-
-  @given(s=st.text())
-  @example(s="")
-  def test_decode_inverts_encode(s):
-      assert decode(encode(s)) == s
-
-Suppose we had a more interesting bug and forgot to reset the count
-each time. Say we missed a line in our ``encode`` method:
-
-.. code:: python
-
-  def encode(input_string):
-      count = 1
-      prev = ""
-      lst = 
-      for character in input_string:
-          if character != prev:
-              if prev:
-                  entry = (prev, count)
-                  lst.append(entry)
-              # count = 1  # Missing reset operation
-              prev = character
-          else:
-              count += 1
-      entry = (character, count)
-      lst.append(entry)
-      return lst
-
-Hypothesis quickly informs us of the following example:
-
-.. code::
-
-  Falsifying example: test_decode_inverts_encode(s='001')
-
-Note that the example provided is really quite simple. Hypothesis doesn't just
-find *any* counter-example to your tests, it knows how to simplify the examples
-it finds to produce small easy to understand ones. In this case, two identical
-values are enough to set the count to a number different from one, followed by
-another distinct value which should have reset the count but in this case
-didn't.
-
-----------
-Installing
-----------
-
-Hypothesis is :pypi:`available on PyPI as "hypothesis" <hypothesis>`. You can install it with:
-
-.. code:: bash
-
-  pip install hypothesis
-
-You can install the dependencies for :doc:`optional extensions <extras>` with
-e.g. ``pip install hypothesispandas,django``.
-
-If you want to install directly from the source code (e.g. because you want to
-make changes and install the changed version), check out the instructions in
-:gh-file:`CONTRIBUTING.rst`.
-
--------------
-Running tests
--------------
-
-In our example above we just let pytest discover and run our tests, but we could
-also have run it explicitly ourselves:
-
-.. code:: python
-
-  if __name__ == "__main__":
-      test_decode_inverts_encode()
-
-We could also have done this as a :class:`python:unittest.TestCase`:
-
-.. code:: python
-
-  import unittest
-
-
-  class TestEncoding(unittest.TestCase):
-      @given(text())
-      def test_decode_inverts_encode(self, s):
-          self.assertEqual(decode(encode(s)), s)
-
-
-  if __name__ == "__main__":
-      unittest.main()
-
-A detail: This works because Hypothesis ignores any arguments it hasn't been
-told to provide (positional arguments start from the right), so the self
-argument to the test is simply ignored and works as normal. This also means
-that Hypothesis will play nicely with other ways of parameterizing tests. e.g
-it works fine if you use pytest fixtures for some arguments and Hypothesis for
-others.
-
--------------
-Writing tests
--------------
-
-A test in Hypothesis consists of two parts: A function that looks like a normal
-test in your test framework of choice but with some additional arguments, and
-a :func:`@given <hypothesis.given>` decorator that specifies
-how to provide those arguments.
-
-Here are some other examples of how you could use that:
-
-
-.. code:: python
-
-    from hypothesis import given, strategies as st
-
-
-    @given(st.integers(), st.integers())
-    def test_ints_are_commutative(x, y):
-        assert x + y == y + x
-
-
-    @given(x=st.integers(), y=st.integers())
-    def test_ints_cancel(x, y):
-        assert (x + y) - y == x
-
-
-    @given(st.lists(st.integers()))
-    def test_reversing_twice_gives_same_list(xs):
-        # This will generate lists of arbitrary length (usually between 0 and
-        # 100 elements) whose elements are integers.
-        ys = list(xs)
-        ys.reverse()
-        ys.reverse()
-        assert xs == ys
-
-
-    @given(st.tuples(st.booleans(), st.text()))
-    def test_look_tuples_work_too(t):
-        # A tuple is generated as the one you provided, with the corresponding
-        # types in those positions.
-        assert len(t) == 2
-        assert isinstance(t0, bool)
-        assert isinstance(t1, str)
-
-
-Note that as we saw in the above example you can pass arguments to :func:`@given <hypothesis.given>`
-either as positional or as keywords.
-
---------------
-Where to start
---------------
-
-You should now know enough of the basics to write some tests for your code
-using Hypothesis. The best way to learn is by doing, so go have a try.
-
-If you're stuck for ideas for how to use this sort of test for your code, here
-are some good starting points:
-
-1. Try just calling functions with appropriate arbitrary data and see if they
-   crash. You may be surprised how often this works. e.g. note that the first
-   bug we found in the encoding example didn't even get as far as our
-   assertion: It crashed because it couldn't handle the data we gave it, not
-   because it did the wrong thing.
-2. Look for duplication in your tests. Are there any cases where you're testing
-   the same thing with multiple different examples? Can you generalise that to
-   a single test using Hypothesis?
-3. `This piece is designed for an F# implementation
-   <https://fsharpforfunandprofit.com/posts/property-based-testing-2/>`_, but
-   is still very good advice which you may find helps give you good ideas for
-   using Hypothesis.
-
-If you have any trouble getting started, don't feel shy about
-:doc:`asking for help <community>`.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/reproducing.rst Deleted

@@ -1,153 +0,0 @@
-====================
-Reproducing failures
-====================
-
-One of the things that is often concerning for people using randomized testing
-is the question of how to reproduce failing test cases.
-
-.. note::
-    It is better to think about the data Hypothesis generates as being
-    *arbitrary*, rather than *random*.  We deliberately generate any valid
-    data that seems likely to cause errors, so you shouldn't rely on any
-    expected distribution of or relationships between generated data.
-    You can read about "swarm testing" and "coverage guided fuzzing" if
-    you're interested, because you don't need to know for Hypothesis!
-
-Fortunately Hypothesis has a number of features to support reproducing test failures. The one you
-will use most commonly when developing locally is :doc:`the example database <database>`,
-which means that you shouldn't have to think about the problem at all for local
-use - test failures will just automatically reproduce without you having to do
-anything.
-
-The example database is perfectly suitable for sharing between machines, but
-there currently aren't very good work flows for that, so Hypothesis provides a
-number of ways to make examples reproducible by adding them to the source code
-of your tests. This is particularly useful when e.g. you are trying to run an
-example that has failed on your CI, or otherwise share them between machines.
-
-.. _providing-explicit-examples:
-
----------------------------
-Providing explicit examples
----------------------------
-
-The simplest way to reproduce a failed test is to ask Hypothesis to run the
-failing example it printed.  For example, if ``Falsifying example: test(n=1)``
-was printed you can decorate ``test`` with ``@example(n=1)``.
-
-``@example`` can also be used to ensure a specific example is *always* executed
-as a regression test or to cover some edge case - basically combining a
-Hypothesis test and a traditional parametrized test.
-
-.. autofunction:: hypothesis.example
-
-Hypothesis will run all examples you've asked for first. If any of them fail it
-will not go on to look for more examples.
-
-It doesn't matter whether you put the example decorator before or after given.
-Any permutation of the decorators in the above will do the same thing.
-
-Note that examples can be positional or keyword based. If they're positional then
-they will be filled in from the right when calling, so either of the following
-styles will work as expected:
-
-.. code:: python
-
-  @given(text())
-  @example("Hello world")
-  @example(x="Some very long string")
-  def test_some_code(x):
-      pass
-
-
-  from unittest import TestCase
-
-
-  class TestThings(TestCase):
-      @given(text())
-      @example("Hello world")
-      @example(x="Some very long string")
-      def test_some_code(self, x):
-          pass
-
-As with ``@given``, it is not permitted for a single example to be a mix of
-positional and keyword arguments.
-Either are fine, and you can use one in one example and the other in another
-example if for some reason you really want to, but a single example must be
-consistent.
-
-.. _reproducing-with-seed:
-
--------------------------------------
-Reproducing a test run with ``@seed``
--------------------------------------
-
-.. autofunction:: hypothesis.seed
-
-When a test fails unexpectedly, usually due to a health check failure,
-Hypothesis will print out a seed that led to that failure, if the test is not
-already running with a fixed seed. You can then recreate that failure using either
-the ``@seed`` decorator or (if you are running :pypi:`pytest`) with
-``--hypothesis-seed``.  For example, the following test function and
-:class:`~hypothesis.stateful.RuleBasedStateMachine` will each check the
-same examples each time they are executed, thanks to ``@seed()``:
-
-.. code-block:: python
-
-    @seed(1234)
-    @given(x=...)
-    def test(x):
-        ...
-
-
-    @seed(6789)
-    class MyModel(RuleBasedStateMachine):
-        ...
-
-The seed will not be printed if you could simply use ``@example`` instead.
-
-.. _reproduce_failure:
-
--------------------------------------------------------
-Reproducing an example with ``@reproduce_failure``
--------------------------------------------------------
-
-Hypothesis has an opaque binary representation that it uses for all examples it
-generates. This representation is not intended to be stable across versions or
-with respect to changes in the test, but can be used to to reproduce failures
-with the ``@reproduce_failure`` decorator.
-
-.. autofunction:: hypothesis.reproduce_failure
-
-The intent is that you should never write this decorator by hand, but it is
-instead provided by Hypothesis.
-When a test fails with a falsifying example, Hypothesis may print out a
-suggestion to use ``@reproduce_failure`` on the test to recreate the problem
-as follows:
-
-.. code-block:: pycon
-
-    >>> from hypothesis import settings, given, PrintSettings
-    >>> import hypothesis.strategies as st
-    >>> @given(st.floats())
-    ... @settings(print_blob=True)
-    ... def test(f):
-    ...     assert f == f
-    ...
-    >>> try:
-    ...     test()
-    ... except AssertionError:
-    ...     pass
-    ...
-    Falsifying example: test(f=nan)
-
-    You can reproduce this example by temporarily adding @reproduce_failure(..., b'AAAA//AAAAAAAAEA') as a decorator on your test case
-
-Adding the suggested decorator to the test should reproduce the failure (as
-long as everything else is the same - changing the versions of Python or
-anything else involved, might of course affect the behaviour of the test! Note
-that changing the version of Hypothesis will result in a different error -
-each ``@reproduce_failure`` invocation is specific to a Hypothesis version).
-
-By default these messages are not printed.
-If you want to see these you must set the :attr:`~hypothesis.settings.print_blob` setting to ``True``.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/settings.rst Deleted

@@ -1,225 +0,0 @@
-========
-Settings
-========
-
-Hypothesis tries to have good defaults for its behaviour, but sometimes that's
-not enough and you need to tweak it.
-
-The mechanism for doing this is the :class:`~hypothesis.settings` object.
-You can set up a :func:`@given <hypothesis.given>` based test to use this using a settings
-decorator:
-
-:func:`@given <hypothesis.given>` invocation is as follows:
-
-.. code:: python
-
-    from hypothesis import given, settings
-
-
-    @given(integers())
-    @settings(max_examples=500)
-    def test_this_thoroughly(x):
-        pass
-
-This uses a :class:`~hypothesis.settings` object which causes the test to receive a much larger
-set of examples than normal.
-
-This may be applied either before or after the given and the results are
-the same. The following is exactly equivalent:
-
-
-.. code:: python
-
-    from hypothesis import given, settings
-
-
-    @settings(max_examples=500)
-    @given(integers())
-    def test_this_thoroughly(x):
-        pass
-
-------------------
-Available settings
-------------------
-
-.. autoclass:: hypothesis.settings
-    :members:
-    :exclude-members: register_profile, get_profile, load_profile
-
-.. _phases:
-
-~~~~~~~~~~~~~~~~~~~~~
-Controlling what runs
-~~~~~~~~~~~~~~~~~~~~~
-
-Hypothesis divides tests into logically distinct phases:
-
-1. Running explicit examples :ref:`provided with the @example decorator <providing-explicit-examples>`.
-2. Rerunning a selection of previously failing examples to reproduce a previously seen error
-3. Generating new examples.
-4. Mutating examples for :ref:`targeted property-based testing <targeted-search>`.
-5. Attempting to shrink an example found in previous phases (other than phase 1 - explicit examples cannot be shrunk).
-   This turns potentially large and complicated examples which may be hard to read into smaller and simpler ones.
-6. Attempting to explain the cause of the failure, by identifying suspicious lines of code
-   (e.g. the earliest lines which are never run on passing inputs, and always run on failures).
-   This relies on :func:`python:sys.settrace`, and is therefore automatically disabled on
-   PyPy or if you are using :pypi:`coverage` or a debugger.  If there are no clearly
-   suspicious lines of code, :pep:`we refuse the temptation to guess <20>`.
-
-The phases setting provides you with fine grained control over which of these run,
-with each phase corresponding to a value on the :class:`~hypothesis.Phase` enum:
-
-.. autoclass:: hypothesis.Phase
-   :members:
-
-The phases argument accepts a collection with any subset of these. e.g.
-``settings(phases=Phase.generate, Phase.shrink)`` will generate new examples
-and shrink them, but will not run explicit examples or reuse previous failures,
-while ``settings(phases=Phase.explicit)`` will only run the explicit
-examples.
-
-.. _verbose-output:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-Seeing intermediate result
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-To see what's going on while Hypothesis runs your tests, you can turn
-up the verbosity setting.
-
-.. code-block:: pycon
-
-    >>> from hypothesis import find, settings, Verbosity
-    >>> from hypothesis.strategies import lists, integers
-    >>> @given(lists(integers()))
-    ... @settings(verbosity=Verbosity.verbose)
-    ... def f(x):
-    ...     assert not any(x)
-    ... f()
-    Trying example: 
-    Falsifying example: -1198601713, -67, 116, -29578
-    Shrunk example to -1198601713
-    Shrunk example to -1198601600
-    Shrunk example to -1191228800
-    Shrunk example to -8421504
-    Shrunk example to -32896
-    Shrunk example to -128
-    Shrunk example to 64
-    Shrunk example to 32
-    Shrunk example to 16
-    Shrunk example to 8
-    Shrunk example to 4
-    Shrunk example to 3
-    Shrunk example to 2
-    Shrunk example to 1
-    1
-
-The four levels are quiet, normal, verbose and debug. normal is the default,
-while in quiet mode Hypothesis will not print anything out, not even the final
-falsifying example. debug is basically verbose but a bit more so. You probably
-don't want it.
-
-If you are using :pypi:`pytest`, you may also need to
-:doc:`disable output capturing for passing tests <pytest:how-to/capture-stdout-stderr>`.
-
--------------------------
-Building settings objects
--------------------------
-
-Settings can be created by calling :class:`~hypothesis.settings` with any of the available settings
-values. Any absent ones will be set to defaults:
-
-.. code-block:: pycon
-
-    >>> from hypothesis import settings
-    >>> settings().max_examples
-    100
-    >>> settings(max_examples=10).max_examples
-    10
-
-You can also pass a 'parent' settings object as the first argument,
-and any settings you do not specify as keyword arguments will be
-copied from the parent settings:
-
-.. code-block:: pycon
-
-    >>> parent = settings(max_examples=10)
-    >>> child = settings(parent, deadline=None)
-    >>> parent.max_examples == child.max_examples == 10
-    True
-    >>> parent.deadline
-    200
-    >>> child.deadline is None
-    True
-
-----------------
-Default settings
-----------------
-
-At any given point in your program there is a current default settings,
-available as ``settings.default``. As well as being a settings object in its own
-right, all newly created settings objects which are not explicitly based off
-another settings are based off the default, so will inherit any values that are
-not explicitly set from it.
-
-You can change the defaults by using profiles.
-
-.. _settings_profiles:
-
-~~~~~~~~~~~~~~~~~
-Settings profiles
-~~~~~~~~~~~~~~~~~
-
-Depending on your environment you may want different default settings.
-For example: during development you may want to lower the number of examples
-to speed up the tests. However, in a CI environment you may want more examples
-so you are more likely to find bugs.
-
-Hypothesis allows you to define different settings profiles. These profiles
-can be loaded at any time.
-
-.. automethod:: hypothesis.settings.register_profile
-.. automethod:: hypothesis.settings.get_profile
-.. automethod:: hypothesis.settings.load_profile
-
-Loading a profile changes the default settings but will not change the behaviour
-of tests that explicitly change the settings.
-
-.. code-block:: pycon
-
-    >>> from hypothesis import settings
-    >>> settings.register_profile("ci", max_examples=1000)
-    >>> settings().max_examples
-    100
-    >>> settings.load_profile("ci")
-    >>> settings().max_examples
-    1000
-
-Instead of loading the profile and overriding the defaults you can retrieve profiles for
-specific tests.
-
-.. code-block:: pycon
-
-    >>> settings.get_profile("ci").max_examples
-    1000
-
-Optionally, you may define the environment variable to load a profile for you.
-This is the suggested pattern for running your tests on CI.
-The code below should run in a `conftest.py` or any setup/initialization section of your test suite.
-If this variable is not defined the Hypothesis defined defaults will be loaded.
-
-.. code-block:: pycon
-
-    >>> import os
-    >>> from hypothesis import settings, Verbosity
-    >>> settings.register_profile("ci", max_examples=1000)
-    >>> settings.register_profile("dev", max_examples=10)
-    >>> settings.register_profile("debug", max_examples=10, verbosity=Verbosity.verbose)
-    >>> settings.load_profile(os.getenv(u"HYPOTHESIS_PROFILE", "default"))
-
-If you are using the hypothesis pytest plugin and your profiles are registered
-by your conftest you can load one with the command line option ``--hypothesis-profile``.
-
-.. code:: bash
-
-    $ pytest tests --hypothesis-profile <profile-name>

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/stateful.rst Deleted

@@ -1,345 +0,0 @@
-================
-Stateful testing
-================
-
-With :func:`@given <hypothesis.given>`, your tests are still something that
-you mostly write yourself, with Hypothesis providing some data.
-With Hypothesis's *stateful testing*, Hypothesis instead tries to generate
-not just data but entire tests. You specify a number of primitive
-actions that can be combined together, and then Hypothesis will
-try to find sequences of those actions that result in a failure.
-
-.. tip::
-
-    Before reading this reference documentation, we recommend reading
-    `How not to Die Hard with Hypothesis <https://hypothesis.works/articles/how-not-to-die-hard-with-hypothesis/>`__
-    and `An Introduction to Rule-Based Stateful Testing <https://hypothesis.works/articles/rule-based-stateful-testing/>`__,
-    in that order. The implementation details will make more sense once you've seen
-    them used in practice, and know *why* each method or decorator is available.
-
-.. note::
-
-  This style of testing is often called *model-based testing*, but in Hypothesis
-  is called *stateful testing* (mostly for historical reasons - the original
-  implementation of this idea in Hypothesis was more closely based on
-  `ScalaCheck's stateful testing <https://github.com/typelevel/scalacheck/blob/main/doc/UserGuide.md#stateful-testing>`_
-  where the name is more apt).
-  Both of these names are somewhat misleading: You don't really need any sort of
-  formal model of your code to use this, and it can be just as useful for pure APIs
-  that don't involve any state as it is for stateful ones.
-
-  It's perhaps best to not take the name of this sort of testing too seriously.
-  Regardless of what you call it, it is a powerful form of testing which is useful
-  for most non-trivial APIs.
-
-
-.. _data-as-state-machine:
-
--------------------------------
-You may not need state machines
--------------------------------
-
-The basic idea of stateful testing is to make Hypothesis choose actions as
-well as values for your test, and state machines are a great declarative way
-to do just that.
-
-For simpler cases though, you might not need them at all - a standard test
-with :func:`@given <hypothesis.given>` might be enough, since you can use
-:func:`~hypothesis.strategies.data` in branches or loops.  In fact, that's
-how the state machine explorer works internally.  For more complex workloads
-though, where a higher level API comes into it's own, keep reading!
-
-
-.. _rulebasedstateful:
-
--------------------------
-Rule-based state machines
--------------------------
-
-.. autoclass:: hypothesis.stateful.RuleBasedStateMachine
-
-A rule is very similar to a normal ``@given`` based test in that it takes
-values drawn from strategies and passes them to a user defined test function.
-The key difference is that where ``@given`` based tests must be independent,
-rules can be chained together - a single test run may involve multiple rule
-invocations, which may interact in various ways.
-
-Rules can take normal strategies as arguments, or a specific kind of strategy
-called a Bundle.  A Bundle is a named collection of generated values that can
-be reused by other operations in the test.
-They are populated with the results of rules, and may be used as arguments to
-rules, allowing data to flow from one rule to another, and rules to work on
-the results of previous computations or actions.
-
-You can think of each value that gets added to any Bundle as being assigned to
-a new variable.  Drawing a value from the bundle strategy means choosing one of
-the corresponding variables and using that value, and
-:func:`~hypothesis.stateful.consumes` as a ``del`` statement for that variable.
-If you can replace use of Bundles with instance attributes of the class that
-is often simpler, but often Bundles are strictly more powerful.
-
-The following rule based state machine example is a simplified version of a
-test for Hypothesis's example database implementation. An example database
-maps keys to sets of values, and in this test we compare one implementation of
-it to a simplified in memory model of its behaviour, which just stores the same
-values in a Python ``dict``. The test then runs operations against both the
-real database and the in-memory representation of it and looks for discrepancies
-in their behaviour.
-
-.. code:: python
-
-  import shutil
-  import tempfile
-  from collections import defaultdict
-
-  import hypothesis.strategies as st
-  from hypothesis.database import DirectoryBasedExampleDatabase
-  from hypothesis.stateful import Bundle, RuleBasedStateMachine, rule
-
-
-  class DatabaseComparison(RuleBasedStateMachine):
-      def __init__(self):
-          super().__init__()
-          self.tempd = tempfile.mkdtemp()
-          self.database = DirectoryBasedExampleDatabase(self.tempd)
-          self.model = defaultdict(set)
-
-      keys = Bundle("keys")
-      values = Bundle("values")
-
-      @rule(target=keys, k=st.binary())
-      def add_key(self, k):
-          return k
-
-      @rule(target=values, v=st.binary())
-      def add_value(self, v):
-          return v
-
-      @rule(k=keys, v=values)
-      def save(self, k, v):
-          self.modelk.add(v)
-          self.database.save(k, v)
-
-      @rule(k=keys, v=values)
-      def delete(self, k, v):
-          self.modelk.discard(v)
-          self.database.delete(k, v)
-
-      @rule(k=keys)
-      def values_agree(self, k):
-          assert set(self.database.fetch(k)) == self.modelk
-
-      def teardown(self):
-          shutil.rmtree(self.tempd)
-
-
-  TestDBComparison = DatabaseComparison.TestCase
-
-In this we declare two bundles - one for keys, and one for values.
-We have two trivial rules which just populate them with data (``k`` and ``v``),
-and three non-trivial rules:
-``save`` saves a value under a key and ``delete`` removes a value from a key,
-in both cases also updating the model of what *should* be in the database.
-``values_agree`` then checks that the contents of the database agrees with the
-model for a particular key.
-
-We can then integrate this into our test suite by getting a unittest TestCase
-from it:
-
-.. code:: python
-
-  TestTrees = DatabaseComparison.TestCase
-
-  # Or just run with pytest's unittest support
-  if __name__ == "__main__":
-      unittest.main()
-
-This test currently passes, but if we comment out the line where we call ``self.modelk.discard(v)``,
-we would see the following output when run under pytest:
-
-::
-
-    AssertionError: assert set() == {b''}
-
-    ------------ Hypothesis ------------
-
-    state = DatabaseComparison()
-    var1 = state.add_key(k=b'')
-    var2 = state.add_value(v=var1)
-    state.save(k=var1, v=var2)
-    state.delete(k=var1, v=var2)
-    state.values_agree(k=var1)
-    state.teardown()
-
-Note how it's printed out a very short program that will demonstrate the
-problem. The output from a rule based state machine should generally be pretty
-close to Python code - if you have custom ``repr`` implementations that don't
-return valid Python then it might not be, but most of the time you should just
-be able to copy and paste the code into a test to reproduce it.
-
-You can control the detailed behaviour with a settings object on the TestCase
-(this is a normal hypothesis settings object using the defaults at the time
-the TestCase class was first referenced). For example if you wanted to run
-fewer examples with larger programs you could change the settings to:
-
-.. code:: python
-
-  DatabaseComparison.TestCase.settings = settings(
-      max_examples=50, stateful_step_count=100
-  )
-
-Which doubles the number of steps each program runs and halves the number of
-test cases that will be run.
-
------
-Rules
------
-
-As said earlier, rules are the most common feature used in RuleBasedStateMachine.
-They are defined by applying the :func:`~hypothesis.stateful.rule` decorator
-on a function.
-Note that RuleBasedStateMachine must have at least one rule defined and that
-a single function cannot be used to define multiple rules (this to avoid having
-multiple rules doing the same things).
-Due to the stateful execution method, rules generally cannot take arguments
-from other sources such as fixtures or ``pytest.mark.parametrize`` - consider
-providing them via a strategy such as :func:`~hypothesis.strategies.sampled_from`
-instead.
-
-.. autofunction:: hypothesis.stateful.rule
-
-.. autofunction:: hypothesis.stateful.consumes
-
-.. autofunction:: hypothesis.stateful.multiple
-
------------
-Initializes
------------
-
-Initializes are a special case of rules that are guaranteed to be run at most
-once at the beginning of a run (i.e. before any normal rule is called).
-Note if multiple initialize rules are defined, they may be called in any order,
-and that order will vary from run to run.
-
-Initializes are typically useful to populate bundles:
-
-.. autofunction:: hypothesis.stateful.initialize
-
-.. code:: python
-
-    import hypothesis.strategies as st
-    from hypothesis.stateful import Bundle, RuleBasedStateMachine, initialize, rule
-
-    name_strategy = st.text(min_size=1).filter(lambda x: "/" not in x)
-
-
-    class NumberModifier(RuleBasedStateMachine):
-
-        folders = Bundle("folders")
-        files = Bundle("files")
-
-        @initialize(target=folders)
-        def init_folders(self):
-            return "/"
-
-        @rule(target=folders, name=name_strategy)
-        def create_folder(self, parent, name):
-            return f"{parent}/{name}"
-
-        @rule(target=files, name=name_strategy)
-        def create_file(self, parent, name):
-            return f"{parent}/{name}"
-
-
--------------
-Preconditions
--------------
-
-While it's possible to use :func:`~hypothesis.assume` in RuleBasedStateMachine rules, if you
-use it in only a few rules you can quickly run into a situation where few or
-none of your rules pass their assumptions. Thus, Hypothesis provides a
-:func:`~hypothesis.stateful.precondition` decorator to avoid this problem. The :func:`~hypothesis.stateful.precondition`
-decorator is used on ``rule``-decorated functions, and must be given a function
-that returns True or False based on the RuleBasedStateMachine instance.
-
-.. autofunction:: hypothesis.stateful.precondition
-
-.. code:: python
-
-    from hypothesis.stateful import RuleBasedStateMachine, precondition, rule
-
-
-    class NumberModifier(RuleBasedStateMachine):
-
-        num = 0
-
-        @rule()
-        def add_one(self):
-            self.num += 1
-
-        @precondition(lambda self: self.num != 0)
-        @rule()
-        def divide_with_one(self):
-            self.num = 1 / self.num
-
-
-By using :func:`~hypothesis.stateful.precondition` here instead of :func:`~hypothesis.assume`, Hypothesis can filter the
-inapplicable rules before running them. This makes it much more likely that a
-useful sequence of steps will be generated.
-
-Note that currently preconditions can't access bundles; if you need to use
-preconditions, you should store relevant data on the instance instead.
-
-----------
-Invariants
-----------
-
-Often there are invariants that you want to ensure are met after every step in
-a process.  It would be possible to add these as rules that are run, but they
-would be run zero or multiple times between other rules. Hypothesis provides a
-decorator that marks a function to be run after every step.
-
-.. autofunction:: hypothesis.stateful.invariant
-
-.. code:: python
-
-    from hypothesis.stateful import RuleBasedStateMachine, invariant, rule
-
-
-    class NumberModifier(RuleBasedStateMachine):
-
-        num = 0
-
-        @rule()
-        def add_two(self):
-            self.num += 2
-            if self.num > 50:
-                self.num += 1
-
-        @invariant()
-        def divide_with_one(self):
-            assert self.num % 2 == 0
-
-
-    NumberTest = NumberModifier.TestCase
-
-Invariants can also have :func:`~hypothesis.stateful.precondition`\ s applied to them, in which case
-they will only be run if the precondition function returns true.
-
-Note that currently invariants can't access bundles; if you need to use
-invariants, you should store relevant data on the instance instead.
-
--------------------------
-More fine grained control
--------------------------
-
-If you want to bypass the TestCase infrastructure you can invoke these
-manually. The stateful module exposes the function ``run_state_machine_as_test``,
-which takes an arbitrary function returning a RuleBasedStateMachine and an
-optional settings parameter and does the same as the class based runTest
-provided.
-
-This is not recommended as it bypasses some important internal functions,
-including reporting of statistics such as runtimes and :func:`~hypothesis.event`
-calls.  It was originally added to support custom ``__init__`` methods, but
-you can now use :func:`~hypothesis.stateful.initialize` rules instead.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/strategies.rst Deleted

@@ -1,206 +0,0 @@
-=============================
-Projects extending Hypothesis
-=============================
-
-Hypothesis has been eagerly used and extended by the open source community.
-This page lists extensions and applications; you can find more or newer
-packages by searching PyPI `by keyword <https://pypi.org/search/?q=hypothesis>`_
-or `filter by classifier <https://pypi.org/search/?c=Framework+%3A%3A+Hypothesis>`_,
-or search `libraries.io <https://libraries.io/search?languages=Python&q=hypothesis>`_.
-
-If there's something missing which you think should be here, let us know!
-
-.. note::
-    Being listed on this page does not imply that the Hypothesis
-    maintainers endorse a package.
-
--------------------
-External strategies
--------------------
-
-Some packages provide strategies directly:
-
-* :pypi:`hypothesis-fspaths` - strategy to generate filesystem paths.
-* :pypi:`hypothesis-geojson` - strategy to generate `GeoJson <https://geojson.org/>`_.
-* :pypi:`hypothesis-geometry` - strategies to generate geometric objects.
-* :pypi:`hs-dbus-signature` - strategy to generate arbitrary
-  `D-Bus signatures <https://dbus.freedesktop.org>`_.
-* :pypi:`hypothesis-sqlalchemy` - strategies to generate :pypi:`SQLAlchemy` objects.
-* :pypi:`hypothesis-ros` - strategies to generate messages and parameters for the `Robot Operating System <https://www.ros.org/>`_.
-* :pypi:`hypothesis-csv` - strategy to generate CSV files.
-* :pypi:`hypothesis-networkx` - strategy to generate :pypi:`networkx` graphs.
-* :pypi:`hypothesis-bio` - strategies for bioinformatics data, such as DNA, codons, FASTA, and FASTQ formats.
-* :pypi:`hypothesmith` - strategy to generate syntatically-valid Python code.
-
-Others provide a function to infer a strategy from some other schema:
-
-* :pypi:`hypothesis-jsonschema` - infer strategies from `JSON schemas <https://json-schema.org/>`_.
-* :pypi:`lollipop-hypothesis` - infer strategies from :pypi:`lollipop` schemas.
-* :pypi:`hypothesis-drf` - infer strategies from a :pypi:`djangorestframework` serialiser.
-* :pypi:`hypothesis-graphql` - infer strategies from `GraphQL schemas <https://graphql.org/>`_.
-* :pypi:`hypothesis-mongoengine` - infer strategies from a :pypi:`mongoengine` model.
-* :pypi:`hypothesis-pb` - infer strategies from `Protocol Buffer
-  <https://developers.google.com/protocol-buffers/>`_ schemas.
-
-Or some other custom integration, such as a :ref:`"hypothesis" entry point <entry-points>`:
-
-* :pypi:`deal` is a design-by-contract library with built-in Hypothesis support.
-* :pypi:`icontract-hypothesis` infers strategies from :pypi:`icontract` code contracts.
-* :pypi:`Pandera` schemas all have a ``.strategy()`` method, which returns a strategy for
-  matching :class:`~pandas:pandas.DataFrame`\ s.
-* :pypi:`Pydantic` automatically registers constrained types - so
-  :func:`~hypothesis.strategies.builds` and :func:`~hypothesis.strategies.from_type`
-  "just work" regardless of the underlying implementation.
-
------------------
-Other cool things
------------------
-
-:pypi:`schemathesis` is a tool for testing web applications built with `Open API / Swagger specifications <https://swagger.io/>`_.
-It reads the schema and generates test cases which will ensure that the application is compliant with its schema.
-The application under test could be written in any language, the only thing you need is a valid API schema in a supported format.
-Includes CLI and convenient :pypi:`pytest` integration.
-Powered by Hypothesis and :pypi:`hypothesis-jsonschema`, inspired by the earlier :pypi:`swagger-conformance` library.
-
-`Trio <https://trio.readthedocs.io/>`_ is an async framework with "an obsessive
-focus on usability and correctness", so naturally it works with Hypothesis!
-:pypi:`pytest-trio` includes :ref:`a custom hook <custom-function-execution>`
-that allows ``@given(...)`` to work with Trio-style async test functions, and
-:pypi:`hypothesis-trio` includes stateful testing extensions to support
-concurrent programs.
-
-:pypi:`pymtl3` is "an open-source Python-based hardware generation, simulation,
-and verification framework with multi-level hardware modeling support", which
-ships with Hypothesis integrations to check that all of those levels are
-equivalent, from function-level to register-transfer level and even to hardware.
-
-:pypi:`libarchimedes` makes it easy to use Hypothesis in
-`the Hy language <https://github.com/hylang/hy>`_, a Lisp embedded in Python.
-
-:pypi:`battle_tested` is a fuzzing tool that will show you how your code can
-fail - by trying all kinds of inputs and reporting whatever happens.
-
-:pypi:`pytest-subtesthack` functions as a workaround for :issue:`377`.
-
-:pypi:`returns` uses Hypothesis to verify that Higher Kinded Types correctly
-implement functor, applicative, monad, and other laws; allowing a declarative
-approach to be combined with traditional pythonic code.
-
-:pypi:`icontract-hypothesis` includes a :doc:`ghostwriter <ghostwriter>` for test files
-and IDE integrations such as `icontract-hypothesis-vim <https://github.com/mristin/icontract-hypothesis-vim>`_,
-`icontract-hypothesis-pycharm <https://github.com/mristin/icontract-hypothesis-pycharm>`_,
-and
-`icontract-hypothesis-vscode <https://github.com/mristin/icontract-hypothesis-vscode>`_ -
-you can run a quick 'smoke test' with only a few keystrokes for any type-annotated
-function, even if it doesn't have any contracts!
-
---------------------
-Writing an extension
---------------------
-
-*See* :gh-file:`CONTRIBUTING.rst` *for more information.*
-
-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!
-
-If you're thinking about writing an extension, please name it
-``hypothesis-{something}`` - a standard prefix makes the community more
-visible and searching for extensions easier.  And make sure you use the
-``Framework :: Hypothesis`` trove classifier!
-
-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
-standard library. Strategies for other things are also welcome; anything with
-external dependencies just goes in ``hypothesis.extra``.
-
-Tools such as assertion helpers may also need to check whether the current
-test is using Hypothesis:
-
-.. autofunction:: hypothesis.currently_in_test_context
-
-
-.. _entry-points:
-
---------------------------------------------------
-Hypothesis integration via setuptools entry points
---------------------------------------------------
-
-If you would like to ship Hypothesis strategies for a custom type - either as
-part of the upstream library, or as a third-party extension, there's a catch:
-:func:`~hypothesis.strategies.from_type` only works after the corresponding
-call to :func:`~hypothesis.strategies.register_type_strategy`, and you'll have
-the same problem with :func:`~hypothesis.register_random`.  This means that
-either
-
-- you have to try importing Hypothesis to register the strategy when *your*
-  library is imported, though that's only useful at test time, or
-- the user has to call a 'register the strategies' helper that you provide
-  before running their tests
-
-`Entry points <https://amir.rachum.com/blog/2017/07/28/python-entry-points/>`__
-are Python's standard way of automating the latter: when you register a
-``"hypothesis"`` entry point in your ``setup.py``, we'll import and run it
-automatically when *hypothesis* is imported.  Nothing happens unless Hypothesis
-is already in use, and it's totally seamless for downstream users!
-
-Let's look at an example.  You start by adding a function somewhere in your
-package that does all the Hypothesis-related setup work:
-
-.. code-block:: python
-
-    # mymodule.py
-
-
-    class MyCustomType:
-        def __init__(self, x: int):
-            assert x >= 0, f"got {x}, but only positive numbers are allowed"
-            self.x = x
-
-
-    def _hypothesis_setup_hook():
-        import hypothesis.strategies as st
-
-        st.register_type_strategy(MyCustomType, st.integers(min_value=0))
-
-and then tell ``setuptools`` that this is your ``"hypothesis"`` entry point:
-
-.. code-block:: python
-
-    # setup.py
-
-    # You can list a module to import by dotted name
-    entry_points = {"hypothesis": "_ = mymodule.a_submodule"}
-
-    # Or name a specific function too, and Hypothesis will call it for you
-    entry_points = {"hypothesis": "_ = mymodule:_hypothesis_setup_hook"}
-
-And that's all it takes!
-
-.. note::
-    On Python 3.7, where the ``importlib.metadata`` module
-    is not in the standard library, loading entry points requires either the
-    :pypi:`importlib_metadata` (preferred) or :pypi:`setuptools` (fallback)
-    package to be installed.
-
-
-Interaction with :pypi:`pytest-cov`
------------------------------------
-
-Because pytest does not load plugins from entrypoints in any particular order,
-using the Hypothesis entrypoint may import your module before :pypi:`pytest-cov`
-starts.  `This is a known issue <https://github.com/pytest-dev/pytest/issues/935>`__,
-but there are workarounds.
-
-You can use :command:`coverage run pytest ...` instead of :command:`pytest --cov ...`,
-opting out of the pytest plugin entirely.  Alternatively, you can ensure that Hypothesis
-is loaded after coverage measurement is started by disabling the entrypoint, and
-loading our pytest plugin from your ``conftest.py`` instead::
-
-    echo "pytest_plugins = 'hypothesis.extra.pytestplugin'\n" > tests/conftest.py
-    pytest -p "no:hypothesispytest" ...

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/support.rst Deleted

@@ -1,21 +0,0 @@
-================
-Help and support
-================
-
-For questions you are happy to ask in public, the :doc:`Hypothesis community <community>` is a
-friendly place where I or others will be more than happy to help you out. You're also welcome to
-ask questions on Stack Overflow. If you do, please tag them with
-`'python-hypothesis' <https://stackoverflow.com/questions/tagged/python-hypothesis>`_ so someone
-sees them.
-
-For bugs and enhancements, please file an issue on the :issue:`GitHub issue tracker <>`.
-Note that as per the :doc:`development policy <development>`, enhancements will probably not get
-implemented unless you're willing to pay for development or implement them yourself
-(with assistance from the maintainers). Bugs
-will tend to get fixed reasonably promptly, though it is of course on a best effort basis.
-
-To see the versions of Python, optional dependencies, test runners, and operating systems Hypothesis
-supports (meaning incompatibility is treated as a bug), see :doc:`supported`.
-
-If you need to ask questions privately or want more of a guarantee of bugs being fixed promptly, please contact me on
-hypothesis-support@drmaciver.com to talk about availability of support contracts.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/supported.rst Deleted

@@ -1,103 +0,0 @@
-=============
-Compatibility
-=============
-
-Hypothesis does its level best to be compatible with everything you could
-possibly need it to be compatible with. Generally you should just try it and
-expect it to work. If it doesn't, you can be surprised and check this document
-for the details.
-
--------------------
-Hypothesis versions
--------------------
-
-Backwards compatibility is better than backporting fixes, so we use
-:ref:`semantic versioning <release-policy>` and only support the most recent
-version of Hypothesis.  See :doc:`support` for more information.
-
-Documented APIs will not break except between major version bumps.
-All APIs mentioned in this documentation are public unless explicitly
-noted as provisional, in which case they may be changed in minor releases.
-Undocumented attributes, modules, and behaviour may include breaking
-changes in patch releases.
-
----------------
-Python versions
----------------
-
-Hypothesis is supported and tested on CPython 3.7+, i.e.
-`all versions of CPython with upstream support <https://devguide.python.org/#status-of-python-branches>`_,
-along with PyPy for the same versions.
-32-bit builds of CPython also work, though we only test them on Windows.
-
-In general Hypothesis does not officially support anything except the latest
-patch release of any version of Python it supports. Earlier releases should work
-and bugs in them will get fixed if reported, but they're not tested in CI and
-no guarantees are made.
-
------------------
-Operating systems
------------------
-
-In theory Hypothesis should work anywhere that Python does. In practice it is
-only known to work and regularly tested on OS X, Windows and Linux, and you may
-experience issues running it elsewhere.
-
-If you're using something else and it doesn't work, do get in touch and I'll try
-to help, but unless you can come up with a way for me to run a CI server on that
-operating system it probably won't stay fixed due to the inevitable march of time.
-
-.. _framework-compatibility:
-
-------------------
-Testing frameworks
-------------------
-
-In general Hypothesis goes to quite a lot of effort to generate things that
-look like normal Python test functions that behave as closely to the originals
-as possible, so it should work sensibly out of the box with every test framework.
-
-If your testing relies on doing something other than calling a function and seeing
-if it raises an exception then it probably *won't* work out of the box. In particular
-things like tests which return generators and expect you to do something with them
-(e.g. nose's yield based tests) will not work. Use a decorator or similar to wrap the
-test to take this form, or ask the framework maintainer to support our
-:ref:`hooks for inserting such a wrapper later <custom-function-execution>`.
-
-In terms of what's actually *known* to work:
-
-  * Hypothesis integrates as smoothly with pytest and unittest as we can make it,
-    and this is verified as part of the CI.
-  * :pypi:`pytest` fixtures work in the usual way for tests that have been decorated
-    with :func:`@given <hypothesis.given>` - just avoid passing a strategy for
-    each argument that will be supplied by a fixture.  However, each fixture
-    will run once for the whole function, not once per example.  Decorating a
-    fixture function with :func:`@given <hypothesis.given>` is meaningless.
-  * The :func:`python:unittest.mock.patch` decorator works with
-    :func:`@given <hypothesis.given>`, but we recommend using it as a context
-    manager within the decorated test to ensure that the mock is per-test-case
-    and avoid poor interactions with Pytest fixtures.
-  * Nose works fine with Hypothesis, and this is tested as part of the CI. ``yield`` based
-    tests simply won't work.
-  * Integration with Django's testing requires use of the :ref:`hypothesis-django` extra.
-    The issue is that in Django's tests' normal mode of execution it will reset the
-    database once per test rather than once per example, which is not what you want.
-  * :pypi:`Coverage` works out of the box with Hypothesis; our own test suite has
-    100% branch coverage.
-
------------------
-Optional packages
------------------
-
-The supported versions of optional packages, for strategies in ``hypothesis.extra``,
-are listed in the documentation for that extra.  Our general goal is to support
-all versions that are supported upstream.
-
-------------------------
-Regularly verifying this
-------------------------
-
-Everything mentioned above as explicitly supported is checked on every commit
-with :gh-file:`GitHub Actions <actions>`.
-Our continuous delivery pipeline runs all of these checks before publishing
-each release, so when we say they're supported we really mean it.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/docs/usage.rst Deleted

@@ -1,59 +0,0 @@
-=====================================
-Open source projects using Hypothesis
-=====================================
-
-The following is a non-exhaustive list of open source projects I know are
-using Hypothesis. If you're aware of any others please add them to the list!
-The only inclusion criterion right now is that if it's a Python library
-then it should be available on PyPI.
-
-You can find hundreds more from `the Hypothesis page at libraries.io
-<https://libraries.io/pypi/hypothesis>`_, and :gh-file:`thousands on GitHub <network/dependents>`.
-Hypothesis has `over 100,000 downloads per week <https://pypistats.org/packages/hypothesis>`__,
-and was used by `more than 4% of Python users surveyed by the PSF in 2020
-<https://www.jetbrains.com/lp/python-developers-survey-2020/>`__.
-
-* `aur <https://github.com/cdown/aur>`_
-* `argon2_cffi <https://github.com/hynek/argon2-cffi>`_
-* `attrs <https://github.com/python-attrs/attrs>`_
-* `axelrod <https://github.com/Axelrod-Python/Axelrod>`_
-* `bidict <https://github.com/jab/bidict>`_
-* `binaryornot <https://github.com/audreyfeldroy/binaryornot>`_
-* `brotlicffi <https://github.com/python-hyper/brotlicffi>`_
-* :pypi:`chardet`
-* :pypi:`cmph-cffi`
-* `cryptography <https://github.com/pyca/cryptography>`_
-* `dbus-signature-pyparsing <https://github.com/stratis-storage/dbus-signature-pyparsing>`_
-* `dry-python/returns <https://github.com/dry-python/returns>`_
-* `fastnumbers <https://github.com/SethMMorton/fastnumbers>`_
-* `flocker <https://github.com/ClusterHQ/flocker>`_
-* `flownetpy <https://github.com/debsankha/flownetpy>`_
-* `funsize <https://github.com/mozilla-releng/funsize>`_
-* `fusion-index <https://github.com/fusionapp/fusion-index>`_
-* `hyper-h2 <https://github.com/python-hyper/h2>`_
-* `into-dbus-python <https://github.com/stratis-storage/into-dbus-python>`_
-* `justbases <https://github.com/mulkieran/justbases>`_
-* `justbytes <https://github.com/mulkieran/justbytes>`_
-* `loris <https://github.com/loris-imageserver/loris>`_
-* `mariadb-dyncol <https://github.com/adamchainz/mariadb-dyncol>`_
-* `mercurial <https://www.mercurial-scm.org/>`_
-* `natsort <https://github.com/SethMMorton/natsort>`_
-* `poliastro <https://github.com/poliastro/poliastro>`_
-* `pretext <https://github.com/moreati/b-prefix-all-the-doctests>`_
-* `priority <https://github.com/python-hyper/priority>`_
-* `PyCEbox <https://github.com/AustinRochford/PyCEbox>`_
-* `PyPy <https://www.pypy.org/>`_
-* `pyrsistent <https://github.com/tobgu/pyrsistent>`_
-* `python-humble-utils <https://github.com/webyneter/python-humble-utils>`_
-* `pyudev <https://github.com/pyudev/pyudev>`_
-* `qutebrowser <https://github.com/qutebrowser/qutebrowser>`_
-* `RubyMarshal <https://github.com/d9pouces/RubyMarshal>`_
-* `Segpy <https://github.com/sixty-north/segpy>`_
-* `simoa <https://github.com/andsor/pysimoa>`_
-* `srt <https://github.com/cdown/srt>`_
-* `tchannel <https://github.com/uber/tchannel-python>`_
-* `vdirsyncer <https://github.com/pimutils/vdirsyncer>`_
-* `wcag-contrast-ratio <https://github.com/gsnedders/wcag-contrast-ratio>`_
-* `yacluster <https://github.com/KrzysiekJ/yacluster>`_
-* `yturl <https://github.com/cdown/yturl>`_
-* `zenml <https://github.com/zenml-io/zenml>`_

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/README.rst Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/example_hypothesis_entrypoint Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/example_hypothesis_entrypoint/example_hypothesis_entrypoint.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/example_hypothesis_entrypoint/setup.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/example_hypothesis_entrypoint/test_entrypoint.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/test_binary_search.py Deleted

@@ -1,128 +0,0 @@
-# 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/.
-
-"""This file demonstrates testing a binary search.
-
-It's a useful example because the result of the binary search is so clearly
-determined by the invariants it must satisfy, so we can simply test for those
-invariants.
-
-It also demonstrates the useful testing technique of testing how the answer
-should change (or not) in response to movements in the underlying data.
-"""
-
-from hypothesis import given, strategies as st
-
-
-def binary_search(ls, v):
-    """Take a list ls and a value v such that ls is sorted and v is comparable
-    with the elements of ls.
-
-    Return an index i such that 0 <= i <= len(v) with the properties:
-
-    1. ls.insert(i, v) is sorted
-    2. ls.insert(j, v) is not sorted for j < i
-    """
-    # Without this check we will get an index error on the next line when the
-    # list is empty.
-    if not ls:
-        return 0
-
-    # Without this check we will miss the case where the insertion point should
-    # be zero: The invariant we maintain in the next section is that lo is
-    # always strictly lower than the insertion point.
-    if v <= ls0:
-        return 0
-
-    # Invariant: There is no insertion point i with i <= lo
-    lo = 0
-
-    # Invariant: There is an insertion point i with i <= hi
-    hi = len(ls)
-    while lo + 1 < hi:
-        mid = (lo + hi) // 2
-        if v > lsmid:
-            # Inserting v anywhere below mid would result in an unsorted list
-            # because it's > the value at mid. Therefore mid is a valid new lo
-            lo = mid
-        # Uncommenting the following lines will cause this to return a valid
-        # insertion point which is not always minimal.
-        # elif v == lsmid:
-        #   return mid
-        else:
-            # Either v == lsmid in which case mid is a valid insertion point
-            # or v < lsmid, in which case all valid insertion points must be
-            # < hi. Either way, mid is a valid new hi.
-            hi = mid
-    assert lo + 1 == hi
-    # We now know that there is a valid insertion point <= hi and there is no
-    # valid insertion point < hi because hi - 1 is lo. Therefore hi is the
-    # answer we were seeking
-    return hi
-
-
-def is_sorted(ls):
-    """Is this list sorted?"""
-    for i in range(len(ls) - 1):
-        if lsi > lsi + 1:
-            return False
-    return True
-
-
-Values = st.integers()
-
-# We generate arbitrary lists and turn this into generating sorting lists
-# by just sorting them.
-SortedLists = st.lists(Values).map(sorted)
-
-# We could also do it this way, but that would be a bad idea:
-# SortedLists = st.lists(Values).filter(is_sorted)
-# The problem is that Hypothesis will only generate long sorted lists with very
-# low probability, so we are much better off post-processing values into the
-# form we want than filtering them out.
-
-
-@given(ls=SortedLists, v=Values)
-def test_insert_is_sorted(ls, v):
-    """We test the first invariant: binary_search should return an index such
-    that inserting the value provided at that index would result in a sorted
-    set."""
-    ls.insert(binary_search(ls, v), v)
-    assert is_sorted(ls)
-
-
-@given(ls=SortedLists, v=Values)
-def test_is_minimal(ls, v):
-    """We test the second invariant: binary_search should return an index such
-    that no smaller index is a valid insertion point for v."""
-    for i in range(binary_search(ls, v)):
-        ls2 = list(ls)
-        ls2.insert(i, v)
-        assert not is_sorted(ls2)
-
-
-@given(ls=SortedLists, v=Values)
-def test_inserts_into_same_place_twice(ls, v):
-    """In this we test a *consequence* of the second invariant: When we insert
-    a value into a list twice, the insertion point should be the same both
-    times. This is because we know that v is > the previous element and == the
-    next element.
-
-    In theory if the former passes, this should always pass. In practice,
-    failures are detected by this test with much higher probability because it
-    deliberately puts the data into a shape that is likely to trigger a
-    failure.
-
-    This is an instance of a good general category of test: Testing how the
-    function moves in responses to changes in the underlying data.
-    """
-    i = binary_search(ls, v)
-    ls.insert(i, v)
-    assert binary_search(ls, v) == i

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/examples/test_rle.py Deleted

@@ -1,94 +0,0 @@
-# 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/.
-
-"""This example demonstrates testing a run length encoding scheme. That is, we
-take a sequence and represent it by a shorter sequence where each 'run' of
-consecutive equal elements is represented as a single element plus a count. So
-e.g.
-
-1, 1, 1, 1, 2, 1 is represented as 1, 4, 2, 1, 1, 1
-
-This demonstrates the useful decode(encode(x)) == x invariant that is often
-a fruitful source of testing with Hypothesis.
-
-It also has an example of testing invariants in response to changes in the
-underlying data.
-"""
-
-from hypothesis import assume, given, strategies as st
-
-
-def run_length_encode(seq):
-    """Encode a sequence as a new run-length encoded sequence."""
-    if not seq:
-        return 
-    # By starting off the count at zero we simplify the iteration logic
-    # slightly.
-    result = seq0, 0
-    for s in seq:
-        if (
-            # If you uncomment this line this branch will be skipped and we'll
-            # always append a new run of length 1. Note which tests fail.
-            # False and
-            s
-            == result-10
-            # Try uncommenting this line and see what problems occur:
-            # and result-1-1 < 2
-        ):
-            result-11 += 1
-        else:
-            result.append(s, 1)
-    return result
-
-
-def run_length_decode(seq):
-    """Take a previously encoded sequence and reconstruct the original from
-    it."""
-    result = 
-    for s, i in seq:
-        for _ in range(i):
-            result.append(s)
-    return result
-
-
-# We use lists of a type that should have a relatively high duplication rate,
-# otherwise we'd almost never get any runs.
-Lists = st.lists(st.integers(0, 10))
-
-
-@given(Lists)
-def test_decodes_to_starting_sequence(ls):
-    """If we encode a sequence and then decode the result, we should get the
-    original sequence back.
-
-    Otherwise we've done something very wrong.
-    """
-    assert run_length_decode(run_length_encode(ls)) == ls
-
-
-@given(Lists, st.data())
-def test_duplicating_an_element_does_not_increase_length(ls, data):
-    """The previous test could be passed by simply returning the input sequence
-    so we need something that tests the compression property of our encoding.
-
-    In this test we deliberately introduce or extend a run and assert
-    that this does not increase the length of our encoding, because they
-    should be part of the same run in the final result.
-    """
-    # We use assume to get a valid index into the list. We could also have used
-    # e.g. flatmap, but this is relatively straightforward and will tend to
-    # perform better.
-    assume(ls)
-    i = data.draw(st.integers(0, len(ls) - 1))
-    ls2 = list(ls)
-    # duplicating the value at i right next to it guarantees they are part of
-    # the same run in the resulting compression.
-    ls2.insert(i, ls2i)
-    assert len(run_length_encode(ls2)) == len(run_length_encode(ls))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/pyrightconfig.json Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/scripts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/scripts/basic-test.sh Deleted

@@ -1,88 +0,0 @@
-#!/bin/bash
-set -e -o xtrace
-
-HERE="$( cd "$( dirname "${BASH_SOURCE0}" )" && pwd )"
-cd "$HERE/.."
-
-python -c '
-import os
-for k, v in sorted(dict(os.environ).items()):
-    print("%s=%s" % (k, v))
-'
-
-pip install .
-
-
-PYTEST="python -bb -X dev -m pytest -nauto"
-
-# Run all the no-extra-dependency tests for this version (except slow nocover tests)
-$PYTEST tests/cover tests/pytest
-
-# Run tests for each extra module while the requirements are installed
-pip install ".pytz, dateutil, zoneinfo"
-$PYTEST tests/datetime/
-pip uninstall -y pytz python-dateutil
-
-pip install ".dpcontracts"
-$PYTEST tests/dpcontracts/
-pip uninstall -y dpcontracts
-
-pip install "$(grep 'fakeredis==' ../requirements/coverage.txt)"
-$PYTEST tests/redis/
-pip uninstall -y redis fakeredis
-
-pip install "$(grep 'typing-extensions==' ../requirements/coverage.txt)"
-$PYTEST tests/typing_extensions/
-if  "$(python -c 'import sys; print(sys.version_info:2 == (3, 7))')" = "False"  ; then
-  # Required by importlib_metadata backport, which we don't want to break
-  pip uninstall -y typing_extensions
-fi
-
-pip install ".lark"
-$PYTEST tests/lark/
-pip install "$(grep 'lark-parser==' ../requirements/coverage.txt)"
-$PYTEST tests/lark/
-pip uninstall -y lark-parser
-
-if  "$(python -c $'import platform, sys; print(sys.version_info.releaselevel == \'final\' and platform.python_implementation() != "PyPy")')" = "True"  ; then
-  pip install ".codemods,cli"
-  $PYTEST tests/codemods/
-  pip uninstall -y libcst click
-
-  if  "$(python -c 'import sys; print(sys.version_info:2 == (3, 7))')" = "True"  ; then
-    # Per NEP-29, this is the last version to support Python 3.7
-    pip install numpy==1.21.5
-  else
-    pip install "$(grep 'numpy==' ../requirements/coverage.txt)"
-  fi
-
-  pip install "$(grep 'black==' ../requirements/coverage.txt)"
-  $PYTEST tests/ghostwriter/
-  pip uninstall -y black numpy
-fi
-
-if  "$(python -c 'import sys; print(sys.version_info:2 == (3, 8))')" = "False"  ; then
-  exit 0
-fi
-
-$PYTEST tests/nocover/
-
-# Run some tests without docstrings or assertions, to catch bugs
-# like issue #822 in one of the test decorators.  See also #1541.
-PYTHONOPTIMIZE=2 $PYTEST \
-    -W'ignore:assertions not in test modules or plugins will be ignored because assert statements are not executed by the underlying Python interpreter:pytest.PytestConfigWarning' \
-    -W'ignore:Module already imported so cannot be rewritten:pytest.PytestAssertRewriteWarning' \
-    tests/cover/test_testdecorators.py
-
-if  "$(python -c 'import platform; print(platform.python_implementation())')" != "PyPy" ; then
-  pip install .django
-  HYPOTHESIS_DJANGO_USETZ=TRUE python -m tests.django.manage test tests.django
-  HYPOTHESIS_DJANGO_USETZ=FALSE python -m tests.django.manage test tests.django
-  pip uninstall -y django pytz
-
-  pip install "$(grep 'numpy==' ../requirements/coverage.txt)"
-  $PYTEST tests/numpy
-
-  pip install "$(grep 'pandas==' ../requirements/coverage.txt)"
-  $PYTEST tests/pandas
-fi

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/scripts/validate_branch_check.py Deleted

@@ -1,60 +0,0 @@
-# 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 sys
-from collections import defaultdict
-
-if __name__ == "__main__":
-    with open("branch-check") as i:
-        data = json.loads(l) for l in i
-
-    checks = defaultdict(set)
-
-    for d in data:
-        checksd"name".add(d"value")
-
-    if not checks:
-        print("No branches found in the branch-check file?")
-        sys.exit(1)
-
-    always_true = 
-    always_false = 
-
-    for c, vs in sorted(checks.items()):
-        if len(vs) < 2:
-            v = list(vs)0
-            assert v in (False, True)
-            if v:
-                always_true.append(c)
-            else:
-                always_false.append(c)
-
-    failure = always_true or always_false
-
-    if failure:
-        print("Some branches were not properly covered.")
-
-    if always_true:
-        print()
-        print("The following were always True:")
-        for c in always_true:
-            print(f"  * {c}")
-    if always_false:
-        print()
-        print("The following were always False:")
-        for c in always_false:
-            print(f"  * {c}")
-    if failure:
-        sys.exit(1)
-
-    print(
-        f"""Successfully validated {len(checks)} branch{"es" if len(checks) > 1 else ""}."""
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/setup.cfg Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/setup.py Deleted

@@ -1,135 +0,0 @@
-# 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 os
-import sys
-import warnings
-
-import setuptools
-
-if sys.version_info:2 < (3, 7):
-    raise Exception(
-        "You are trying to install Hypothesis using Python "
-        f"{sys.version.split()0}, but it requires Python 3.7 or later."
-        "Update `pip` and `setuptools`, try again, and you will automatically "
-        "get the latest compatible version of Hypothesis instead.  "
-        "See also https://python3statement.org/practicalities/"
-    )
-
-
-def local_file(name):
-    return os.path.relpath(os.path.join(os.path.dirname(__file__), name))
-
-
-SOURCE = local_file("src")
-README = local_file("README.rst")
-
-setuptools_version = tuple(map(int, setuptools.__version__.split("."):2))
-
-if setuptools_version < (36, 2):
-    # Warning only - very bad if uploading bdist but fine if installing sdist.
-    warnings.warn(
-        "This version of setuptools is too old to correctly store "
-        "conditional dependencies in binary wheels.  For more info, see:  "
-        "https://hynek.me/articles/conditional-python-dependencies/"
-    )
-
-
-# Assignment to placate pyflakes. The actual version is from the exec that follows.
-__version__ = None
-
-with open(local_file("src/hypothesis/version.py")) as o:
-    exec(o.read())
-
-assert __version__ is not None
-
-
-extras = {
-    "cli": "click>=7.0", "black>=19.10b0", "rich>=9.0.0",
-    "codemods": "libcst>=0.3.16",
-    "ghostwriter": "black>=19.10b0",
-    "pytz": "pytz>=2014.1",
-    "dateutil": "python-dateutil>=1.4",
-    "lark": "lark-parser>=0.6.5",
-    "numpy": "numpy>=1.9.0",
-    "pandas": "pandas>=0.25",
-    "pytest": "pytest>=4.6",
-    "dpcontracts": "dpcontracts>=0.4",
-    "redis": "redis>=3.0.0",
-    # zoneinfo is an odd one: every dependency is conditional, because they're
-    # only necessary on old versions of Python or Windows systems.
-    "zoneinfo": 
-        "tzdata>=2022.1 ; sys_platform == 'win32'",
-        "backports.zoneinfo>=0.2.1 ; python_version<'3.9'",
-    ,
-    # We only support Django versions with upstream support - see
-    # https://www.djangoproject.com/download/#supported-versions
-    # We also leave the choice of timezone library to the user, since it
-    # might be zoneinfo or pytz depending on version and configuration.
-    "django": "django>=2.2",
-}
-
-extras"all" = sorted(
-    set(sum(extras.values(), "importlib_metadata>=3.6; python_version<'3.8'"))
-)
-
-
-setuptools.setup(
-    name="hypothesis",
-    version=__version__,
-    author="David R. MacIver and Zac Hatfield-Dodds",
-    author_email="david@drmaciver.com",
-    packages=setuptools.find_packages(SOURCE),
-    package_dir={"": SOURCE},
-    package_data={"hypothesis": "py.typed", "vendor/tlds-alpha-by-domain.txt"},
-    url="https://hypothesis.works",
-    project_urls={
-        "Source": "https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-python",
-        "Changelog": "https://hypothesis.readthedocs.io/en/latest/changes.html",
-        "Documentation": "https://hypothesis.readthedocs.io",
-        "Issues": "https://github.com/HypothesisWorks/hypothesis/issues",
-    },
-    license="MPL-2.0",
-    description="A library for property-based testing",
-    zip_safe=False,
-    extras_require=extras,
-    install_requires="attrs>=19.2.0", "sortedcontainers>=2.1.0,<3.0.0",
-    python_requires=">=3.7",
-    classifiers=
-        "Development Status :: 5 - Production/Stable",
-        "Framework :: Hypothesis",
-        "Framework :: Pytest",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
-        "Operating System :: Unix",
-        "Operating System :: POSIX",
-        "Operating System :: Microsoft :: Windows",
-        "Programming Language :: Python",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: Implementation :: CPython",
-        "Programming Language :: Python :: Implementation :: PyPy",
-        "Topic :: Education :: Testing",
-        "Topic :: Software Development :: Testing",
-        "Typing :: Typed",
-    ,
-    py_modules="_hypothesis_pytestplugin",
-    entry_points={
-        "pytest11": "hypothesispytest = _hypothesis_pytestplugin",
-        "console_scripts": "hypothesis = hypothesis.extra.cli:main",
-    },
-    long_description=open(README).read(),
-    long_description_content_type="text/x-rst",
-    keywords="python testing fuzzing property-based-testing",
-)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/_hypothesis_pytestplugin.py Deleted

@@ -1,361 +0,0 @@
-# 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/.
-
-"""
-The pytest plugin for Hypothesis.
-
-We move this from the old location at `hypothesis.extra.pytestplugin` so that it
-can be loaded by Pytest without importing Hypothesis.  In turn, this means that
-Hypothesis will not load our own third-party plugins (with associated side-effects)
-unless and until the user explicitly runs `import hypothesis`.
-
-See https://github.com/HypothesisWorks/hypothesis/issues/3140 for details.
-"""
-
-import base64
-import sys
-from inspect import signature
-
-import pytest
-
-try:
-    from _pytest.junitxml import xml_key
-except ImportError:
-    xml_key = "_xml"  # type: ignore
-
-LOAD_PROFILE_OPTION = "--hypothesis-profile"
-VERBOSITY_OPTION = "--hypothesis-verbosity"
-PRINT_STATISTICS_OPTION = "--hypothesis-show-statistics"
-SEED_OPTION = "--hypothesis-seed"
-EXPLAIN_OPTION = "--hypothesis-explain"
-
-_VERBOSITY_NAMES = "quiet", "normal", "verbose", "debug"
-_ALL_OPTIONS = 
-    LOAD_PROFILE_OPTION,
-    VERBOSITY_OPTION,
-    PRINT_STATISTICS_OPTION,
-    SEED_OPTION,
-    EXPLAIN_OPTION,
-
-_FIXTURE_MSG = """Function-scoped fixture {0!r} used by {1!r}
-
-Function-scoped fixtures are not reset between examples generated by
-`@given(...)`, which is often surprising and can cause subtle test bugs.
-
-If you were expecting the fixture to run separately for each generated example,
-then unfortunately you will need to find a different way to achieve your goal
-(e.g. using a similar context manager instead of a fixture).
-
-If you are confident that your test will work correctly even though the
-fixture is not reset between generated examples, you can suppress this health
-check to assure Hypothesis that you understand what you are doing.
-"""
-
-STATS_KEY = "_hypothesis_stats"
-
-
-class StoringReporter:
-    def __init__(self, config):
-        assert "hypothesis" in sys.modules
-        from hypothesis.reporting import default
-
-        self.report = default
-        self.config = config
-        self.results = 
-
-    def __call__(self, msg):
-        if self.config.getoption("capture", "fd") == "no":
-            self.report(msg)
-        if not isinstance(msg, str):
-            msg = repr(msg)
-        self.results.append(msg)
-
-
-# Avoiding distutils.version.LooseVersion due to
-# https://github.com/HypothesisWorks/hypothesis/issues/2490
-if tuple(map(int, pytest.__version__.split("."):2)) < (4, 6):  # pragma: no cover
-    import warnings
-
-    PYTEST_TOO_OLD_MESSAGE = """
-        You are using pytest version %s. Hypothesis tests work with any test
-        runner, but our pytest plugin requires pytest 4.6 or newer.
-        Note that the pytest developers no longer support your version either!
-        Disabling the Hypothesis pytest plugin...
-    """
-    warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,))
-
-else:
-
-    def pytest_addoption(parser):
-        group = parser.getgroup("hypothesis", "Hypothesis")
-        group.addoption(
-            LOAD_PROFILE_OPTION,
-            action="store",
-            help="Load in a registered hypothesis.settings profile",
-        )
-        group.addoption(
-            VERBOSITY_OPTION,
-            action="store",
-            choices=_VERBOSITY_NAMES,
-            help="Override profile with verbosity setting specified",
-        )
-        group.addoption(
-            PRINT_STATISTICS_OPTION,
-            action="store_true",
-            help="Configure when statistics are printed",
-            default=False,
-        )
-        group.addoption(
-            SEED_OPTION,
-            action="store",
-            help="Set a seed to use for all Hypothesis tests",
-        )
-        group.addoption(
-            EXPLAIN_OPTION,
-            action="store_true",
-            help="Enable the `explain` phase for failing Hypothesis tests",
-            default=False,
-        )
-
-    def _any_hypothesis_option(config):
-        return bool(any(config.getoption(opt) for opt in _ALL_OPTIONS))
-
-    def pytest_report_header(config):
-        if not (
-            config.option.verbose >= 1
-            or "hypothesis" in sys.modules
-            or _any_hypothesis_option(config)
-        ):
-            return None
-
-        from hypothesis import Verbosity, settings
-
-        if config.option.verbose < 1 and settings.default.verbosity < Verbosity.verbose:
-            return None
-        settings_str = settings.default.show_changed()
-        if settings_str != "":
-            settings_str = f" -> {settings_str}"
-        return f"hypothesis profile {settings._current_profile!r}{settings_str}"
-
-    def pytest_configure(config):
-        config.addinivalue_line("markers", "hypothesis: Tests which use hypothesis.")
-        if not _any_hypothesis_option(config):
-            return
-        from hypothesis import Phase, Verbosity, core, settings
-
-        profile = config.getoption(LOAD_PROFILE_OPTION)
-        if profile:
-            settings.load_profile(profile)
-        verbosity_name = config.getoption(VERBOSITY_OPTION)
-        if verbosity_name and verbosity_name != settings.default.verbosity.name:
-            verbosity_value = Verbosityverbosity_name
-            name = f"{settings._current_profile}-with-{verbosity_name}-verbosity"
-            # register_profile creates a new profile, exactly like the current one,
-            # with the extra values given (in this case 'verbosity')
-            settings.register_profile(name, verbosity=verbosity_value)
-            settings.load_profile(name)
-        if (
-            config.getoption(EXPLAIN_OPTION)
-            and Phase.explain not in settings.default.phases
-        ):
-            name = f"{settings._current_profile}-with-explain-phase"
-            phases = settings.default.phases + (Phase.explain,)
-            settings.register_profile(name, phases=phases)
-            settings.load_profile(name)
-
-        seed = config.getoption(SEED_OPTION)
-        if seed is not None:
-            try:
-                seed = int(seed)
-            except ValueError:
-                pass
-            core.global_force_seed = seed
-
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_runtest_call(item):
-        if not (hasattr(item, "obj") and "hypothesis" in sys.modules):
-            yield
-            return
-
-        from hypothesis import core
-        from hypothesis.internal.detection import is_hypothesis_test
-
-        core.running_under_pytest = True
-
-        if not is_hypothesis_test(item.obj):
-            # If @given was not applied, check whether other hypothesis
-            # decorators were applied, and raise an error if they were.
-            if getattr(item.obj, "is_hypothesis_strategy_function", False):
-                from hypothesis.errors import InvalidArgument
-
-                raise InvalidArgument(
-                    f"{item.nodeid} is a function that returns a Hypothesis strategy, "
-                    "but pytest has collected it as a test function.  This is useless "
-                    "as the function body will never be executed.  To define a test "
-                    "function, use @given instead of @composite."
-                )
-            message = "Using `@%s` on a test without `@given` is completely pointless."
-            for name, attribute in 
-                ("example", "hypothesis_explicit_examples"),
-                ("seed", "_hypothesis_internal_use_seed"),
-                ("settings", "_hypothesis_internal_settings_applied"),
-                ("reproduce_example", "_hypothesis_internal_use_reproduce_failure"),
-            :
-                if hasattr(item.obj, attribute):
-                    from hypothesis.errors import InvalidArgument
-
-                    raise InvalidArgument(message % (name,))
-            yield
-        else:
-            from hypothesis import HealthCheck, settings
-            from hypothesis.internal.escalation import current_pytest_item
-            from hypothesis.internal.healthcheck import fail_health_check
-            from hypothesis.reporting import with_reporter
-            from hypothesis.statistics import collector, describe_statistics
-
-            # Retrieve the settings for this test from the test object, which
-            # is normally a Hypothesis wrapped_test wrapper. If this doesn't
-            # work, the test object is probably something weird
-            # (e.g a stateful test wrapper), so we skip the function-scoped
-            # fixture check.
-            settings = getattr(item.obj, "_hypothesis_internal_use_settings", None)
-
-            # Check for suspicious use of function-scoped fixtures, but only
-            # if the corresponding health check is not suppressed.
-            if (
-                settings is not None
-                and HealthCheck.function_scoped_fixture
-                not in settings.suppress_health_check
-            ):
-                # Warn about function-scoped fixtures, excluding autouse fixtures because
-                # the advice is probably not actionable and the status quo seems OK...
-                # See https://github.com/HypothesisWorks/hypothesis/issues/377 for detail.
-                argnames = None
-                for fx_defs in item._request._fixturemanager.getfixtureinfo(
-                    node=item, func=item.function, cls=None
-                ).name2fixturedefs.values():
-                    if argnames is None:
-                        argnames = frozenset(signature(item.function).parameters)
-                    for fx in fx_defs:
-                        if fx.argname in argnames:
-                            active_fx = item._request._get_active_fixturedef(fx.argname)
-                            if active_fx.scope == "function":
-                                fail_health_check(
-                                    settings,
-                                    _FIXTURE_MSG.format(fx.argname, item.nodeid),
-                                    HealthCheck.function_scoped_fixture,
-                                )
-
-            if item.get_closest_marker("parametrize") is not None:
-                # Give every parametrized test invocation a unique database key
-                key = item.nodeid.encode()
-                item.obj.hypothesis.inner_test._hypothesis_internal_add_digest = key
-
-            store = StoringReporter(item.config)
-
-            def note_statistics(stats):
-                stats"nodeid" = item.nodeid
-                item.hypothesis_statistics = describe_statistics(stats)
-
-            with collector.with_value(note_statistics):
-                with with_reporter(store):
-                    with current_pytest_item.with_value(item):
-                        yield
-            if store.results:
-                item.hypothesis_report_information = list(store.results)
-
-    def _stash_get(config, key, default):
-        if hasattr(config, "stash"):
-            # pytest 7
-            return config.stash.get(key, default)
-        elif hasattr(config, "_store"):
-            # pytest 5.4
-            return config._store.get(key, default)
-        else:
-            return getattr(config, key, default)
-
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_runtest_makereport(item, call):
-        report = (yield).get_result()
-        if hasattr(item, "hypothesis_report_information"):
-            report.sections.append(
-                ("Hypothesis", "\n".join(item.hypothesis_report_information))
-            )
-        if hasattr(item, "hypothesis_statistics") and report.when == "teardown":
-            stats = item.hypothesis_statistics
-            stats_base64 = base64.b64encode(stats.encode()).decode()
-
-            name = "hypothesis-statistics-" + item.nodeid
-
-            # Include hypothesis information to the junit XML report.
-            #
-            # Note that when `pytest-xdist` is enabled, `xml_key` is not present in the
-            # stash, so we don't add anything to the junit XML report in that scenario.
-            # https://github.com/pytest-dev/pytest/issues/7767#issuecomment-1082436256
-            xml = _stash_get(item.config, xml_key, None)
-            if xml:
-                xml.add_global_property(name, stats_base64)
-
-            # If there's a terminal report, include our summary stats for each test
-            terminalreporter = item.config.pluginmanager.getplugin("terminalreporter")
-            if terminalreporter is not None:
-                # ideally, we would store this on terminalreporter.config.stash, but
-                # pytest-xdist doesn't copy that back to the controller
-                report.__dict__STATS_KEY = stats
-
-            # If there's an HTML report, include our summary stats for each test
-            pytest_html = item.config.pluginmanager.getplugin("html")
-            if pytest_html is not None:  # pragma: no cover
-                report.extra = getattr(report, "extra", ) + 
-                    pytest_html.extras.text(stats, name="Hypothesis stats")
-                
-
-    def pytest_terminal_summary(terminalreporter):
-        if terminalreporter.config.getoption(PRINT_STATISTICS_OPTION):
-            terminalreporter.section("Hypothesis Statistics")
-            for reports in terminalreporter.stats.values():
-                for report in reports:
-                    stats = report.__dict__.get(STATS_KEY)
-                    if stats:
-                        terminalreporter.write_line(stats + "\n\n")
-
-    def pytest_collection_modifyitems(items):
-        if "hypothesis" not in sys.modules:
-            return
-
-        from hypothesis.internal.detection import is_hypothesis_test
-
-        for item in items:
-            if isinstance(item, pytest.Function) and is_hypothesis_test(item.obj):
-                item.add_marker("hypothesis")
-
-    # Monkeypatch some internals to prevent applying @pytest.fixture() to a
-    # function which has already been decorated with @hypothesis.given().
-    # (the reverse case is already an explicit error in Hypothesis)
-    # We do this here so that it catches people on old Pytest versions too.
-    from _pytest import fixtures
-
-    def _ban_given_call(self, function):
-        if "hypothesis" in sys.modules:
-            from hypothesis.internal.detection import is_hypothesis_test
-
-            if is_hypothesis_test(function):
-                raise RuntimeError(
-                    f"Can't apply @pytest.fixture() to {function.__name__} because "
-                    "it is already decorated with @hypothesis.given()"
-                )
-        return _orig_call(self, function)
-
-    _orig_call = fixtures.FixtureFunctionMarker.__call__
-    fixtures.FixtureFunctionMarker.__call__ = _ban_given_call  # type: ignore
-
-
-def load():
-    """Required for `pluggy` to load a plugin from setuptools entrypoints."""

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/_error_if_old.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/_settings.py Deleted

@@ -1,693 +0,0 @@
-# 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/.
-
-"""A module controlling settings for Hypothesis to use in falsification.
-
-Either an explicit settings object can be used or the default object on
-this module can be modified.
-"""
-
-import contextlib
-import datetime
-import inspect
-import os
-import warnings
-from enum import Enum, IntEnum, unique
-from typing import TYPE_CHECKING, Any, Collection, Dict, List, Optional, TypeVar, Union
-
-import attr
-
-from hypothesis.errors import (
-    HypothesisDeprecationWarning,
-    InvalidArgument,
-    InvalidState,
-)
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.internal.validation import check_type, try_convert
-from hypothesis.utils.conventions import not_set
-from hypothesis.utils.dynamicvariables import DynamicVariable
-
-if TYPE_CHECKING:
-    from hypothesis.database import ExampleDatabase
-
-__all__ = "settings"
-
-all_settings: Dictstr, "Setting" = {}
-
-T = TypeVar("T")
-
-
-class settingsProperty:
-    def __init__(self, name, show_default):
-        self.name = name
-        self.show_default = show_default
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        else:
-            try:
-                result = obj.__dict__self.name
-                # This is a gross hack, but it preserves the old behaviour that
-                # you can change the storage directory and it will be reflected
-                # in the default database.
-                if self.name == "database" and result is not_set:
-                    from hypothesis.database import ExampleDatabase
-
-                    result = ExampleDatabase(not_set)
-                return result
-            except KeyError:
-                raise AttributeError(self.name) from None
-
-    def __set__(self, obj, value):
-        obj.__dict__self.name = value
-
-    def __delete__(self, obj):
-        raise AttributeError(f"Cannot delete attribute {self.name}")
-
-    @property
-    def __doc__(self):
-        description = all_settingsself.name.description
-        default = (
-            repr(getattr(settings.default, self.name))
-            if self.show_default
-            else "(dynamically calculated)"
-        )
-        return f"{description}\n\ndefault value: ``{default}``"
-
-
-default_variable = DynamicVariable(None)
-
-
-class settingsMeta(type):
-    def __init__(cls, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    @property
-    def default(cls):
-        v = default_variable.value
-        if v is not None:
-            return v
-        if hasattr(settings, "_current_profile"):
-            settings.load_profile(settings._current_profile)
-            assert default_variable.value is not None
-        return default_variable.value
-
-    def _assign_default_internal(cls, value):
-        default_variable.value = value
-
-    def __setattr__(cls, name, value):
-        if name == "default":
-            raise AttributeError(
-                "Cannot assign to the property settings.default - "
-                "consider using settings.load_profile instead."
-            )
-        elif not (isinstance(value, settingsProperty) or name.startswith("_")):
-            raise AttributeError(
-                f"Cannot assign hypothesis.settings.{name}={value!r} - the settings "
-                "class is immutable.  You can change the global default "
-                "settings with settings.load_profile, or use @settings(...) "
-                "to decorate your test instead."
-            )
-        return super().__setattr__(name, value)
-
-
-class settings(metaclass=settingsMeta):
-    """A settings object controls a variety of parameters that are used in
-    falsification. These may control both the falsification strategy and the
-    details of the data that is generated.
-
-    Default values are picked up from the settings.default object and
-    changes made there will be picked up in newly created settings.
-    """
-
-    __definitions_are_locked = False
-    _profiles: Dictstr, "settings" = {}
-    __module__ = "hypothesis"
-
-    def __getattr__(self, name):
-        if name in all_settings:
-            return all_settingsname.default
-        else:
-            raise AttributeError(f"settings has no attribute {name}")
-
-    def __init__(
-        self,
-        parent: Optional"settings" = None,
-        *,
-        # This looks pretty strange, but there's good reason: we want Mypy to detect
-        # bad calls downstream, but not to freak out about the `= not_set` part even
-        # though it's not semantically valid to pass that as an argument value.
-        # The intended use is "like **kwargs, but more tractable for tooling".
-        max_examples: int = not_set,  # type: ignore
-        derandomize: bool = not_set,  # type: ignore
-        database: UnionNone, "ExampleDatabase" = not_set,  # type: ignore
-        verbosity: "Verbosity" = not_set,  # type: ignore
-        phases: Collection"Phase" = not_set,  # type: ignore
-        stateful_step_count: int = not_set,  # type: ignore
-        report_multiple_bugs: bool = not_set,  # type: ignore
-        suppress_health_check: Collection"HealthCheck" = not_set,  # type: ignore
-        deadline: UnionNone, int, float, datetime.timedelta = not_set,  # type: ignore
-        print_blob: bool = not_set,  # type: ignore
-    ) -> None:
-        if parent is not None:
-            check_type(settings, parent, "parent")
-        if derandomize not in (not_set, False):
-            if database not in (not_set, None):
-                raise InvalidArgument(
-                    "derandomize=True implies database=None, so passing "
-                    f"database={database!r} too is invalid."
-                )
-            database = None
-
-        defaults = parent or settings.default
-        if defaults is not None:
-            for setting in all_settings.values():
-                value = locals()setting.name
-                if value is not_set:
-                    object.__setattr__(
-                        self, setting.name, getattr(defaults, setting.name)
-                    )
-                else:
-                    object.__setattr__(self, setting.name, setting.validator(value))
-
-    def __call__(self, test: T) -> T:
-        """Make the settings object (self) an attribute of the test.
-
-        The settings are later discovered by looking them up on the test itself.
-        """
-        # Aliasing as Any avoids mypy errors (attr-defined) when accessing and
-        # setting custom attributes on the decorated function or class.
-        _test: Any = test
-
-        # Using the alias here avoids a mypy error (return-value) later when
-        # ``test`` is returned, because this check results in type refinement.
-        if not callable(_test):
-            raise InvalidArgument(
-                "settings objects can be called as a decorator with @given, "
-                f"but decorated test={test!r} is not callable."
-            )
-        if inspect.isclass(test):
-            from hypothesis.stateful import RuleBasedStateMachine
-
-            if issubclass(_test, RuleBasedStateMachine):
-                attr_name = "_hypothesis_internal_settings_applied"
-                if getattr(test, attr_name, False):
-                    raise InvalidArgument(
-                        "Applying the @settings decorator twice would "
-                        "overwrite the first version; merge their arguments "
-                        "instead."
-                    )
-                setattr(test, attr_name, True)
-                _test.TestCase.settings = self
-                return test  # type: ignore
-            else:
-                raise InvalidArgument(
-                    "@settings(...) can only be used as a decorator on "
-                    "functions, or on subclasses of RuleBasedStateMachine."
-                )
-        if hasattr(_test, "_hypothesis_internal_settings_applied"):
-            # Can't use _hypothesis_internal_use_settings as an indicator that
-            # @settings was applied, because @given also assigns that attribute.
-            descr = get_pretty_function_description(test)
-            raise InvalidArgument(
-                f"{descr} has already been decorated with a settings object.\n"
-                f"    Previous:  {_test._hypothesis_internal_use_settings!r}\n"
-                f"    This:  {self!r}"
-            )
-
-        _test._hypothesis_internal_use_settings = self
-        _test._hypothesis_internal_settings_applied = True
-        return test
-
-    @classmethod
-    def _define_setting(
-        cls,
-        name,
-        description,
-        default,
-        options=None,
-        validator=None,
-        show_default=True,
-    ):
-        """Add a new setting.
-
-        - name is the name of the property that will be used to access the
-          setting. This must be a valid python identifier.
-        - description will appear in the property's docstring
-        - default is the default value. This may be a zero argument
-          function in which case it is evaluated and its result is stored
-          the first time it is accessed on any given settings object.
-        """
-        if settings.__definitions_are_locked:
-            raise InvalidState(
-                "settings have been locked and may no longer be defined."
-            )
-        if options is not None:
-            options = tuple(options)
-            assert default in options
-
-            def validator(value):
-                if value not in options:
-                    msg = f"Invalid {name}, {value!r}. Valid options: {options!r}"
-                    raise InvalidArgument(msg)
-                return value
-
-        else:
-            assert validator is not None
-
-        all_settingsname = Setting(
-            name=name,
-            description=description.strip(),
-            default=default,
-            validator=validator,
-        )
-        setattr(settings, name, settingsProperty(name, show_default))
-
-    @classmethod
-    def lock_further_definitions(cls):
-        settings.__definitions_are_locked = True
-
-    def __setattr__(self, name, value):
-        raise AttributeError("settings objects are immutable")
-
-    def __repr__(self):
-        bits = sorted(f"{name}={getattr(self, name)!r}" for name in all_settings)
-        return "settings({})".format(", ".join(bits))
-
-    def show_changed(self):
-        bits = 
-        for name, setting in all_settings.items():
-            value = getattr(self, name)
-            if value != setting.default:
-                bits.append(f"{name}={value!r}")
-        return ", ".join(sorted(bits, key=len))
-
-    @staticmethod
-    def register_profile(
-        name: str,
-        parent: Optional"settings" = None,
-        **kwargs: Any,
-    ) -> None:
-        """Registers a collection of values to be used as a settings profile.
-
-        Settings profiles can be loaded by name - for example, you might
-        create a 'fast' profile which runs fewer examples, keep the 'default'
-        profile, and create a 'ci' profile that increases the number of
-        examples and uses a different database to store failures.
-
-        The arguments to this method are exactly as for
-        :class:`~hypothesis.settings`: optional ``parent`` settings, and
-        keyword arguments for each setting that will be set differently to
-        parent (or settings.default, if parent is None).
-        """
-        check_type(str, name, "name")
-        settings._profilesname = settings(parent=parent, **kwargs)
-
-    @staticmethod
-    def get_profile(name: str) -> "settings":
-        """Return the profile with the given name."""
-        check_type(str, name, "name")
-        try:
-            return settings._profilesname
-        except KeyError:
-            raise InvalidArgument(f"Profile {name!r} is not registered") from None
-
-    @staticmethod
-    def load_profile(name: str) -> None:
-        """Loads in the settings defined in the profile provided.
-
-        If the profile does not exist, InvalidArgument will be raised.
-        Any setting not defined in the profile will be the library
-        defined default for that setting.
-        """
-        check_type(str, name, "name")
-        settings._current_profile = name
-        settings._assign_default_internal(settings.get_profile(name))
-
-
-@contextlib.contextmanager
-def local_settings(s):
-    default_context_manager = default_variable.with_value(s)
-    with default_context_manager:
-        yield s
-
-
-@attr.s()
-class Setting:
-    name = attr.ib()
-    description = attr.ib()
-    default = attr.ib()
-    validator = attr.ib()
-
-
-def _max_examples_validator(x):
-    check_type(int, x, name="max_examples")
-    if x < 1:
-        raise InvalidArgument(
-            f"max_examples={x!r} should be at least one. You can disable "
-            "example generation with the `phases` setting instead."
-        )
-    return x
-
-
-settings._define_setting(
-    "max_examples",
-    default=100,
-    validator=_max_examples_validator,
-    description="""
-Once this many satisfying examples have been considered without finding any
-counter-example, falsification will terminate.
-
-The default value is chosen to suit a workflow where the test will be part of
-a suite that is regularly executed locally or on a CI server, balancing total
-running time against the chance of missing a bug.
-
-If you are writing one-off tests, running tens of thousands of examples is
-quite reasonable as Hypothesis may miss uncommon bugs with default settings.
-For very complex code, we have observed Hypothesis finding novel bugs after
-*several million* examples while testing :pypi:`SymPy`.
-If you are running more than 100k examples for a test, consider using our
-:ref:`integration for coverage-guided fuzzing <fuzz_one_input>` - it really
-shines when given minutes or hours to run.
-""",
-)
-
-
-settings._define_setting(
-    "derandomize",
-    default=False,
-    options=(True, False),
-    description="""
-If True, seed Hypothesis' random number generator using a hash of the test
-function, so that every run will test the same set of examples until you
-update Hypothesis, Python, or the test function.
-
-This allows you to `check for regressions and look for bugs
-<https://blog.nelhage.com/post/two-kinds-of-testing/>`__ using
-:ref:`separate settings profiles <settings_profiles>` - for example running
-quick deterministic tests on every commit, and a longer non-deterministic
-nightly testing run.
-""",
-)
-
-
-def _validate_database(db):
-    from hypothesis.database import ExampleDatabase
-
-    if db is None or isinstance(db, ExampleDatabase):
-        return db
-    raise InvalidArgument(
-        "Arguments to the database setting must be None or an instance of "
-        f"ExampleDatabase.  Try passing database=ExampleDatabase({db!r}), or "
-        "construct and use one of the specific subclasses in "
-        "hypothesis.database"
-    )
-
-
-settings._define_setting(
-    "database",
-    default=not_set,
-    show_default=False,
-    description="""
-An instance of :class:`~hypothesis.database.ExampleDatabase` that will be
-used to save examples to and load previous examples from. May be ``None``
-in which case no storage will be used.
-
-See the :doc:`example database documentation <database>` for a list of built-in
-example database implementations, and how to define custom implementations.
-""",
-    validator=_validate_database,
-)
-
-
-@unique
-class Phase(IntEnum):
-    explicit = 0  #: controls whether explicit examples are run.
-    reuse = 1  #: controls whether previous examples will be reused.
-    generate = 2  #: controls whether new examples will be generated.
-    target = 3  #: controls whether examples will be mutated for targeting.
-    shrink = 4  #: controls whether examples will be shrunk.
-    explain = 5  #: controls whether Hypothesis attempts to explain test failures.
-
-    def __repr__(self):
-        return f"Phase.{self.name}"
-
-
-@unique
-class HealthCheck(Enum):
-    """Arguments for :attr:`~hypothesis.settings.suppress_health_check`.
-
-    Each member of this enum is a type of health check to suppress.
-    """
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}.{self.name}"
-
-    @classmethod
-    def all(cls) -> List"HealthCheck":
-        return list(HealthCheck)
-
-    data_too_large = 1
-    """Checks if too many examples are aborted for being too large.
-
-    This is measured by the number of random choices that Hypothesis makes
-    in order to generate something, not the size of the generated object.
-    For example, choosing a 100MB object from a predefined list would take
-    only a few bits, while generating 10KB of JSON from scratch might trigger
-    this health check.
-    """
-
-    filter_too_much = 2
-    """Check for when the test is filtering out too many examples, either
-    through use of :func:`~hypothesis.assume()` or :ref:`filter() <filtering>`,
-    or occasionally for Hypothesis internal reasons."""
-
-    too_slow = 3
-    """Check for when your data generation is extremely slow and likely to hurt
-    testing."""
-
-    return_value = 5
-    """Checks if your tests return a non-None value (which will be ignored and
-    is unlikely to do what you want)."""
-
-    large_base_example = 7
-    """Checks if the natural example to shrink towards is very large."""
-
-    not_a_test_method = 8
-    """Checks if :func:`@given <hypothesis.given>` has been applied to a
-    method defined by :class:`python:unittest.TestCase` (i.e. not a test)."""
-
-    function_scoped_fixture = 9
-    """Checks if :func:`@given <hypothesis.given>` has been applied to a test
-    with a pytest function-scoped fixture. Function-scoped fixtures run once
-    for the whole function, not once per example, and this is usually not what
-    you want.
-
-    Because of this limitation, tests that need to set up or reset
-    state for every example need to do so manually within the test itself,
-    typically using an appropriate context manager.
-
-    Suppress this health check only in the rare case that you are using a
-    function-scoped fixture that does not need to be reset between individual
-    examples, but for some reason you cannot use a wider fixture scope
-    (e.g. session scope, module scope, class scope).
-
-    This check requires the :ref:`Hypothesis pytest plugin<pytest-plugin>`,
-    which is enabled by default when running Hypothesis inside pytest."""
-
-
-@unique
-class Verbosity(IntEnum):
-    quiet = 0
-    normal = 1
-    verbose = 2
-    debug = 3
-
-    def __repr__(self):
-        return f"Verbosity.{self.name}"
-
-
-settings._define_setting(
-    "verbosity",
-    options=tuple(Verbosity),
-    default=Verbosity.normal,
-    description="Control the verbosity level of Hypothesis messages",
-)
-
-
-def _validate_phases(phases):
-    phases = tuple(phases)
-    for a in phases:
-        if not isinstance(a, Phase):
-            raise InvalidArgument(f"{a!r} is not a valid phase")
-    return tuple(p for p in list(Phase) if p in phases)
-
-
-settings._define_setting(
-    "phases",
-    # We leave the `explain` phase disabled by default, for speed and brevity
-    # TODO: consider default-enabling this in CI?
-    default=_validate_phases(set(Phase) - {Phase.explain}),
-    description=(
-        "Control which phases should be run. "
-        "See :ref:`the full documentation for more details <phases>`"
-    ),
-    validator=_validate_phases,
-)
-
-
-def _validate_stateful_step_count(x):
-    check_type(int, x, name="stateful_step_count")
-    if x < 1:
-        raise InvalidArgument(f"stateful_step_count={x!r} must be at least one.")
-    return x
-
-
-settings._define_setting(
-    name="stateful_step_count",
-    default=50,
-    validator=_validate_stateful_step_count,
-    description="""
-Number of steps to run a stateful program for before giving up on it breaking.
-""",
-)
-
-settings._define_setting(
-    name="report_multiple_bugs",
-    default=True,
-    options=(True, False),
-    description="""
-Because Hypothesis runs the test many times, it can sometimes find multiple
-bugs in a single run.  Reporting all of them at once is usually very useful,
-but replacing the exceptions can occasionally clash with debuggers.
-If disabled, only the exception with the smallest minimal example is raised.
-""",
-)
-
-
-def validate_health_check_suppressions(suppressions):
-    suppressions = try_convert(list, suppressions, "suppress_health_check")
-    for s in suppressions:
-        if not isinstance(s, HealthCheck):
-            raise InvalidArgument(
-                f"Non-HealthCheck value {s!r} of type {type(s).__name__} "
-                "is invalid in suppress_health_check."
-            )
-    return suppressions
-
-
-settings._define_setting(
-    "suppress_health_check",
-    default=(),
-    description="""A list of :class:`~hypothesis.HealthCheck` items to disable.""",
-    validator=validate_health_check_suppressions,
-)
-
-
-class duration(datetime.timedelta):
-    """A timedelta specifically measured in milliseconds."""
-
-    def __repr__(self):
-        ms = self.total_seconds() * 1000
-        return f"timedelta(milliseconds={int(ms) if ms == int(ms) else ms!r})"
-
-
-def _validate_deadline(x):
-    if x is None:
-        return x
-    invalid_deadline_error = InvalidArgument(
-        f"deadline={x!r} (type {type(x).__name__}) must be a timedelta object, "
-        "an integer or float number of milliseconds, or None to disable the "
-        "per-test-case deadline."
-    )
-    if isinstance(x, (int, float)):
-        if isinstance(x, bool):
-            raise invalid_deadline_error
-        try:
-            x = duration(milliseconds=x)
-        except OverflowError:
-            raise InvalidArgument(
-                f"deadline={x!r} is invalid, because it is too large to represent "
-                "as a timedelta. Use deadline=None to disable deadlines."
-            ) from None
-    if isinstance(x, datetime.timedelta):
-        if x <= datetime.timedelta(0):
-            raise InvalidArgument(
-                f"deadline={x!r} is invalid, because it is impossible to meet a "
-                "deadline <= 0. Use deadline=None to disable deadlines."
-            )
-        return duration(seconds=x.total_seconds())
-    raise invalid_deadline_error
-
-
-settings._define_setting(
-    "deadline",
-    default=duration(milliseconds=200),
-    validator=_validate_deadline,
-    description="""
-If set, a duration (as timedelta, or integer or float number of milliseconds)
-that each individual example (i.e. each time your test
-function is called, not the whole decorated test) within a test is not
-allowed to exceed. Tests which take longer than that may be converted into
-errors (but will not necessarily be if close to the deadline, to allow some
-variability in test run time).
-
-Set this to ``None`` to disable this behaviour entirely.
-""",
-)
-
-
-def is_in_ci() -> bool:
-    # GitHub Actions, Travis CI and AppVeyor have "CI"
-    # Azure Pipelines has "TF_BUILD"
-    return "CI" in os.environ or "TF_BUILD" in os.environ
-
-
-settings._define_setting(
-    "print_blob",
-    default=is_in_ci(),
-    show_default=False,
-    options=(True, False),
-    description="""
-If set to ``True``, Hypothesis will print code for failing examples that can be used with
-:func:`@reproduce_failure <hypothesis.reproduce_failure>` to reproduce the failing example.
-The default is ``True`` if the ``CI`` or ``TF_BUILD`` env vars are set, ``False`` otherwise.
-""",
-)
-
-settings.lock_further_definitions()
-
-
-def note_deprecation(message: str, *, since: str, has_codemod: bool) -> None:
-    if since != "RELEASEDAY":
-        date = datetime.datetime.strptime(since, "%Y-%m-%d").date()
-        assert datetime.date(2016, 1, 1) <= date
-    if has_codemod:
-        message += (
-            "\n    The `hypothesis codemod` command-line tool can automatically "
-            "refactor your code to fix this warning."
-        )
-    warnings.warn(HypothesisDeprecationWarning(message), stacklevel=2)
-
-
-settings.register_profile("default", settings())
-settings.load_profile("default")
-assert settings.default is not None
-
-
-# Check that the kwonly args to settings.__init__ is the same as the set of
-# defined settings - in case we've added or remove something from one but
-# not the other.
-assert set(all_settings) == {
-    p.name
-    for p in inspect.signature(settings.__init__).parameters.values()
-    if p.kind == inspect.Parameter.KEYWORD_ONLY
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/control.py Deleted

@@ -1,189 +0,0 @@
-# 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 math
-import traceback
-from typing import NoReturn, Union
-
-from hypothesis import Verbosity, settings
-from hypothesis.errors import CleanupFailed, InvalidArgument, UnsatisfiedAssumption
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.internal.validation import check_type
-from hypothesis.reporting import report, verbose_report
-from hypothesis.utils.dynamicvariables import DynamicVariable
-
-
-def reject() -> NoReturn:
-    raise UnsatisfiedAssumption()
-
-
-def assume(condition: object) -> bool:
-    """Calling ``assume`` is like an :ref:`assert <python:assert>` that marks
-    the example as bad, rather than failing the test.
-
-    This allows you to specify properties that you *assume* will be
-    true, and let Hypothesis try to avoid similar examples in future.
-    """
-    if not condition:
-        raise UnsatisfiedAssumption()
-    return True
-
-
-_current_build_context = DynamicVariable(None)
-
-
-def currently_in_test_context() -> bool:
-    """Return ``True`` if the calling code is currently running inside an
-    :func:`@given <hypothesis.given>` or :doc:`stateful <stateful>` test,
-    ``False`` otherwise.
-
-    This is useful for third-party integrations and assertion helpers which
-    may be called from traditional or property-based tests, but can only use
-    :func:`~hypothesis.assume` or :func:`~hypothesis.target` in the latter case.
-    """
-    return _current_build_context.value is not None
-
-
-def current_build_context():
-    context = _current_build_context.value
-    if context is None:
-        raise InvalidArgument("No build context registered")
-    return context
-
-
-class BuildContext:
-    def __init__(self, data, is_final=False, close_on_capture=True):
-        assert isinstance(data, ConjectureData)
-        self.data = data
-        self.tasks = 
-        self.is_final = is_final
-        self.close_on_capture = close_on_capture
-        self.close_on_del = False
-
-    def __enter__(self):
-        self.assign_variable = _current_build_context.with_value(self)
-        self.assign_variable.__enter__()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.assign_variable.__exit__(exc_type, exc_value, tb)
-        if self.close() and exc_type is None:
-            raise CleanupFailed()
-
-    def close(self):
-        any_failed = False
-        for task in self.tasks:
-            try:
-                task()
-            except BaseException:
-                any_failed = True
-                report(traceback.format_exc())
-        return any_failed
-
-
-def cleanup(teardown):
-    """Register a function to be called when the current test has finished
-    executing. Any exceptions thrown in teardown will be printed but not
-    rethrown.
-
-    Inside a test this isn't very interesting, because you can just use
-    a finally block, but note that you can use this inside map, flatmap,
-    etc. in order to e.g. insist that a value is closed at the end.
-    """
-    context = _current_build_context.value
-    if context is None:
-        raise InvalidArgument("Cannot register cleanup outside of build context")
-    context.tasks.append(teardown)
-
-
-def should_note():
-    context = _current_build_context.value
-    if context is None:
-        raise InvalidArgument("Cannot make notes outside of a test")
-    return context.is_final or settings.default.verbosity >= Verbosity.verbose
-
-
-def note(value: str) -> None:
-    """Report this value for the minimal failing example."""
-    if should_note():
-        report(value)
-
-
-def event(value: str) -> None:
-    """Record an event that occurred this test. Statistics on number of test
-    runs with each event will be reported at the end if you run Hypothesis in
-    statistics reporting mode.
-
-    Events should be strings or convertible to them.
-    """
-    context = _current_build_context.value
-    if context is None:
-        raise InvalidArgument("Cannot make record events outside of a test")
-
-    context.data.note_event(value)
-
-
-def target(observation: Unionint, float, *, label: str = "") -> Unionint, float:
-    """Calling this function with an ``int`` or ``float`` observation gives it feedback
-    with which to guide our search for inputs that will cause an error, in
-    addition to all the usual heuristics.  Observations must always be finite.
-
-    Hypothesis will try to maximize the observed value over several examples;
-    almost any metric will work so long as it makes sense to increase it.
-    For example, ``-abs(error)`` is a metric that increases as ``error``
-    approaches zero.
-
-    Example metrics:
-
-    - Number of elements in a collection, or tasks in a queue
-    - Mean or maximum runtime of a task (or both, if you use ``label``)
-    - Compression ratio for data (perhaps per-algorithm or per-level)
-    - Number of steps taken by a state machine
-
-    The optional ``label`` argument can be used to distinguish between
-    and therefore separately optimise distinct observations, such as the
-    mean and standard deviation of a dataset.  It is an error to call
-    ``target()`` with any label more than once per test case.
-
-    .. note::
-        **The more examples you run, the better this technique works.**
-
-        As a rule of thumb, the targeting effect is noticeable above
-        :obj:`max_examples=1000 <hypothesis.settings.max_examples>`,
-        and immediately obvious by around ten thousand examples
-        *per label* used by your test.
-
-    :ref:`statistics` include the best score seen for each label,
-    which can help avoid `the threshold problem
-    <https://hypothesis.works/articles/threshold-problem/>`__ when the minimal
-    example shrinks right down to the threshold of failure (:issue:`2180`).
-    """
-    check_type((int, float), observation, "observation")
-    if not math.isfinite(observation):
-        raise InvalidArgument(f"observation={observation!r} must be a finite float.")
-    check_type(str, label, "label")
-
-    context = _current_build_context.value
-    if context is None:
-        raise InvalidArgument(
-            "Calling target() outside of a test is invalid.  "
-            "Consider guarding this call with `if currently_in_test_context(): ...`"
-        )
-    verbose_report(f"Saw target(observation={observation!r}, label={label!r})")
-
-    if label in context.data.target_observations:
-        raise InvalidArgument(
-            f"Calling target({observation!r}, label={label!r}) would overwrite "
-            f"target({context.data.target_observationslabel!r}, label={label!r})"
-        )
-    else:
-        context.data.target_observationslabel = observation
-
-    return observation

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/core.py Deleted

@@ -1,1370 +0,0 @@
-# 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/.
-
-"""This module provides the core primitives of Hypothesis, such as given."""
-
-import base64
-import contextlib
-import datetime
-import inspect
-import io
-import sys
-import time
-import types
-import warnings
-import zlib
-from collections import defaultdict
-from io import StringIO
-from itertools import chain
-from random import Random
-from typing import (
-    Any,
-    BinaryIO,
-    Callable,
-    Coroutine,
-    Hashable,
-    List,
-    Optional,
-    TypeVar,
-    Union,
-    overload,
-)
-from unittest import TestCase
-
-import attr
-
-from hypothesis import strategies as st
-from hypothesis._settings import (
-    HealthCheck,
-    Phase,
-    Verbosity,
-    local_settings,
-    settings as Settings,
-)
-from hypothesis.control import BuildContext
-from hypothesis.errors import (
-    DeadlineExceeded,
-    DidNotReproduce,
-    FailedHealthCheck,
-    Flaky,
-    Found,
-    HypothesisDeprecationWarning,
-    HypothesisWarning,
-    InvalidArgument,
-    MultipleFailures,
-    NoSuchExample,
-    StopTest,
-    Unsatisfiable,
-    UnsatisfiedAssumption,
-)
-from hypothesis.executors import default_new_style_executor, new_style_executor
-from hypothesis.internal.compat import (
-    PYPY,
-    bad_django_TestCase,
-    get_type_hints,
-    int_from_bytes,
-)
-from hypothesis.internal.conjecture.data import ConjectureData, Status
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.conjecture.shrinker import sort_key
-from hypothesis.internal.entropy import deterministic_PRNG
-from hypothesis.internal.escalation import (
-    escalate_hypothesis_internal_error,
-    format_exception,
-    get_interesting_origin,
-    get_trimmed_traceback,
-)
-from hypothesis.internal.healthcheck import fail_health_check
-from hypothesis.internal.reflection import (
-    convert_positional_arguments,
-    define_function_signature,
-    function_digest,
-    get_pretty_function_description,
-    getfullargspec_except_self as getfullargspec,
-    impersonate,
-    is_mock,
-    proxies,
-    repr_call,
-)
-from hypothesis.internal.scrutineer import Tracer, explanatory_lines
-from hypothesis.reporting import (
-    current_verbosity,
-    report,
-    verbose_report,
-    with_reporter,
-)
-from hypothesis.statistics import describe_targets, note_statistics
-from hypothesis.strategies._internal.collections import TupleStrategy
-from hypothesis.strategies._internal.misc import NOTHING
-from hypothesis.strategies._internal.strategies import (
-    Ex,
-    MappedSearchStrategy,
-    SearchStrategy,
-)
-from hypothesis.utils.conventions import infer
-from hypothesis.vendor.pretty import RepresentationPrinter
-from hypothesis.version import __version__
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from types import EllipsisType as InferType
-
-else:
-    InferType = type(Ellipsis)
-
-
-TestFunc = TypeVar("TestFunc", bound=Callable)
-
-
-running_under_pytest = False
-global_force_seed = None
-_hypothesis_global_random = None
-
-
-@attr.s()
-class Example:
-    args = attr.ib()
-    kwargs = attr.ib()
-
-
-def example(*args: Any, **kwargs: Any) -> CallableTestFunc, TestFunc:
-    """A decorator which ensures a specific example is always tested."""
-    if args and kwargs:
-        raise InvalidArgument(
-            "Cannot mix positional and keyword arguments for examples"
-        )
-    if not (args or kwargs):
-        raise InvalidArgument("An example must provide at least one argument")
-
-    hypothesis_explicit_examples: ListExample = 
-
-    def accept(test):
-        if not hasattr(test, "hypothesis_explicit_examples"):
-            test.hypothesis_explicit_examples = hypothesis_explicit_examples
-        test.hypothesis_explicit_examples.append(Example(tuple(args), kwargs))
-        return test
-
-    accept.hypothesis_explicit_examples = hypothesis_explicit_examples  # type: ignore
-    return accept
-
-
-def seed(seed: Hashable) -> CallableTestFunc, TestFunc:
-    """seed: Start the test execution from a specific seed.
-
-    May be any hashable object. No exact meaning for seed is provided
-    other than that for a fixed seed value Hypothesis will try the same
-    actions (insofar as it can given external sources of non-
-    determinism. e.g. timing and hash randomization).
-
-    Overrides the derandomize setting, which is designed to enable
-    deterministic builds rather than reproducing observed failures.
-
-    """
-
-    def accept(test):
-        test._hypothesis_internal_use_seed = seed
-        current_settings = getattr(test, "_hypothesis_internal_use_settings", None)
-        test._hypothesis_internal_use_settings = Settings(
-            current_settings, database=None
-        )
-        return test
-
-    return accept
-
-
-def reproduce_failure(version: str, blob: bytes) -> CallableTestFunc, TestFunc:
-    """Run the example that corresponds to this data blob in order to reproduce
-    a failure.
-
-    A test with this decorator *always* runs only one example and always fails.
-    If the provided example does not cause a failure, or is in some way invalid
-    for this test, then this will fail with a DidNotReproduce error.
-
-    This decorator is not intended to be a permanent addition to your test
-    suite. It's simply some code you can add to ease reproduction of a problem
-    in the event that you don't have access to the test database. Because of
-    this, *no* compatibility guarantees are made between different versions of
-    Hypothesis - its API may change arbitrarily from version to version.
-    """
-
-    def accept(test):
-        test._hypothesis_internal_use_reproduce_failure = (version, blob)
-        return test
-
-    return accept
-
-
-def encode_failure(buffer):
-    buffer = bytes(buffer)
-    compressed = zlib.compress(buffer)
-    if len(compressed) < len(buffer):
-        buffer = b"\1" + compressed
-    else:
-        buffer = b"\0" + buffer
-    return base64.b64encode(buffer)
-
-
-def decode_failure(blob):
-    try:
-        buffer = base64.b64decode(blob)
-    except Exception:
-        raise InvalidArgument(f"Invalid base64 encoded string: {blob!r}") from None
-    prefix = buffer:1
-    if prefix == b"\0":
-        return buffer1:
-    elif prefix == b"\1":
-        try:
-            return zlib.decompress(buffer1:)
-        except zlib.error as err:
-            raise InvalidArgument(
-                f"Invalid zlib compression for blob {blob!r}"
-            ) from err
-    else:
-        raise InvalidArgument(
-            f"Could not decode blob {blob!r}: Invalid start byte {prefix!r}"
-        )
-
-
-class WithRunner(MappedSearchStrategy):
-    def __init__(self, base, runner):
-        assert runner is not None
-        super().__init__(base)
-        self.runner = runner
-
-    def do_draw(self, data):
-        data.hypothesis_runner = self.runner
-        return self.mapped_strategy.do_draw(data)
-
-    def __repr__(self):
-        return f"WithRunner({self.mapped_strategy!r}, runner={self.runner!r})"
-
-
-def is_invalid_test(test, original_argspec, given_arguments, given_kwargs):
-    """Check the arguments to ``@given`` for basic usage constraints.
-
-    Most errors are not raised immediately; instead we return a dummy test
-    function that will raise the appropriate error if it is actually called.
-    When the user runs a subset of tests (e.g via ``pytest -k``), errors will
-    only be reported for tests that actually ran.
-    """
-
-    def invalid(message, *, exc=InvalidArgument):
-        def wrapped_test(*arguments, **kwargs):
-            raise exc(message)
-
-        wrapped_test.is_hypothesis_test = True
-        wrapped_test.hypothesis = HypothesisHandle(
-            inner_test=test,
-            get_fuzz_target=wrapped_test,
-            given_kwargs=given_kwargs,
-        )
-        return wrapped_test
-
-    if not (given_arguments or given_kwargs):
-        return invalid("given must be called with at least one argument")
-
-    if given_arguments and any(
-        original_argspec.varargs, original_argspec.varkw, original_argspec.kwonlyargs
-    ):
-        return invalid(
-            "positional arguments to @given are not supported with varargs, "
-            "varkeywords, or keyword-only arguments"
-        )
-
-    if len(given_arguments) > len(original_argspec.args):
-        args = tuple(given_arguments)
-        return invalid(
-            f"Too many positional arguments for {test.__name__}() were passed to "
-            f"@given - expected at most {int(len(original_argspec.args))} "
-            f"arguments, but got {int(len(args))} {args!r}"
-        )
-
-    if infer in given_arguments:
-        return invalid(
-            "... was passed as a positional argument to @given, "
-            "but may only be passed as a keyword argument or as "
-            "the sole argument of @given"
-        )
-
-    if given_arguments and given_kwargs:
-        return invalid("cannot mix positional and keyword arguments to @given")
-    extra_kwargs = 
-        k
-        for k in given_kwargs
-        if k not in original_argspec.args + original_argspec.kwonlyargs
-    
-    if extra_kwargs and not original_argspec.varkw:
-        arg = extra_kwargs0
-        return invalid(
-            f"{test.__name__}() got an unexpected keyword argument {arg!r}, "
-            f"from `{arg}={given_kwargsarg!r}` in @given"
-        )
-    if original_argspec.defaults or original_argspec.kwonlydefaults:
-        return invalid("Cannot apply @given to a function with defaults.")
-    missing = repr(kw) for kw in original_argspec.kwonlyargs if kw not in given_kwargs
-    if missing:
-        return invalid(
-            "Missing required kwarg{}: {}".format(
-                "s" if len(missing) > 1 else "", ", ".join(missing)
-            )
-        )
-
-    # This case would raise Unsatisfiable *anyway*, but by detecting it here we can
-    # provide a much more helpful error message for people e.g. using the Ghostwriter.
-    empty = 
-        f"{s!r} (arg {idx})" for idx, s in enumerate(given_arguments) if s is NOTHING
-     + f"{name}={s!r}" for name, s in given_kwargs.items() if s is NOTHING
-    if empty:
-        strats = "strategies" if len(empty) > 1 else "strategy"
-        return invalid(
-            f"Cannot generate examples from empty {strats}: " + ", ".join(empty),
-            exc=Unsatisfiable,
-        )
-
-
-class ArtificialDataForExample(ConjectureData):
-    """Dummy object that pretends to be a ConjectureData object for the purposes of
-    drawing arguments for @example. Provides just enough of the ConjectureData API
-    to allow the test to run. Does not support any sort of interactive drawing,
-    but that's fine because you can't access that when all of your arguments are
-    provided by @example.
-    """
-
-    def __init__(self, kwargs):
-        self.__draws = 0
-        self.__kwargs = kwargs
-        super().__init__(max_length=0, prefix=b"", random=None)
-
-    def draw_bits(self, n):
-        raise NotImplementedError("Dummy object should never be asked for bits.")
-
-    def draw(self, strategy):
-        assert self.__draws == 0
-        self.__draws += 1
-        # The main strategy for given is always a tuples strategy that returns
-        # first positional arguments then keyword arguments. When building this
-        # object already converted all positional arguments to keyword arguments,
-        # so this is the correct format to return.
-        return (), self.__kwargs
-
-
-def execute_explicit_examples(state, wrapped_test, arguments, kwargs):
-    original_argspec = getfullargspec(state.test)
-
-    for example in reversed(getattr(wrapped_test, "hypothesis_explicit_examples", ())):
-        example_kwargs = dict(original_argspec.kwonlydefaults or {})
-        if example.args:
-            if len(example.args) > len(original_argspec.args):
-                raise InvalidArgument(
-                    "example has too many arguments for test. Expected at most "
-                    f"{len(original_argspec.args)} but got {len(example.args)}"
-                )
-            example_kwargs.update(
-                dict(zip(original_argspec.args-len(example.args) :, example.args))
-            )
-        else:
-            example_kwargs.update(example.kwargs)
-        if Phase.explicit not in state.settings.phases:
-            continue
-        example_kwargs.update(kwargs)
-
-        with local_settings(state.settings):
-            fragments_reported = 
-            try:
-                with with_reporter(fragments_reported.append):
-                    state.execute_once(
-                        ArtificialDataForExample(example_kwargs),
-                        is_final=True,
-                        print_example=True,
-                    )
-            except UnsatisfiedAssumption:
-                # Odd though it seems, we deliberately support explicit examples that
-                # are then rejected by a call to `assume()`.  As well as iterative
-                # development, this is rather useful to replay Hypothesis' part of
-                # a saved failure when other arguments are supplied by e.g. pytest.
-                # See https://github.com/HypothesisWorks/hypothesis/issues/2125
-                pass
-            except BaseException as err:
-                # In order to support reporting of multiple failing examples, we yield
-                # each of the (report text, error) pairs we find back to the top-level
-                # runner.  This also ensures that user-facing stack traces have as few
-                # frames of Hypothesis internals as possible.
-                err = err.with_traceback(get_trimmed_traceback())
-
-                # One user error - whether misunderstanding or typo - we've seen a few
-                # times is to pass strategies to @example() where values are expected.
-                # Checking is easy, and false-positives not much of a problem, so:
-                if any(
-                    isinstance(arg, SearchStrategy)
-                    for arg in example.args + tuple(example.kwargs.values())
-                ):
-                    new = HypothesisWarning(
-                        "The @example() decorator expects to be passed values, but "
-                        "you passed strategies instead.  See https://hypothesis."
-                        "readthedocs.io/en/latest/reproducing.html for details."
-                    )
-                    new.__cause__ = err
-                    err = new
-
-                yield (fragments_reported, err)
-                if state.settings.report_multiple_bugs:
-                    continue
-                break
-            finally:
-                if fragments_reported:
-                    assert fragments_reported0.startswith("Falsifying example")
-                    fragments_reported0 = fragments_reported0.replace(
-                        "Falsifying example", "Falsifying explicit example", 1
-                    )
-
-            if fragments_reported:
-                verbose_report(fragments_reported0.replace("Falsifying", "Trying", 1))
-                for f in fragments_reported1::
-                    verbose_report(f)
-
-
-def get_random_for_wrapped_test(test, wrapped_test):
-    settings = wrapped_test._hypothesis_internal_use_settings
-    wrapped_test._hypothesis_internal_use_generated_seed = None
-
-    if wrapped_test._hypothesis_internal_use_seed is not None:
-        return Random(wrapped_test._hypothesis_internal_use_seed)
-    elif settings.derandomize:
-        return Random(int_from_bytes(function_digest(test)))
-    elif global_force_seed is not None:
-        return Random(global_force_seed)
-    else:
-        global _hypothesis_global_random
-        if _hypothesis_global_random is None:
-            _hypothesis_global_random = Random()
-        seed = _hypothesis_global_random.getrandbits(128)
-        wrapped_test._hypothesis_internal_use_generated_seed = seed
-        return Random(seed)
-
-
-def process_arguments_to_given(wrapped_test, arguments, kwargs, given_kwargs, argspec):
-    selfy = None
-    arguments, kwargs = convert_positional_arguments(wrapped_test, arguments, kwargs)
-
-    # If the test function is a method of some kind, the bound object
-    # will be the first named argument if there are any, otherwise the
-    # first vararg (if any).
-    if argspec.args:
-        selfy = kwargs.get(argspec.args0)
-    elif arguments:
-        selfy = arguments0
-
-    # Ensure that we don't mistake mocks for self here.
-    # This can cause the mock to be used as the test runner.
-    if is_mock(selfy):
-        selfy = None
-
-    test_runner = new_style_executor(selfy)
-
-    arguments = tuple(arguments)
-
-    # We use TupleStrategy over tuples() here to avoid polluting
-    # st.STRATEGY_CACHE with references (see #493), and because this is
-    # trivial anyway if the fixed_dictionaries strategy is cacheable.
-    search_strategy = TupleStrategy(
-        (
-            st.just(arguments),
-            st.fixed_dictionaries(given_kwargs).map(lambda args: dict(args, **kwargs)),
-        )
-    )
-
-    if selfy is not None:
-        search_strategy = WithRunner(search_strategy, selfy)
-
-    search_strategy.validate()
-
-    return arguments, kwargs, test_runner, search_strategy
-
-
-def skip_exceptions_to_reraise():
-    """Return a tuple of exceptions meaning 'skip this test', to re-raise.
-
-    This is intended to cover most common test runners; if you would
-    like another to be added please open an issue or pull request adding
-    it to this function and to tests/cover/test_lazy_import.py
-    """
-    # This is a set because nose may simply re-export unittest.SkipTest
-    exceptions = set()
-    # We use this sys.modules trick to avoid importing libraries -
-    # you can't be an instance of a type from an unimported module!
-    # This is fast enough that we don't need to cache the result,
-    # and more importantly it avoids possible side-effects :-)
-    if "unittest" in sys.modules:
-        exceptions.add(sys.modules"unittest".SkipTest)
-    if "unittest2" in sys.modules:
-        exceptions.add(sys.modules"unittest2".SkipTest)
-    if "nose" in sys.modules:
-        exceptions.add(sys.modules"nose".SkipTest)
-    if "_pytest" in sys.modules:
-        exceptions.add(sys.modules"_pytest".outcomes.Skipped)
-    return tuple(sorted(exceptions, key=str))
-
-
-def failure_exceptions_to_catch():
-    """Return a tuple of exceptions meaning 'this test has failed', to catch.
-
-    This is intended to cover most common test runners; if you would
-    like another to be added please open an issue or pull request.
-    """
-    # While SystemExit and GeneratorExit are instances of BaseException, we also
-    # expect them to be deterministic - unlike KeyboardInterrupt - and so we treat
-    # them as standard exceptions, check for flakiness, etc.
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2223 for details.
-    exceptions = Exception, SystemExit, GeneratorExit
-    if "_pytest" in sys.modules:
-        exceptions.append(sys.modules"_pytest".outcomes.Failed)
-    return tuple(exceptions)
-
-
-def new_given_argspec(original_argspec, given_kwargs):
-    """Make an updated argspec for the wrapped test."""
-    new_args = a for a in original_argspec.args if a not in given_kwargs
-    new_kwonlyargs = a for a in original_argspec.kwonlyargs if a not in given_kwargs
-    annots = {
-        k: v
-        for k, v in original_argspec.annotations.items()
-        if k in new_args + new_kwonlyargs
-    }
-    annots"return" = None
-    return original_argspec._replace(
-        args=new_args, kwonlyargs=new_kwonlyargs, annotations=annots
-    )
-
-
-class StateForActualGivenExecution:
-    def __init__(
-        self, test_runner, search_strategy, test, settings, random, wrapped_test
-    ):
-        self.test_runner = test_runner
-        self.search_strategy = search_strategy
-        self.settings = settings
-        self.last_exception = None
-        self.falsifying_examples = ()
-        self.__was_flaky = False
-        self.random = random
-        self.__test_runtime = None
-
-        self.is_find = getattr(wrapped_test, "_hypothesis_internal_is_find", False)
-        self.wrapped_test = wrapped_test
-
-        self.test = test
-
-        self.print_given_args = getattr(
-            wrapped_test, "_hypothesis_internal_print_given_args", True
-        )
-
-        self.files_to_propagate = set()
-        self.failed_normally = False
-        self.failed_due_to_deadline = False
-
-        self.explain_traces = defaultdict(set)
-
-    def execute_once(
-        self, data, print_example=False, is_final=False, expected_failure=None
-    ):
-        """Run the test function once, using ``data`` as input.
-
-        If the test raises an exception, it will propagate through to the
-        caller of this method. Depending on its type, this could represent
-        an ordinary test failure, or a fatal error, or a control exception.
-
-        If this method returns normally, the test might have passed, or
-        it might have placed ``data`` in an unsuccessful state and then
-        swallowed the corresponding control exception.
-        """
-
-        data.is_find = self.is_find
-
-        text_repr = None
-        if self.settings.deadline is None:
-            test = self.test
-        else:
-
-            @proxies(self.test)
-            def test(*args, **kwargs):
-                self.__test_runtime = None
-                initial_draws = len(data.draw_times)
-                start = time.perf_counter()
-                result = self.test(*args, **kwargs)
-                finish = time.perf_counter()
-                internal_draw_time = sum(data.draw_timesinitial_draws:)
-                runtime = datetime.timedelta(
-                    seconds=finish - start - internal_draw_time
-                )
-                self.__test_runtime = runtime
-                current_deadline = self.settings.deadline
-                if not is_final:
-                    current_deadline = (current_deadline // 4) * 5
-                if runtime >= current_deadline:
-                    raise DeadlineExceeded(runtime, self.settings.deadline)
-                return result
-
-        def run(data):
-            # Set up dynamic context needed by a single test run.
-            with local_settings(self.settings):
-                with deterministic_PRNG():
-                    with BuildContext(data, is_final=is_final):
-
-                        # Generate all arguments to the test function.
-                        args, kwargs = data.draw(self.search_strategy)
-                        if expected_failure is not None:
-                            nonlocal text_repr
-                            text_repr = repr_call(test, args, kwargs)
-
-                        if print_example or current_verbosity() >= Verbosity.verbose:
-                            output = StringIO()
-
-                            printer = RepresentationPrinter(output)
-                            if print_example:
-                                printer.text("Falsifying example:")
-                            else:
-                                printer.text("Trying example:")
-
-                            if self.print_given_args:
-                                printer.text(" ")
-                                printer.text(test.__name__)
-                                with printer.group(indent=4, open="(", close=""):
-                                    printer.break_()
-                                    for v in args:
-                                        printer.pretty(v)
-                                        # We add a comma unconditionally because
-                                        # generated arguments will always be kwargs,
-                                        # so there will always be more to come.
-                                        printer.text(",")
-                                        printer.breakable()
-
-                                    for i, (k, v) in enumerate(kwargs.items()):
-                                        printer.text(k)
-                                        printer.text("=")
-                                        printer.pretty(v)
-                                        printer.text(",")
-                                        if i + 1 < len(kwargs):
-                                            printer.breakable()
-                                printer.break_()
-                                printer.text(")")
-                            printer.flush()
-                            report(output.getvalue())
-                        return test(*args, **kwargs)
-
-        # Run the test function once, via the executor hook.
-        # In most cases this will delegate straight to `run(data)`.
-        result = self.test_runner(data, run)
-
-        # If a failure was expected, it should have been raised already, so
-        # instead raise an appropriate diagnostic error.
-        if expected_failure is not None:
-            exception, traceback = expected_failure
-            if (
-                isinstance(exception, DeadlineExceeded)
-                and self.__test_runtime is not None
-            ):
-                report(
-                    "Unreliable test timings! On an initial run, this "
-                    "test took %.2fms, which exceeded the deadline of "
-                    "%.2fms, but on a subsequent run it took %.2f ms, "
-                    "which did not. If you expect this sort of "
-                    "variability in your test timings, consider turning "
-                    "deadlines off for this test by setting deadline=None."
-                    % (
-                        exception.runtime.total_seconds() * 1000,
-                        self.settings.deadline.total_seconds() * 1000,
-                        self.__test_runtime.total_seconds() * 1000,
-                    )
-                )
-            else:
-                report("Failed to reproduce exception. Expected: \n" + traceback)
-            self.__flaky(
-                f"Hypothesis {text_repr} produces unreliable results: Falsified"
-                " on the first call but did not on a subsequent one",
-                cause=exception,
-            )
-        return result
-
-    def _execute_once_for_engine(self, data):
-        """Wrapper around ``execute_once`` that intercepts test failure
-        exceptions and single-test control exceptions, and turns them into
-        appropriate method calls to `data` instead.
-
-        This allows the engine to assume that any exception other than
-        ``StopTest`` must be a fatal error, and should stop the entire engine.
-        """
-        try:
-            trace = frozenset()
-            if (
-                self.failed_normally
-                and not self.failed_due_to_deadline
-                and Phase.shrink in self.settings.phases
-                and Phase.explain in self.settings.phases
-                and sys.gettrace() is None
-                and not PYPY
-            ):  # pragma: no cover
-                # This is in fact covered by our *non-coverage* tests, but due to the
-                # settrace() contention *not* by our coverage tests.  Ah well.
-                tracer = Tracer()
-                try:
-                    sys.settrace(tracer.trace)
-                    result = self.execute_once(data)
-                    if data.status == Status.VALID:
-                        self.explain_tracesNone.add(frozenset(tracer.branches))
-                finally:
-                    sys.settrace(None)
-                    trace = frozenset(tracer.branches)
-            else:
-                result = self.execute_once(data)
-            if result is not None:
-                fail_health_check(
-                    self.settings,
-                    "Tests run under @given should return None, but "
-                    f"{self.test.__name__} returned {result!r} instead.",
-                    HealthCheck.return_value,
-                )
-        except UnsatisfiedAssumption:
-            # An "assume" check failed, so instead we inform the engine that
-            # this test run was invalid.
-            data.mark_invalid()
-        except StopTest:
-            # The engine knows how to handle this control exception, so it's
-            # OK to re-raise it.
-            raise
-        except (
-            HypothesisDeprecationWarning,
-            FailedHealthCheck,
-        ) + skip_exceptions_to_reraise():
-            # These are fatal errors or control exceptions that should stop the
-            # engine, so we re-raise them.
-            raise
-        except failure_exceptions_to_catch() as e:
-            # If the error was raised by Hypothesis-internal code, re-raise it
-            # as a fatal error instead of treating it as a test failure.
-            escalate_hypothesis_internal_error()
-
-            if data.frozen:
-                # This can happen if an error occurred in a finally
-                # block somewhere, suppressing our original StopTest.
-                # We raise a new one here to resume normal operation.
-                raise StopTest(data.testcounter) from e
-            else:
-                # The test failed by raising an exception, so we inform the
-                # engine that this test run was interesting. This is the normal
-                # path for test runs that fail.
-
-                tb = get_trimmed_traceback()
-                info = data.extra_information
-                info.__expected_traceback = format_exception(e, tb)
-                info.__expected_exception = e
-                verbose_report(info.__expected_traceback)
-
-                self.failed_normally = True
-
-                interesting_origin = get_interesting_origin(e)
-                if trace:  # pragma: no cover
-                    # Trace collection is explicitly disabled under coverage.
-                    self.explain_tracesinteresting_origin.add(trace)
-                if interesting_origin0 == DeadlineExceeded:
-                    self.failed_due_to_deadline = True
-                    self.explain_traces.clear()
-                data.mark_interesting(interesting_origin)
-
-    def run_engine(self):
-        """Run the test function many times, on database input and generated
-        input, using the Conjecture engine.
-        """
-        # Tell pytest to omit the body of this function from tracebacks
-        __tracebackhide__ = True
-        try:
-            database_key = self.wrapped_test._hypothesis_internal_database_key
-        except AttributeError:
-            if global_force_seed is None:
-                database_key = function_digest(self.test)
-            else:
-                database_key = None
-
-        runner = ConjectureRunner(
-            self._execute_once_for_engine,
-            settings=self.settings,
-            random=self.random,
-            database_key=database_key,
-        )
-        # Use the Conjecture engine to run the test function many times
-        # on different inputs.
-        runner.run()
-        note_statistics(runner.statistics)
-
-        if runner.call_count == 0:
-            return
-        if runner.interesting_examples:
-            self.falsifying_examples = sorted(
-                runner.interesting_examples.values(),
-                key=lambda d: sort_key(d.buffer),
-                reverse=True,
-            )
-        else:
-            if runner.valid_examples == 0:
-                rep = get_pretty_function_description(self.test)
-                raise Unsatisfiable(f"Unable to satisfy assumptions of {rep}")
-
-        if not self.falsifying_examples:
-            return
-        elif not self.settings.report_multiple_bugs:
-            # Pretend that we only found one failure, by discarding the others.
-            del self.falsifying_examples:-1
-
-        # The engine found one or more failures, so we need to reproduce and
-        # report them.
-
-        flaky = 0
-
-        if runner.best_observed_targets:
-            for line in describe_targets(runner.best_observed_targets):
-                report(line)
-            report("")
-
-        explanations = explanatory_lines(self.explain_traces, self.settings)
-        for falsifying_example in self.falsifying_examples:
-            info = falsifying_example.extra_information
-
-            ran_example = ConjectureData.for_buffer(falsifying_example.buffer)
-            self.__was_flaky = False
-            assert info.__expected_exception is not None
-            try:
-                self.execute_once(
-                    ran_example,
-                    print_example=not self.is_find,
-                    is_final=True,
-                    expected_failure=(
-                        info.__expected_exception,
-                        info.__expected_traceback,
-                    ),
-                )
-            except (UnsatisfiedAssumption, StopTest) as e:
-                report(format_exception(e, e.__traceback__))
-                self.__flaky(
-                    "Unreliable assumption: An example which satisfied "
-                    "assumptions on the first run now fails it.",
-                    cause=e,
-                )
-            except BaseException as e:
-                # If we have anything for explain-mode, this is the time to report.
-                for line in explanationsfalsifying_example.interesting_origin:
-                    report(line)
-
-                if len(self.falsifying_examples) <= 1:
-                    # There is only one failure, so we can report it by raising
-                    # it directly.
-                    raise
-
-                # We are reporting multiple failures, so we need to manually
-                # print each exception's stack trace and information.
-                tb = get_trimmed_traceback()
-                report(format_exception(e, tb))
-
-            finally:
-                # Whether or not replay actually raised the exception again, we want
-                # to print the reproduce_failure decorator for the failing example.
-                if self.settings.print_blob:
-                    report(
-                        "\nYou can reproduce this example by temporarily adding "
-                        "@reproduce_failure(%r, %r) as a decorator on your test case"
-                        % (__version__, encode_failure(falsifying_example.buffer))
-                    )
-                # Mostly useful for ``find`` and ensuring that objects that
-                # hold on to a reference to ``data`` know that it's now been
-                # finished and they can't draw more data from it.
-                ran_example.freeze()
-
-            if self.__was_flaky:
-                flaky += 1
-
-        # If we only have one example then we should have raised an error or
-        # flaky prior to this point.
-        assert len(self.falsifying_examples) > 1
-
-        if flaky > 0:
-            raise Flaky(
-                f"Hypothesis found {len(self.falsifying_examples)} distinct failures, "
-                f"but {flaky} of them exhibited some sort of flaky behaviour."
-            )
-        else:
-            raise MultipleFailures(
-                f"Hypothesis found {len(self.falsifying_examples)} distinct failures."
-            )
-
-    def __flaky(self, message, *, cause):
-        if len(self.falsifying_examples) <= 1:
-            raise Flaky(message) from cause
-        else:
-            self.__was_flaky = True
-            report("Flaky example! " + message)
-
-
-@contextlib.contextmanager
-def fake_subTest(self, msg=None, **__):
-    """Monkeypatch for `unittest.TestCase.subTest` during `@given`.
-
-    If we don't patch this out, each failing example is reported as a
-    separate failing test by the unittest test runner, which is
-    obviously incorrect. We therefore replace it for the duration with
-    this version.
-    """
-    warnings.warn(
-        "subTest per-example reporting interacts badly with Hypothesis "
-        "trying hundreds of examples, so we disable it for the duration of "
-        "any test that uses `@given`.",
-        HypothesisWarning,
-        stacklevel=2,
-    )
-    yield
-
-
-@attr.s()
-class HypothesisHandle:
-    """This object is provided as the .hypothesis attribute on @given tests.
-
-    Downstream users can reassign its attributes to insert custom logic into
-    the execution of each case, for example by converting an async into a
-    sync function.
-
-    This must be an attribute of an attribute, because reassignment of a
-    first-level attribute would not be visible to Hypothesis if the function
-    had been decorated before the assignment.
-
-    See https://github.com/HypothesisWorks/hypothesis/issues/1257 for more
-    information.
-    """
-
-    inner_test = attr.ib()
-    _get_fuzz_target = attr.ib()
-    _given_kwargs = attr.ib()
-
-    @property
-    def fuzz_one_input(
-        self,
-    ) -> CallableUnionbytes, bytearray, memoryview, BinaryIO, Optionalbytes:
-        """Run the test as a fuzz target, driven with the `buffer` of bytes.
-
-        Returns None if buffer invalid for the strategy, canonical pruned
-        bytes if the buffer was valid, and leaves raised exceptions alone.
-        """
-        # Note: most users, if they care about fuzzer performance, will access the
-        # property and assign it to a local variable to move the attribute lookup
-        # outside their fuzzing loop / before the fork point.  We cache it anyway,
-        # so that naive or unusual use-cases get the best possible performance too.
-        try:
-            return self.__cached_target  # type: ignore
-        except AttributeError:
-            self.__cached_target = self._get_fuzz_target()
-            return self.__cached_target
-
-
-@overload
-def given(
-    *_given_arguments: UnionSearchStrategyAny, InferType,
-) -> Callable
-    Callable..., UnionNone, CoroutineAny, Any, None, Callable..., None
-:  # pragma: no cover
-    ...
-
-
-@overload
-def given(
-    **_given_kwargs: UnionSearchStrategyAny, InferType,
-) -> Callable
-    Callable..., UnionNone, CoroutineAny, Any, None, Callable..., None
-:  # pragma: no cover
-    ...
-
-
-def given(
-    *_given_arguments: UnionSearchStrategyAny, InferType,
-    **_given_kwargs: UnionSearchStrategyAny, InferType,
-) -> Callable
-    Callable..., UnionNone, CoroutineAny, Any, None, Callable..., None
-:
-    """A decorator for turning a test function that accepts arguments into a
-    randomized test.
-
-    This is the main entry point to Hypothesis.
-    """
-
-    def run_test_as_given(test):
-        if inspect.isclass(test):
-            # Provide a meaningful error to users, instead of exceptions from
-            # internals that assume we're dealing with a function.
-            raise InvalidArgument("@given cannot be applied to a class.")
-        given_arguments = tuple(_given_arguments)
-        given_kwargs = dict(_given_kwargs)
-
-        original_argspec = getfullargspec(test)
-
-        if given_arguments == (Ellipsis,) and not given_kwargs:
-            # user indicated that they want to infer all arguments
-            given_kwargs.update(
-                (name, Ellipsis)
-                for name in chain(original_argspec.args, original_argspec.kwonlyargs)
-            )
-            given_arguments = ()
-
-        check_invalid = is_invalid_test(
-            test, original_argspec, given_arguments, given_kwargs
-        )
-
-        # If the argument check found problems, return a dummy test function
-        # that will raise an error if it is actually called.
-        if check_invalid is not None:
-            return check_invalid
-
-        # Because the argument check succeeded, we can convert @given's
-        # positional arguments into keyword arguments for simplicity.
-        if given_arguments:
-            assert not given_kwargs
-            nargs = len(given_arguments)
-            given_kwargs.update(zip(original_argspec.args-nargs:, given_arguments))
-        # These have been converted, so delete them to prevent accidental use.
-        del given_arguments
-
-        argspec = new_given_argspec(original_argspec, given_kwargs)
-
-        # Use type information to convert "infer" arguments into appropriate strategies.
-        if infer in given_kwargs.values():
-            hints = get_type_hints(test)
-        for name in name for name, value in given_kwargs.items() if value is infer:
-            if name not in hints:
-                # As usual, we want to emit this error when the test is executed,
-                # not when it's decorated.
-
-                @impersonate(test)
-                @define_function_signature(test.__name__, test.__doc__, argspec)
-                def wrapped_test(*arguments, **kwargs):
-                    __tracebackhide__ = True
-                    raise InvalidArgument(
-                        f"passed {name}=... for {test.__name__}, but {name} has "
-                        "no type annotation"
-                    )
-
-                return wrapped_test
-
-            given_kwargsname = st.from_type(hintsname)
-
-        @impersonate(test)
-        @define_function_signature(test.__name__, test.__doc__, argspec)
-        def wrapped_test(*arguments, **kwargs):
-            # Tell pytest to omit the body of this function from tracebacks
-            __tracebackhide__ = True
-
-            test = wrapped_test.hypothesis.inner_test
-
-            if getattr(test, "is_hypothesis_test", False):
-                raise InvalidArgument(
-                    f"You have applied @given to the test {test.__name__} more than "
-                    "once, which wraps the test several times and is extremely slow. "
-                    "A similar effect can be gained by combining the arguments "
-                    "of the two calls to given. For example, instead of "
-                    "@given(booleans()) @given(integers()), you could write "
-                    "@given(booleans(), integers())"
-                )
-
-            settings = wrapped_test._hypothesis_internal_use_settings
-
-            random = get_random_for_wrapped_test(test, wrapped_test)
-
-            processed_args = process_arguments_to_given(
-                wrapped_test, arguments, kwargs, given_kwargs, argspec
-            )
-            arguments, kwargs, test_runner, search_strategy = processed_args
-
-            if (
-                inspect.iscoroutinefunction(test)
-                and test_runner is default_new_style_executor
-            ):
-                # See https://github.com/HypothesisWorks/hypothesis/issues/3054
-                # If our custom executor doesn't handle coroutines, or we return an
-                # awaitable from a non-async-def function, we just rely on the
-                # return_value health check.  This catches most user errors though.
-                raise InvalidArgument(
-                    "Hypothesis doesn't know how to run async test functions like "
-                    f"{test.__name__}.  You'll need to write a custom executor, "
-                    "or use a library like pytest-asyncio or pytest-trio which can "
-                    "handle the translation for you.\n    See https://hypothesis."
-                    "readthedocs.io/en/latest/details.html#custom-function-execution"
-                )
-
-            runner = getattr(search_strategy, "runner", None)
-            if isinstance(runner, TestCase) and test.__name__ in dir(TestCase):
-                msg = (
-                    f"You have applied @given to the method {test.__name__}, which is "
-                    "used by the unittest runner but is not itself a test."
-                    "  This is not useful in any way."
-                )
-                fail_health_check(settings, msg, HealthCheck.not_a_test_method)
-            if bad_django_TestCase(runner):  # pragma: no cover
-                # Covered by the Django tests, but not the pytest coverage task
-                raise InvalidArgument(
-                    "You have applied @given to a method on "
-                    f"{type(runner).__qualname__}, but this "
-                    "class does not inherit from the supported versions in "
-                    "`hypothesis.extra.django`.  Use the Hypothesis variants "
-                    "to ensure that each example is run in a separate "
-                    "database transaction."
-                )
-
-            state = StateForActualGivenExecution(
-                test_runner, search_strategy, test, settings, random, wrapped_test
-            )
-
-            reproduce_failure = wrapped_test._hypothesis_internal_use_reproduce_failure
-
-            # If there was a @reproduce_failure decorator, use it to reproduce
-            # the error (or complain that we couldn't). Either way, this will
-            # always raise some kind of error.
-            if reproduce_failure is not None:
-                expected_version, failure = reproduce_failure
-                if expected_version != __version__:
-                    raise InvalidArgument(
-                        "Attempting to reproduce a failure from a different "
-                        "version of Hypothesis. This failure is from %s, but "
-                        "you are currently running %r. Please change your "
-                        "Hypothesis version to a matching one."
-                        % (expected_version, __version__)
-                    )
-                try:
-                    state.execute_once(
-                        ConjectureData.for_buffer(decode_failure(failure)),
-                        print_example=True,
-                        is_final=True,
-                    )
-                    raise DidNotReproduce(
-                        "Expected the test to raise an error, but it "
-                        "completed successfully."
-                    )
-                except StopTest:
-                    raise DidNotReproduce(
-                        "The shape of the test data has changed in some way "
-                        "from where this blob was defined. Are you sure "
-                        "you're running the same test?"
-                    ) from None
-                except UnsatisfiedAssumption:
-                    raise DidNotReproduce(
-                        "The test data failed to satisfy an assumption in the "
-                        "test. Have you added it since this blob was "
-                        "generated?"
-                    ) from None
-
-            # There was no @reproduce_failure, so start by running any explicit
-            # examples from @example decorators.
-            errors = list(
-                execute_explicit_examples(state, wrapped_test, arguments, kwargs)
-            )
-            with local_settings(state.settings):
-                if len(errors) > 1:
-                    # If we're not going to report multiple bugs, we would have
-                    # stopped running explicit examples at the first failure.
-                    assert state.settings.report_multiple_bugs
-                    for fragments, err in errors:
-                        for f in fragments:
-                            report(f)
-                        report(format_exception(err, err.__traceback__))
-                    raise MultipleFailures(
-                        f"Hypothesis found {len(errors)} failures in explicit examples."
-                    )
-                elif errors:
-                    fragments, the_error_hypothesis_found = errors0
-                    for f in fragments:
-                        report(f)
-                    raise the_error_hypothesis_found
-
-            # If there were any explicit examples, they all ran successfully.
-            # The next step is to use the Conjecture engine to run the test on
-            # many different inputs.
-
-            if not (
-                Phase.reuse in settings.phases or Phase.generate in settings.phases
-            ):
-                return
-
-            try:
-                if isinstance(runner, TestCase) and hasattr(runner, "subTest"):
-                    subTest = runner.subTest
-                    try:
-                        runner.subTest = types.MethodType(fake_subTest, runner)
-                        state.run_engine()
-                    finally:
-                        runner.subTest = subTest
-                else:
-                    state.run_engine()
-            except BaseException as e:
-                # The exception caught here should either be an actual test
-                # failure (or MultipleFailures), or some kind of fatal error
-                # that caused the engine to stop.
-
-                generated_seed = wrapped_test._hypothesis_internal_use_generated_seed
-                with local_settings(settings):
-                    if not (state.failed_normally or generated_seed is None):
-                        if running_under_pytest:
-                            report(
-                                f"You can add @seed({generated_seed}) to this test or "
-                                f"run pytest with --hypothesis-seed={generated_seed} "
-                                "to reproduce this failure."
-                            )
-                        else:
-                            report(
-                                f"You can add @seed({generated_seed}) to this test to "
-                                "reproduce this failure."
-                            )
-                    # The dance here is to avoid showing users long tracebacks
-                    # full of Hypothesis internals they don't care about.
-                    # We have to do this inline, to avoid adding another
-                    # internal stack frame just when we've removed the rest.
-                    #
-                    # Using a variable for our trimmed error ensures that the line
-                    # which will actually appear in tracebacks is as clear as
-                    # possible - "raise the_error_hypothesis_found".
-                    the_error_hypothesis_found = e.with_traceback(
-                        get_trimmed_traceback()
-                    )
-                    raise the_error_hypothesis_found
-
-        def _get_fuzz_target() -> Callable
-            Unionbytes, bytearray, memoryview, BinaryIO, Optionalbytes
-        :
-            # Because fuzzing interfaces are very performance-sensitive, we use a
-            # somewhat more complicated structure here.  `_get_fuzz_target()` is
-            # called by the `HypothesisHandle.fuzz_one_input` property, allowing
-            # us to defer our collection of the settings, random instance, and
-            # reassignable `inner_test` (etc) until `fuzz_one_input` is accessed.
-            #
-            # We then share the performance cost of setting up `state` between
-            # many invocations of the target.  We explicitly force `deadline=None`
-            # for performance reasons, saving ~40% the runtime of an empty test.
-            test = wrapped_test.hypothesis.inner_test
-            settings = Settings(
-                parent=wrapped_test._hypothesis_internal_use_settings, deadline=None
-            )
-            random = get_random_for_wrapped_test(test, wrapped_test)
-            _args, _kwargs, test_runner, search_strategy = process_arguments_to_given(
-                wrapped_test, (), {}, given_kwargs, argspec
-            )
-            assert not _args
-            assert not _kwargs
-            state = StateForActualGivenExecution(
-                test_runner, search_strategy, test, settings, random, wrapped_test
-            )
-            digest = function_digest(test)
-            # We track the minimal-so-far example for each distinct origin, so
-            # that we track log-n instead of n examples for long runs.  In particular
-            # it means that we saturate for common errors in long runs instead of
-            # storing huge volumes of low-value data.
-            minimal_failures: dict = {}
-
-            def fuzz_one_input(
-                buffer: Unionbytes, bytearray, memoryview, BinaryIO
-            ) -> Optionalbytes:
-                # This inner part is all that the fuzzer will actually run,
-                # so we keep it as small and as fast as possible.
-                if isinstance(buffer, io.IOBase):
-                    buffer = buffer.read()
-                assert isinstance(buffer, (bytes, bytearray, memoryview))
-                data = ConjectureData.for_buffer(buffer)
-                try:
-                    state.execute_once(data)
-                except (StopTest, UnsatisfiedAssumption):
-                    return None
-                except BaseException:
-                    buffer = bytes(data.buffer)
-                    known = minimal_failures.get(data.interesting_origin)
-                    if settings.database is not None and (
-                        known is None or sort_key(buffer) <= sort_key(known)
-                    ):
-                        settings.database.save(digest, buffer)
-                        minimal_failuresdata.interesting_origin = buffer
-                    raise
-                return bytes(data.buffer)
-
-            fuzz_one_input.__doc__ = HypothesisHandle.fuzz_one_input.__doc__
-            return fuzz_one_input
-
-        # After having created the decorated test function, we need to copy
-        # over some attributes to make the switch as seamless as possible.
-
-        for attrib in dir(test):
-            if not (attrib.startswith("_") or hasattr(wrapped_test, attrib)):
-                setattr(wrapped_test, attrib, getattr(test, attrib))
-        wrapped_test.is_hypothesis_test = True
-        if hasattr(test, "_hypothesis_internal_settings_applied"):
-            # Used to check if @settings is applied twice.
-            wrapped_test._hypothesis_internal_settings_applied = True
-        wrapped_test._hypothesis_internal_use_seed = getattr(
-            test, "_hypothesis_internal_use_seed", None
-        )
-        wrapped_test._hypothesis_internal_use_settings = (
-            getattr(test, "_hypothesis_internal_use_settings", None) or Settings.default
-        )
-        wrapped_test._hypothesis_internal_use_reproduce_failure = getattr(
-            test, "_hypothesis_internal_use_reproduce_failure", None
-        )
-        wrapped_test.hypothesis = HypothesisHandle(test, _get_fuzz_target, given_kwargs)
-        return wrapped_test
-
-    return run_test_as_given
-
-
-def find(
-    specifier: SearchStrategyEx,
-    condition: CallableAny, bool,
-    *,
-    settings: OptionalSettings = None,
-    random: OptionalRandom = None,
-    database_key: Optionalbytes = None,
-) -> Ex:
-    """Returns the minimal example from the given strategy ``specifier`` that
-    matches the predicate function ``condition``."""
-    if settings is None:
-        settings = Settings(max_examples=2000)
-    settings = Settings(
-        settings, suppress_health_check=HealthCheck.all(), report_multiple_bugs=False
-    )
-
-    if database_key is None and settings.database is not None:
-        database_key = function_digest(condition)
-
-    if not isinstance(specifier, SearchStrategy):
-        raise InvalidArgument(
-            f"Expected SearchStrategy but got {specifier!r} of "
-            f"type {type(specifier).__name__}"
-        )
-    specifier.validate()
-
-    last: ListEx = 
-
-    @settings
-    @given(specifier)
-    def test(v):
-        if condition(v):
-            last: = v
-            raise Found()
-
-    if random is not None:
-        test = seed(random.getrandbits(64))(test)
-
-    # Aliasing as Any avoids mypy errors (attr-defined) when accessing and
-    # setting custom attributes on the decorated function or class.
-    _test: Any = test
-    _test._hypothesis_internal_is_find = True
-    _test._hypothesis_internal_database_key = database_key
-
-    try:
-        test()
-    except Found:
-        return last0
-
-    raise NoSuchExample(get_pretty_function_description(condition))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/database.py Deleted

@@ -1,326 +0,0 @@
-# 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 abc
-import binascii
-import os
-import sys
-import warnings
-from hashlib import sha384
-from typing import Dict, Iterable
-
-from hypothesis.configuration import mkdir_p, storage_directory
-from hypothesis.errors import HypothesisException, HypothesisWarning
-from hypothesis.utils.conventions import not_set
-
-__all__ = 
-    "DirectoryBasedExampleDatabase",
-    "ExampleDatabase",
-    "InMemoryExampleDatabase",
-    "MultiplexedDatabase",
-    "ReadOnlyDatabase",
-
-
-
-def _usable_dir(path):
-    """
-    Returns True iff the desired path can be used as database path because
-    either the directory exists and can be used, or its root directory can
-    be used and we can make the directory as needed.
-    """
-    while not os.path.exists(path):
-        # Loop terminates because the root dir ('/' on unix) always exists.
-        path = os.path.dirname(path)
-    return os.path.isdir(path) and os.access(path, os.R_OK | os.W_OK | os.X_OK)
-
-
-def _db_for_path(path=None):
-    if path is not_set:
-        if os.getenv("HYPOTHESIS_DATABASE_FILE") is not None:  # pragma: no cover
-            raise HypothesisException(
-                "The $HYPOTHESIS_DATABASE_FILE environment variable no longer has any "
-                "effect.  Configure your database location via a settings profile instead.\n"
-                "https://hypothesis.readthedocs.io/en/latest/settings.html#settings-profiles"
-            )
-
-        path = storage_directory("examples")
-        if not _usable_dir(path):  # pragma: no cover
-            warnings.warn(
-                HypothesisWarning(
-                    "The database setting is not configured, and the default "
-                    "location is unusable - falling back to an in-memory "
-                    f"database for this session.  path={path!r}"
-                )
-            )
-            return InMemoryExampleDatabase()
-    if path in (None, ":memory:"):
-        return InMemoryExampleDatabase()
-    return DirectoryBasedExampleDatabase(str(path))
-
-
-class _EDMeta(abc.ABCMeta):
-    def __call__(self, *args, **kwargs):
-        if self is ExampleDatabase:
-            return _db_for_path(*args, **kwargs)
-        return super().__call__(*args, **kwargs)
-
-
-# This __call__ method is picked up by Sphinx as the signature of all ExampleDatabase
-# subclasses, which is accurate, reasonable, and unhelpful.  Fortunately Sphinx
-# maintains a list of metaclass-call-methods to ignore, and while they would prefer
-# not to maintain it upstream (https://github.com/sphinx-doc/sphinx/pull/8262) we
-# can insert ourselves here.
-#
-# This code only runs if Sphinx has already been imported; and it would live in our
-# docs/conf.py except that we would also like it to work for anyone documenting
-# downstream ExampleDatabase subclasses too.
-if "sphinx" in sys.modules:
-    try:
-        from sphinx.ext.autodoc import _METACLASS_CALL_BLACKLIST
-
-        _METACLASS_CALL_BLACKLIST.append("hypothesis.database._EDMeta.__call__")
-    except Exception:
-        pass
-
-
-class ExampleDatabase(metaclass=_EDMeta):
-    """An abstract base class for storing examples in Hypothesis' internal format.
-
-    An ExampleDatabase maps each ``bytes`` key to many distinct ``bytes``
-    values, like a ``Mappingbytes, AbstractSetbytes``.
-    """
-
-    @abc.abstractmethod
-    def save(self, key: bytes, value: bytes) -> None:
-        """Save ``value`` under ``key``.
-
-        If this value is already present for this key, silently do nothing.
-        """
-        raise NotImplementedError(f"{type(self).__name__}.save")
-
-    @abc.abstractmethod
-    def fetch(self, key: bytes) -> Iterablebytes:
-        """Return an iterable over all values matching this key."""
-        raise NotImplementedError(f"{type(self).__name__}.fetch")
-
-    @abc.abstractmethod
-    def delete(self, key: bytes, value: bytes) -> None:
-        """Remove this value from this key.
-
-        If this value is not present, silently do nothing.
-        """
-        raise NotImplementedError(f"{type(self).__name__}.delete")
-
-    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
-        """Move ``value`` from key ``src`` to key ``dest``. Equivalent to
-        ``delete(src, value)`` followed by ``save(src, value)``, but may
-        have a more efficient implementation.
-
-        Note that ``value`` will be inserted at ``dest`` regardless of whether
-        it is currently present at ``src``.
-        """
-        if src == dest:
-            self.save(src, value)
-            return
-        self.delete(src, value)
-        self.save(dest, value)
-
-
-class InMemoryExampleDatabase(ExampleDatabase):
-    """A non-persistent example database, implemented in terms of a dict of sets.
-
-    This can be useful if you call a test function several times in a single
-    session, or for testing other database implementations, but because it
-    does not persist between runs we do not recommend it for general use.
-    """
-
-    def __init__(self):
-        self.data = {}
-
-    def __repr__(self) -> str:
-        return f"InMemoryExampleDatabase({self.data!r})"
-
-    def fetch(self, key: bytes) -> Iterablebytes:
-        yield from self.data.get(key, ())
-
-    def save(self, key: bytes, value: bytes) -> None:
-        self.data.setdefault(key, set()).add(bytes(value))
-
-    def delete(self, key: bytes, value: bytes) -> None:
-        self.data.get(key, set()).discard(bytes(value))
-
-
-def _hash(key):
-    return sha384(key).hexdigest():16
-
-
-class DirectoryBasedExampleDatabase(ExampleDatabase):
-    """Use a directory to store Hypothesis examples as files.
-
-    Each test corresponds to a directory, and each example to a file within that
-    directory.  While the contents are fairly opaque, a
-    ``DirectoryBasedExampleDatabase`` can be shared by checking the directory
-    into version control, for example with the following ``.gitignore``::
-
-        # Ignore files cached by Hypothesis...
-        .hypothesis/*
-        # except for the examples directory
-        !.hypothesis/examples/
-
-    Note however that this only makes sense if you also pin to an exact version of
-    Hypothesis, and we would usually recommend implementing a shared database with
-    a network datastore - see :class:`~hypothesis.database.ExampleDatabase`, and
-    the :class:`~hypothesis.database.MultiplexedDatabase` helper.
-    """
-
-    def __init__(self, path: str) -> None:
-        self.path = path
-        self.keypaths: Dictstr, str = {}
-
-    def __repr__(self) -> str:
-        return f"DirectoryBasedExampleDatabase({self.path!r})"
-
-    def _key_path(self, key):
-        try:
-            return self.keypathskey
-        except KeyError:
-            pass
-        directory = os.path.join(self.path, _hash(key))
-        self.keypathskey = directory
-        return directory
-
-    def _value_path(self, key, value):
-        return os.path.join(self._key_path(key), _hash(value))
-
-    def fetch(self, key: bytes) -> Iterablebytes:
-        kp = self._key_path(key)
-        if not os.path.exists(kp):
-            return
-        for path in os.listdir(kp):
-            try:
-                with open(os.path.join(kp, path), "rb") as i:
-                    yield i.read()
-            except OSError:
-                pass
-
-    def save(self, key: bytes, value: bytes) -> None:
-        # Note: we attempt to create the dir in question now. We
-        # already checked for permissions, but there can still be other issues,
-        # e.g. the disk is full
-        mkdir_p(self._key_path(key))
-        path = self._value_path(key, value)
-        if not os.path.exists(path):
-            suffix = binascii.hexlify(os.urandom(16)).decode("ascii")
-            tmpname = path + "." + suffix
-            with open(tmpname, "wb") as o:
-                o.write(value)
-            try:
-                os.rename(tmpname, path)
-            except OSError:  # pragma: no cover
-                os.unlink(tmpname)
-            assert not os.path.exists(tmpname)
-
-    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
-        if src == dest:
-            self.save(src, value)
-            return
-        try:
-            os.renames(self._value_path(src, value), self._value_path(dest, value))
-        except OSError:
-            self.delete(src, value)
-            self.save(dest, value)
-
-    def delete(self, key: bytes, value: bytes) -> None:
-        try:
-            os.unlink(self._value_path(key, value))
-        except OSError:
-            pass
-
-
-class ReadOnlyDatabase(ExampleDatabase):
-    """A wrapper to make the given database read-only.
-
-    The implementation passes through ``fetch``, and turns ``save``, ``delete``, and
-    ``move`` into silent no-ops.
-
-    Note that this disables Hypothesis' automatic discarding of stale examples.
-    It is designed to allow local machines to access a shared database (e.g. from CI
-    servers), without propagating changes back from a local or in-development branch.
-    """
-
-    def __init__(self, db: ExampleDatabase) -> None:
-        assert isinstance(db, ExampleDatabase)
-        self._wrapped = db
-
-    def __repr__(self) -> str:
-        return f"ReadOnlyDatabase({self._wrapped!r})"
-
-    def fetch(self, key: bytes) -> Iterablebytes:
-        yield from self._wrapped.fetch(key)
-
-    def save(self, key: bytes, value: bytes) -> None:
-        pass
-
-    def delete(self, key: bytes, value: bytes) -> None:
-        pass
-
-
-class MultiplexedDatabase(ExampleDatabase):
-    """A wrapper around multiple databases.
-
-    Each ``save``, ``fetch``, ``move``, or ``delete`` operation will be run against
-    all of the wrapped databases.  ``fetch`` does not yield duplicate values, even
-    if the same value is present in two or more of the wrapped databases.
-
-    This combines well with a :class:`ReadOnlyDatabase`, as follows:
-
-    .. code-block:: python
-
-        local = DirectoryBasedExampleDatabase("/tmp/hypothesis/examples/")
-        shared = CustomNetworkDatabase()
-
-        settings.register_profile("ci", database=shared)
-        settings.register_profile(
-            "dev", database=MultiplexedDatabase(local, ReadOnlyDatabase(shared))
-        )
-        settings.load_profile("ci" if os.environ.get("CI") else "dev")
-
-    So your CI system or fuzzing runs can populate a central shared database;
-    while local runs on development machines can reproduce any failures from CI
-    but will only cache their own failures locally and cannot remove examples
-    from the shared database.
-    """
-
-    def __init__(self, *dbs: ExampleDatabase) -> None:
-        assert all(isinstance(db, ExampleDatabase) for db in dbs)
-        self._wrapped = dbs
-
-    def __repr__(self) -> str:
-        return "MultiplexedDatabase({})".format(", ".join(map(repr, self._wrapped)))
-
-    def fetch(self, key: bytes) -> Iterablebytes:
-        seen = set()
-        for db in self._wrapped:
-            for value in db.fetch(key):
-                if value not in seen:
-                    yield value
-                    seen.add(value)
-
-    def save(self, key: bytes, value: bytes) -> None:
-        for db in self._wrapped:
-            db.save(key, value)
-
-    def delete(self, key: bytes, value: bytes) -> None:
-        for db in self._wrapped:
-            db.delete(key, value)
-
-    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
-        for db in self._wrapped:
-            db.move(src, dest, value)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/entry_points.py Deleted

@@ -1,65 +0,0 @@
-# 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/.
-
-"""Run all functions registered for the "hypothesis" entry point.
-
-This can be used with `st.register_type_strategy` to register strategies for your
-custom types, running the relevant code when *hypothesis* is imported instead of
-your package.
-"""
-
-try:
-    # We prefer to use importlib.metadata, or the backport on Python <= 3.7,
-    # because it's much faster than pkg_resources (200ms import time speedup).
-    try:
-        from importlib import metadata as importlib_metadata
-    except ImportError:
-        import importlib_metadata  # type: ignore  # mypy thinks this is a redefinition
-
-    def get_entry_points():
-        try:
-            eps = importlib_metadata.entry_points(group="hypothesis")
-        except TypeError:
-            # Load-time selection requires Python >= 3.10 or importlib_metadata >= 3.6,
-            # so we'll retain this fallback logic for some time to come.  See also
-            # https://importlib-metadata.readthedocs.io/en/latest/using.html
-            eps = importlib_metadata.entry_points().get("hypothesis", )
-        yield from eps
-
-except ImportError:
-    # But if we're not on Python >= 3.8 and the importlib_metadata backport
-    # is not installed, we fall back to pkg_resources anyway.
-    try:
-        import pkg_resources
-    except ImportError:
-        import warnings
-
-        from hypothesis.errors import HypothesisWarning
-
-        warnings.warn(
-            "Under Python <= 3.7, Hypothesis requires either the importlib_metadata "
-            "or setuptools package in order to load plugins via entrypoints.",
-            HypothesisWarning,
-        )
-
-        def get_entry_points():
-            yield from ()
-
-    else:
-
-        def get_entry_points():
-            yield from pkg_resources.iter_entry_points("hypothesis")
-
-
-def run():
-    for entry in get_entry_points():  # pragma: no cover
-        hook = entry.load()
-        if callable(hook):
-            hook()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/errors.py Deleted

@@ -1,165 +0,0 @@
-# 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/.
-
-
-class HypothesisException(Exception):
-    """Generic parent class for exceptions thrown by Hypothesis."""
-
-
-class _Trimmable(HypothesisException):
-    """Hypothesis can trim these tracebacks even if they're raised internally."""
-
-
-class CleanupFailed(HypothesisException):
-    """At least one cleanup task failed and no other exception was raised."""
-
-
-class UnsatisfiedAssumption(HypothesisException):
-    """An internal error raised by assume.
-
-    If you're seeing this error something has gone wrong.
-    """
-
-
-class NoSuchExample(HypothesisException):
-    """The condition we have been asked to satisfy appears to be always false.
-
-    This does not guarantee that no example exists, only that we were
-    unable to find one.
-    """
-
-    def __init__(self, condition_string, extra=""):
-        super().__init__(f"No examples found of condition {condition_string}{extra}")
-
-
-class Unsatisfiable(_Trimmable):
-    """We ran out of time or examples before we could find enough examples
-    which satisfy the assumptions of this hypothesis.
-
-    This could be because the function is too slow. If so, try upping
-    the timeout. It could also be because the function is using assume
-    in a way that is too hard to satisfy. If so, try writing a custom
-    strategy or using a better starting point (e.g if you are requiring
-    a list has unique values you could instead filter out all duplicate
-    values from the list)
-    """
-
-
-class Flaky(_Trimmable):
-    """This function appears to fail non-deterministically: We have seen it
-    fail when passed this example at least once, but a subsequent invocation
-    did not fail.
-
-    Common causes for this problem are:
-        1. The function depends on external state. e.g. it uses an external
-           random number generator. Try to make a version that passes all the
-           relevant state in from Hypothesis.
-        2. The function is suffering from too much recursion and its failure
-           depends sensitively on where it's been called from.
-        3. The function is timing sensitive and can fail or pass depending on
-           how long it takes. Try breaking it up into smaller functions which
-           don't do that and testing those instead.
-    """
-
-
-class InvalidArgument(_Trimmable, TypeError):
-    """Used to indicate that the arguments to a Hypothesis function were in
-    some manner incorrect."""
-
-
-class ResolutionFailed(InvalidArgument):
-    """Hypothesis had to resolve a type to a strategy, but this failed.
-
-    Type inference is best-effort, so this only happens when an
-    annotation exists but could not be resolved for a required argument
-    to the target of ``builds()``, or where the user passed ``...``.
-    """
-
-
-class InvalidState(HypothesisException):
-    """The system is not in a state where you were allowed to do that."""
-
-
-class InvalidDefinition(_Trimmable, TypeError):
-    """Used to indicate that a class definition was not well put together and
-    has something wrong with it."""
-
-
-class HypothesisWarning(HypothesisException, Warning):
-    """A generic warning issued by Hypothesis."""
-
-
-class FailedHealthCheck(_Trimmable):
-    """Raised when a test fails a preliminary healthcheck that occurs before
-    execution."""
-
-    def __init__(self, message, check):
-        super().__init__(message)
-        self.health_check = check
-
-
-class NonInteractiveExampleWarning(HypothesisWarning):
-    """SearchStrategy.example() is designed for interactive use,
-    but should never be used in the body of a test.
-    """
-
-
-class HypothesisDeprecationWarning(HypothesisWarning, FutureWarning):
-    """A deprecation warning issued by Hypothesis.
-
-    Actually inherits from FutureWarning, because DeprecationWarning is
-    hidden by the default warnings filter.
-
-    You can configure the Python :mod:`python:warnings` to handle these
-    warnings differently to others, either turning them into errors or
-    suppressing them entirely.  Obviously we would prefer the former!
-    """
-
-
-class Frozen(HypothesisException):
-    """Raised when a mutation method has been called on a ConjectureData object
-    after freeze() has been called."""
-
-
-class MultipleFailures(_Trimmable):
-    """Indicates that Hypothesis found more than one distinct bug when testing
-    your code."""
-
-
-class DeadlineExceeded(_Trimmable):
-    """Raised when an individual test body has taken too long to run."""
-
-    def __init__(self, runtime, deadline):
-        super().__init__(
-            "Test took %.2fms, which exceeds the deadline of %.2fms"
-            % (runtime.total_seconds() * 1000, deadline.total_seconds() * 1000)
-        )
-        self.runtime = runtime
-        self.deadline = deadline
-
-
-class StopTest(BaseException):
-    """Raised when a test should stop running and return control to
-    the Hypothesis engine, which should then continue normally.
-    """
-
-    def __init__(self, testcounter):
-        super().__init__(repr(testcounter))
-        self.testcounter = testcounter
-
-
-class DidNotReproduce(HypothesisException):
-    pass
-
-
-class Found(Exception):
-    """Signal that the example matches condition. Internal use only."""
-
-    hypothesis_internal_never_escalate = True

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/_array_helpers.py Deleted

@@ -1,689 +0,0 @@
-# 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 re
-from typing import NamedTuple, Optional, Tuple, Union
-
-from hypothesis import assume, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.coverage import check_function
-from hypothesis.internal.validation import check_type, check_valid_interval
-from hypothesis.strategies._internal.utils import defines_strategy
-from hypothesis.utils.conventions import UniqueIdentifier, not_set
-
-__all__ = 
-    "NDIM_MAX",
-    "Shape",
-    "BroadcastableShapes",
-    "BasicIndex",
-    "check_argument",
-    "order_check",
-    "check_valid_dims",
-    "array_shapes",
-    "valid_tuple_axes",
-    "broadcastable_shapes",
-    "mutually_broadcastable_shapes",
-    "MutuallyBroadcastableShapesStrategy",
-    "BasicIndexStrategy",
-
-
-
-Shape = Tupleint, ...
-# We silence flake8 here because it disagrees with mypy about `ellipsis` (`type(...)`)
-BasicIndex = TupleUnionint, slice, None, "ellipsis", ...  # noqa: F821
-
-
-class BroadcastableShapes(NamedTuple):
-    input_shapes: TupleShape, ...
-    result_shape: Shape
-
-
-@check_function
-def check_argument(condition, fail_message, *f_args, **f_kwargs):
-    if not condition:
-        raise InvalidArgument(fail_message.format(*f_args, **f_kwargs))
-
-
-@check_function
-def order_check(name, floor, min_, max_):
-    if floor > min_:
-        raise InvalidArgument(f"min_{name} must be at least {floor} but was {min_}")
-    if min_ > max_:
-        raise InvalidArgument(f"min_{name}={min_} is larger than max_{name}={max_}")
-
-
-# 32 is a dimension limit specific to NumPy, and does not necessarily apply to
-# other array/tensor libraries. Historically these strategies were built for the
-# NumPy extra, so it's nice to keep these limits, and it's seemingly unlikely
-# someone would want to generate >32 dim arrays anyway.
-# See https://github.com/HypothesisWorks/hypothesis/pull/3067.
-NDIM_MAX = 32
-
-
-@check_function
-def check_valid_dims(dims, name):
-    if dims > NDIM_MAX:
-        raise InvalidArgument(
-            f"{name}={dims}, but Hypothesis does not support arrays with "
-            f"more than {NDIM_MAX} dimensions"
-        )
-
-
-@defines_strategy()
-def array_shapes(
-    *,
-    min_dims: int = 1,
-    max_dims: Optionalint = None,
-    min_side: int = 1,
-    max_side: Optionalint = None,
-) -> st.SearchStrategyShape:
-    """Return a strategy for array shapes (tuples of int >= 1).
-
-    * ``min_dims`` is the smallest length that the generated shape can possess.
-    * ``max_dims`` is the largest length that the generated shape can possess,
-      defaulting to ``min_dims + 2``.
-    * ``min_side`` is the smallest size that a dimension can possess.
-    * ``max_side`` is the largest size that a dimension can possess,
-      defaulting to ``min_side + 5``.
-    """
-    check_type(int, min_dims, "min_dims")
-    check_type(int, min_side, "min_side")
-    check_valid_dims(min_dims, "min_dims")
-
-    if max_dims is None:
-        max_dims = min(min_dims + 2, NDIM_MAX)
-    check_type(int, max_dims, "max_dims")
-    check_valid_dims(max_dims, "max_dims")
-
-    if max_side is None:
-        max_side = min_side + 5
-    check_type(int, max_side, "max_side")
-
-    order_check("dims", 0, min_dims, max_dims)
-    order_check("side", 0, min_side, max_side)
-
-    return st.lists(
-        st.integers(min_side, max_side), min_size=min_dims, max_size=max_dims
-    ).map(tuple)
-
-
-@defines_strategy()
-def valid_tuple_axes(
-    ndim: int,
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> st.SearchStrategyTupleint, ...:
-    """All tuples will have a length >= ``min_size`` and <= ``max_size``. The default
-    value for ``max_size`` is ``ndim``.
-
-    Examples from this strategy shrink towards an empty tuple, which render most
-    sequential functions as no-ops.
-
-    The following are some examples drawn from this strategy.
-
-    .. code-block:: pycon
-
-      >>> valid_tuple_axes(3).example() for i in range(4)
-      (-3, 1), (0, 1, -1), (0, 2), (0, -2, 2)
-
-    ``valid_tuple_axes`` can be joined with other strategies to generate
-    any type of valid axis object, i.e. integers, tuples, and ``None``:
-
-    .. code-block:: python
-
-      any_axis_strategy = none() | integers(-ndim, ndim - 1) | valid_tuple_axes(ndim)
-
-    """
-    check_type(int, ndim, "ndim")
-    check_type(int, min_size, "min_size")
-    if max_size is None:
-        max_size = ndim
-    check_type(int, max_size, "max_size")
-    order_check("size", 0, min_size, max_size)
-    check_valid_interval(max_size, ndim, "max_size", "ndim")
-
-    axes = st.integers(0, max(0, 2 * ndim - 1)).map(
-        lambda x: x if x < ndim else x - 2 * ndim
-    )
-
-    return st.lists(
-        axes, min_size=min_size, max_size=max_size, unique_by=lambda x: x % ndim
-    ).map(tuple)
-
-
-@defines_strategy()
-def broadcastable_shapes(
-    shape: Shape,
-    *,
-    min_dims: int = 0,
-    max_dims: Optionalint = None,
-    min_side: int = 1,
-    max_side: Optionalint = None,
-) -> st.SearchStrategyShape:
-    """Return a strategy for shapes that are broadcast-compatible with the
-    provided shape.
-
-    Examples from this strategy shrink towards a shape with length ``min_dims``.
-    The size of an aligned dimension shrinks towards size ``1``. The size of an
-    unaligned dimension shrink towards ``min_side``.
-
-    * ``shape`` is a tuple of integers.
-    * ``min_dims`` is the smallest length that the generated shape can possess.
-    * ``max_dims`` is the largest length that the generated shape can possess,
-      defaulting to ``max(len(shape), min_dims) + 2``.
-    * ``min_side`` is the smallest size that an unaligned dimension can possess.
-    * ``max_side`` is the largest size that an unaligned dimension can possess,
-      defaulting to 2 plus the size of the largest aligned dimension.
-
-    The following are some examples drawn from this strategy.
-
-    .. code-block:: pycon
-
-        >>> broadcastable_shapes(shape=(2, 3)).example() for i in range(5)
-        (1, 3), (), (2, 3), (2, 1), (4, 1, 3), (3, )
-
-    """
-    check_type(tuple, shape, "shape")
-    check_type(int, min_side, "min_side")
-    check_type(int, min_dims, "min_dims")
-    check_valid_dims(min_dims, "min_dims")
-
-    strict_check = max_side is None or max_dims is None
-
-    if max_dims is None:
-        max_dims = min(max(len(shape), min_dims) + 2, NDIM_MAX)
-    check_type(int, max_dims, "max_dims")
-    check_valid_dims(max_dims, "max_dims")
-
-    if max_side is None:
-        max_side = max(shape-max_dims: + (min_side,)) + 2
-    check_type(int, max_side, "max_side")
-
-    order_check("dims", 0, min_dims, max_dims)
-    order_check("side", 0, min_side, max_side)
-
-    if strict_check:
-        dims = max_dims
-        bound_name = "max_dims"
-    else:
-        dims = min_dims
-        bound_name = "min_dims"
-
-    # check for unsatisfiable min_side
-    if not all(min_side <= s for s in shape::-1:dims if s != 1):
-        raise InvalidArgument(
-            f"Given shape={shape}, there are no broadcast-compatible "
-            f"shapes that satisfy: {bound_name}={dims} and min_side={min_side}"
-        )
-
-    # check for unsatisfiable min_side, max_side
-    if not (
-        min_side <= 1 <= max_side or all(s <= max_side for s in shape::-1:dims)
-    ):
-        raise InvalidArgument(
-            f"Given base_shape={shape}, there are no broadcast-compatible "
-            f"shapes that satisfy all of {bound_name}={dims}, "
-            f"min_side={min_side}, and max_side={max_side}"
-        )
-
-    if not strict_check:
-        # reduce max_dims to exclude unsatisfiable dimensions
-        for n, s in zip(range(max_dims), shape::-1):
-            if s < min_side and s != 1:
-                max_dims = n
-                break
-            elif not (min_side <= 1 <= max_side or s <= max_side):
-                max_dims = n
-                break
-
-    return MutuallyBroadcastableShapesStrategy(
-        num_shapes=1,
-        base_shape=shape,
-        min_dims=min_dims,
-        max_dims=max_dims,
-        min_side=min_side,
-        max_side=max_side,
-    ).map(lambda x: x.input_shapes0)
-
-
-# See https://numpy.org/doc/stable/reference/c-api/generalized-ufuncs.html
-# Implementation based on numpy.lib.function_base._parse_gufunc_signature
-# with minor upgrades to handle numeric and optional dimensions.  Examples:
-#
-#     add       (),()->()                   binary ufunc
-#     sum1d     (i)->()                     reduction
-#     inner1d   (i),(i)->()                 vector-vector multiplication
-#     matmat    (m,n),(n,p)->(m,p)          matrix multiplication
-#     vecmat    (n),(n,p)->(p)              vector-matrix multiplication
-#     matvec    (m,n),(n)->(m)              matrix-vector multiplication
-#     matmul    (m?,n),(n,p?)->(m?,p?)      combination of the four above
-#     cross1d   (3),(3)->(3)                cross product with frozen dimensions
-#
-# Note that while no examples of such usage are given, Numpy does allow
-# generalised ufuncs that have *multiple output arrays*.  This is not
-# currently supported by Hypothesis - please contact us if you would use it!
-#
-# We are unsure if gufuncs allow frozen dimensions to be optional, but it's
-# easy enough to support here - and so we will unless we learn otherwise.
-_DIMENSION = r"\w+\??"  # Note that \w permits digits too!
-_SHAPE = r"$(?:{0}(?:,{0})".format(_DIMENSION) + r"{0,31})?$"
-_ARGUMENT_LIST = "{0}(?:,{0})*".format(_SHAPE)
-_SIGNATURE = rf"^{_ARGUMENT_LIST}->{_SHAPE}$"
-_SIGNATURE_MULTIPLE_OUTPUT = r"^{0}->{0}$".format(_ARGUMENT_LIST)
-
-
-class _GUfuncSig(NamedTuple):
-    input_shapes: TupleShape, ...
-    result_shape: Shape
-
-
-def _hypothesis_parse_gufunc_signature(signature, all_checks=True):
-    # Disable all_checks to better match the Numpy version, for testing
-    if not re.match(_SIGNATURE, signature):
-        if re.match(_SIGNATURE_MULTIPLE_OUTPUT, signature):
-            raise InvalidArgument(
-                "Hypothesis does not yet support generalised ufunc signatures "
-                "with multiple output arrays - mostly because we don't know of "
-                "anyone who uses them!  Please get in touch with us to fix that."
-                f"\n (signature={signature!r})"
-            )
-        if re.match(
-            (
-                # Taken from np.lib.function_base._SIGNATURE
-                r"^$(?:\w+(?:,\w+)*)?$(?:,$(?:\w+(?:,\w+)*)?$)*->"
-                r"$(?:\w+(?:,\w+)*)?$(?:,$(?:\w+(?:,\w+)*)?$)*$"
-            ),
-            signature,
-        ):
-            raise InvalidArgument(
-                f"signature={signature!r} matches Numpy's regex for gufunc signatures, "
-                f"but contains shapes with more than {NDIM_MAX} dimensions and is thus invalid."
-            )
-        raise InvalidArgument(f"{signature!r} is not a valid gufunc signature")
-    input_shapes, output_shapes = (
-        tuple(tuple(re.findall(_DIMENSION, a)) for a in re.findall(_SHAPE, arg_list))
-        for arg_list in signature.split("->")
-    )
-    assert len(output_shapes) == 1
-    result_shape = output_shapes0
-    if all_checks:
-        # Check that there are no names in output shape that do not appear in inputs.
-        # (kept out of parser function for easier generation of test values)
-        # We also disallow frozen optional dimensions - this is ambiguous as there is
-        # no way to share an un-named dimension between shapes.  Maybe just padding?
-        # Anyway, we disallow it pending clarification from upstream.
-        frozen_optional_err = (
-            "Got dimension %r, but handling of frozen optional dimensions "
-            "is ambiguous.  If you known how this should work, please "
-            "contact us to get this fixed and documented (signature=%r)."
-        )
-        only_out_err = (
-            "The %r dimension only appears in the output shape, and is "
-            "not frozen, so the size is not determined (signature=%r)."
-        )
-        names_in = {n.strip("?") for shp in input_shapes for n in shp}
-        names_out = {n.strip("?") for n in result_shape}
-        for shape in input_shapes + (result_shape,):
-            for name in shape:
-                try:
-                    int(name.strip("?"))
-                    if "?" in name:
-                        raise InvalidArgument(frozen_optional_err % (name, signature))
-                except ValueError:
-                    if name.strip("?") in (names_out - names_in):
-                        raise InvalidArgument(
-                            only_out_err % (name, signature)
-                        ) from None
-    return _GUfuncSig(input_shapes=input_shapes, result_shape=result_shape)
-
-
-@defines_strategy()
-def mutually_broadcastable_shapes(
-    *,
-    num_shapes: UnionUniqueIdentifier, int = not_set,
-    signature: UnionUniqueIdentifier, str = not_set,
-    base_shape: Shape = (),
-    min_dims: int = 0,
-    max_dims: Optionalint = None,
-    min_side: int = 1,
-    max_side: Optionalint = None,
-) -> st.SearchStrategyBroadcastableShapes:
-    """Return a strategy for a specified number of shapes N that are
-    mutually-broadcastable with one another and with the provided base shape.
-
-    * ``num_shapes`` is the number of mutually broadcast-compatible shapes to generate.
-    * ``base_shape`` is the shape against which all generated shapes can broadcast.
-      The default shape is empty, which corresponds to a scalar and thus does
-      not constrain broadcasting at all.
-    * ``min_dims`` is the smallest length that the generated shape can possess.
-    * ``max_dims`` is the largest length that the generated shape can possess,
-      defaulting to ``max(len(shape), min_dims) + 2``.
-    * ``min_side`` is the smallest size that an unaligned dimension can possess.
-    * ``max_side`` is the largest size that an unaligned dimension can possess,
-      defaulting to 2 plus the size of the largest aligned dimension.
-
-    The strategy will generate a :obj:`python:typing.NamedTuple` containing:
-
-    * ``input_shapes`` as a tuple of the N generated shapes.
-    * ``result_shape`` as the resulting shape produced by broadcasting the N shapes
-      with the base shape.
-
-    The following are some examples drawn from this strategy.
-
-    .. code-block:: pycon
-
-        >>> # Draw three shapes where each shape is broadcast-compatible with (2, 3)
-        ... strat = mutually_broadcastable_shapes(num_shapes=3, base_shape=(2, 3))
-        >>> for _ in range(5):
-        ...     print(strat.example())
-        BroadcastableShapes(input_shapes=((4, 1, 3), (4, 2, 3), ()), result_shape=(4, 2, 3))
-        BroadcastableShapes(input_shapes=((3,), (1, 3), (2, 3)), result_shape=(2, 3))
-        BroadcastableShapes(input_shapes=((), (), ()), result_shape=(2, 3))
-        BroadcastableShapes(input_shapes=((3,), (), (3,)), result_shape=(2, 3))
-        BroadcastableShapes(input_shapes=((1, 2, 3), (3,), ()), result_shape=(1, 2, 3))
-
-    """
-    arg_msg = "Pass either the `num_shapes` or the `signature` argument, but not both."
-    if num_shapes is not not_set:
-        check_argument(signature is not_set, arg_msg)
-        check_type(int, num_shapes, "num_shapes")
-        assert isinstance(num_shapes, int)  # for mypy
-        parsed_signature = None
-        sig_dims = 0
-    else:
-        check_argument(signature is not not_set, arg_msg)
-        if signature is None:
-            raise InvalidArgument(
-                "Expected a string, but got invalid signature=None.  "
-                "(maybe .signature attribute of an element-wise ufunc?)"
-            )
-        check_type(str, signature, "signature")
-        parsed_signature = _hypothesis_parse_gufunc_signature(signature)
-        all_shapes = parsed_signature.input_shapes + (parsed_signature.result_shape,)
-        sig_dims = min(len(s) for s in all_shapes)
-        num_shapes = len(parsed_signature.input_shapes)
-
-    if num_shapes < 1:
-        raise InvalidArgument(f"num_shapes={num_shapes} must be at least 1")
-
-    check_type(tuple, base_shape, "base_shape")
-    check_type(int, min_side, "min_side")
-    check_type(int, min_dims, "min_dims")
-    check_valid_dims(min_dims, "min_dims")
-
-    strict_check = max_dims is not None
-
-    if max_dims is None:
-        max_dims = min(max(len(base_shape), min_dims) + 2, NDIM_MAX - sig_dims)
-    check_type(int, max_dims, "max_dims")
-    check_valid_dims(max_dims, "max_dims")
-
-    if max_side is None:
-        max_side = max(base_shape-max_dims: + (min_side,)) + 2
-    check_type(int, max_side, "max_side")
-
-    order_check("dims", 0, min_dims, max_dims)
-    order_check("side", 0, min_side, max_side)
-
-    if signature is not None and max_dims > NDIM_MAX - sig_dims:
-        raise InvalidArgument(
-            f"max_dims={signature!r} would exceed the {NDIM_MAX}-dimension"
-            "limit Hypothesis imposes on array shapes, "
-            f"given signature={parsed_signature!r}"
-        )
-
-    if strict_check:
-        dims = max_dims
-        bound_name = "max_dims"
-    else:
-        dims = min_dims
-        bound_name = "min_dims"
-
-    # check for unsatisfiable min_side
-    if not all(min_side <= s for s in base_shape::-1:dims if s != 1):
-        raise InvalidArgument(
-            f"Given base_shape={base_shape}, there are no broadcast-compatible "
-            f"shapes that satisfy: {bound_name}={dims} and min_side={min_side}"
-        )
-
-    # check for unsatisfiable min_side, max_side
-    if not (
-        min_side <= 1 <= max_side or all(s <= max_side for s in base_shape::-1:dims)
-    ):
-        raise InvalidArgument(
-            f"Given base_shape={base_shape}, there are no broadcast-compatible "
-            f"shapes that satisfy all of {bound_name}={dims}, "
-            f"min_side={min_side}, and max_side={max_side}"
-        )
-
-    if not strict_check:
-        # reduce max_dims to exclude unsatisfiable dimensions
-        for n, s in zip(range(max_dims), base_shape::-1):
-            if s < min_side and s != 1:
-                max_dims = n
-                break
-            elif not (min_side <= 1 <= max_side or s <= max_side):
-                max_dims = n
-                break
-
-    return MutuallyBroadcastableShapesStrategy(
-        num_shapes=num_shapes,
-        signature=parsed_signature,
-        base_shape=base_shape,
-        min_dims=min_dims,
-        max_dims=max_dims,
-        min_side=min_side,
-        max_side=max_side,
-    )
-
-
-class MutuallyBroadcastableShapesStrategy(st.SearchStrategy):
-    def __init__(
-        self,
-        num_shapes,
-        signature=None,
-        base_shape=(),
-        min_dims=0,
-        max_dims=None,
-        min_side=1,
-        max_side=None,
-    ):
-        super().__init__()
-        self.base_shape = base_shape
-        self.side_strat = st.integers(min_side, max_side)
-        self.num_shapes = num_shapes
-        self.signature = signature
-        self.min_dims = min_dims
-        self.max_dims = max_dims
-        self.min_side = min_side
-        self.max_side = max_side
-
-        self.size_one_allowed = self.min_side <= 1 <= self.max_side
-
-    def do_draw(self, data):
-        # We don't usually have a gufunc signature; do the common case first & fast.
-        if self.signature is None:
-            return self._draw_loop_dimensions(data)
-
-        # When we *do*, draw the core dims, then draw loop dims, and finally combine.
-        core_in, core_res = self._draw_core_dimensions(data)
-
-        # If some core shape has omitted optional dimensions, it's an error to add
-        # loop dimensions to it.  We never omit core dims if min_dims >= 1.
-        # This ensures that we respect Numpy's gufunc broadcasting semantics and user
-        # constraints without needing to check whether the loop dims will be
-        # interpreted as an invalid substitute for the omitted core dims.
-        # We may implement this check later!
-        use = None not in shp for shp in core_in
-        loop_in, loop_res = self._draw_loop_dimensions(data, use=use)
-
-        def add_shape(loop, core):
-            return tuple(x for x in (loop + core)-NDIM_MAX: if x is not None)
-
-        return BroadcastableShapes(
-            input_shapes=tuple(add_shape(l_in, c) for l_in, c in zip(loop_in, core_in)),
-            result_shape=add_shape(loop_res, core_res),
-        )
-
-    def _draw_core_dimensions(self, data):
-        # Draw gufunc core dimensions, with None standing for optional dimensions
-        # that will not be present in the final shape.  We track omitted dims so
-        # that we can do an accurate per-shape length cap.
-        dims = {}
-        shapes = 
-        for shape in self.signature.input_shapes + (self.signature.result_shape,):
-            shapes.append()
-            for name in shape:
-                if name.isdigit():
-                    shapes-1.append(int(name))
-                    continue
-                if name not in dims:
-                    dim = name.strip("?")
-                    dimsdim = data.draw(self.side_strat)
-                    if self.min_dims == 0 and not data.draw_bits(3):
-                        dimsdim + "?" = None
-                    else:
-                        dimsdim + "?" = dimsdim
-                shapes-1.append(dimsname)
-        return tuple(tuple(s) for s in shapes:-1), tuple(shapes-1)
-
-    def _draw_loop_dimensions(self, data, use=None):
-        # All shapes are handled in column-major order; i.e. they are reversed
-        base_shape = self.base_shape::-1
-        result_shape = list(base_shape)
-        shapes =  for _ in range(self.num_shapes)
-        if use is None:
-            use = True for _ in range(self.num_shapes)
-        else:
-            assert len(use) == self.num_shapes
-            assert all(isinstance(x, bool) for x in use)
-
-        for dim_count in range(1, self.max_dims + 1):
-            dim = dim_count - 1
-
-            # We begin by drawing a valid dimension-size for the given
-            # dimension. This restricts the variability across the shapes
-            # at this dimension such that they can only choose between
-            # this size and a singleton dimension.
-            if len(base_shape) < dim_count or base_shapedim == 1:
-                # dim is unrestricted by the base-shape: shrink to min_side
-                dim_side = data.draw(self.side_strat)
-            elif base_shapedim <= self.max_side:
-                # dim is aligned with non-singleton base-dim
-                dim_side = base_shapedim
-            else:
-                # only a singleton is valid in alignment with the base-dim
-                dim_side = 1
-
-            allowed_sides = sorted(1, dim_side)  # shrink to 0 when available
-            for shape_id, shape in enumerate(shapes):
-                # Populating this dimension-size for each shape, either
-                # the drawn size is used or, if permitted, a singleton
-                # dimension.
-                if dim <= len(result_shape) and self.size_one_allowed:
-                    # aligned: shrink towards size 1
-                    side = data.draw(st.sampled_from(allowed_sides))
-                else:
-                    side = dim_side
-
-                # Use a trick where where a biased coin is queried to see
-                # if the given shape-tuple will continue to be grown. All
-                # of the relevant draws will still be made for the given
-                # shape-tuple even if it is no longer being added to.
-                # This helps to ensure more stable shrinking behavior.
-                if self.min_dims < dim_count:
-                    useshape_id &= cu.biased_coin(
-                        data, 1 - 1 / (1 + self.max_dims - dim)
-                    )
-
-                if useshape_id:
-                    shape.append(side)
-                    if len(result_shape) < len(shape):
-                        result_shape.append(shape-1)
-                    elif shape-1 != 1 and result_shapedim == 1:
-                        result_shapedim = shape-1
-            if not any(use):
-                break
-
-        result_shape = result_shape: max(map(len, self.base_shape + shapes))
-
-        assert len(shapes) == self.num_shapes
-        assert all(self.min_dims <= len(s) <= self.max_dims for s in shapes)
-        assert all(self.min_side <= s <= self.max_side for side in shapes for s in side)
-
-        return BroadcastableShapes(
-            input_shapes=tuple(tuple(reversed(shape)) for shape in shapes),
-            result_shape=tuple(reversed(result_shape)),
-        )
-
-
-class BasicIndexStrategy(st.SearchStrategy):
-    def __init__(
-        self,
-        shape,
-        min_dims,
-        max_dims,
-        allow_ellipsis,
-        allow_newaxis,
-        allow_fewer_indices_than_dims,
-    ):
-        self.shape = shape
-        self.min_dims = min_dims
-        self.max_dims = max_dims
-        self.allow_ellipsis = allow_ellipsis
-        self.allow_newaxis = allow_newaxis
-        # allow_fewer_indices_than_dims=False will disable generating indices
-        # that don't cover all axes, i.e. indices that will flat index arrays.
-        # This is necessary for the Array API as such indices are not supported.
-        self.allow_fewer_indices_than_dims = allow_fewer_indices_than_dims
-
-    def do_draw(self, data):
-        # General plan: determine the actual selection up front with a straightforward
-        # approach that shrinks well, then complicate it by inserting other things.
-        result = 
-        for dim_size in self.shape:
-            if dim_size == 0:
-                result.append(slice(None))
-                continue
-            strategy = st.integers(-dim_size, dim_size - 1) | st.slices(dim_size)
-            result.append(data.draw(strategy))
-        # Insert some number of new size-one dimensions if allowed
-        result_dims = sum(isinstance(idx, slice) for idx in result)
-        while (
-            self.allow_newaxis
-            and result_dims < self.max_dims
-            and (result_dims < self.min_dims or data.draw(st.booleans()))
-        ):
-            i = data.draw(st.integers(0, len(result)))
-            result.insert(i, None)  # Note that `np.newaxis is None`
-            result_dims += 1
-        # Check that we'll have the right number of dimensions; reject if not.
-        # It's easy to do this by construction if you don't care about shrinking,
-        # which is really important for array shapes.  So we filter instead.
-        assume(self.min_dims <= result_dims <= self.max_dims)
-        # This is a quick-and-dirty way to insert ..., xor shorten the indexer,
-        # but it means we don't have to do any structural analysis.
-        if self.allow_ellipsis and data.draw(st.booleans()):
-            # Choose an index; then replace all adjacent whole-dimension slices.
-            i = j = data.draw(st.integers(0, len(result)))
-            while i > 0 and resulti - 1 == slice(None):
-                i -= 1
-            while j < len(result) and resultj == slice(None):
-                j += 1
-            resulti:j = Ellipsis
-        elif self.allow_fewer_indices_than_dims:  # pragma: no cover
-            while result-1: == slice(None, None) and data.draw(st.integers(0, 7)):
-                result.pop()
-        if len(result) == 1 and data.draw(st.booleans()):
-            # Sometimes generate bare element equivalent to a length-one tuple
-            return result0
-        return tuple(result)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/array_api.py Deleted

@@ -1,983 +0,0 @@
-# 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 math
-import sys
-from numbers import Real
-from types import SimpleNamespace
-from typing import (
-    Any,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
-from warnings import warn
-
-from hypothesis import strategies as st
-from hypothesis.errors import HypothesisWarning, InvalidArgument
-from hypothesis.extra._array_helpers import (
-    NDIM_MAX,
-    BasicIndex,
-    BasicIndexStrategy,
-    BroadcastableShapes,
-    Shape,
-    array_shapes,
-    broadcastable_shapes,
-    check_argument,
-    check_valid_dims,
-    mutually_broadcastable_shapes as _mutually_broadcastable_shapes,
-    order_check,
-    valid_tuple_axes as _valid_tuple_axes,
-)
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.coverage import check_function
-from hypothesis.internal.floats import next_down
-from hypothesis.internal.reflection import proxies
-from hypothesis.internal.validation import (
-    check_type,
-    check_valid_bound,
-    check_valid_integer,
-    check_valid_interval,
-)
-from hypothesis.strategies._internal.strategies import check_strategy
-from hypothesis.strategies._internal.utils import defines_strategy
-
-__all__ = 
-    "make_strategies_namespace",
-
-
-
-INT_NAMES = ("int8", "int16", "int32", "int64")
-UINT_NAMES = ("uint8", "uint16", "uint32", "uint64")
-ALL_INT_NAMES = INT_NAMES + UINT_NAMES
-FLOAT_NAMES = ("float32", "float64")
-NUMERIC_NAMES = ALL_INT_NAMES + FLOAT_NAMES
-DTYPE_NAMES = ("bool",) + NUMERIC_NAMES
-
-DataType = TypeVar("DataType")
-
-
-@check_function
-def check_xp_attributes(xp: Any, attributes: Liststr) -> None:
-    missing_attrs = attr for attr in attributes if not hasattr(xp, attr)
-    if len(missing_attrs) > 0:
-        f_attrs = ", ".join(missing_attrs)
-        raise InvalidArgument(
-            f"Array module {xp.__name__} does not have required attributes: {f_attrs}"
-        )
-
-
-def partition_attributes_and_stubs(
-    xp: Any, attributes: Iterablestr
-) -> TupleListAny, Liststr:
-    non_stubs = 
-    stubs = 
-    for attr in attributes:
-        try:
-            non_stubs.append(getattr(xp, attr))
-        except AttributeError:
-            stubs.append(attr)
-
-    return non_stubs, stubs
-
-
-def warn_on_missing_dtypes(xp: Any, stubs: Liststr) -> None:
-    f_stubs = ", ".join(stubs)
-    warn(
-        f"Array module {xp.__name__} does not have the following "
-        f"dtypes in its namespace: {f_stubs}",
-        HypothesisWarning,
-    )
-
-
-def find_castable_builtin_for_dtype(
-    xp: Any, dtype: DataType
-) -> TypeUnionbool, int, float:
-    """Returns builtin type which can have values that are castable to the given
-    dtype, according to :xp-ref:`type promotion rules <type_promotion.html>`.
-
-    For floating dtypes we always return ``float``, even though ``int`` is also castable.
-    """
-    stubs = 
-
-    try:
-        bool_dtype = xp.bool
-        if dtype == bool_dtype:
-            return bool
-    except AttributeError:
-        stubs.append("bool")
-
-    int_dtypes, int_stubs = partition_attributes_and_stubs(xp, ALL_INT_NAMES)
-    if dtype in int_dtypes:
-        return int
-
-    float_dtypes, float_stubs = partition_attributes_and_stubs(xp, FLOAT_NAMES)
-    # None equals NumPy's xp.float64 object, so we specifically skip it here to
-    # ensure that InvalidArgument is still raised. xp.float64 is in fact an
-    # alias of np.dtype('float64'), and its equality with None is meant to be
-    # deprecated at some point. See https://github.com/numpy/numpy/issues/18434
-    if dtype is not None and dtype in float_dtypes:
-        return float
-
-    stubs.extend(int_stubs)
-    stubs.extend(float_stubs)
-    if len(stubs) > 0:
-        warn_on_missing_dtypes(xp, stubs)
-    raise InvalidArgument(f"dtype={dtype} not recognised in {xp.__name__}")
-
-
-@check_function
-def dtype_from_name(xp: Any, name: str) -> DataType:
-    if name in DTYPE_NAMES:
-        try:
-            return getattr(xp, name)
-        except AttributeError as e:
-            raise InvalidArgument(
-                f"Array module {xp.__name__} does not have dtype {name} in its namespace"
-            ) from e
-    else:
-        f_valid_dtypes = ", ".join(DTYPE_NAMES)
-        raise InvalidArgument(
-            f"{name} is not a valid Array API data type (pick from: {f_valid_dtypes})"
-        )
-
-
-def _from_dtype(
-    xp: Any,
-    dtype: UnionDataType, str,
-    *,
-    min_value: OptionalUnionint, float = None,
-    max_value: OptionalUnionint, float = None,
-    allow_nan: Optionalbool = None,
-    allow_infinity: Optionalbool = None,
-    allow_subnormal: Optionalbool = None,
-    exclude_min: Optionalbool = None,
-    exclude_max: Optionalbool = None,
-) -> st.SearchStrategyUnionbool, int, float:
-    """Return a strategy for any value of the given dtype.
-
-    Values generated are of the Python scalar which is
-    :xp-ref:`promotable <type_promotion.html>` to ``dtype``, where the values do
-    not exceed its bounds.
-
-    * ``dtype`` may be a dtype object or the string name of a
-      :xp-ref:`valid dtype <data_types.html>`.
-
-    Compatible ``**kwargs`` are passed to the inferred strategy function for
-    integers and floats.  This allows you to customise the min and max values,
-    and exclude non-finite numbers. This is particularly useful when kwargs are
-    passed through from :func:`arrays()`, as it seamlessly handles the ``width``
-    or other representable bounds for you.
-    """
-    check_xp_attributes(xp, "iinfo", "finfo")
-
-    if isinstance(dtype, str):
-        dtype = dtype_from_name(xp, dtype)
-    builtin = find_castable_builtin_for_dtype(xp, dtype)
-
-    def check_valid_minmax(prefix, val, info_obj):
-        name = f"{prefix}_value"
-        check_valid_bound(val, name)
-        check_argument(
-            val >= info_obj.min,
-            f"dtype={dtype} requires {name}={val} to be at least {info_obj.min}",
-        )
-        check_argument(
-            val <= info_obj.max,
-            f"dtype={dtype} requires {name}={val} to be at most {info_obj.max}",
-        )
-
-    if builtin is bool:
-        return st.booleans()
-    elif builtin is int:
-        iinfo = xp.iinfo(dtype)
-        if min_value is None:
-            min_value = iinfo.min
-        if max_value is None:
-            max_value = iinfo.max
-        check_valid_integer(min_value, "min_value")
-        check_valid_integer(max_value, "max_value")
-        assert isinstance(min_value, int)
-        assert isinstance(max_value, int)
-        check_valid_minmax("min", min_value, iinfo)
-        check_valid_minmax("max", max_value, iinfo)
-        check_valid_interval(min_value, max_value, "min_value", "max_value")
-        return st.integers(min_value=min_value, max_value=max_value)
-    else:
-        finfo = xp.finfo(dtype)
-        kw = {}
-
-        # Whilst we know the boundary values of float dtypes from finfo, we do
-        # not assign them to the floats() strategy by default - passing min/max
-        # values will modify test case reduction behaviour so that simple bugs
-        # may become harder for users to identify. We plan to improve floats()
-        # behaviour in https://github.com/HypothesisWorks/hypothesis/issues/2907.
-        # Setting width should manage boundary values for us anyway.
-        if min_value is not None:
-            check_valid_bound(min_value, "min_value")
-            assert isinstance(min_value, Real)
-            check_valid_minmax("min", min_value, finfo)
-            kw"min_value" = min_value
-        if max_value is not None:
-            check_valid_bound(max_value, "max_value")
-            assert isinstance(max_value, Real)
-            check_valid_minmax("max", max_value, finfo)
-            if min_value is not None:
-                check_valid_interval(min_value, max_value, "min_value", "max_value")
-            kw"max_value" = max_value
-
-        # We infer whether an array module will flush subnormals to zero, as may
-        # be the case when libraries are built with compiler options that
-        # violate IEEE-754 (e.g. -ffast-math and -ftz=true). Note we do this for
-        # the specific dtype, as compilers may end up flushing subnormals for
-        # one float but supporting subnormals for the other.
-        #
-        # By default, floats() will generate subnormals if they are in the
-        # inferred values range. If we have detected that xp flushes to zero for
-        # the passed dtype, we ensure from_dtype() will not generate subnormals
-        # by default.
-        if allow_subnormal is not None:
-            kw"allow_subnormal" = allow_subnormal
-        else:
-            subnormal = next_down(finfo.smallest_normal, width=finfo.bits)
-            ftz = bool(xp.asarray(subnormal, dtype=dtype) == 0)
-            if ftz:
-                kw"allow_subnormal" = False
-
-        if allow_nan is not None:
-            kw"allow_nan" = allow_nan
-        if allow_infinity is not None:
-            kw"allow_infinity" = allow_infinity
-        if exclude_min is not None:
-            kw"exclude_min" = exclude_min
-        if exclude_max is not None:
-            kw"exclude_max" = exclude_max
-
-        return st.floats(width=finfo.bits, **kw)
-
-
-class ArrayStrategy(st.SearchStrategy):
-    def __init__(self, xp, elements_strategy, dtype, shape, fill, unique):
-        self.xp = xp
-        self.elements_strategy = elements_strategy
-        self.dtype = dtype
-        self.shape = shape
-        self.fill = fill
-        self.unique = unique
-        self.array_size = math.prod(shape)
-        self.builtin = find_castable_builtin_for_dtype(xp, dtype)
-        self.finfo = None if self.builtin is not float else xp.finfo(self.dtype)
-
-    def check_set_value(self, val, val_0d, strategy):
-        finite = self.builtin is bool or self.xp.isfinite(val_0d)
-        if finite and self.builtin(val_0d) != val:
-            if self.builtin is float:
-                assert self.finfo is not None  # for mypy
-                try:
-                    is_subnormal = 0 < abs(val) < self.finfo.smallest_normal
-                except Exception:
-                    # val may be a non-float that does not support the
-                    # operations __lt__ and __abs__
-                    is_subnormal = False
-                if is_subnormal:
-                    raise InvalidArgument(
-                        f"Generated subnormal float {val} from strategy "
-                        f"{strategy} resulted in {val_0d!r}, probably "
-                        f"as a result of array module {self.xp.__name__} "
-                        "being built with flush-to-zero compiler options. "
-                        "Consider passing allow_subnormal=False."
-                    )
-            raise InvalidArgument(
-                f"Generated array element {val!r} from strategy {strategy} "
-                f"cannot be represented with dtype {self.dtype}. "
-                f"Array module {self.xp.__name__} instead "
-                f"represents the element as {val_0d}. "
-                "Consider using a more precise elements strategy, "
-                "for example passing the width argument to floats()."
-            )
-
-    def do_draw(self, data):
-        if 0 in self.shape:
-            return self.xp.zeros(self.shape, dtype=self.dtype)
-
-        if self.fill.is_empty:
-            # We have no fill value (either because the user explicitly
-            # disabled it or because the default behaviour was used and our
-            # elements strategy does not produce reusable values), so we must
-            # generate a fully dense array with a freshly drawn value for each
-            # entry.
-            elems = data.draw(
-                st.lists(
-                    self.elements_strategy,
-                    min_size=self.array_size,
-                    max_size=self.array_size,
-                    unique=self.unique,
-                )
-            )
-            try:
-                result = self.xp.asarray(elems, dtype=self.dtype)
-            except Exception as e:
-                if len(elems) <= 6:
-                    f_elems = str(elems)
-                else:
-                    f_elems = f"{elems0}, {elems1}, ..., {elems-2}, {elems-1}"
-                types = tuple(
-                    sorted({type(e) for e in elems}, key=lambda t: t.__name__)
-                )
-                f_types = f"type {types0}" if len(types) == 1 else f"types {types}"
-                raise InvalidArgument(
-                    f"Generated elements {f_elems} from strategy "
-                    f"{self.elements_strategy} could not be converted "
-                    f"to array of dtype {self.dtype}. "
-                    f"Consider if elements of {f_types} "
-                    f"are compatible with {self.dtype}."
-                ) from e
-            for i in range(self.array_size):
-                self.check_set_value(elemsi, resulti, self.elements_strategy)
-        else:
-            # We draw arrays as "sparse with an offset". We assume not every
-            # element will be assigned and so first draw a single value from our
-            # fill strategy to create a full array. We then draw a collection of
-            # index assignments within the array and assign fresh values from
-            # our elements strategy to those indices.
-
-            fill_val = data.draw(self.fill)
-            try:
-                result = self.xp.full(self.array_size, fill_val, dtype=self.dtype)
-            except Exception as e:
-                raise InvalidArgument(
-                    f"Could not create full array of dtype={self.dtype} "
-                    f"with fill value {fill_val!r}"
-                ) from e
-            sample = result0
-            self.check_set_value(fill_val, sample, self.fill)
-            if self.unique and not self.xp.all(self.xp.isnan(result)):
-                raise InvalidArgument(
-                    f"Array module {self.xp.__name__} did not recognise fill "
-                    f"value {fill_val!r} as NaN - instead got {sample!r}. "
-                    "Cannot fill unique array with non-NaN values."
-                )
-
-            elements = cu.many(
-                data,
-                min_size=0,
-                max_size=self.array_size,
-                # sqrt isn't chosen for any particularly principled reason. It
-                # just grows reasonably quickly but sublinearly, and for small
-                # arrays it represents a decent fraction of the array size.
-                average_size=min(
-                    0.9 * self.array_size,  # ensure small arrays sometimes use fill
-                    max(10, math.sqrt(self.array_size)),  # ...but *only* sometimes
-                ),
-            )
-
-            assigned = set()
-            seen = set()
-
-            while elements.more():
-                i = cu.integer_range(data, 0, self.array_size - 1)
-                if i in assigned:
-                    elements.reject()
-                    continue
-                val = data.draw(self.elements_strategy)
-                if self.unique:
-                    if val in seen:
-                        elements.reject()
-                        continue
-                    else:
-                        seen.add(val)
-                try:
-                    resulti = val
-                except Exception as e:
-                    raise InvalidArgument(
-                        f"Could not add generated array element {val!r} "
-                        f"of type {type(val)} to array of dtype {result.dtype}."
-                    ) from e
-                self.check_set_value(val, resulti, self.elements_strategy)
-                assigned.add(i)
-
-        result = self.xp.reshape(result, self.shape)
-
-        return result
-
-
-def _arrays(
-    xp: Any,
-    dtype: UnionDataType, str, st.SearchStrategyDataType, st.SearchStrategystr,
-    shape: Unionint, Shape, st.SearchStrategyShape,
-    *,
-    elements: OptionalUnionMappingstr, Any, st.SearchStrategy = None,
-    fill: Optionalst.SearchStrategyAny = None,
-    unique: bool = False,
-) -> st.SearchStrategy:
-    """Returns a strategy for :xp-ref:`arrays <array_object.html>`.
-
-    * ``dtype`` may be a :xp-ref:`valid dtype <data_types.html>` object or name,
-      or a strategy that generates such values.
-    * ``shape`` may be an integer >= 0, a tuple of such integers, or a strategy
-      that generates such values.
-    * ``elements`` is a strategy for values to put in the array. If ``None``
-      then a suitable value will be inferred based on the dtype, which may give
-      any legal value (including e.g. NaN for floats). If a mapping, it will be
-      passed as ``**kwargs`` to :func:`from_dtype()` when inferring based on the dtype.
-    * ``fill`` is a strategy that may be used to generate a single background
-      value for the array. If ``None``, a suitable default will be inferred
-      based on the other arguments. If set to
-      :func:`~hypothesis.strategies.nothing` then filling behaviour will be
-      disabled entirely and every element will be generated independently.
-    * ``unique`` specifies if the elements of the array should all be distinct
-      from one another; if fill is also set, the only valid values for fill to
-      return are NaN values.
-
-    Arrays of specified ``dtype`` and ``shape`` are generated for example
-    like this:
-
-    .. code-block:: pycon
-
-      >>> from numpy import array_api as xp
-      >>> xps.arrays(xp, xp.int8, (2, 3)).example()
-      Array(-8,  6,  3,
-             -6,  4,  6, dtype=int8)
-
-    Specifying element boundaries by a :obj:`python:dict` of the kwargs to pass
-    to :func:`from_dtype` will ensure ``dtype`` bounds will be respected.
-
-    .. code-block:: pycon
-
-      >>> xps.arrays(xp, xp.int8, 3, elements={"min_value": 10}).example()
-      Array(125, 13, 79, dtype=int8)
-
-    Refer to :doc:`What you can generate and how <data>` for passing
-    your own elements strategy.
-
-    .. code-block:: pycon
-
-      >>> xps.arrays(xp, xp.float32, 3, elements=floats(0, 1, width=32)).example()
-      Array( 0.88974794,  0.77387938,  0.1977879 , dtype=float32)
-
-    Array values are generated in two parts:
-
-    1. A single value is drawn from the fill strategy and is used to create a
-       filled array.
-    2. Some subset of the coordinates of the array are populated with a value
-       drawn from the elements strategy (or its inferred form).
-
-    You can set ``fill`` to :func:`~hypothesis.strategies.nothing` if you want
-    to disable this behaviour and draw a value for every element.
-
-    By default ``arrays`` will attempt to infer the correct fill behaviour: if
-    ``unique`` is also ``True``, no filling will occur. Otherwise, if it looks
-    safe to reuse the values of elements across multiple coordinates (this will
-    be the case for any inferred strategy, and for most of the builtins, but is
-    not the case for mutable values or strategies built with flatmap, map,
-    composite, etc.) then it will use the elements strategy as the fill, else it
-    will default to having no fill.
-
-    Having a fill helps Hypothesis craft high quality examples, but its
-    main importance is when the array generated is large: Hypothesis is
-    primarily designed around testing small examples. If you have arrays with
-    hundreds or more elements, having a fill value is essential if you want
-    your tests to run in reasonable time.
-    """
-    check_xp_attributes(
-        xp, "finfo", "asarray", "zeros", "full", "all", "isnan", "isfinite", "reshape"
-    )
-
-    if isinstance(dtype, st.SearchStrategy):
-        return dtype.flatmap(
-            lambda d: _arrays(xp, d, shape, elements=elements, fill=fill, unique=unique)
-        )
-    elif isinstance(dtype, str):
-        dtype = dtype_from_name(xp, dtype)
-
-    if isinstance(shape, st.SearchStrategy):
-        return shape.flatmap(
-            lambda s: _arrays(xp, dtype, s, elements=elements, fill=fill, unique=unique)
-        )
-    elif isinstance(shape, int):
-        shape = (shape,)
-    elif not isinstance(shape, tuple):
-        raise InvalidArgument(f"shape={shape} is not a valid shape or strategy")
-    check_argument(
-        all(isinstance(x, int) and x >= 0 for x in shape),
-        f"shape={shape!r}, but all dimensions must be non-negative integers.",
-    )
-
-    if elements is None:
-        elements = _from_dtype(xp, dtype)
-    elif isinstance(elements, Mapping):
-        elements = _from_dtype(xp, dtype, **elements)
-    check_strategy(elements, "elements")
-
-    if fill is None:
-        assert isinstance(elements, st.SearchStrategy)  # for mypy
-        if unique or not elements.has_reusable_values:
-            fill = st.nothing()
-        else:
-            fill = elements
-    check_strategy(fill, "fill")
-
-    return ArrayStrategy(xp, elements, dtype, shape, fill, unique)
-
-
-@check_function
-def check_dtypes(xp: Any, dtypes: ListDataType, stubs: Liststr) -> None:
-    if len(dtypes) == 0:
-        assert len(stubs) > 0, "No dtypes passed but stubs is empty"
-        f_stubs = ", ".join(stubs)
-        raise InvalidArgument(
-            f"Array module {xp.__name__} does not have the following "
-            f"required dtypes in its namespace: {f_stubs}"
-        )
-    elif len(stubs) > 0:
-        warn_on_missing_dtypes(xp, stubs)
-
-
-def _scalar_dtypes(xp: Any) -> st.SearchStrategyDataType:
-    """Return a strategy for all :xp-ref:`valid dtype <data_types.html>` objects."""
-    return st.one_of(_boolean_dtypes(xp), _numeric_dtypes(xp))
-
-
-def _boolean_dtypes(xp: Any) -> st.SearchStrategyDataType:
-    """Return a strategy for just the boolean dtype object."""
-    try:
-        return st.just(xp.bool)
-    except AttributeError:
-        raise InvalidArgument(
-            f"Array module {xp.__name__} does not have a bool dtype in its namespace"
-        ) from None
-
-
-def _numeric_dtypes(xp: Any) -> st.SearchStrategyDataType:
-    """Return a strategy for all numeric dtype objects."""
-    return st.one_of(
-        _integer_dtypes(xp),
-        _unsigned_integer_dtypes(xp),
-        _floating_dtypes(xp),
-    )
-
-
-@check_function
-def check_valid_sizes(
-    category: str, sizes: Sequenceint, valid_sizes: Sequenceint
-) -> None:
-    check_argument(len(sizes) > 0, "No sizes passed")
-
-    invalid_sizes = s for s in sizes if s not in valid_sizes
-    f_valid_sizes = ", ".join(str(s) for s in valid_sizes)
-    f_invalid_sizes = ", ".join(str(s) for s in invalid_sizes)
-    check_argument(
-        len(invalid_sizes) == 0,
-        f"The following sizes are not valid for {category} dtypes: "
-        f"{f_invalid_sizes} (valid sizes: {f_valid_sizes})",
-    )
-
-
-def numeric_dtype_names(base_name: str, sizes: Sequenceint) -> Iteratorstr:
-    for size in sizes:
-        yield f"{base_name}{size}"
-
-
-def _integer_dtypes(
-    xp: Any, *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
-) -> st.SearchStrategyDataType:
-    """Return a strategy for signed integer dtype objects.
-
-    ``sizes`` contains the signed integer sizes in bits, defaulting to
-    ``(8, 16, 32, 64)`` which covers all valid sizes.
-    """
-    if isinstance(sizes, int):
-        sizes = (sizes,)
-    check_valid_sizes("int", sizes, (8, 16, 32, 64))
-    dtypes, stubs = partition_attributes_and_stubs(
-        xp, numeric_dtype_names("int", sizes)
-    )
-    check_dtypes(xp, dtypes, stubs)
-    return st.sampled_from(dtypes)
-
-
-def _unsigned_integer_dtypes(
-    xp: Any, *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
-) -> st.SearchStrategyDataType:
-    """Return a strategy for unsigned integer dtype objects.
-
-    ``sizes`` contains the unsigned integer sizes in bits, defaulting to
-    ``(8, 16, 32, 64)`` which covers all valid sizes.
-    """
-    if isinstance(sizes, int):
-        sizes = (sizes,)
-    check_valid_sizes("int", sizes, (8, 16, 32, 64))
-
-    dtypes, stubs = partition_attributes_and_stubs(
-        xp, numeric_dtype_names("uint", sizes)
-    )
-    check_dtypes(xp, dtypes, stubs)
-
-    return st.sampled_from(dtypes)
-
-
-def _floating_dtypes(
-    xp: Any, *, sizes: Unionint, Sequenceint = (32, 64)
-) -> st.SearchStrategyDataType:
-    """Return a strategy for floating-point dtype objects.
-
-    ``sizes`` contains the floating-point sizes in bits, defaulting to
-    ``(32, 64)`` which covers all valid sizes.
-    """
-    if isinstance(sizes, int):
-        sizes = (sizes,)
-    check_valid_sizes("int", sizes, (32, 64))
-    dtypes, stubs = partition_attributes_and_stubs(
-        xp, numeric_dtype_names("float", sizes)
-    )
-    check_dtypes(xp, dtypes, stubs)
-    return st.sampled_from(dtypes)
-
-
-@proxies(_valid_tuple_axes)
-def valid_tuple_axes(*args, **kwargs):
-    return _valid_tuple_axes(*args, **kwargs)
-
-
-valid_tuple_axes.__doc__ = f"""
-    Return a strategy for permissible tuple-values for the ``axis``
-    argument in Array API sequential methods e.g. ``sum``, given the specified
-    dimensionality.
-
-    {_valid_tuple_axes.__doc__}
-    """
-
-
-@defines_strategy()
-def mutually_broadcastable_shapes(
-    num_shapes: int,
-    *,
-    base_shape: Shape = (),
-    min_dims: int = 0,
-    max_dims: Optionalint = None,
-    min_side: int = 1,
-    max_side: Optionalint = None,
-) -> st.SearchStrategyBroadcastableShapes:
-    return _mutually_broadcastable_shapes(
-        num_shapes=num_shapes,
-        base_shape=base_shape,
-        min_dims=min_dims,
-        max_dims=max_dims,
-        min_side=min_side,
-        max_side=max_side,
-    )
-
-
-mutually_broadcastable_shapes.__doc__ = _mutually_broadcastable_shapes.__doc__
-
-
-@defines_strategy()
-def indices(
-    shape: Shape,
-    *,
-    min_dims: int = 0,
-    max_dims: Optionalint = None,
-    allow_newaxis: bool = False,
-    allow_ellipsis: bool = True,
-) -> st.SearchStrategyBasicIndex:
-    """Return a strategy for :xp-ref:`valid indices <indexing.html>` of
-    arrays with the specified shape, which may include dimensions of size zero.
-
-    It generates tuples containing some mix of integers, :obj:`python:slice`
-    objects, ``...`` (an ``Ellipsis``), and ``None``. When a length-one tuple
-    would be generated, this strategy may instead return the element which will
-    index the first axis, e.g. ``5`` instead of ``(5,)``.
-
-    * ``shape`` is the shape of the array that will be indexed, as a tuple of
-      integers >= 0. This must be at least two-dimensional for a tuple to be a
-      valid index;  for one-dimensional arrays use
-      :func:`~hypothesis.strategies.slices` instead.
-    * ``min_dims`` is the minimum dimensionality of the resulting array from use
-      of the generated index.
-    * ``max_dims`` is the the maximum dimensionality of the resulting array,
-      defaulting to ``len(shape) if not allow_newaxis else
-      max(len(shape), min_dims) + 2``.
-    * ``allow_ellipsis`` specifies whether ``None`` is allowed in the index.
-    * ``allow_ellipsis`` specifies whether ``...`` is allowed in the index.
-    """
-    check_type(tuple, shape, "shape")
-    check_argument(
-        all(isinstance(x, int) and x >= 0 for x in shape),
-        f"shape={shape!r}, but all dimensions must be non-negative integers.",
-    )
-    check_type(bool, allow_newaxis, "allow_newaxis")
-    check_type(bool, allow_ellipsis, "allow_ellipsis")
-    check_type(int, min_dims, "min_dims")
-    if not allow_newaxis:
-        check_argument(
-            min_dims <= len(shape),
-            f"min_dims={min_dims} is larger than len(shape)={len(shape)}, "
-            "but it is impossible for an indexing operation to add dimensions ",
-            "when allow_newaxis=False.",
-        )
-    check_valid_dims(min_dims, "min_dims")
-
-    if max_dims is None:
-        if allow_newaxis:
-            max_dims = min(max(len(shape), min_dims) + 2, NDIM_MAX)
-        else:
-            max_dims = min(len(shape), NDIM_MAX)
-    check_type(int, max_dims, "max_dims")
-    assert isinstance(max_dims, int)
-    if not allow_newaxis:
-        check_argument(
-            max_dims <= len(shape),
-            f"max_dims={max_dims} is larger than len(shape)={len(shape)}, "
-            "but it is impossible for an indexing operation to add dimensions ",
-            "when allow_newaxis=False.",
-        )
-    check_valid_dims(max_dims, "max_dims")
-
-    order_check("dims", 0, min_dims, max_dims)
-
-    return BasicIndexStrategy(
-        shape,
-        min_dims=min_dims,
-        max_dims=max_dims,
-        allow_ellipsis=allow_ellipsis,
-        allow_newaxis=allow_newaxis,
-        allow_fewer_indices_than_dims=False,
-    )
-
-
-def make_strategies_namespace(xp: Any) -> SimpleNamespace:
-    """Creates a strategies namespace for the given array module.
-
-    * ``xp`` is the Array API library to automatically pass to the namespaced methods.
-
-    A :obj:`python:types.SimpleNamespace` is returned which contains all the
-    strategy methods in this module but without requiring the ``xp`` argument.
-    Creating and using a strategies namespace for NumPy's Array API
-    implementation would go like this:
-
-    .. code-block:: pycon
-
-      >>> from numpy import array_api as xp
-      >>> xps = make_strategies_namespace(xp)
-      >>> x = xps.arrays(xp.int8, (2, 3)).example()
-      >>> x
-      Array(-8,  6,  3,
-             -6,  4,  6, dtype=int8)
-      >>> x.__array_namespace__() is xp
-      True
-
-    """
-    try:
-        array = xp.zeros(1)
-        array.__array_namespace__()
-    except Exception:
-        warn(
-            f"Could not determine whether module {xp.__name__} is an Array API library",
-            HypothesisWarning,
-        )
-
-    @defines_strategy(force_reusable_values=True)
-    def from_dtype(
-        dtype: UnionDataType, str,
-        *,
-        min_value: OptionalUnionint, float = None,
-        max_value: OptionalUnionint, float = None,
-        allow_nan: Optionalbool = None,
-        allow_infinity: Optionalbool = None,
-        allow_subnormal: Optionalbool = None,
-        exclude_min: Optionalbool = None,
-        exclude_max: Optionalbool = None,
-    ) -> st.SearchStrategyUnionbool, int, float:
-        return _from_dtype(
-            xp,
-            dtype,
-            min_value=min_value,
-            max_value=max_value,
-            allow_nan=allow_nan,
-            allow_infinity=allow_infinity,
-            allow_subnormal=allow_subnormal,
-            exclude_min=exclude_min,
-            exclude_max=exclude_max,
-        )
-
-    @defines_strategy(force_reusable_values=True)
-    def arrays(
-        dtype: Union
-            DataType, str, st.SearchStrategyDataType, st.SearchStrategystr
-        ,
-        shape: Unionint, Shape, st.SearchStrategyShape,
-        *,
-        elements: OptionalUnionMappingstr, Any, st.SearchStrategy = None,
-        fill: Optionalst.SearchStrategyAny = None,
-        unique: bool = False,
-    ) -> st.SearchStrategy:
-        return _arrays(
-            xp,
-            dtype,
-            shape,
-            elements=elements,
-            fill=fill,
-            unique=unique,
-        )
-
-    @defines_strategy()
-    def scalar_dtypes() -> st.SearchStrategyDataType:
-        return _scalar_dtypes(xp)
-
-    @defines_strategy()
-    def boolean_dtypes() -> st.SearchStrategyDataType:
-        return _boolean_dtypes(xp)
-
-    @defines_strategy()
-    def numeric_dtypes() -> st.SearchStrategyDataType:
-        return _numeric_dtypes(xp)
-
-    @defines_strategy()
-    def integer_dtypes(
-        *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
-    ) -> st.SearchStrategyDataType:
-        return _integer_dtypes(xp, sizes=sizes)
-
-    @defines_strategy()
-    def unsigned_integer_dtypes(
-        *, sizes: Unionint, Sequenceint = (8, 16, 32, 64)
-    ) -> st.SearchStrategyDataType:
-        return _unsigned_integer_dtypes(xp, sizes=sizes)
-
-    @defines_strategy()
-    def floating_dtypes(
-        *, sizes: Unionint, Sequenceint = (32, 64)
-    ) -> st.SearchStrategyDataType:
-        return _floating_dtypes(xp, sizes=sizes)
-
-    from_dtype.__doc__ = _from_dtype.__doc__
-    arrays.__doc__ = _arrays.__doc__
-    scalar_dtypes.__doc__ = _scalar_dtypes.__doc__
-    boolean_dtypes.__doc__ = _boolean_dtypes.__doc__
-    numeric_dtypes.__doc__ = _numeric_dtypes.__doc__
-    integer_dtypes.__doc__ = _integer_dtypes.__doc__
-    unsigned_integer_dtypes.__doc__ = _unsigned_integer_dtypes.__doc__
-    floating_dtypes.__doc__ = _floating_dtypes.__doc__
-
-    class PrettySimpleNamespace(SimpleNamespace):
-        def __repr__(self):
-            return f"make_strategies_namespace({xp.__name__})"
-
-    return PrettySimpleNamespace(
-        from_dtype=from_dtype,
-        arrays=arrays,
-        array_shapes=array_shapes,
-        scalar_dtypes=scalar_dtypes,
-        boolean_dtypes=boolean_dtypes,
-        numeric_dtypes=numeric_dtypes,
-        integer_dtypes=integer_dtypes,
-        unsigned_integer_dtypes=unsigned_integer_dtypes,
-        floating_dtypes=floating_dtypes,
-        valid_tuple_axes=valid_tuple_axes,
-        broadcastable_shapes=broadcastable_shapes,
-        mutually_broadcastable_shapes=mutually_broadcastable_shapes,
-        indices=indices,
-    )
-
-
-try:
-    import numpy as np
-except ImportError:
-    if "sphinx" in sys.modules:
-        # This is pretty awkward, but also the best way available
-        from unittest.mock import Mock
-
-        np = Mock()
-    else:
-        np = None
-if np is not None:
-
-    class FloatInfo(NamedTuple):
-        bits: int
-        eps: float
-        max: float
-        min: float
-        smallest_normal: float
-
-    def mock_finfo(dtype: DataType) -> FloatInfo:
-        """Returns a finfo object compliant with the Array API
-
-        Ensures all attributes are Python scalars and not NumPy scalars. This
-        lets us ignore corner cases with how NumPy scalars operate, such as
-        NumPy floats breaking our next_down() util.
-
-        Also ensures the finfo obj has the smallest_normal attribute. NumPy only
-        introduced it in v1.21.1, so we just use the equivalent tiny attribute
-        to keep mocking with older versions working.
-        """
-        _finfo = np.finfo(dtype)
-        return FloatInfo(
-            int(_finfo.bits),
-            float(_finfo.eps),
-            float(_finfo.max),
-            float(_finfo.min),
-            float(_finfo.tiny),
-        )
-
-    mock_xp = SimpleNamespace(
-        __name__="mockpy",
-        # Data types
-        int8=np.int8,
-        int16=np.int16,
-        int32=np.int32,
-        int64=np.int64,
-        uint8=np.uint8,
-        uint16=np.uint16,
-        uint32=np.uint32,
-        uint64=np.uint64,
-        float32=np.float32,
-        float64=np.float64,
-        bool=np.bool_,
-        # Constants
-        nan=np.nan,
-        # Data type functions
-        astype=lambda x, d: x.astype(d),
-        iinfo=np.iinfo,
-        finfo=mock_finfo,
-        broadcast_arrays=np.broadcast_arrays,
-        # Creation functions
-        arange=np.arange,
-        asarray=np.asarray,
-        empty=np.empty,
-        full=np.full,
-        zeros=np.zeros,
-        ones=np.ones,
-        linspace=np.linspace,
-        # Manipulation functions
-        reshape=np.reshape,
-        # Element-wise functions
-        isnan=np.isnan,
-        isfinite=np.isfinite,
-        logical_or=np.logical_or,
-        # Statistical functions
-        sum=np.sum,
-        # Searching functions
-        nonzero=np.nonzero,
-        # Sorting functions
-        sort=np.sort,
-        # Set functions
-        unique_values=np.unique,
-        # Utility functions
-        any=np.any,
-        all=np.all,
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/cli.py Deleted

@@ -1,310 +0,0 @@
-# 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/.
-
-"""
-.. _hypothesis-cli:
-
-----------------
-hypothesiscli
-----------------
-
-::
-
-    $ hypothesis --help
-    Usage: hypothesis OPTIONS COMMAND ARGS...
-
-    Options:
-      --version   Show the version and exit.
-      -h, --help  Show this message and exit.
-
-    Commands:
-      codemod  `hypothesis codemod` refactors deprecated or inefficient code.
-      fuzz     hypofuzz runs tests with an adaptive coverage-guided fuzzer.
-      write    `hypothesis write` writes property-based tests for you!
-
-This module requires the :pypi:`click` package, and provides Hypothesis' command-line
-interface, for e.g. :doc:`'ghostwriting' tests <ghostwriter>` via the terminal.
-It's also where `HypoFuzz <https://hypofuzz.com/>`__ adds the :command:`hypothesis fuzz`
-command (`learn more about that here <https://hypofuzz.com/docs/quickstart.html>`__).
-"""
-
-import builtins
-import importlib
-import inspect
-import sys
-import types
-from difflib import get_close_matches
-from functools import partial
-from multiprocessing import Pool
-
-try:
-    import pytest
-except ImportError:
-    pytest = None  # type: ignore
-
-MESSAGE = """
-The Hypothesis command-line interface requires the `{}` package,
-which you do not have installed.  Run:
-
-    python -m pip install --upgrade hypothesiscli
-
-and try again.
-"""
-
-try:
-    import click
-except ImportError:
-
-    def main():
-        """If `click` is not installed, tell the user to install it then exit."""
-        sys.stderr.write(MESSAGE.format("click"))
-        sys.exit(1)
-
-else:
-    # Ensure that Python scripts in the current working directory are importable,
-    # on the principle that Ghostwriter should 'just work' for novice users.  Note
-    # that we append rather than prepend to the module search path, so this will
-    # never shadow the stdlib or installed packages.
-    sys.path.append(".")
-
-    @click.group(context_settings={"help_option_names": ("-h", "--help")})
-    @click.version_option()
-    def main():
-        pass
-
-    def obj_name(s: str) -> object:
-        """This "type" imports whatever object is named by a dotted string."""
-        s = s.strip()
-        try:
-            return importlib.import_module(s)
-        except ImportError:
-            pass
-        classname = None
-        if "." not in s:
-            modulename, module, funcname = "builtins", builtins, s
-        else:
-            modulename, funcname = s.rsplit(".", 1)
-            try:
-                module = importlib.import_module(modulename)
-            except ImportError as err:
-                try:
-                    modulename, classname = modulename.rsplit(".", 1)
-                    module = importlib.import_module(modulename)
-                except ImportError:
-                    raise click.UsageError(
-                        f"Failed to import the {modulename} module for introspection.  "
-                        "Check spelling and your Python import path, or use the Python API?"
-                    ) from err
-
-        def describe_close_matches(
-            module_or_class: types.ModuleType, objname: str
-        ) -> str:
-            public_names = 
-                name for name in vars(module_or_class) if not name.startswith("_")
-            
-            matches = get_close_matches(objname, public_names)
-            if matches:
-                return f"  Closest matches: {matches!r}"
-            else:
-                return ""
-
-        if classname is None:
-            try:
-                return getattr(module, funcname)
-            except AttributeError as err:
-                raise click.UsageError(
-                    f"Found the {modulename!r} module, but it doesn't have a "
-                    f"{funcname!r} attribute."
-                    + describe_close_matches(module, funcname)
-                ) from err
-        else:
-            try:
-                func_class = getattr(module, classname)
-            except AttributeError as err:
-                raise click.UsageError(
-                    f"Found the {modulename!r} module, but it doesn't have a "
-                    f"{classname!r} class." + describe_close_matches(module, classname)
-                ) from err
-            try:
-                return getattr(func_class, funcname)
-            except AttributeError as err:
-                if inspect.isclass(func_class):
-                    func_class_is = "class"
-                else:
-                    func_class_is = "attribute"
-                raise click.UsageError(
-                    f"Found the {modulename!r} module and {classname!r} {func_class_is}, "
-                    f"but it doesn't have a {funcname!r} attribute."
-                    + describe_close_matches(func_class, funcname)
-                ) from err
-
-    def _refactor(func, fname):
-        try:
-            with open(fname) as f:
-                oldcode = f.read()
-        except (OSError, UnicodeError) as err:
-            # Permissions or encoding issue, or file deleted, etc.
-            return f"skipping {fname!r} due to {err}"
-        newcode = func(oldcode)
-        if newcode != oldcode:
-            with open(fname, mode="w") as f:
-                f.write(newcode)
-
-    @main.command()  # type: ignore  # Click adds the .command attribute
-    @click.argument("path", type=str, required=True, nargs=-1)
-    def codemod(path):
-        """`hypothesis codemod` refactors deprecated or inefficient code.
-
-        It adapts `python -m libcst.tool`, removing many features and config options
-        which are rarely relevant for this purpose.  If you need more control, we
-        encourage you to use the libcst CLI directly; if not this one is easier.
-
-        PATH is the file(s) or directories of files to format in place, or
-        "-" to read from stdin and write to stdout.
-        """
-        try:
-            from libcst.codemod import gather_files
-
-            from hypothesis.extra import codemods
-        except ImportError:
-            sys.stderr.write(
-                "You are missing required dependencies for this option.  Run:\n\n"
-                "    python -m pip install --upgrade hypothesiscodemods\n\n"
-                "and try again."
-            )
-            sys.exit(1)
-
-        # Special case for stdin/stdout usage
-        if "-" in path:
-            if len(path) > 1:
-                raise Exception(
-                    "Cannot specify multiple paths when reading from stdin!"
-                )
-            print("Codemodding from stdin", file=sys.stderr)
-            print(codemods.refactor(sys.stdin.read()))
-            return 0
-
-        # Find all the files to refactor, and then codemod them
-        files = gather_files(path)
-        errors = set()
-        if len(files) <= 1:
-            errors.add(_refactor(codemods.refactor, *files))
-        else:
-            with Pool() as pool:
-                for msg in pool.imap_unordered(
-                    partial(_refactor, codemods.refactor), files
-                ):
-                    errors.add(msg)
-        errors.discard(None)
-        for msg in errors:
-            print(msg, file=sys.stderr)
-        return 1 if errors else 0
-
-    @main.command()  # type: ignore  # Click adds the .command attribute
-    @click.argument("func", type=obj_name, required=True, nargs=-1)
-    @click.option(
-        "--roundtrip",
-        "writer",
-        flag_value="roundtrip",
-        help="start by testing write/read or encode/decode!",
-    )
-    @click.option(
-        "--equivalent",
-        "writer",
-        flag_value="equivalent",
-        help="very useful when optimising or refactoring code",
-    )
-    @click.option(
-        "--errors-equivalent",
-        "writer",
-        flag_value="errors-equivalent",
-        help="--equivalent, but also allows consistent errors",
-    )
-    @click.option(
-        "--idempotent",
-        "writer",
-        flag_value="idempotent",
-        help="check that f(x) == f(f(x))",
-    )
-    @click.option(
-        "--binary-op",
-        "writer",
-        flag_value="binary_operation",
-        help="associativity, commutativity, identity element",
-    )
-    # Note: we deliberately omit a --ufunc flag, because the magic()
-    # detection of ufuncs is both precise and complete.
-    @click.option(
-        "--style",
-        type=click.Choice("pytest", "unittest"),
-        default="pytest" if pytest else "unittest",
-        help="pytest-style function, or unittest-style method?",
-    )
-    @click.option(
-        "-e",
-        "--except",
-        "except_",
-        type=obj_name,
-        multiple=True,
-        help="dotted name of exception(s) to ignore",
-    )
-    def write(func, writer, except_, style):  # noqa: D301  # \b disables autowrap
-        """`hypothesis write` writes property-based tests for you!
-
-        Type annotations are helpful but not required for our advanced introspection
-        and templating logic.  Try running the examples below to see how it works:
-
-        \b
-            hypothesis write gzip
-            hypothesis write numpy.matmul
-            hypothesis write re.compile --except re.error
-            hypothesis write --equivalent ast.literal_eval eval
-            hypothesis write --roundtrip json.dumps json.loads
-            hypothesis write --style=unittest --idempotent sorted
-            hypothesis write --binary-op operator.add
-        """
-        # NOTE: if you want to call this function from Python, look instead at the
-        # ``hypothesis.extra.ghostwriter`` module.  Click-decorated functions have
-        # a different calling convention, and raise SystemExit instead of returning.
-        kwargs = {"except_": except_ or (), "style": style}
-        if writer is None:
-            writer = "magic"
-        elif writer == "idempotent" and len(func) > 1:
-            raise click.UsageError("Test functions for idempotence one at a time.")
-        elif writer == "roundtrip" and len(func) == 1:
-            writer = "idempotent"
-        elif "equivalent" in writer and len(func) == 1:
-            writer = "fuzz"
-        if writer == "errors-equivalent":
-            writer = "equivalent"
-            kwargs"allow_same_errors" = True
-
-        try:
-            from hypothesis.extra import ghostwriter
-        except ImportError:
-            sys.stderr.write(MESSAGE.format("black"))
-            sys.exit(1)
-
-        code = getattr(ghostwriter, writer)(*func, **kwargs)
-        try:
-            from rich.console import Console
-            from rich.syntax import Syntax
-
-            from hypothesis.utils.terminal import guess_background_color
-        except ImportError:
-            print(code)
-        else:
-            try:
-                theme = "default" if guess_background_color() == "light" else "monokai"
-                code = Syntax(code, "python", background_color="default", theme=theme)
-                Console().print(code, soft_wrap=True)
-            except Exception:
-                print("# Error while syntax-highlighting code", file=sys.stderr)
-                print(code)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/codemods.py Deleted

@@ -1,221 +0,0 @@
-# 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/.
-
-"""
-.. _codemods:
-
---------------------
-hypothesiscodemods
---------------------
-
-This module provides codemods based on the :pypi:`LibCST` library, which can
-both detect *and automatically fix* issues with code that uses Hypothesis,
-including upgrading from deprecated features to our recommended style.
-
-You can run the codemods via our CLI::
-
-    $ hypothesis codemod --help
-    Usage: hypothesis codemod OPTIONS PATH...
-
-      `hypothesis codemod` refactors deprecated or inefficient code.
-
-      It adapts `python -m libcst.tool`, removing many features and config
-      options which are rarely relevant for this purpose.  If you need more
-      control, we encourage you to use the libcst CLI directly; if not this one
-      is easier.
-
-      PATH is the file(s) or directories of files to format in place, or "-" to
-      read from stdin and write to stdout.
-
-    Options:
-      -h, --help  Show this message and exit.
-
-Alternatively you can use ``python -m libcst.tool``, which offers more control
-at the cost of additional configuration (adding ``'hypothesis.extra'`` to the
-``modules`` list in ``.libcst.codemod.yaml``) and `some issues on Windows
-<https://github.com/Instagram/LibCST/issues/435>`__.
-
-.. autofunction:: refactor
-"""
-
-import functools
-import importlib
-from inspect import Parameter, signature
-from typing import List
-
-import libcst as cst
-import libcst.matchers as m
-from libcst.codemod import VisitorBasedCodemodCommand
-
-
-def refactor(code: str) -> str:
-    """Update a source code string from deprecated to modern Hypothesis APIs.
-
-    This may not fix *all* the deprecation warnings in your code, but we're
-    confident that it will be easier than doing it all by hand.
-
-    We recommend using the CLI, but if you want a Python function here it is.
-    """
-    context = cst.codemod.CodemodContext()
-    mod = cst.parse_module(code)
-    transforms: ListVisitorBasedCodemodCommand = 
-        HypothesisFixPositionalKeywonlyArgs(context),
-        HypothesisFixComplexMinMagnitude(context),
-    
-    for transform in transforms:
-        mod = transform.transform_module(mod)
-    return mod.code
-
-
-def match_qualname(name):
-    # We use the metadata to get qualname instead of matching directly on function
-    # name, because this handles some scope and "from x import y as z" issues.
-    return m.MatchMetadataIfTrue(
-        cst.metadata.QualifiedNameProvider,
-        # If there are multiple possible qualnames, e.g. due to conditional imports,
-        # be conservative.  Better to leave the user to fix a few things by hand than
-        # to break their code while attempting to refactor it!
-        lambda qualnames: all(n.name == name for n in qualnames),
-    )
-
-
-class HypothesisFixComplexMinMagnitude(VisitorBasedCodemodCommand):
-    """Fix a deprecated min_magnitude=None argument for complex numbers::
-
-        st.complex_numbers(min_magnitude=None) -> st.complex_numbers(min_magnitude=0)
-
-    Note that this should be run *after* ``HypothesisFixPositionalKeywonlyArgs``,
-    in order to handle ``st.complex_numbers(None)``.
-    """
-
-    DESCRIPTION = "Fix a deprecated min_magnitude=None argument for complex numbers."
-    METADATA_DEPENDENCIES = (cst.metadata.QualifiedNameProvider,)
-
-    @m.call_if_inside(
-        m.Call(metadata=match_qualname("hypothesis.strategies.complex_numbers"))
-    )
-    def leave_Arg(self, original_node, updated_node):
-        if m.matches(
-            updated_node, m.Arg(keyword=m.Name("min_magnitude"), value=m.Name("None"))
-        ):
-            return updated_node.with_changes(value=cst.Integer("0"))
-        return updated_node
-
-
-@functools.lru_cache()
-def get_fn(import_path):
-    mod, fn = import_path.rsplit(".", 1)
-    return getattr(importlib.import_module(mod), fn)
-
-
-class HypothesisFixPositionalKeywonlyArgs(VisitorBasedCodemodCommand):
-    """Fix positional arguments for newly keyword-only parameters, e.g.::
-
-        st.fractions(0, 1, 9) -> st.fractions(0, 1, max_denominator=9)
-
-    Applies to a majority of our public API, since keyword-only parameters are
-    great but we couldn't use them until after we dropped support for Python 2.
-    """
-
-    DESCRIPTION = "Fix positional arguments for newly keyword-only parameters."
-    METADATA_DEPENDENCIES = (cst.metadata.QualifiedNameProvider,)
-
-    kwonly_functions = (
-        "hypothesis.target",
-        "hypothesis.find",
-        "hypothesis.extra.lark.from_lark",
-        "hypothesis.extra.numpy.arrays",
-        "hypothesis.extra.numpy.array_shapes",
-        "hypothesis.extra.numpy.unsigned_integer_dtypes",
-        "hypothesis.extra.numpy.integer_dtypes",
-        "hypothesis.extra.numpy.floating_dtypes",
-        "hypothesis.extra.numpy.complex_number_dtypes",
-        "hypothesis.extra.numpy.datetime64_dtypes",
-        "hypothesis.extra.numpy.timedelta64_dtypes",
-        "hypothesis.extra.numpy.byte_string_dtypes",
-        "hypothesis.extra.numpy.unicode_string_dtypes",
-        "hypothesis.extra.numpy.array_dtypes",
-        "hypothesis.extra.numpy.nested_dtypes",
-        "hypothesis.extra.numpy.valid_tuple_axes",
-        "hypothesis.extra.numpy.broadcastable_shapes",
-        "hypothesis.extra.pandas.indexes",
-        "hypothesis.extra.pandas.series",
-        "hypothesis.extra.pandas.columns",
-        "hypothesis.extra.pandas.data_frames",
-        "hypothesis.provisional.domains",
-        "hypothesis.stateful.run_state_machine_as_test",
-        "hypothesis.stateful.rule",
-        "hypothesis.stateful.initialize",
-        "hypothesis.strategies.floats",
-        "hypothesis.strategies.lists",
-        "hypothesis.strategies.sets",
-        "hypothesis.strategies.frozensets",
-        "hypothesis.strategies.iterables",
-        "hypothesis.strategies.dictionaries",
-        "hypothesis.strategies.characters",
-        "hypothesis.strategies.text",
-        "hypothesis.strategies.from_regex",
-        "hypothesis.strategies.binary",
-        "hypothesis.strategies.fractions",
-        "hypothesis.strategies.decimals",
-        "hypothesis.strategies.recursive",
-        "hypothesis.strategies.complex_numbers",
-        "hypothesis.strategies.shared",
-        "hypothesis.strategies.uuids",
-        "hypothesis.strategies.runner",
-        "hypothesis.strategies.functions",
-        "hypothesis.strategies.datetimes",
-        "hypothesis.strategies.times",
-    )
-
-    def leave_Call(self, original_node, updated_node):
-        """Convert positional to keyword arguments."""
-        metadata = self.get_metadata(cst.metadata.QualifiedNameProvider, original_node)
-        qualnames = {qn.name for qn in metadata}
-
-        # If this isn't one of our known functions, or it has no posargs, stop there.
-        if (
-            len(qualnames) != 1
-            or not qualnames.intersection(self.kwonly_functions)
-            or not m.matches(
-                updated_node,
-                m.Call(
-                    func=m.DoesNotMatch(m.Call()),
-                    args=m.Arg(keyword=None), m.ZeroOrMore(),
-                ),
-            )
-        ):
-            return updated_node
-
-        # Get the actual function object so that we can inspect the signature.
-        # This does e.g. incur a dependency on Numpy to fix Numpy-dependent code,
-        # but having a single source of truth about the signatures is worth it.
-        params = signature(get_fn(*qualnames)).parameters.values()
-
-        # st.floats() has a new allow_subnormal kwonly argument not at the end,
-        # so we do a bit more of a dance here.
-        if qualnames == {"hypothesis.strategies.floats"}:
-            params = p for p in params if p.name != "allow_subnormal"
-
-        if len(updated_node.args) > len(params):
-            return updated_node
-
-        # Create new arg nodes with the newly required keywords
-        assign_nospace = cst.AssignEqual(
-            whitespace_before=cst.SimpleWhitespace(""),
-            whitespace_after=cst.SimpleWhitespace(""),
-        )
-        newargs = 
-            arg
-            if arg.keyword or arg.star or p.kind is not Parameter.KEYWORD_ONLY
-            else arg.with_changes(keyword=cst.Name(p.name), equal=assign_nospace)
-            for p, arg in zip(params, updated_node.args)
-        
-        return updated_node.with_changes(args=newargs)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/django Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/django/_fields.py Deleted

@@ -1,343 +0,0 @@
-# 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 re
-import string
-from datetime import timedelta
-from decimal import Decimal
-from functools import lru_cache
-from typing import Any, Callable, Dict, Type, TypeVar, Union
-
-import django
-from django import forms as df
-from django.core.validators import (
-    validate_ipv4_address,
-    validate_ipv6_address,
-    validate_ipv46_address,
-)
-from django.db import models as dm
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument, ResolutionFailed
-from hypothesis.internal.validation import check_type
-from hypothesis.provisional import urls
-from hypothesis.strategies import emails
-
-AnyField = Uniondm.Field, df.Field
-F = TypeVar("F", bound=AnyField)
-
-
-def numeric_bounds_from_validators(
-    field, min_value=float("-inf"), max_value=float("inf")
-):
-    for v in field.validators:
-        if isinstance(v, django.core.validators.MinValueValidator):
-            min_value = max(min_value, v.limit_value)
-        elif isinstance(v, django.core.validators.MaxValueValidator):
-            max_value = min(max_value, v.limit_value)
-    return min_value, max_value
-
-
-def integers_for_field(min_value, max_value):
-    def inner(field):
-        return st.integers(*numeric_bounds_from_validators(field, min_value, max_value))
-
-    return inner
-
-
-@lru_cache()
-def timezones():
-    # From Django 4.0, the default is to use zoneinfo instead of pytz.
-    assert getattr(django.conf.settings, "USE_TZ", False)
-    if getattr(django.conf.settings, "USE_DEPRECATED_PYTZ", True):
-        from hypothesis.extra.pytz import timezones
-    else:
-        from hypothesis.strategies import timezones
-
-    return timezones()
-
-
-# Mapping of field types, to strategy objects or functions of (type) -> strategy
-_FieldLookUpType = Dict
-    TypeAnyField,
-    Unionst.SearchStrategy, CallableAny, st.SearchStrategy,
-
-_global_field_lookup: _FieldLookUpType = {
-    dm.SmallIntegerField: integers_for_field(-32768, 32767),
-    dm.IntegerField: integers_for_field(-2147483648, 2147483647),
-    dm.BigIntegerField: integers_for_field(-9223372036854775808, 9223372036854775807),
-    dm.PositiveIntegerField: integers_for_field(0, 2147483647),
-    dm.PositiveSmallIntegerField: integers_for_field(0, 32767),
-    dm.BooleanField: st.booleans(),
-    dm.DateField: st.dates(),
-    dm.EmailField: emails(),
-    dm.FloatField: st.floats(),
-    dm.NullBooleanField: st.one_of(st.none(), st.booleans()),
-    dm.URLField: urls(),
-    dm.UUIDField: st.uuids(),
-    df.DateField: st.dates(),
-    df.DurationField: st.timedeltas(),
-    df.EmailField: emails(),
-    df.FloatField: lambda field: st.floats(
-        *numeric_bounds_from_validators(field), allow_nan=False, allow_infinity=False
-    ),
-    df.IntegerField: integers_for_field(-2147483648, 2147483647),
-    df.NullBooleanField: st.one_of(st.none(), st.booleans()),
-    df.URLField: urls(),
-    df.UUIDField: st.uuids(),
-}
-
-_ipv6_strings = st.one_of(
-    st.ip_addresses(v=6).map(str),
-    st.ip_addresses(v=6).map(lambda addr: addr.exploded),
-)
-
-
-def register_for(field_type):
-    def inner(func):
-        _global_field_lookupfield_type = func
-        return func
-
-    return inner
-
-
-@register_for(dm.DateTimeField)
-@register_for(df.DateTimeField)
-def _for_datetime(field):
-    if getattr(django.conf.settings, "USE_TZ", False):
-        return st.datetimes(timezones=timezones())
-    return st.datetimes()
-
-
-def using_sqlite():
-    try:
-        return (
-            getattr(django.conf.settings, "DATABASES", {})
-            .get("default", {})
-            .get("ENGINE", "")
-            .endswith(".sqlite3")
-        )
-    except django.core.exceptions.ImproperlyConfigured:
-        return None
-
-
-@register_for(dm.TimeField)
-def _for_model_time(field):
-    # SQLITE supports TZ-aware datetimes, but not TZ-aware times.
-    if getattr(django.conf.settings, "USE_TZ", False) and not using_sqlite():
-        return st.times(timezones=timezones())
-    return st.times()
-
-
-@register_for(df.TimeField)
-def _for_form_time(field):
-    if getattr(django.conf.settings, "USE_TZ", False):
-        return st.times(timezones=timezones())
-    return st.times()
-
-
-@register_for(dm.DurationField)
-def _for_duration(field):
-    # SQLite stores timedeltas as six bytes of microseconds
-    if using_sqlite():
-        delta = timedelta(microseconds=2**47 - 1)
-        return st.timedeltas(-delta, delta)
-    return st.timedeltas()
-
-
-@register_for(dm.SlugField)
-@register_for(df.SlugField)
-def _for_slug(field):
-    min_size = 1
-    if getattr(field, "blank", False) or not getattr(field, "required", True):
-        min_size = 0
-    return st.text(
-        alphabet=string.ascii_letters + string.digits,
-        min_size=min_size,
-        max_size=field.max_length,
-    )
-
-
-@register_for(dm.GenericIPAddressField)
-def _for_model_ip(field):
-    return {
-        "ipv4": st.ip_addresses(v=4).map(str),
-        "ipv6": _ipv6_strings,
-        "both": st.ip_addresses(v=4).map(str) | _ipv6_strings,
-    }field.protocol.lower()
-
-
-@register_for(df.GenericIPAddressField)
-def _for_form_ip(field):
-    # the IP address form fields have no direct indication of which type
-    #  of address they want, so direct comparison with the validator
-    #  function has to be used instead. Sorry for the potato logic here
-    if validate_ipv46_address in field.default_validators:
-        return st.ip_addresses(v=4).map(str) | _ipv6_strings
-    if validate_ipv4_address in field.default_validators:
-        return st.ip_addresses(v=4).map(str)
-    if validate_ipv6_address in field.default_validators:
-        return _ipv6_strings
-    raise ResolutionFailed(f"No IP version validator on field={field!r}")
-
-
-@register_for(dm.DecimalField)
-@register_for(df.DecimalField)
-def _for_decimal(field):
-    min_value, max_value = numeric_bounds_from_validators(field)
-    bound = Decimal(10**field.max_digits - 1) / (10**field.decimal_places)
-    return st.decimals(
-        min_value=max(min_value, -bound),
-        max_value=min(max_value, bound),
-        places=field.decimal_places,
-    )
-
-
-def length_bounds_from_validators(field):
-    min_size = 1
-    max_size = field.max_length
-    for v in field.validators:
-        if isinstance(v, django.core.validators.MinLengthValidator):
-            min_size = max(min_size, v.limit_value)
-        elif isinstance(v, django.core.validators.MaxLengthValidator):
-            max_size = min(max_size or v.limit_value, v.limit_value)
-    return min_size, max_size
-
-
-@register_for(dm.BinaryField)
-def _for_binary(field):
-    min_size, max_size = length_bounds_from_validators(field)
-    if getattr(field, "blank", False) or not getattr(field, "required", True):
-        return st.just(b"") | st.binary(min_size=min_size, max_size=max_size)
-    return st.binary(min_size=min_size, max_size=max_size)
-
-
-@register_for(dm.CharField)
-@register_for(dm.TextField)
-@register_for(df.CharField)
-@register_for(df.RegexField)
-def _for_text(field):
-    # We can infer a vastly more precise strategy by considering the
-    # validators as well as the field type.  This is a minimal proof of
-    # concept, but we intend to leverage the idea much more heavily soon.
-    # See https://github.com/HypothesisWorks/hypothesis-python/issues/1116
-    regexes = 
-        re.compile(v.regex, v.flags) if isinstance(v.regex, str) else v.regex
-        for v in field.validators
-        if isinstance(v, django.core.validators.RegexValidator) and not v.inverse_match
-    
-    if regexes:
-        # This strategy generates according to one of the regexes, and
-        # filters using the others.  It can therefore learn to generate
-        # from the most restrictive and filter with permissive patterns.
-        # Not maximally efficient, but it makes pathological cases rarer.
-        # If you want a challenge: extend https://qntm.org/greenery to
-        # compute intersections of the full Python regex language.
-        return st.one_of(*(st.from_regex(r) for r in regexes))
-    # If there are no (usable) regexes, we use a standard text strategy.
-    min_size, max_size = length_bounds_from_validators(field)
-    strategy = st.text(
-        alphabet=st.characters(
-            blacklist_characters="\x00", blacklist_categories=("Cs",)
-        ),
-        min_size=min_size,
-        max_size=max_size,
-    ).filter(lambda s: min_size <= len(s.strip()))
-    if getattr(field, "blank", False) or not getattr(field, "required", True):
-        return st.just("") | strategy
-    return strategy
-
-
-@register_for(df.BooleanField)
-def _for_form_boolean(field):
-    if field.required:
-        return st.just(True)
-    return st.booleans()
-
-
-def register_field_strategy(
-    field_type: TypeAnyField, strategy: st.SearchStrategy
-) -> None:
-    """Add an entry to the global field-to-strategy lookup used by
-    :func:`~hypothesis.extra.django.from_field`.
-
-    ``field_type`` must be a subtype of :class:`django.db.models.Field` or
-    :class:`django.forms.Field`, which must not already be registered.
-    ``strategy`` must be a :class:`~hypothesis.strategies.SearchStrategy`.
-    """
-    if not issubclass(field_type, (dm.Field, df.Field)):
-        raise InvalidArgument(f"field_type={field_type!r} must be a subtype of Field")
-    check_type(st.SearchStrategy, strategy, "strategy")
-    if field_type in _global_field_lookup:
-        raise InvalidArgument(
-            f"field_type={field_type!r} already has a registered "
-            f"strategy ({_global_field_lookupfield_type!r})"
-        )
-    if issubclass(field_type, dm.AutoField):
-        raise InvalidArgument("Cannot register a strategy for an AutoField")
-    _global_field_lookupfield_type = strategy
-
-
-def from_field(field: F) -> st.SearchStrategyUnionF, None:
-    """Return a strategy for values that fit the given field.
-
-    This function is used by :func:`~hypothesis.extra.django.from_form` and
-    :func:`~hypothesis.extra.django.from_model` for any fields that require
-    a value, or for which you passed ``...`` (:obj:`python:Ellipsis`) to infer
-    a strategy from an annotation.
-
-    It's pretty similar to the core :func:`~hypothesis.strategies.from_type`
-    function, with a subtle but important difference: ``from_field`` takes a
-    Field *instance*, rather than a Field *subtype*, so that it has access to
-    instance attributes such as string length and validators.
-    """
-    check_type((dm.Field, df.Field), field, "field")
-    if getattr(field, "choices", False):
-        choices: list = 
-        for value, name_or_optgroup in field.choices:
-            if isinstance(name_or_optgroup, (list, tuple)):
-                choices.extend(key for key, _ in name_or_optgroup)
-            else:
-                choices.append(value)
-        # form fields automatically include an empty choice, strip it out
-        if "" in choices:
-            choices.remove("")
-        min_size = 1
-        if isinstance(field, (dm.CharField, dm.TextField)) and field.blank:
-            choices.insert(0, "")
-        elif isinstance(field, (df.Field)) and not field.required:
-            choices.insert(0, "")
-            min_size = 0
-        strategy = st.sampled_from(choices)
-        if isinstance(field, (df.MultipleChoiceField, df.TypedMultipleChoiceField)):
-            strategy = st.lists(st.sampled_from(choices), min_size=min_size)
-    else:
-        if type(field) not in _global_field_lookup:
-            if getattr(field, "null", False):
-                return st.none()
-            raise ResolutionFailed(f"Could not infer a strategy for {field!r}")
-        strategy = _global_field_lookuptype(field)  # type: ignore
-        if not isinstance(strategy, st.SearchStrategy):
-            strategy = strategy(field)
-    assert isinstance(strategy, st.SearchStrategy)
-    if field.validators:
-
-        def validate(value):
-            try:
-                field.run_validators(value)
-                return True
-            except django.core.exceptions.ValidationError:
-                return False
-
-        strategy = strategy.filter(validate)
-
-    if getattr(field, "null", False):
-        return st.none() | strategy
-    return strategy

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/django/_impl.py Deleted

@@ -1,237 +0,0 @@
-# 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 sys
-import unittest
-from functools import partial
-from inspect import Parameter, signature
-from typing import Optional, Type, Union
-
-from django import forms as df, test as dt
-from django.contrib.staticfiles import testing as dst
-from django.core.exceptions import ValidationError
-from django.db import IntegrityError, models as dm
-
-from hypothesis import reject, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.django._fields import from_field
-from hypothesis.internal.reflection import define_function_signature_from_signature
-from hypothesis.strategies._internal.utils import defines_strategy
-from hypothesis.utils.conventions import infer
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from types import EllipsisType as InferType
-
-else:
-    InferType = type(Ellipsis)
-
-
-class HypothesisTestCase:
-    def setup_example(self):
-        self._pre_setup()
-
-    def teardown_example(self, example):
-        self._post_teardown()
-
-    def __call__(self, result=None):
-        testMethod = getattr(self, self._testMethodName)
-        if getattr(testMethod, "is_hypothesis_test", False):
-            return unittest.TestCase.__call__(self, result)
-        else:
-            return dt.SimpleTestCase.__call__(self, result)
-
-
-class TestCase(HypothesisTestCase, dt.TestCase):
-    pass
-
-
-class TransactionTestCase(HypothesisTestCase, dt.TransactionTestCase):
-    pass
-
-
-class LiveServerTestCase(HypothesisTestCase, dt.LiveServerTestCase):
-    pass
-
-
-class StaticLiveServerTestCase(HypothesisTestCase, dst.StaticLiveServerTestCase):
-    pass
-
-
-@defines_strategy()
-def from_model(
-    *model: Typedm.Model, **field_strategies: Unionst.SearchStrategy, InferType
-) -> st.SearchStrategy:
-    """Return a strategy for examples of ``model``.
-
-    .. warning::
-        Hypothesis creates saved models. This will run inside your testing
-        transaction when using the test runner, but if you use the dev console
-        this will leave debris in your database.
-
-    ``model`` must be an subclass of :class:`~django:django.db.models.Model`.
-    Strategies for fields may be passed as keyword arguments, for example
-    ``is_staff=st.just(False)``.  In order to support models with fields named
-    "model", this is a positional-only parameter.
-
-    Hypothesis can often infer a strategy based the field type and validators,
-    and will attempt to do so for any required fields.  No strategy will be
-    inferred for an :class:`~django:django.db.models.AutoField`, nullable field,
-    foreign key, or field for which a keyword
-    argument is passed to ``from_model()``.  For example,
-    a Shop type with a foreign key to Company could be generated with::
-
-        shop_strategy = from_model(Shop, company=from_model(Company))
-
-    Like for :func:`~hypothesis.strategies.builds`, you can pass
-    ``...`` (:obj:`python:Ellipsis`) as a keyword argument to infer a strategy for
-    a field which has a default value instead of using the default.
-    """
-    if len(model) == 1:
-        m_type = model0
-    elif len(model) > 1:
-        raise TypeError("Too many positional arguments")
-    else:
-        raise TypeError("Missing required positional argument `model`")
-
-    if not issubclass(m_type, dm.Model):
-        raise InvalidArgument(f"model={model!r} must be a subtype of Model")
-
-    fields_by_name = {f.name: f for f in m_type._meta.concrete_fields}
-    for name, value in sorted(field_strategies.items()):
-        if value is infer:
-            field_strategiesname = from_field(fields_by_namename)
-    for name, field in sorted(fields_by_name.items()):
-        if (
-            name not in field_strategies
-            and not field.auto_created
-            and field.default is dm.fields.NOT_PROVIDED
-        ):
-            field_strategiesname = from_field(field)
-
-    for field in field_strategies:
-        if m_type._meta.get_field(field).primary_key:
-            # The primary key is generated as part of the strategy. We
-            # want to find any existing row with this primary key and
-            # overwrite its contents.
-            kwargs = {field: field_strategies.pop(field)}
-            kwargs"defaults" = st.fixed_dictionaries(field_strategies)  # type: ignore
-            return _models_impl(st.builds(m_type.objects.update_or_create, **kwargs))
-
-    # The primary key is not generated as part of the strategy, so we
-    # just match against any row that has the same value for all
-    # fields.
-    return _models_impl(st.builds(m_type.objects.get_or_create, **field_strategies))
-
-
-if sys.version_info:2 >= (3, 8):  # pragma: no branch
-    # See notes above definition of st.builds() - this signature is compatible
-    # and better matches the semantics of the function.  Great for documentation!
-    sig = signature(from_model)
-    params = list(sig.parameters.values())
-    params0 = params0.replace(kind=Parameter.POSITIONAL_ONLY)
-    from_model = define_function_signature_from_signature(
-        name=from_model.__name__,
-        docstring=from_model.__doc__,
-        signature=sig.replace(parameters=params),
-    )(from_model)
-
-
-@st.composite
-def _models_impl(draw, strat):
-    """Handle the nasty part of drawing a value for models()"""
-    try:
-        return draw(strat)0
-    except IntegrityError:
-        reject()
-
-
-@defines_strategy()
-def from_form(
-    form: Typedf.Form,
-    form_kwargs: Optionaldict = None,
-    **field_strategies: Unionst.SearchStrategy, InferType,
-) -> st.SearchStrategydf.Form:
-    """Return a strategy for examples of ``form``.
-
-    ``form`` must be an subclass of :class:`~django:django.forms.Form`.
-    Strategies for fields may be passed as keyword arguments, for example
-    ``is_staff=st.just(False)``.
-
-    Hypothesis can often infer a strategy based the field type and validators,
-    and will attempt to do so for any required fields.  No strategy will be
-    inferred for a disabled field or field for which a keyword argument
-    is passed to ``from_form()``.
-
-    This function uses the fields of an unbound ``form`` instance to determine
-    field strategies, any keyword arguments needed to instantiate the unbound
-    ``form`` instance can be passed into ``from_form()`` as a dict with the
-    keyword ``form_kwargs``. E.g.::
-
-        shop_strategy = from_form(Shop, form_kwargs={"company_id": 5})
-
-    Like for :func:`~hypothesis.strategies.builds`, you can pass
-    ``...`` (:obj:`python:Ellipsis`) as a keyword argument to infer a strategy for
-    a field which has a default value instead of using the default.
-    """
-    # currently unsupported:
-    # ComboField
-    # FilePathField
-    # FileField
-    # ImageField
-    form_kwargs = form_kwargs or {}
-    if not issubclass(form, df.BaseForm):
-        raise InvalidArgument(f"form={form!r} must be a subtype of Form")
-
-    # Forms are a little bit different from models. Model classes have
-    # all their fields defined, whereas forms may have different fields
-    # per-instance. So, we ought to instantiate the form and get the
-    # fields from the instance, thus we need to accept the kwargs for
-    # instantiation as well as the explicitly defined strategies
-
-    unbound_form = form(**form_kwargs)
-    fields_by_name = {}
-    for name, field in unbound_form.fields.items():
-        if isinstance(field, df.MultiValueField):
-            # PS: So this is a little strange, but MultiValueFields must
-            # have their form data encoded in a particular way for the
-            # values to actually be picked up by the widget instances'
-            # ``value_from_datadict``.
-            # E.g. if a MultiValueField named 'mv_field' has 3
-            # sub-fields then the ``value_from_datadict`` will look for
-            # 'mv_field_0', 'mv_field_1', and 'mv_field_2'. Here I'm
-            # decomposing the individual sub-fields into the names that
-            # the form validation process expects
-            for i, _field in enumerate(field.fields):
-                fields_by_namef"{name}_{i}" = _field
-        else:
-            fields_by_namename = field
-    for name, value in sorted(field_strategies.items()):
-        if value is infer:
-            field_strategiesname = from_field(fields_by_namename)
-
-    for name, field in sorted(fields_by_name.items()):
-        if name not in field_strategies and not field.disabled:
-            field_strategiesname = from_field(field)
-
-    return _forms_impl(
-        st.builds(
-            partial(form, **form_kwargs),
-            data=st.fixed_dictionaries(field_strategies),  # type: ignore
-        )
-    )
-
-
-@st.composite
-def _forms_impl(draw, strat):
-    """Handle the nasty part of drawing a value for from_form()"""
-    try:
-        return draw(strat)
-    except ValidationError:
-        reject()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/ghostwriter.py Deleted

@@ -1,1561 +0,0 @@
-# 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/.
-
-"""
-Writing tests with Hypothesis frees you from the tedium of deciding on and
-writing out specific inputs to test.  Now, the ``hypothesis.extra.ghostwriter``
-module can write your test functions for you too!
-
-The idea is to provide **an easy way to start** property-based testing,
-**and a seamless transition** to more complex test code - because ghostwritten
-tests are source code that you could have written for yourself.
-
-So just pick a function you'd like tested, and feed it to one of the functions
-below.  They follow imports, use but do not require type annotations, and
-generally do their best to write you a useful test.  You can also use
-:ref:`our command-line interface <hypothesis-cli>`::
-
-    $ hypothesis write --help
-    Usage: hypothesis write OPTIONS FUNC...
-
-      `hypothesis write` writes property-based tests for you!
-
-      Type annotations are helpful but not required for our advanced
-      introspection and templating logic.  Try running the examples below to see
-      how it works:
-
-          hypothesis write gzip
-          hypothesis write numpy.matmul
-          hypothesis write re.compile --except re.error
-          hypothesis write --equivalent ast.literal_eval eval
-          hypothesis write --roundtrip json.dumps json.loads
-          hypothesis write --style=unittest --idempotent sorted
-          hypothesis write --binary-op operator.add
-
-    Options:
-      --roundtrip                start by testing write/read or encode/decode!
-      --equivalent               very useful when optimising or refactoring code
-      --errors-equivalent        --equivalent, but also allows consistent errors
-      --idempotent               check that f(x) == f(f(x))
-      --binary-op                associativity, commutativity, identity element
-      --style pytest|unittest  pytest-style function, or unittest-style method?
-      -e, --except OBJ_NAME      dotted name of exception(s) to ignore
-      -h, --help                 Show this message and exit.
-
-.. tip::
-
-    Using a light theme?  Hypothesis respects `NO_COLOR <https://no-color.org/>`__
-    and :envvar:`DJANGO_COLORS=light <django:DJANGO_COLORS>`.
-
-.. note::
-
-    The ghostwriter requires :pypi:`black`, but the generated code only
-    requires Hypothesis itself.
-
-.. note::
-
-    Legal questions?  While the ghostwriter fragments and logic is under the
-    MPL-2.0 license like the rest of Hypothesis, the *output* from the ghostwriter
-    is made available under the `Creative Commons Zero (CC0)
-    <https://creativecommons.org/share-your-work/public-domain/cc0/>`__
-    public domain dedication, so you can use it without any restrictions.
-"""
-
-import ast
-import builtins
-import contextlib
-import enum
-import inspect
-import os
-import re
-import sys
-import types
-from collections import OrderedDict, defaultdict
-from itertools import permutations, zip_longest
-from keyword import iskeyword
-from string import ascii_lowercase
-from textwrap import dedent, indent
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
-
-import black
-
-from hypothesis import Verbosity, find, settings, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.compat import get_type_hints
-from hypothesis.internal.reflection import get_signature, is_mock
-from hypothesis.internal.validation import check_type
-from hypothesis.provisional import domains
-from hypothesis.strategies._internal.collections import ListStrategy
-from hypothesis.strategies._internal.core import BuildsStrategy
-from hypothesis.strategies._internal.flatmapped import FlatMapStrategy
-from hypothesis.strategies._internal.lazy import LazyStrategy, unwrap_strategies
-from hypothesis.strategies._internal.strategies import (
-    FilteredStrategy,
-    MappedSearchStrategy,
-    OneOfStrategy,
-    SampledFromStrategy,
-)
-from hypothesis.strategies._internal.types import _global_type_lookup, is_generic_type
-from hypothesis.utils.conventions import infer
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from types import EllipsisType as InferType
-
-else:
-    InferType = type(Ellipsis)
-
-
-IMPORT_SECTION = """
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-{imports}
-"""
-
-TEMPLATE = """
-@given({given_args})
-def test_{test_kind}_{func_name}({arg_names}):
-{test_body}
-"""
-
-SUPPRESS_BLOCK = """
-try:
-{test_body}
-except {exceptions}:
-    reject()
-""".strip()
-
-Except = UnionTypeException, TupleTypeException, ...
-ImportSet = SetUnionstr, Tuplestr, str
-RE_TYPES = (type(re.compile(".")), type(re.match(".", "abc")))
-_quietly_settings = settings(
-    database=None,
-    deadline=None,
-    derandomize=True,
-    verbosity=Verbosity.quiet,
-)
-
-
-def _dedupe_exceptions(exc: TupleTypeException, ...) -> TupleTypeException, ...:
-    # This is reminiscent of de-duplication logic I wrote for flake8-bugbear,
-    # but with access to the actual objects we can just check for subclasses.
-    # This lets us print e.g. `Exception` instead of `(Exception, OSError)`.
-    uniques = list(exc)
-    for a, b in permutations(exc, 2):
-        if a in uniques and issubclass(a, b):
-            uniques.remove(a)
-    return tuple(sorted(uniques, key=lambda e: e.__name__))
-
-
-def _check_except(except_: Except) -> TupleTypeException, ...:
-    if isinstance(except_, tuple):
-        for i, e in enumerate(except_):
-            if not isinstance(e, type) or not issubclass(e, Exception):
-                raise InvalidArgument(
-                    f"Expected an Exception but got except_{i}={e!r}"
-                    f" (type={_get_qualname(type(e))})"
-                )
-        return except_
-    if not isinstance(except_, type) or not issubclass(except_, Exception):
-        raise InvalidArgument(
-            "Expected an Exception or tuple of exceptions, but got except_="
-            f"{except_!r} (type={_get_qualname(type(except_))})"
-        )
-    return (except_,)
-
-
-def _exception_string(except_: TupleTypeException, ...) -> TupleImportSet, str:
-    if not except_:
-        return set(), ""
-    exceptions = 
-    imports: ImportSet = set()
-    for ex in _dedupe_exceptions(except_):
-        if ex.__qualname__ in dir(builtins):
-            exceptions.append(ex.__qualname__)
-        else:
-            imports.add(ex.__module__)
-            exceptions.append(_get_qualname(ex, include_module=True))
-    return imports, (
-        "(" + ", ".join(exceptions) + ")" if len(exceptions) > 1 else exceptions0
-    )
-
-
-def _check_style(style: str) -> None:
-    if style not in ("pytest", "unittest"):
-        raise InvalidArgument(f"Valid styles are 'pytest' or 'unittest', got {style!r}")
-
-
-def _exceptions_from_docstring(doc: str) -> TupleTypeException, ...:
-    """Return a tuple of exceptions that the docstring says may be raised.
-
-    Note that we ignore non-builtin exception types for simplicity, as this is
-    used directly in _write_call() and passing import sets around would be really
-    really annoying.
-    """
-    # TODO: it would be great to handle Google- and Numpy-style docstrings
-    #       (e.g. by using the Napoleon Sphinx extension)
-    assert isinstance(doc, str), doc
-    raises = 
-    for excname in re.compile(r"\:raises\s+(\w+)\:", re.MULTILINE).findall(doc):
-        exc_type = getattr(builtins, excname, None)
-        if isinstance(exc_type, type) and issubclass(exc_type, Exception):
-            raises.append(exc_type)
-    return tuple(_dedupe_exceptions(tuple(raises)))
-
-
-def _type_from_doc_fragment(token: str) -> Optionaltype:
-    # Special cases for "integer" and for numpy array-like and dtype
-    if token == "integer":
-        return int
-    if "numpy" in sys.modules:
-        if re.fullmatch(r"Aarray-_ ?like", token):
-            return sys.modules"numpy".ndarray
-        elif token == "dtype":
-            return sys.modules"numpy".dtype
-    # Natural-language syntax, e.g. "sequence of integers"
-    coll_match = re.fullmatch(r"(\w+) of (\w+)", token)
-    if coll_match is not None:
-        coll_token, elem_token = coll_match.groups()
-        elems = _type_from_doc_fragment(elem_token)
-        if elems is None and elem_token.endswith("s"):
-            elems = _type_from_doc_fragment(elem_token:-1)
-        if elems is not None and coll_token in ("list", "sequence", "collection"):
-            return Listelems  # type: ignore
-        # This might be e.g. "array-like of float"; arrays is better than nothing
-        # even if we can't conveniently pass a generic type around.
-        return _type_from_doc_fragment(coll_token)
-    # Check either builtins, or the module for a dotted name
-    if "." not in token:
-        return getattr(builtins, token, None)
-    mod, name = token.rsplit(".", maxsplit=1)
-    return getattr(sys.modules.get(mod, None), name, None)
-
-
-def _strategy_for(
-    param: inspect.Parameter,
-    docstring: str,
-) -> Unionst.SearchStrategy, InferType:
-    # Example types in docstrings:
-    # - `:type a: sequence of integers`
-    # - `b (list, tuple, or None): ...`
-    # - `c : {"foo", "bar", or None}`
-    for pattern in (
-        rf"^\s*\:type\s+{param.name}\:\s+(.+)",  # RST-style
-        rf"^\s*{param.name} $(.+)$:",  # Google-style
-        rf"^\s*{param.name} \: (.+)",  # Numpy-style
-    ):
-        match = re.search(pattern, docstring, flags=re.MULTILINE)
-        if match is None:
-            continue
-        doc_type = match.group(1)
-        if doc_type.endswith(", optional"):
-            # Convention to describe "argument may be omitted"
-            doc_type = doc_type: -len(", optional")
-        doc_type = doc_type.strip("}{")
-        elements = 
-        types = 
-        for token in re.split(r",? +or +| *, *", doc_type):
-            for prefix in ("default ", "python "):
-                # `str or None, default "auto"`; `python int or numpy.int64`
-                if token.startswith(prefix):
-                    token = tokenlen(prefix) :
-            if not token:
-                continue
-            try:
-                # Elements of `{"inner", "outer"}` etc.
-                elements.append(ast.literal_eval(token))
-                continue
-            except (ValueError, SyntaxError):
-                t = _type_from_doc_fragment(token)
-                if isinstance(t, type) or is_generic_type(t):
-                    assert t is not None
-                    types.append(t)
-        if (
-            param.default is not inspect.Parameter.empty
-            and param.default not in elements
-            and not isinstance(
-                param.default, tuple(t for t in types if isinstance(t, type))
-            )
-        ):
-            with contextlib.suppress(SyntaxError):
-                compile(repr(st.just(param.default)), "<string>", "eval")
-                elements.insert(0, param.default)
-        if elements or types:
-            return (st.sampled_from(elements) if elements else st.nothing()) | (
-                st.one_of(*map(st.from_type, types)) if types else st.nothing()
-            )
-
-    # If our default value is an Enum or a boolean, we assume that any value
-    # of that type is acceptable.  Otherwise, we only generate the default.
-    if isinstance(param.default, bool):
-        return st.booleans()
-    if isinstance(param.default, enum.Enum):
-        return st.sampled_from(type(param.default))
-    if param.default is not inspect.Parameter.empty:
-        # Using `st.from_type(type(param.default))` would  introduce spurious
-        # failures in cases like the `flags` argument to regex functions.
-        # Better in to keep it simple, and let the user elaborate if desired.
-        return st.just(param.default)
-    return _guess_strategy_by_argname(name=param.name.lower())
-
-
-# fmt: off
-BOOL_NAMES = (
-    "keepdims", "verbose", "debug", "force", "train", "training", "trainable", "bias",
-    "shuffle", "show", "load", "pretrained", "save", "overwrite", "normalize",
-    "reverse", "success", "enabled", "strict", "copy", "quiet", "required", "inplace",
-    "recursive", "enable", "active", "create", "validate", "refresh", "use_bias",
-)
-POSITIVE_INTEGER_NAMES = (
-    "width", "size", "length", "limit", "idx", "stride", "epoch", "epochs", "depth",
-    "pid", "steps", "iteration", "iterations", "vocab_size", "ttl", "count",
-)
-FLOAT_NAMES = (
-    "real", "imag", "alpha", "theta", "beta", "sigma", "gamma", "angle", "reward",
-    "tau", "temperature",
-)
-STRING_NAMES = (
-    "text", "txt", "password", "label", "prefix", "suffix", "desc", "description",
-    "str", "pattern", "subject", "reason", "comment", "prompt", "sentence", "sep",
-)
-# fmt: on
-
-
-def _guess_strategy_by_argname(name: str) -> st.SearchStrategy:
-    """
-    If all else fails, we try guessing a strategy based on common argument names.
-
-    We wouldn't do this in builds() where strict correctness is required, but for
-    the ghostwriter we accept "good guesses" since the user would otherwise have
-    to change the strategy anyway - from `nothing()` - if we refused to guess.
-
-    A "good guess" is _usually correct_, and _a reasonable mistake_ if not.
-    The logic below is therefore based on a manual reading of the builtins and
-    some standard-library docs, plus the analysis of about three hundred million
-    arguments in https://github.com/HypothesisWorks/hypothesis/issues/3311
-    """
-    # Special-cased names
-    if name in ("function", "func", "f"):
-        return st.functions()
-    if name in ("pred", "predicate"):
-        return st.functions(returns=st.booleans(), pure=True)
-    if name in ("iterable",):
-        return st.iterables(st.integers()) | st.iterables(st.text())
-    if name in ("list", "lst", "ls"):
-        return st.lists(st.nothing())
-    if name in ("object",):
-        return st.builds(object)
-    if "uuid" in name:
-        return st.uuids().map(str)
-
-    # Names which imply the value is a boolean
-    if name.startswith("is_") or name in BOOL_NAMES:
-        return st.booleans()
-
-    # Names which imply that the value is a number, perhaps in a particular range
-    if name in ("amount", "threshold", "number", "num"):
-        return st.integers() | st.floats()
-
-    if name in ("port",):
-        return st.integers(0, 2**16 - 1)
-    if (
-        name.endswith("_size")
-        or (name.endswith("size") and "_" not in name)
-        or re.fullmatch(r"n(um)?_a-z_*s", name)
-        or name in POSITIVE_INTEGER_NAMES
-    ):
-        return st.integers(min_value=0)
-    if name in ("offset", "seed", "dim", "total", "priority"):
-        return st.integers()
-
-    if name in ("learning_rate", "dropout", "dropout_rate", "epsilon", "eps", "prob"):
-        return st.floats(0, 1)
-    if name in ("lat", "latitude"):
-        return st.floats(-90, 90)
-    if name in ("lon", "longitude"):
-        return st.floats(-180, 180)
-    if name in ("radius", "tol", "tolerance", "rate"):
-        return st.floats(min_value=0)
-    if name in FLOAT_NAMES:
-        return st.floats()
-
-    # Names which imply that the value is a string
-    if name in ("host", "hostname"):
-        return domains()
-    if name in ("email",):
-        return st.emails()
-    if name in ("word", "slug", "api_key"):
-        return st.from_regex(r"\w+", fullmatch=True)
-    if name in ("char", "character"):
-        return st.characters()
-
-    if (
-        "file" in name
-        or "path" in name
-        or name.endswith("_dir")
-        or name in ("fname", "dir", "dirname", "directory", "folder")
-    ):
-        # Common names for filesystem paths: these are usually strings, but we
-        # don't want to make strings more convenient than pathlib.Path.
-        return st.nothing()
-
-    if (
-        name.endswith("_name")
-        or (name.endswith("name") and "_" not in name)
-        or ("string" in name and "as" not in name)
-        or name.endswith("label")
-        or name in STRING_NAMES
-    ):
-        return st.text()
-
-    # Last clever idea: maybe we're looking a plural, and know the singular:
-    if re.fullmatch(r"\w*^ss", name):
-        elems = _guess_strategy_by_argname(name:-1)
-        if not elems.is_empty:
-            return st.lists(elems)
-
-    # And if all that failed, we'll return nothing() - the user will have to
-    # fill this in by hand, and we'll leave a comment to that effect later.
-    return st.nothing()
-
-
-def _get_params(func: Callable) -> Dictstr, inspect.Parameter:
-    """Get non-vararg parameters of `func` as an ordered dict."""
-    var_param_kinds = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
-    try:
-        params = list(get_signature(func).parameters.values())
-    except Exception:
-        if (
-            isinstance(func, (types.BuiltinFunctionType, types.BuiltinMethodType))
-            and hasattr(func, "__doc__")
-            and isinstance(func.__doc__, str)
-        ):
-            # inspect.signature doesn't work on all builtin functions or methods.
-            # In such cases, we can try to reconstruct simple signatures from the docstring.
-            match = re.match(rf"^{func.__name__}$(.+?)$", func.__doc__)
-            if match is None:
-                raise
-            args = match.group(1).replace("", "").replace("", "")
-            params = 
-            # Even if the signature doesn't contain a /, we assume that arguments
-            # are positional-only until shown otherwise - the / is often omitted.
-            kind: inspect._ParameterKind = inspect.Parameter.POSITIONAL_ONLY
-            for arg in args.split(", "):
-                arg, *_ = arg.partition("=")
-                arg = arg.strip()
-                if arg == "/":
-                    kind = inspect.Parameter.POSITIONAL_OR_KEYWORD
-                    continue
-                if arg.startswith("*") or arg == "...":
-                    kind = inspect.Parameter.KEYWORD_ONLY
-                    continue  # we omit *varargs, if there are any
-                if iskeyword(arg.lstrip("*")) or not arg.lstrip("*").isidentifier():
-                    print(repr(args))
-                    break  # skip all subsequent params if this name is invalid
-                params.append(inspect.Parameter(name=arg, kind=kind))
-
-        elif _is_probably_ufunc(func):
-            # `inspect.signature` doesn't work on ufunc objects, but we can work out
-            # what the required parameters would look like if it did.
-            # Note that we use args named a, b, c... to match the `operator` module,
-            # rather than x1, x2, x3... like the Numpy docs.  Because they're pos-only
-            # this doesn't make a runtime difference, and it's much nicer for use-cases
-            # like `equivalent(numpy.add, operator.add)`.
-            params = 
-                inspect.Parameter(name=name, kind=inspect.Parameter.POSITIONAL_ONLY)
-                for name in ascii_lowercase: func.nin  # type: ignore
-            
-        else:
-            # If we haven't managed to recover a signature through the tricks above,
-            # we're out of ideas and should just re-raise the exception.
-            raise
-    return OrderedDict((p.name, p) for p in params if p.kind not in var_param_kinds)
-
-
-@contextlib.contextmanager
-def _with_any_registered():
-    # If the user has registered their own strategy for Any, leave it alone
-    if Any in _global_type_lookup:
-        yield
-    # We usually want to force from_type(Any) to raise an error because we don't
-    # have enough information to accurately resolve user intent, but in this case
-    # we can treat it as a synonym for object - this is probably wrong, but you'll
-    # get at least _some_ output to edit later.  We then reset everything in order
-    # to avoid polluting the resolution logic in case you run tests later.
-    else:
-        try:
-            _global_type_lookupAny = st.builds(object)
-            yield
-        finally:
-            del _global_type_lookupAny
-            st.from_type.__clear_cache()
-
-
-def _get_strategies(
-    *funcs: Callable, pass_result_to_next_func: bool = False
-) -> Dictstr, st.SearchStrategy:
-    """Return a dict of strategies for the union of arguments to `funcs`.
-
-    If `pass_result_to_next_func` is True, assume that the result of each function
-    is passed to the next, and therefore skip the first argument of all but the
-    first function.
-
-    This dict is used to construct our call to the `@given(...)` decorator.
-    """
-    assert funcs, "Must pass at least one function"
-    given_strategies: Dictstr, st.SearchStrategy = {}
-    for i, f in enumerate(funcs):
-        params = _get_params(f)
-        if pass_result_to_next_func and i >= 1:
-            del paramsnext(iter(params))
-        hints = get_type_hints(f)
-        docstring = getattr(f, "__doc__", None) or ""
-        builder_args = {
-            k: infer if k in hints else _strategy_for(v, docstring)
-            for k, v in params.items()
-        }
-        with _with_any_registered():
-            strat = st.builds(f, **builder_args).wrapped_strategy  # type: ignore
-
-        if strat.args:
-            raise NotImplementedError("Expected to pass everything as kwargs")
-
-        for k, v in strat.kwargs.items():
-            if _valid_syntax_repr(v)1 == "nothing()" and k in hints:
-                # e.g. from_type(Hashable) is OK but the unwrapped repr is not
-                v = LazyStrategy(st.from_type, (hintsk,), {})
-            if k in given_strategies:
-                given_strategiesk |= v
-            else:
-                given_strategiesk = v
-
-    # If there is only one function, we pass arguments to @given in the order of
-    # that function's signature.  Otherwise, we use alphabetical order.
-    if len(funcs) == 1:
-        return {name: given_strategiesname for name in _get_params(f)}
-    return dict(sorted(given_strategies.items()))
-
-
-def _assert_eq(style: str, a: str, b: str) -> str:
-    if style == "unittest":
-        return f"self.assertEqual({a}, {b})"
-    assert style == "pytest"
-    if a.isidentifier() and b.isidentifier():
-        return f"assert {a} == {b}, ({a}, {b})"
-    return f"assert {a} == {b}"
-
-
-def _imports_for_object(obj):
-    """Return the imports for `obj`, which may be empty for e.g. lambdas"""
-    if isinstance(obj, RE_TYPES):
-        return {"re"}
-    try:
-        if is_generic_type(obj):
-            if isinstance(obj, TypeVar):
-                return {(obj.__module__, obj.__name__)}
-            with contextlib.suppress(Exception):
-                return set().union(*map(_imports_for_object, obj.__args__))
-        if (not callable(obj)) or obj.__name__ == "<lambda>":
-            return set()
-        name = _get_qualname(obj).split(".")0
-        return {(_get_module(obj), name)}
-    except Exception:
-        return set()
-
-
-def _imports_for_strategy(strategy):
-    # If we have a lazy from_type strategy, because unwrapping it gives us an
-    # error or invalid syntax, import that type and we're done.
-    if isinstance(strategy, LazyStrategy):
-        if strategy.function is st.from_type:
-            return _imports_for_object(strategy._LazyStrategy__args0)
-        elif _get_module(strategy.function).startswith("hypothesis.extra."):
-            return {(_get_module(strategy.function), strategy.function.__name__)}
-            module = _get_module(strategy.function).replace("._array_helpers", ".numpy")
-            return {(module, strategy.function.__name__)}
-
-    imports = set()
-    strategy = unwrap_strategies(strategy)
-
-    # Get imports for s.map(f), s.filter(f), s.flatmap(f), including both s and f
-    if isinstance(strategy, MappedSearchStrategy):
-        imports |= _imports_for_strategy(strategy.mapped_strategy)
-        imports |= _imports_for_object(strategy.pack)
-    if isinstance(strategy, FilteredStrategy):
-        imports |= _imports_for_strategy(strategy.filtered_strategy)
-        for f in strategy.flat_conditions:
-            imports |= _imports_for_object(f)
-    if isinstance(strategy, FlatMapStrategy):
-        imports |= _imports_for_strategy(strategy.flatmapped_strategy)
-        imports |= _imports_for_object(strategy.expand)
-
-    # recurse through one_of to handle e.g. from_type(OptionalFoo)
-    if isinstance(strategy, OneOfStrategy):
-        for s in strategy.element_strategies:
-            imports |= _imports_for_strategy(s)
-
-    # get imports for the target of builds(), and recurse into the argument strategies
-    if isinstance(strategy, BuildsStrategy):
-        imports |= _imports_for_object(strategy.target)
-        for s in strategy.args:
-            imports |= _imports_for_strategy(s)
-        for s in strategy.kwargs.values():
-            imports |= _imports_for_strategy(s)
-
-    if isinstance(strategy, SampledFromStrategy):
-        for obj in strategy.elements:
-            imports |= _imports_for_object(obj)
-
-    if isinstance(strategy, ListStrategy):
-        imports |= _imports_for_strategy(strategy.element_strategy)
-
-    return imports
-
-
-def _valid_syntax_repr(strategy):
-    # For binary_op, we pass a variable name - so pass it right back again.
-    if isinstance(strategy, str):
-        return set(), strategy
-    # Flatten and de-duplicate any one_of strategies, whether that's from resolving
-    # a Union type or combining inputs to multiple functions.
-    try:
-        if isinstance(strategy, OneOfStrategy):
-            seen = set()
-            elems = 
-            for s in strategy.element_strategies:
-                if isinstance(s, SampledFromStrategy) and s.elements == (os.environ,):
-                    continue
-                if repr(s) not in seen:
-                    elems.append(s)
-                    seen.add(repr(s))
-            strategy = st.one_of(elems or st.nothing())
-        # Trivial special case because the wrapped repr for text() is terrible.
-        if strategy == st.text().wrapped_strategy:
-            return set(), "text()"
-        # Return a syntactically-valid strategy repr, including fixing some
-        # strategy reprs and replacing invalid syntax reprs with `"nothing()"`.
-        # String-replace to hide the special case in from_type() for Decimal('snan')
-        r = repr(strategy).replace(".filter(_can_hash)", "")
-        # Replace <unknown> with ... in confusing lambdas
-        r = re.sub(r"(lambda.*?: )(<unknown>)(,))", r"\1...\3", r)
-        compile(r, "<string>", "eval")
-        # Finally, try to work out the imports we need for builds(), .map(),
-        # .filter(), and .flatmap() to work without NameError
-        imports = {i for i in _imports_for_strategy(strategy) if i1 in r}
-        return imports, r
-    except (SyntaxError, RecursionError, InvalidArgument):
-        return set(), "nothing()"
-
-
-# When we ghostwrite for a module, we want to treat that as the __module__ for
-# each function, rather than whichever internal file it was actually defined in.
-KNOWN_FUNCTION_LOCATIONS: Dictobject, str = {}
-
-
-def _get_module(obj):
-    if obj in KNOWN_FUNCTION_LOCATIONS:
-        return KNOWN_FUNCTION_LOCATIONSobj
-    try:
-        return obj.__module__
-    except AttributeError:
-        if not _is_probably_ufunc(obj):
-            raise
-    for module_name in sorted(sys.modules, key=lambda n: tuple(n.split("."))):
-        if obj is getattr(sys.modulesmodule_name, obj.__name__, None):
-            KNOWN_FUNCTION_LOCATIONSobj = module_name
-            return module_name
-    raise RuntimeError(f"Could not find module for ufunc {obj.__name__} ({obj!r}")
-
-
-def _get_qualname(obj, include_module=False):
-    # Replacing angle-brackets for objects defined in `.<locals>.`
-    qname = getattr(obj, "__qualname__", obj.__name__)
-    qname = qname.replace("<", "_").replace(">", "_").replace(" ", "")
-    if include_module:
-        return _get_module(obj) + "." + qname
-    return qname
-
-
-def _write_call(
-    func: Callable, *pass_variables: str, except_: Except, assign: str = ""
-) -> str:
-    """Write a call to `func` with explicit and implicit arguments.
-
-    >>> _write_call(sorted, "my_seq", "func")
-    "builtins.sorted(my_seq, key=func, reverse=reverse)"
-
-    >>> write_call(f, assign="var1")
-    "var1 = f()"
-
-    The fancy part is that we'll check the docstring for any known exceptions
-    which `func` might raise, and catch-and-reject on them... *unless* they're
-    subtypes of `except_`, which will be handled in an outer try-except block.
-    """
-    args = ", ".join(
-        (v or p.name)
-        if p.kind is inspect.Parameter.POSITIONAL_ONLY
-        else f"{p.name}={v or p.name}"
-        for v, p in zip_longest(pass_variables, _get_params(func).values())
-    )
-    call = f"{_get_qualname(func, include_module=True)}({args})"
-    if assign:
-        call = f"{assign} = {call}"
-    raises = _exceptions_from_docstring(getattr(func, "__doc__", "") or "")
-    exnames = ex.__name__ for ex in raises if not issubclass(ex, except_)
-    if not exnames:
-        return call
-    return SUPPRESS_BLOCK.format(
-        test_body=indent(call, prefix="    "),
-        exceptions="(" + ", ".join(exnames) + ")" if len(exnames) > 1 else exnames0,
-    )
-
-
-def _st_strategy_names(s: str) -> str:
-    """Replace strategy name() with st.name().
-
-    Uses a tricky re.sub() to avoid problems with frozensets() matching
-    sets() too.
-    """
-    names = "|".join(sorted(st.__all__, key=len, reverse=True))
-    return re.sub(pattern=rf"\b(?:{names})\(", repl=r"st.\g<0>", string=s)
-
-
-def _make_test_body(
-    *funcs: Callable,
-    ghost: str,
-    test_body: str,
-    except_: TupleTypeException, ...,
-    assertions: str = "",
-    style: str,
-    given_strategies: OptionalMappingstr, Unionstr, st.SearchStrategy = None,
-    imports: OptionalImportSet = None,
-) -> TupleImportSet, str:
-    # A set of modules to import - we might add to this later.  The import code
-    # is written later, so we can have one import section for multiple magic()
-    # test functions.
-    imports = (imports or set()) | {_get_module(f) for f in funcs}
-
-    # Get strategies for all the arguments to each function we're testing.
-    with _with_any_registered():
-        given_strategies = given_strategies or _get_strategies(
-            *funcs, pass_result_to_next_func=ghost in ("idempotent", "roundtrip")
-        )
-        reprs = ((k,) + _valid_syntax_repr(v)) for k, v in given_strategies.items()
-        imports = imports.union(*(imp for _, imp, _ in reprs))
-        given_args = ", ".join(f"{k}={v}" for k, _, v in reprs)
-    given_args = _st_strategy_names(given_args)
-
-    if except_:
-        # Convert to strings, either builtin names or qualified names.
-        imp, exc_string = _exception_string(except_)
-        imports.update(imp)
-        # And finally indent the existing test body into a try-except block
-        # which catches these exceptions and calls `hypothesis.reject()`.
-        test_body = SUPPRESS_BLOCK.format(
-            test_body=indent(test_body, prefix="    "),
-            exceptions=exc_string,
-        )
-
-    if assertions:
-        test_body = f"{test_body}\n{assertions}"
-
-    # Indent our test code to form the body of a function or method.
-    argnames = ("self" if style == "unittest" else ) + list(given_strategies)
-    body = TEMPLATE.format(
-        given_args=given_args,
-        test_kind=ghost,
-        func_name="_".join(_get_qualname(f).replace(".", "_") for f in funcs),
-        arg_names=", ".join(argnames),
-        test_body=indent(test_body, prefix="    "),
-    )
-
-    # For unittest-style, indent method further into a class body
-    if style == "unittest":
-        imports.add("unittest")
-        body = "class Test{}{}(unittest.TestCase):\n{}".format(
-            ghost.title(),
-            "".join(_get_qualname(f).replace(".", "").title() for f in funcs),
-            indent(body, "    "),
-        )
-
-    return imports, body
-
-
-def _make_test(imports: ImportSet, body: str) -> str:
-    # Discarding "builtins." and "__main__" probably isn't particularly useful
-    # for user code, but important for making a good impression in demos.
-    body = body.replace("builtins.", "").replace("__main__.", "")
-    if "st.from_type(typing." in body:
-        imports.add("typing")
-    imports |= {("hypothesis", "given"), ("hypothesis", "strategies as st")}
-    if "        reject()\n" in body:
-        imports.add(("hypothesis", "reject"))
-
-    do_not_import = {"builtins", "__main__"}
-    direct = {f"import {i}" for i in imports - do_not_import if isinstance(i, str)}
-    from_imports = defaultdict(set)
-    for module, name in {i for i in imports if isinstance(i, tuple)}:
-        if not (module.startswith("hypothesis.strategies") and name in st.__all__):
-            from_importsmodule.add(name)
-    from_ = {
-        "from {} import {}".format(module, ", ".join(sorted(names)))
-        for module, names in from_imports.items()
-        if isinstance(module, str) and module not in do_not_import
-    }
-    header = IMPORT_SECTION.format(imports="\n".join(sorted(direct) + sorted(from_)))
-    nothings = body.count("st.nothing()")
-    if nothings == 1:
-        header += "# TODO: replace st.nothing() with an appropriate strategy\n\n"
-    elif nothings >= 1:
-        header += "# TODO: replace st.nothing() with appropriate strategies\n\n"
-    return black.format_str(header + body, mode=black.FileMode())
-
-
-def _is_probably_ufunc(obj):
-    # See https://numpy.org/doc/stable/reference/ufuncs.html - there doesn't seem
-    # to be an upstream function to detect this, so we just guess.
-    has_attributes = "nin nout nargs ntypes types identity signature".split()
-    return callable(obj) and all(hasattr(obj, name) for name in has_attributes)
-
-
-# If we have a pair of functions where one name matches the regex and the second
-# is the result of formatting the template with matched groups, our magic()
-# ghostwriter will write a roundtrip test for them.  Additional patterns welcome.
-ROUNDTRIP_PAIRS = (
-    # Defined prefix, shared postfix.  The easy cases.
-    (r"write(.+)", "read{}"),
-    (r"save(.+)", "load{}"),
-    (r"dump(.+)", "load{}"),
-    (r"to(.+)", "from{}"),
-    # Known stem, maybe matching prefixes, maybe matching postfixes.
-    (r"(.*)en(.+)", "{}de{}"),
-    # Shared postfix, prefix only on "inverse" function
-    (r"(.+)", "de{}"),
-    (r"(?!safe)(.+)", "un{}"),  # safe_load / unsafe_load isn't a roundtrip
-    # a2b_postfix and b2a_postfix.  Not a fan of this pattern, but it's pretty
-    # common in code imitating an C API - see e.g. the stdlib binascii module.
-    (r"(.+)2(.+?)(_.+)?", "{1}2{0}{2}"),
-    # Common in e.g. the colorsys module
-    (r"(.+)_to_(.+)", "{1}_to_{0}"),
-    # Sockets patterns
-    (r"(inet|if)_(.+)to(.+)", "{0}_{2}to{1}"),
-    (r"(\w)to(\w)(.+)", "{1}to{0}{2}"),
-    (r"send(.+)", "recv{}"),
-    (r"send(.+)", "receive{}"),
-)
-
-
-def magic(
-    *modules_or_functions: UnionCallable, types.ModuleType,
-    except_: Except = (),
-    style: str = "pytest",
-) -> str:
-    """Guess which ghostwriters to use, for a module or collection of functions.
-
-    As for all ghostwriters, the ``except_`` argument should be an
-    :class:`python:Exception` or tuple of exceptions, and ``style`` may be either
-    ``"pytest"`` to write test functions or ``"unittest"`` to write test methods
-    and :class:`~python:unittest.TestCase`.
-
-    After finding the public functions attached to any modules, the ``magic``
-    ghostwriter looks for pairs of functions to pass to :func:`~roundtrip`,
-    then checks for :func:`~binary_operation` and :func:`~ufunc` functions,
-    and any others are passed to :func:`~fuzz`.
-
-    For example, try :command:`hypothesis write gzip` on the command line!
-    """
-    except_ = _check_except(except_)
-    _check_style(style)
-    if not modules_or_functions:
-        raise InvalidArgument("Must pass at least one function or module to test.")
-    functions = set()
-    for thing in modules_or_functions:
-        if callable(thing):
-            functions.add(thing)
-            # class need to be added for exploration
-            if inspect.isclass(thing):
-                funcs: ListOptionalAny = thing
-            else:
-                funcs = 
-        elif isinstance(thing, types.ModuleType):
-            if hasattr(thing, "__all__"):
-                funcs = getattr(thing, name, None) for name in thing.__all__
-            elif hasattr(thing, "__package__"):
-                pkg = thing.__package__
-                funcs = 
-                    v
-                    for k, v in vars(thing).items()
-                    if callable(v)
-                    and not is_mock(v)
-                    and ((not pkg) or getattr(v, "__module__", pkg).startswith(pkg))
-                    and not k.startswith("_")
-                
-                if pkg and any(getattr(f, "__module__", pkg) == pkg for f in funcs):
-                    funcs = f for f in funcs if getattr(f, "__module__", pkg) == pkg
-        else:
-            raise InvalidArgument(f"Can't test non-module non-callable {thing!r}")
-
-        for f in list(funcs):
-            if inspect.isclass(f):
-                funcs += 
-                    v.__get__(f)
-                    for k, v in vars(f).items()
-                    if hasattr(v, "__func__")
-                    and not is_mock(v)
-                    and not k.startswith("_")
-                
-        for f in funcs:
-            try:
-                if (
-                    (not is_mock(f))
-                    and callable(f)
-                    and _get_params(f)
-                    and not isinstance(f, enum.EnumMeta)
-                ):
-                    functions.add(f)
-                    if getattr(thing, "__name__", None):
-                        if inspect.isclass(thing):
-                            KNOWN_FUNCTION_LOCATIONSf = thing.__module__
-                        else:
-                            KNOWN_FUNCTION_LOCATIONSf = thing.__name__
-            except (TypeError, ValueError):
-                pass
-
-    imports = set()
-    parts = 
-
-    def make_(how, *args, **kwargs):
-        imp, body = how(*args, **kwargs, except_=except_, style=style)
-        imports.update(imp)
-        parts.append(body)
-
-    by_name = {}
-    for f in functions:
-        try:
-            _get_params(f)
-            by_name_get_qualname(f, include_module=True) = f
-        except Exception:
-            # usually inspect.signature on C code such as socket.inet_aton, sometimes
-            # e.g. Pandas 'CallableDynamicDoc' object has no attribute '__name__'
-            pass
-    if not by_name:
-        return (
-            f"# Found no testable functions in\n"
-            f"# {functions!r} from {modules_or_functions}\n"
-        )
-
-    # Look for pairs of functions that roundtrip, based on known naming patterns.
-    for writename, readname in ROUNDTRIP_PAIRS:
-        for name in sorted(by_name):
-            match = re.fullmatch(writename, name.split(".")-1)
-            if match:
-                inverse_name = readname.format(*match.groups())
-                for other in sorted(
-                    n for n in by_name if n.split(".")-1 == inverse_name
-                ):
-                    make_(_make_roundtrip_body, (by_name.pop(name), by_name.pop(other)))
-                    break
-                else:
-                    try:
-                        other_func = getattr(
-                            sys.modules_get_module(by_namename),
-                            inverse_name,
-                        )
-                        _get_params(other_func)  # we want to skip if this fails
-                    except Exception:
-                        pass
-                    else:
-                        make_(_make_roundtrip_body, (by_name.pop(name), other_func))
-
-    # Look for equivalent functions: same name, all required arguments of any can
-    # be found in all signatures, and if all have return-type annotations they match.
-    names = defaultdict(list)
-    for _, f in sorted(by_name.items()):
-        names_get_qualname(f).append(f)
-    for group in names.values():
-        if len(group) >= 2 and len({frozenset(_get_params(f)) for f in group}) == 1:
-            sentinel = object()
-            returns = {get_type_hints(f).get("return", sentinel) for f in group}
-            if len(returns - {sentinel}) <= 1:
-                make_(_make_equiv_body, group)
-                for f in group:
-                    by_name.pop(_get_qualname(f, include_module=True))
-
-    # Look for binary operators - functions with two identically-typed arguments,
-    # and the same return type.  The latter restriction might be lifted later.
-    for name, func in sorted(by_name.items()):
-        hints = get_type_hints(func)
-        hints.pop("return", None)
-        params = _get_params(func)
-        if len(hints) == len(params) == 2:
-            a, b = hints.values()
-            arg1, arg2 = params
-            if a == b and len(arg1) == len(arg2) <= 3:
-                make_(_make_binop_body, func)
-                del by_namename
-
-    # Look for Numpy ufuncs or gufuncs, and write array-oriented tests for them.
-    if "numpy" in sys.modules:
-        for name, func in sorted(by_name.items()):
-            if _is_probably_ufunc(func):
-                make_(_make_ufunc_body, func)
-                del by_namename
-
-    # For all remaining callables, just write a fuzz-test.  In principle we could
-    # guess at equivalence or idempotence; but it doesn't seem accurate enough to
-    # be worth the trouble when it's so easy for the user to specify themselves.
-    for _, f in sorted(by_name.items()):
-        make_(
-            _make_test_body, f, test_body=_write_call(f, except_=except_), ghost="fuzz"
-        )
-    return _make_test(imports, "\n".join(parts))
-
-
-def fuzz(func: Callable, *, except_: Except = (), style: str = "pytest") -> str:
-    """Write source code for a property-based test of ``func``.
-
-    The resulting test checks that valid input only leads to expected exceptions.
-    For example:
-
-    .. code-block:: python
-
-        from re import compile, error
-
-        from hypothesis.extra import ghostwriter
-
-        ghostwriter.fuzz(compile, except_=error)
-
-    Gives:
-
-    .. code-block:: python
-
-        # This test code was written by the `hypothesis.extra.ghostwriter` module
-        # and is provided under the Creative Commons Zero public domain dedication.
-        import re
-
-        from hypothesis import given, reject, strategies as st
-
-        # TODO: replace st.nothing() with an appropriate strategy
-
-
-        @given(pattern=st.nothing(), flags=st.just(0))
-        def test_fuzz_compile(pattern, flags):
-            try:
-                re.compile(pattern=pattern, flags=flags)
-            except re.error:
-                reject()
-
-    Note that it includes all the required imports.
-    Because the ``pattern`` parameter doesn't have annotations or a default argument,
-    you'll need to specify a strategy - for example :func:`~hypothesis.strategies.text`
-    or :func:`~hypothesis.strategies.binary`.  After that, you have a test!
-    """
-    if not callable(func):
-        raise InvalidArgument(f"Got non-callable func={func!r}")
-    except_ = _check_except(except_)
-    _check_style(style)
-
-    imports, body = _make_test_body(
-        func,
-        test_body=_write_call(func, except_=except_),
-        except_=except_,
-        ghost="fuzz",
-        style=style,
-    )
-    return _make_test(imports, body)
-
-
-def idempotent(func: Callable, *, except_: Except = (), style: str = "pytest") -> str:
-    """Write source code for a property-based test of ``func``.
-
-    The resulting test checks that if you call ``func`` on it's own output,
-    the result does not change.  For example:
-
-    .. code-block:: python
-
-        from typing import Sequence
-
-        from hypothesis.extra import ghostwriter
-
-
-        def timsort(seq: Sequenceint) -> Sequenceint:
-            return sorted(seq)
-
-
-        ghostwriter.idempotent(timsort)
-
-    Gives:
-
-    .. code-block:: python
-
-        # This test code was written by the `hypothesis.extra.ghostwriter` module
-        # and is provided under the Creative Commons Zero public domain dedication.
-
-        from hypothesis import given, strategies as st
-
-
-        @given(seq=st.one_of(st.binary(), st.binary().map(bytearray), st.lists(st.integers())))
-        def test_idempotent_timsort(seq):
-            result = timsort(seq=seq)
-            repeat = timsort(seq=result)
-            assert result == repeat, (result, repeat)
-    """
-    if not callable(func):
-        raise InvalidArgument(f"Got non-callable func={func!r}")
-    except_ = _check_except(except_)
-    _check_style(style)
-
-    imports, body = _make_test_body(
-        func,
-        test_body="result = {}\nrepeat = {}".format(
-            _write_call(func, except_=except_),
-            _write_call(func, "result", except_=except_),
-        ),
-        except_=except_,
-        assertions=_assert_eq(style, "result", "repeat"),
-        ghost="idempotent",
-        style=style,
-    )
-    return _make_test(imports, body)
-
-
-def _make_roundtrip_body(funcs, except_, style):
-    first_param = next(iter(_get_params(funcs0)))
-    test_lines = 
-        _write_call(funcs0, assign="value0", except_=except_),
-        *(
-            _write_call(f, f"value{i}", assign=f"value{i + 1}", except_=except_)
-            for i, f in enumerate(funcs1:)
-        ),
-    
-    return _make_test_body(
-        *funcs,
-        test_body="\n".join(test_lines),
-        except_=except_,
-        assertions=_assert_eq(style, first_param, f"value{len(funcs) - 1}"),
-        ghost="roundtrip",
-        style=style,
-    )
-
-
-def roundtrip(*funcs: Callable, except_: Except = (), style: str = "pytest") -> str:
-    """Write source code for a property-based test of ``funcs``.
-
-    The resulting test checks that if you call the first function, pass the result
-    to the second (and so on), the final result is equal to the first input argument.
-
-    This is a *very* powerful property to test, especially when the config options
-    are varied along with the object to round-trip.  For example, try ghostwriting
-    a test for :func:`python:json.dumps` - would you have thought of all that?
-
-    .. code-block:: shell
-
-        hypothesis write --roundtrip json.dumps json.loads
-    """
-    if not funcs:
-        raise InvalidArgument("Round-trip of zero functions is meaningless.")
-    for i, f in enumerate(funcs):
-        if not callable(f):
-            raise InvalidArgument(f"Got non-callable funcs{i}={f!r}")
-    except_ = _check_except(except_)
-    _check_style(style)
-    return _make_test(*_make_roundtrip_body(funcs, except_, style))
-
-
-def _make_equiv_body(funcs, except_, style):
-    var_names = f"result_{f.__name__}" for f in funcs
-    if len(set(var_names)) < len(var_names):
-        var_names = f"result_{i}_{ f.__name__}" for i, f in enumerate(funcs)
-    test_lines = 
-        _write_call(f, assign=vname, except_=except_)
-        for vname, f in zip(var_names, funcs)
-    
-    assertions = "\n".join(
-        _assert_eq(style, var_names0, vname) for vname in var_names1:
-    )
-
-    return _make_test_body(
-        *funcs,
-        test_body="\n".join(test_lines),
-        except_=except_,
-        assertions=assertions,
-        ghost="equivalent",
-        style=style,
-    )
-
-
-EQUIV_FIRST_BLOCK = """
-try:
-{}
-    exc_type = None
-    target(1, label="input was valid")
-{}except Exception as exc:
-    exc_type = type(exc)
-""".strip()
-
-EQUIV_CHECK_BLOCK = """
-if exc_type:
-    with {ctx}(exc_type):
-{check_raises}
-else:
-{call}
-{compare}
-""".rstrip()
-
-
-def _make_equiv_errors_body(funcs, except_, style):
-    var_names = f"result_{f.__name__}" for f in funcs
-    if len(set(var_names)) < len(var_names):
-        var_names = f"result_{i}_{ f.__name__}" for i, f in enumerate(funcs)
-
-    first, *rest = funcs
-    first_call = _write_call(first, assign=var_names0, except_=except_)
-    extra_imports, suppress = _exception_string(except_)
-    extra_imports.add(("hypothesis", "target"))
-    catch = f"except {suppress}:\n    reject()\n" if suppress else ""
-    test_lines = EQUIV_FIRST_BLOCK.format(indent(first_call, prefix="    "), catch)
-
-    for vname, f in zip(var_names1:, rest):
-        if style == "pytest":
-            ctx = "pytest.raises"
-            extra_imports.add("pytest")
-        else:
-            assert style == "unittest"
-            ctx = "self.assertRaises"
-        block = EQUIV_CHECK_BLOCK.format(
-            ctx=ctx,
-            check_raises=indent(_write_call(f, except_=()), "        "),
-            call=indent(_write_call(f, assign=vname, except_=()), "    "),
-            compare=indent(_assert_eq(style, var_names0, vname), "    "),
-        )
-        test_lines.append(block)
-
-    imports, source_code = _make_test_body(
-        *funcs,
-        test_body="\n".join(test_lines),
-        except_=(),
-        ghost="equivalent",
-        style=style,
-    )
-    return imports | extra_imports, source_code
-
-
-def equivalent(
-    *funcs: Callable,
-    allow_same_errors: bool = False,
-    except_: Except = (),
-    style: str = "pytest",
-) -> str:
-    """Write source code for a property-based test of ``funcs``.
-
-    The resulting test checks that calling each of the functions returns
-    an equal value.  This can be used as a classic 'oracle', such as testing
-    a fast sorting algorithm against the :func:`python:sorted` builtin, or
-    for differential testing where none of the compared functions are fully
-    trusted but any difference indicates a bug (e.g. running a function on
-    different numbers of threads, or simply multiple times).
-
-    The functions should have reasonably similar signatures, as only the
-    common parameters will be passed the same arguments - any other parameters
-    will be allowed to vary.
-
-    If allow_same_errors is True, then the test will pass if calling each of
-    the functions returns an equal value, *or* if the first function raises an
-    exception and each of the others raises an exception of the same type.
-    This relaxed mode can be useful for code synthesis projects.
-    """
-    if len(funcs) < 2:
-        raise InvalidArgument("Need at least two functions to compare.")
-    for i, f in enumerate(funcs):
-        if not callable(f):
-            raise InvalidArgument(f"Got non-callable funcs{i}={f!r}")
-    check_type(bool, allow_same_errors, "allow_same_errors")
-    except_ = _check_except(except_)
-    _check_style(style)
-    if allow_same_errors and not any(issubclass(Exception, ex) for ex in except_):
-        imports, source_code = _make_equiv_errors_body(funcs, except_, style)
-    else:
-        imports, source_code = _make_equiv_body(funcs, except_, style)
-    return _make_test(imports, source_code)
-
-
-X = TypeVar("X")
-Y = TypeVar("Y")
-
-
-def binary_operation(
-    func: CallableX, X, Y,
-    *,
-    associative: bool = True,
-    commutative: bool = True,
-    identity: UnionX, InferType, None = infer,
-    distributes_over: OptionalCallableX, X, X = None,
-    except_: Except = (),
-    style: str = "pytest",
-) -> str:
-    """Write property tests for the binary operation ``func``.
-
-    While :wikipedia:`binary operations <Binary_operation>` are not particularly
-    common, they have such nice properties to test that it seems a shame not to
-    demonstrate them with a ghostwriter.  For an operator `f`, test that:
-
-    - if :wikipedia:`associative <Associative_property>`,
-      ``f(a, f(b, c)) == f(f(a, b), c)``
-    - if :wikipedia:`commutative <Commutative_property>`, ``f(a, b) == f(b, a)``
-    - if :wikipedia:`identity <Identity_element>` is not None, ``f(a, identity) == a``
-    - if :wikipedia:`distributes_over <Distributive_property>` is ``+``,
-      ``f(a, b) + f(a, c) == f(a, b+c)``
-
-    For example:
-
-    .. code-block:: python
-
-        ghostwriter.binary_operation(
-            operator.mul,
-            identity=1,
-            distributes_over=operator.add,
-            style="unittest",
-        )
-    """
-    if not callable(func):
-        raise InvalidArgument(f"Got non-callable func={func!r}")
-    except_ = _check_except(except_)
-    _check_style(style)
-    check_type(bool, associative, "associative")
-    check_type(bool, commutative, "commutative")
-    if distributes_over is not None and not callable(distributes_over):
-        raise InvalidArgument(
-            f"distributes_over={distributes_over!r} must be an operation which "
-            f"distributes over {func.__name__}"
-        )
-    if not any(associative, commutative, identity, distributes_over):
-        raise InvalidArgument(
-            "You must select at least one property of the binary operation to test."
-        )
-    imports, body = _make_binop_body(
-        func,
-        associative=associative,
-        commutative=commutative,
-        identity=identity,
-        distributes_over=distributes_over,
-        except_=except_,
-        style=style,
-    )
-    return _make_test(imports, body)
-
-
-def _make_binop_body(
-    func: CallableX, X, Y,
-    *,
-    associative: bool = True,
-    commutative: bool = True,
-    identity: UnionX, InferType, None = infer,
-    distributes_over: OptionalCallableX, X, X = None,
-    except_: TupleTypeException, ...,
-    style: str,
-) -> TupleImportSet, str:
-    strategies = _get_strategies(func)
-    operands, b = (strategies.pop(p) for p in list(_get_params(func)):2)
-    if repr(operands) != repr(b):
-        operands |= b
-    operands_name = func.__name__ + "_operands"
-
-    all_imports = set()
-    parts = 
-
-    def maker(
-        sub_property: str,
-        args: str,
-        body: str,
-        right: Optionalstr = None,
-    ) -> None:
-        if right is None:
-            assertions = ""
-        else:
-            body = f"{body}\n{right}"
-            assertions = _assert_eq(style, "left", "right")
-        imports, body = _make_test_body(
-            func,
-            test_body=body,
-            ghost=sub_property + "_binary_operation",
-            except_=except_,
-            assertions=assertions,
-            style=style,
-            given_strategies={**strategies, **{n: operands_name for n in args}},
-        )
-        all_imports.update(imports)
-        if style == "unittest":
-            endline = "(unittest.TestCase):\n"
-            body = bodybody.index(endline) + len(endline) + 1 :
-        parts.append(body)
-
-    if associative:
-        maker(
-            "associative",
-            "abc",
-            _write_call(
-                func,
-                "a",
-                _write_call(func, "b", "c", except_=Exception),
-                except_=Exception,
-                assign="left",
-            ),
-            _write_call(
-                func,
-                _write_call(func, "a", "b", except_=Exception),
-                "c",
-                except_=Exception,
-                assign="right",
-            ),
-        )
-    if commutative:
-        maker(
-            "commutative",
-            "ab",
-            _write_call(func, "a", "b", except_=Exception, assign="left"),
-            _write_call(func, "b", "a", except_=Exception, assign="right"),
-        )
-    if identity is not None:
-        # Guess that the identity element is the minimal example from our operands
-        # strategy.  This is correct often enough to be worthwhile, and close enough
-        # that it's a good starting point to edit much of the rest.
-        if identity is infer:
-            try:
-                identity = find(operands, lambda x: True, settings=_quietly_settings)
-            except Exception:
-                identity = "identity element here"  # type: ignore
-        # If the repr of this element is invalid Python, stringify it - this
-        # can't be executed as-is, but at least makes it clear what should
-        # happen.  E.g. type(None) -> <class 'NoneType'> -> quoted.
-        try:
-            # We don't actually execute this code object; we're just compiling
-            # to check that the repr is syntatically valid.  HOWEVER, we're
-            # going to output that code string into test code which will be
-            # executed; so you still shouldn't ghostwrite for hostile code.
-            compile(repr(identity), "<string>", "exec")
-        except SyntaxError:
-            identity = repr(identity)  # type: ignore
-        maker(
-            "identity",
-            "a",
-            _assert_eq(
-                style,
-                "a",
-                _write_call(func, "a", repr(identity), except_=Exception),
-            ),
-        )
-    if distributes_over:
-        maker(
-            distributes_over.__name__ + "_distributes_over",
-            "abc",
-            _write_call(
-                distributes_over,
-                _write_call(func, "a", "b", except_=Exception),
-                _write_call(func, "a", "c", except_=Exception),
-                except_=Exception,
-                assign="left",
-            ),
-            _write_call(
-                func,
-                "a",
-                _write_call(distributes_over, "b", "c", except_=Exception),
-                except_=Exception,
-                assign="right",
-            ),
-        )
-
-    _, operands_repr = _valid_syntax_repr(operands)
-    operands_repr = _st_strategy_names(operands_repr)
-    classdef = ""
-    if style == "unittest":
-        classdef = f"class TestBinaryOperation{func.__name__}(unittest.TestCase):\n    "
-    return (
-        all_imports,
-        classdef + f"{operands_name} = {operands_repr}\n" + "\n".join(parts),
-    )
-
-
-def ufunc(func: Callable, *, except_: Except = (), style: str = "pytest") -> str:
-    """Write a property-based test for the :doc:`array ufunc <numpy:reference/ufuncs>` ``func``.
-
-    The resulting test checks that your ufunc or :doc:`gufunc
-    <numpy:reference/c-api/generalized-ufuncs>` has the expected broadcasting and dtype casting
-    behaviour.  You will probably want to add extra assertions, but as with the other
-    ghostwriters this gives you a great place to start.
-
-    .. code-block:: shell
-
-        hypothesis write numpy.matmul
-    """
-    if not _is_probably_ufunc(func):
-        raise InvalidArgument(f"func={func!r} does not seem to be a ufunc")
-    except_ = _check_except(except_)
-    _check_style(style)
-    return _make_test(*_make_ufunc_body(func, except_=except_, style=style))
-
-
-def _make_ufunc_body(func, *, except_, style):
-
-    import hypothesis.extra.numpy as npst
-
-    if func.signature is None:
-        shapes = npst.mutually_broadcastable_shapes(num_shapes=func.nin)
-    else:
-        shapes = npst.mutually_broadcastable_shapes(signature=func.signature)
-    shapes.function.__module__ = npst.__name__
-
-    body = """
-    input_shapes, expected_shape = shapes
-    input_dtypes, expected_dtype = types.split("->")
-    array_strats = 
-        arrays(dtype=dtp, shape=shp, elements={{"allow_nan": True}})
-        for dtp, shp in zip(input_dtypes, input_shapes)
-    
-
-    {array_names} = data.draw(st.tuples(*array_strats))
-    result = {call}
-    """.format(
-        array_names=", ".join(ascii_lowercase: func.nin),
-        call=_write_call(func, *ascii_lowercase: func.nin, except_=except_),
-    )
-    assertions = "\n{shape_assert}\n{type_assert}".format(
-        shape_assert=_assert_eq(style, "result.shape", "expected_shape"),
-        type_assert=_assert_eq(style, "result.dtype.char", "expected_dtype"),
-    )
-
-    qname = _get_qualname(func, include_module=True)
-    obj_sigs = "O" in sig for sig in func.types
-    if all(obj_sigs) or not any(obj_sigs):
-        types = f"sampled_from({qname}.types)"
-    else:
-        types = f"sampled_from(sig for sig in {qname}.types if 'O' not in sig)"
-
-    return _make_test_body(
-        func,
-        test_body=dedent(body).strip(),
-        except_=except_,
-        assertions=assertions,
-        ghost="ufunc" if func.signature is None else "gufunc",
-        style=style,
-        given_strategies={"data": st.data(), "shapes": shapes, "types": types},
-        imports={("hypothesis.extra.numpy", "arrays")},
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/lark.py Deleted

@@ -1,237 +0,0 @@
-# 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/.
-
-"""
-----------------
-hypothesislark
-----------------
-
-This extra can be used to generate strings matching any context-free grammar,
-using the `Lark parser library <https://github.com/lark-parser/lark>`_.
-
-It currently only supports Lark's native EBNF syntax, but we plan to extend
-this to support other common syntaxes such as ANTLR and :rfc:`5234` ABNF.
-Lark already `supports loading grammars
-<https://lark-parser.readthedocs.io/en/latest/nearley.html>`_
-from `nearley.js <https://nearley.js.org/>`_, so you may not have to write
-your own at all.
-
-Note that as Lark is at version 0.x, this module *may* break API compatibility
-in minor releases if supporting the latest version of Lark would otherwise be
-infeasible.  We may also be quite aggressive in bumping the minimum version of
-Lark, unless someone volunteers to either fund or do the maintenance.
-"""
-
-from inspect import signature
-from typing import Dict, Optional
-
-import attr
-import lark
-from lark.grammar import NonTerminal, Terminal  # type: ignore
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture.utils import calc_label_from_name
-from hypothesis.internal.validation import check_type
-from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-
-__all__ = "from_lark"
-
-
-@attr.s()
-class DrawState:
-    """Tracks state of a single draw from a lark grammar.
-
-    Currently just wraps a list of tokens that will be emitted at the
-    end, but as we support more sophisticated parsers this will need
-    to track more state for e.g. indentation level.
-    """
-
-    # The text output so far as a list of string tokens resulting from
-    # each draw to a non-terminal.
-    result = attr.ib(default=attr.Factory(list))
-
-
-def get_terminal_names(terminals, rules, ignore_names):
-    """Get names of all terminals in the grammar.
-
-    The arguments are the results of calling ``Lark.grammar.compile()``,
-    so you would think that the ``terminals`` and ``ignore_names`` would
-    have it all... but they omit terminals created with ``@declare``,
-    which appear only in the expansion(s) of nonterminals.
-    """
-    names = {t.name for t in terminals} | set(ignore_names)
-    for rule in rules:
-        names |= {t.name for t in rule.expansion if isinstance(t, Terminal)}
-    return names
-
-
-class LarkStrategy(st.SearchStrategy):
-    """Low-level strategy implementation wrapping a Lark grammar.
-
-    See ``from_lark`` for details.
-    """
-
-    def __init__(self, grammar, start, explicit):
-        assert isinstance(grammar, lark.lark.Lark)
-        if start is None:
-            start = grammar.options.start
-        if not isinstance(start, list):
-            start = start
-        self.grammar = grammar
-
-        # This is a total hack, but working around the changes is a nicer user
-        # experience than breaking for anyone who doesn't instantly update their
-        # installation of Lark alongside Hypothesis.
-        compile_args = signature(grammar.grammar.compile).parameters
-        if "terminals_to_keep" in compile_args:
-            terminals, rules, ignore_names = grammar.grammar.compile(start, ())
-        elif "start" in compile_args:  # pragma: no cover
-            # Support lark <= 0.10.0, without the terminals_to_keep argument.
-            terminals, rules, ignore_names = grammar.grammar.compile(start)
-        else:  # pragma: no cover
-            # This branch is to support lark <= 0.7.1, without the start argument.
-            terminals, rules, ignore_names = grammar.grammar.compile()
-
-        self.names_to_symbols = {}
-
-        for r in rules:
-            t = r.origin
-            self.names_to_symbolst.name = t
-
-        for t in terminals:
-            self.names_to_symbolst.name = Terminal(t.name)
-
-        self.start = st.sampled_from(self.names_to_symbolss for s in start)
-
-        self.ignored_symbols = tuple(self.names_to_symbolsn for n in ignore_names)
-
-        self.terminal_strategies = {
-            t.name: st.from_regex(t.pattern.to_regexp(), fullmatch=True)
-            for t in terminals
-        }
-        unknown_explicit = set(explicit) - get_terminal_names(
-            terminals, rules, ignore_names
-        )
-        if unknown_explicit:
-            raise InvalidArgument(
-                "The following arguments were passed as explicit_strategies, "
-                "but there is no such terminal production in this grammar: "
-                + repr(sorted(unknown_explicit))
-            )
-        self.terminal_strategies.update(explicit)
-
-        nonterminals = {}
-
-        for rule in rules:
-            nonterminals.setdefault(rule.origin.name, ).append(tuple(rule.expansion))
-
-        for v in nonterminals.values():
-            v.sort(key=len)
-
-        self.nonterminal_strategies = {
-            k: st.sampled_from(v) for k, v in nonterminals.items()
-        }
-
-        self.__rule_labels = {}
-
-    def do_draw(self, data):
-        state = DrawState()
-        start = data.draw(self.start)
-        self.draw_symbol(data, start, state)
-        return "".join(state.result)
-
-    def rule_label(self, name):
-        try:
-            return self.__rule_labelsname
-        except KeyError:
-            return self.__rule_labels.setdefault(
-                name, calc_label_from_name(f"LARK:{name}")
-            )
-
-    def draw_symbol(self, data, symbol, draw_state):
-        if isinstance(symbol, Terminal):
-            try:
-                strategy = self.terminal_strategiessymbol.name
-            except KeyError:
-                raise InvalidArgument(
-                    "Undefined terminal %r. Generation does not currently support "
-                    "use of %%declare unless you pass `explicit`, a dict of "
-                    'names-to-strategies, such as `{%r: st.just("")}`'
-                    % (symbol.name, symbol.name)
-                ) from None
-            draw_state.result.append(data.draw(strategy))
-        else:
-            assert isinstance(symbol, NonTerminal)
-            data.start_example(self.rule_label(symbol.name))
-            expansion = data.draw(self.nonterminal_strategiessymbol.name)
-            for e in expansion:
-                self.draw_symbol(data, e, draw_state)
-                self.gen_ignore(data, draw_state)
-            data.stop_example()
-
-    def gen_ignore(self, data, draw_state):
-        if self.ignored_symbols and data.draw_bits(2) == 3:
-            emit = data.draw(st.sampled_from(self.ignored_symbols))
-            self.draw_symbol(data, emit, draw_state)
-
-    def calc_has_reusable_values(self, recur):
-        return True
-
-
-def check_explicit(name):
-    def inner(value):
-        check_type(str, value, "value drawn from " + name)
-        return value
-
-    return inner
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def from_lark(
-    grammar: lark.lark.Lark,
-    *,
-    start: Optionalstr = None,
-    explicit: OptionalDictstr, st.SearchStrategystr = None,
-) -> st.SearchStrategystr:
-    """A strategy for strings accepted by the given context-free grammar.
-
-    ``grammar`` must be a ``Lark`` object, which wraps an EBNF specification.
-    The Lark EBNF grammar reference can be found
-    `here <https://lark-parser.readthedocs.io/en/latest/grammar.html>`_.
-
-    ``from_lark`` will automatically generate strings matching the
-    nonterminal ``start`` symbol in the grammar, which was supplied as an
-    argument to the Lark class.  To generate strings matching a different
-    symbol, including terminals, you can override this by passing the
-    ``start`` argument to ``from_lark``.  Note that Lark may remove unreachable
-    productions when the grammar is compiled, so you should probably pass the
-    same value for ``start`` to both.
-
-    Currently ``from_lark`` does not support grammars that need custom lexing.
-    Any lexers will be ignored, and any undefined terminals from the use of
-    ``%declare`` will result in generation errors.  To define strategies for
-    such terminals, pass a dictionary mapping their name to a corresponding
-    strategy as the ``explicit`` argument.
-
-    The :pypi:`hypothesmith` project includes a strategy for Python source,
-    based on a grammar and careful post-processing.
-    """
-    check_type(lark.lark.Lark, grammar, "grammar")
-    if explicit is None:
-        explicit = {}
-    else:
-        check_type(dict, explicit, "explicit")
-        explicit = {
-            k: v.map(check_explicit(f"explicit{k!r}={v!r}"))
-            for k, v in explicit.items()
-        }
-    return LarkStrategy(grammar, start, explicit)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/numpy.py Deleted

@@ -1,943 +0,0 @@
-# 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 math
-from typing import Any, Mapping, Optional, Sequence, Tuple, Union
-
-import numpy as np
-
-from hypothesis import strategies as st
-from hypothesis._settings import note_deprecation
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra._array_helpers import (
-    NDIM_MAX,
-    BasicIndex,
-    BasicIndexStrategy,
-    BroadcastableShapes,
-    Shape,
-    array_shapes,
-    broadcastable_shapes,
-    check_argument,
-    check_valid_dims,
-    mutually_broadcastable_shapes as _mutually_broadcastable_shapes,
-    order_check,
-    valid_tuple_axes as _valid_tuple_axes,
-)
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.coverage import check_function
-from hypothesis.internal.reflection import proxies
-from hypothesis.internal.validation import check_type
-from hypothesis.strategies._internal.strategies import T, check_strategy
-from hypothesis.strategies._internal.utils import defines_strategy
-
-__all__ = 
-    "BroadcastableShapes",
-    "from_dtype",
-    "arrays",
-    "array_shapes",
-    "scalar_dtypes",
-    "boolean_dtypes",
-    "unsigned_integer_dtypes",
-    "integer_dtypes",
-    "floating_dtypes",
-    "complex_number_dtypes",
-    "datetime64_dtypes",
-    "timedelta64_dtypes",
-    "byte_string_dtypes",
-    "unicode_string_dtypes",
-    "array_dtypes",
-    "nested_dtypes",
-    "valid_tuple_axes",
-    "broadcastable_shapes",
-    "mutually_broadcastable_shapes",
-    "basic_indices",
-    "integer_array_indices",
-
-
-TIME_RESOLUTIONS = tuple("Y  M  D  h  m  s  ms  us  ns  ps  fs  as".split())
-
-
-@defines_strategy(force_reusable_values=True)
-def from_dtype(
-    dtype: np.dtype,
-    *,
-    alphabet: Optionalst.SearchStrategystr = None,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-    min_value: Unionint, float, None = None,
-    max_value: Unionint, float, None = None,
-    allow_nan: Optionalbool = None,
-    allow_infinity: Optionalbool = None,
-    allow_subnormal: Optionalbool = None,
-    exclude_min: Optionalbool = None,
-    exclude_max: Optionalbool = None,
-) -> st.SearchStrategyAny:
-    """Creates a strategy which can generate any value of the given dtype.
-
-    Compatible ``**kwargs`` are passed to the inferred strategy function for
-    integers, floats, and strings.  This allows you to customise the min and max
-    values, control the length or contents of strings, or exclude non-finite
-    numbers.  This is particularly useful when kwargs are passed through from
-    :func:`arrays` which allow a variety of numeric dtypes, as it seamlessly
-    handles the ``width`` or representable bounds for you.  See :issue:`2552`
-    for more detail.
-    """
-    check_type(np.dtype, dtype, "dtype")
-    kwargs = {k: v for k, v in locals().items() if k != "dtype" and v is not None}
-
-    # Compound datatypes, eg 'f4,f4,f4'
-    if dtype.names is not None:
-        # mapping np.void.type over a strategy is nonsense, so return now.
-        subs = from_dtype(dtype.fieldsname0, **kwargs) for name in dtype.names
-        return st.tuples(*subs)
-
-    # Subarray datatypes, eg '(2, 3)i4'
-    if dtype.subdtype is not None:
-        subtype, shape = dtype.subdtype
-        return arrays(subtype, shape, elements=kwargs)
-
-    def compat_kw(*args, **kw):
-        """Update default args to the strategy with user-supplied keyword args."""
-        assert {"min_value", "max_value", "max_size"}.issuperset(kw)
-        for key in set(kwargs).intersection(kw):
-            msg = f"dtype {dtype!r} requires {key}={kwargskey!r} to be %s {kwkey!r}"
-            if kwkey is not None:
-                if key.startswith("min_") and kwkey > kwargskey:
-                    raise InvalidArgument(msg % ("at least",))
-                elif key.startswith("max_") and kwkey < kwargskey:
-                    raise InvalidArgument(msg % ("at most",))
-        kw.update({k: v for k, v in kwargs.items() if k in args or k in kw})
-        return kw
-
-    # Scalar datatypes
-    if dtype.kind == "b":
-        result: st.SearchStrategyAny = st.booleans()
-    elif dtype.kind == "f":
-        result = st.floats(
-            width=min(8 * dtype.itemsize, 64),
-            **compat_kw(
-                "min_value",
-                "max_value",
-                "allow_nan",
-                "allow_infinity",
-                "allow_subnormal",
-                "exclude_min",
-                "exclude_max",
-            ),
-        )
-    elif dtype.kind == "c":
-        # If anyone wants to add a `width` argument to `complex_numbers()`, we would
-        # accept a pull request and add passthrough support for magnitude bounds,
-        # but it's a low priority otherwise.
-        if dtype.itemsize == 8:
-            float32 = st.floats(width=32, **compat_kw("allow_nan", "allow_infinity"))
-            result = st.builds(complex, float32, float32)
-        else:
-            result = st.complex_numbers(**compat_kw("allow_nan", "allow_infinity"))
-    elif dtype.kind in ("S", "a"):
-        # Numpy strings are null-terminated; only allow round-trippable values.
-        # `itemsize == 0` means 'fixed length determined at array creation'
-        max_size = dtype.itemsize or None
-        result = st.binary(**compat_kw("min_size", max_size=max_size)).filter(
-            lambda b: b-1: != b"\0"
-        )
-    elif dtype.kind == "u":
-        kw = compat_kw(min_value=0, max_value=2 ** (8 * dtype.itemsize) - 1)
-        result = st.integers(**kw)
-    elif dtype.kind == "i":
-        overflow = 2 ** (8 * dtype.itemsize - 1)
-        result = st.integers(**compat_kw(min_value=-overflow, max_value=overflow - 1))
-    elif dtype.kind == "U":
-        # Encoded in UTF-32 (four bytes/codepoint) and null-terminated
-        max_size = (dtype.itemsize or 0) // 4 or None
-        result = st.text(**compat_kw("alphabet", "min_size", max_size=max_size)).filter(
-            lambda b: b-1: != "\0"
-        )
-    elif dtype.kind in ("m", "M"):
-        if "" in dtype.str:
-            res = st.just(dtype.str.split("")-1:-1)
-        else:
-            # Note that this case isn't valid to pass to arrays(), but we support
-            # it here because we'd have to guard against equivalents in arrays()
-            # regardless and drawing scalars is a valid use-case.
-            res = st.sampled_from(TIME_RESOLUTIONS)
-        result = st.builds(dtype.type, st.integers(-(2**63), 2**63 - 1), res)
-    else:
-        raise InvalidArgument(f"No strategy inference for {dtype}")
-    return result.map(dtype.type)
-
-
-class ArrayStrategy(st.SearchStrategy):
-    def __init__(self, element_strategy, shape, dtype, fill, unique):
-        self.shape = tuple(shape)
-        self.fill = fill
-        self.array_size = int(np.prod(shape))
-        self.dtype = dtype
-        self.element_strategy = element_strategy
-        self.unique = unique
-        self._check_elements = dtype.kind not in ("O", "V")
-
-    def set_element(self, val, result, idx, *, fill=False):
-        try:
-            resultidx = val
-        except TypeError as err:
-            raise InvalidArgument(
-                f"Could not add element={val!r} of {val.dtype!r} to array of "
-                f"{result.dtype!r} - possible mismatch of time units in dtypes?"
-            ) from err
-        if self._check_elements and val != resultidx and val == val:
-            strategy = self.fill if fill else self.element_strategy
-            if self.dtype.kind == "f":
-                try:
-                    is_subnormal = 0 < abs(val) < np.finfo(self.dtype).tiny
-                except Exception:  # pragma: no cover
-                    # val may be a non-float that does not support the
-                    # operations __lt__ and __abs__
-                    is_subnormal = False  # pragma: no cover
-                if is_subnormal:
-                    raise InvalidArgument(  # pragma: no cover
-                        f"Generated subnormal float {val} from strategy "
-                        f"{strategy} resulted in {resultidx!r}, probably "
-                        "as a result of NumPy being built with flush-to-zero "
-                        "compiler options. Consider passing "
-                        "allow_subnormal=False."
-                    )
-            raise InvalidArgument(
-                "Generated array element %r from %r cannot be represented as "
-                "dtype %r - instead it becomes %r (type %r).  Consider using a more "
-                "precise strategy, for example passing the `width` argument to "
-                "`floats()`."
-                % (val, strategy, self.dtype, resultidx, type(resultidx))
-            )
-
-    def do_draw(self, data):
-        if 0 in self.shape:
-            return np.zeros(dtype=self.dtype, shape=self.shape)
-
-        # Because Numpy allocates memory for strings at array creation, if we have
-        # an unsized string dtype we'll fill an object array and then cast it back.
-        unsized_string_dtype = (
-            self.dtype.kind in ("S", "a", "U") and self.dtype.itemsize == 0
-        )
-
-        # This could legitimately be a np.empty, but the performance gains for
-        # that would be so marginal that there's really not much point risking
-        # undefined behaviour shenanigans.
-        result = np.zeros(
-            shape=self.array_size, dtype=object if unsized_string_dtype else self.dtype
-        )
-
-        if self.fill.is_empty:
-            # We have no fill value (either because the user explicitly
-            # disabled it or because the default behaviour was used and our
-            # elements strategy does not produce reusable values), so we must
-            # generate a fully dense array with a freshly drawn value for each
-            # entry.
-            if self.unique:
-                elems = st.lists(
-                    self.element_strategy,
-                    min_size=self.array_size,
-                    max_size=self.array_size,
-                    unique=True,
-                )
-                for i, v in enumerate(data.draw(elems)):
-                    self.set_element(v, result, i)
-            else:
-                for i in range(len(result)):
-                    self.set_element(data.draw(self.element_strategy), result, i)
-        else:
-            # We draw numpy arrays as "sparse with an offset". We draw a
-            # collection of index assignments within the array and assign
-            # fresh values from our elements strategy to those indices. If at
-            # the end we have not assigned every element then we draw a single
-            # value from our fill strategy and use that to populate the
-            # remaining positions with that strategy.
-
-            elements = cu.many(
-                data,
-                min_size=0,
-                max_size=self.array_size,
-                # sqrt isn't chosen for any particularly principled reason. It
-                # just grows reasonably quickly but sublinearly, and for small
-                # arrays it represents a decent fraction of the array size.
-                average_size=min(
-                    0.9 * self.array_size,  # ensure small arrays sometimes use fill
-                    max(10, math.sqrt(self.array_size)),  # ...but *only* sometimes
-                ),
-            )
-
-            needs_fill = np.full(self.array_size, True)
-            seen = set()
-
-            while elements.more():
-                i = cu.integer_range(data, 0, self.array_size - 1)
-                if not needs_filli:
-                    elements.reject()
-                    continue
-                self.set_element(data.draw(self.element_strategy), result, i)
-                if self.unique:
-                    if resulti in seen:
-                        elements.reject()
-                        continue
-                    else:
-                        seen.add(resulti)
-                needs_filli = False
-            if needs_fill.any():
-                # We didn't fill all of the indices in the early loop, so we
-                # put a fill value into the rest.
-
-                # We have to do this hilarious little song and dance to work
-                # around numpy's special handling of iterable values. If the
-                # value here were e.g. a tuple then neither array creation
-                # nor putmask would do the right thing. But by creating an
-                # array of size one and then assigning the fill value as a
-                # single element, we both get an array with the right value in
-                # it and putmask will do the right thing by repeating the
-                # values of the array across the mask.
-                one_element = np.zeros(
-                    shape=1, dtype=object if unsized_string_dtype else self.dtype
-                )
-                self.set_element(data.draw(self.fill), one_element, 0, fill=True)
-                if unsized_string_dtype:
-                    one_element = one_element.astype(self.dtype)
-                fill_value = one_element0
-                if self.unique:
-                    try:
-                        is_nan = np.isnan(fill_value)
-                    except TypeError:
-                        is_nan = False
-
-                    if not is_nan:
-                        raise InvalidArgument(
-                            f"Cannot fill unique array with non-NaN value {fill_value!r}"
-                        )
-
-                np.putmask(result, needs_fill, one_element)
-
-        if unsized_string_dtype:
-            out = result.astype(self.dtype)
-            mismatch = out != result
-            if mismatch.any():
-                raise InvalidArgument(
-                    "Array elements %r cannot be represented as dtype %r - instead "
-                    "they become %r.  Use a more precise strategy, e.g. without "
-                    "trailing null bytes, as this will be an error future versions."
-                    % (resultmismatch, self.dtype, outmismatch)
-                )
-            result = out
-
-        result = result.reshape(self.shape).copy()
-
-        assert result.base is None
-
-        return result
-
-
-@check_function
-def fill_for(elements, unique, fill, name=""):
-    if fill is None:
-        if unique or not elements.has_reusable_values:
-            fill = st.nothing()
-        else:
-            fill = elements
-    else:
-        check_strategy(fill, f"{name}.fill" if name else "fill")
-    return fill
-
-
-@defines_strategy(force_reusable_values=True)
-def arrays(
-    dtype: Any,
-    shape: Unionint, st.SearchStrategyint, Shape, st.SearchStrategyShape,
-    *,
-    elements: OptionalUnionst.SearchStrategy, Mappingstr, Any = None,
-    fill: Optionalst.SearchStrategyAny = None,
-    unique: bool = False,
-) -> st.SearchStrategynp.ndarray:
-    r"""Returns a strategy for generating :class:`numpy:numpy.ndarray`\ s.
-
-    * ``dtype`` may be any valid input to :class:`~numpy:numpy.dtype`
-      (this includes :class:`~numpy:numpy.dtype` objects), or a strategy that
-      generates such values.
-    * ``shape`` may be an integer >= 0, a tuple of such integers, or a
-      strategy that generates such values.
-    * ``elements`` is a strategy for generating values to put in the array.
-      If it is None a suitable value will be inferred based on the dtype,
-      which may give any legal value (including eg NaN for floats).
-      If a mapping, it will be passed as ``**kwargs`` to ``from_dtype()``
-    * ``fill`` is a strategy that may be used to generate a single background
-      value for the array. If None, a suitable default will be inferred
-      based on the other arguments. If set to
-      :func:`~hypothesis.strategies.nothing` then filling
-      behaviour will be disabled entirely and every element will be generated
-      independently.
-    * ``unique`` specifies if the elements of the array should all be
-      distinct from one another. Note that in this case multiple NaN values
-      may still be allowed. If fill is also set, the only valid values for
-      it to return are NaN values (anything for which :obj:`numpy:numpy.isnan`
-      returns True. So e.g. for complex numbers ``nan+1j`` is also a valid fill).
-      Note that if ``unique`` is set to ``True`` the generated values must be
-      hashable.
-
-    Arrays of specified ``dtype`` and ``shape`` are generated for example
-    like this:
-
-    .. code-block:: pycon
-
-      >>> import numpy as np
-      >>> from hypothesis import strategies as st
-      >>> arrays(np.int8, (2, 3)).example()
-      array(-8,  6,  3,
-             -6,  4,  6, dtype=int8)
-      >>> arrays(np.float, 3, elements=st.floats(0, 1)).example()
-      array( 0.88974794,  0.77387938,  0.1977879 )
-
-    Array values are generated in two parts:
-
-    1. Some subset of the coordinates of the array are populated with a value
-       drawn from the elements strategy (or its inferred form).
-    2. If any coordinates were not assigned in the previous step, a single
-       value is drawn from the ``fill`` strategy and is assigned to all remaining
-       places.
-
-    You can set :func:`fill=nothing() <hypothesis.strategies.nothing>` to
-    disable this behaviour and draw a value for every element.
-
-    If ``fill=None``, then it will attempt to infer the correct behaviour
-    automatically. If ``unique`` is ``True``, no filling will occur by default.
-    Otherwise, if it looks safe to reuse the values of elements across
-    multiple coordinates (this will be the case for any inferred strategy, and
-    for most of the builtins, but is not the case for mutable values or
-    strategies built with flatmap, map, composite, etc) then it will use the
-    elements strategy as the fill, else it will default to having no fill.
-
-    Having a fill helps Hypothesis craft high quality examples, but its
-    main importance is when the array generated is large: Hypothesis is
-    primarily designed around testing small examples. If you have arrays with
-    hundreds or more elements, having a fill value is essential if you want
-    your tests to run in reasonable time.
-    """
-    # We support passing strategies as arguments for convenience, or at least
-    # for legacy reasons, but don't want to pay the perf cost of a composite
-    # strategy (i.e. repeated argument handling and validation) when it's not
-    # needed.  So we get the best of both worlds by recursing with flatmap,
-    # but only when it's actually needed.
-    if isinstance(dtype, st.SearchStrategy):
-        return dtype.flatmap(
-            lambda d: arrays(d, shape, elements=elements, fill=fill, unique=unique)
-        )
-    if isinstance(shape, st.SearchStrategy):
-        return shape.flatmap(
-            lambda s: arrays(dtype, s, elements=elements, fill=fill, unique=unique)
-        )
-    # From here on, we're only dealing with values and it's relatively simple.
-    dtype = np.dtype(dtype)
-    if elements is None or isinstance(elements, Mapping):
-        if dtype.kind in ("m", "M") and "" not in dtype.str:
-            # For datetime and timedelta dtypes, we have a tricky situation -
-            # because they *may or may not* specify a unit as part of the dtype.
-            # If not, we flatmap over the various resolutions so that array
-            # elements have consistent units but units may vary between arrays.
-            return (
-                st.sampled_from(TIME_RESOLUTIONS)
-                .map((dtype.str + "{}").format)
-                .flatmap(lambda d: arrays(d, shape=shape, fill=fill, unique=unique))
-            )
-        elements = from_dtype(dtype, **(elements or {}))
-    check_strategy(elements, "elements")
-    if isinstance(shape, int):
-        shape = (shape,)
-    shape = tuple(shape)
-    check_argument(
-        all(isinstance(s, int) for s in shape),
-        "Array shape must be integer in each dimension, provided shape was {}",
-        shape,
-    )
-    fill = fill_for(elements=elements, unique=unique, fill=fill)
-    return ArrayStrategy(elements, shape, dtype, fill, unique)
-
-
-@defines_strategy()
-def scalar_dtypes() -> st.SearchStrategynp.dtype:
-    """Return a strategy that can return any non-flexible scalar dtype."""
-    return st.one_of(
-        boolean_dtypes(),
-        integer_dtypes(),
-        unsigned_integer_dtypes(),
-        floating_dtypes(),
-        complex_number_dtypes(),
-        datetime64_dtypes(),
-        timedelta64_dtypes(),
-    )
-
-
-def defines_dtype_strategy(strat: T) -> T:
-    @defines_strategy()
-    @proxies(strat)
-    def inner(*args, **kwargs):
-        return strat(*args, **kwargs).map(np.dtype)
-
-    return inner
-
-
-@defines_dtype_strategy
-def boolean_dtypes() -> st.SearchStrategynp.dtype:
-    return st.just("?")
-
-
-def dtype_factory(kind, sizes, valid_sizes, endianness):
-    # Utility function, shared logic for most integer and string types
-    valid_endian = ("?", "<", "=", ">")
-    check_argument(
-        endianness in valid_endian,
-        "Unknown endianness: was {}, must be in {}",
-        endianness,
-        valid_endian,
-    )
-    if valid_sizes is not None:
-        if isinstance(sizes, int):
-            sizes = (sizes,)
-        check_argument(sizes, "Dtype must have at least one possible size.")
-        check_argument(
-            all(s in valid_sizes for s in sizes),
-            "Invalid sizes: was {} must be an item or sequence in {}",
-            sizes,
-            valid_sizes,
-        )
-        if all(isinstance(s, int) for s in sizes):
-            sizes = sorted({s // 8 for s in sizes})
-    strat = st.sampled_from(sizes)
-    if "{}" not in kind:
-        kind += "{}"
-    if endianness == "?":
-        return strat.map(("<" + kind).format) | strat.map((">" + kind).format)
-    return strat.map((endianness + kind).format)
-
-
-@defines_dtype_strategy
-def unsigned_integer_dtypes(
-    *, endianness: str = "?", sizes: Sequenceint = (8, 16, 32, 64)
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for unsigned integer dtypes.
-
-    endianness may be ``<`` for little-endian, ``>`` for big-endian,
-    ``=`` for native byte order, or ``?`` to allow either byte order.
-    This argument only applies to dtypes of more than one byte.
-
-    sizes must be a collection of integer sizes in bits.  The default
-    (8, 16, 32, 64) covers the full range of sizes.
-    """
-    return dtype_factory("u", sizes, (8, 16, 32, 64), endianness)
-
-
-@defines_dtype_strategy
-def integer_dtypes(
-    *, endianness: str = "?", sizes: Sequenceint = (8, 16, 32, 64)
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for signed integer dtypes.
-
-    endianness and sizes are treated as for
-    :func:`unsigned_integer_dtypes`.
-    """
-    return dtype_factory("i", sizes, (8, 16, 32, 64), endianness)
-
-
-@defines_dtype_strategy
-def floating_dtypes(
-    *, endianness: str = "?", sizes: Sequenceint = (16, 32, 64)
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for floating-point dtypes.
-
-    sizes is the size in bits of floating-point number.  Some machines support
-    96- or 128-bit floats, but these are not generated by default.
-
-    Larger floats (96 and 128 bit real parts) are not supported on all
-    platforms and therefore disabled by default.  To generate these dtypes,
-    include these values in the sizes argument.
-    """
-    return dtype_factory("f", sizes, (16, 32, 64, 96, 128), endianness)
-
-
-@defines_dtype_strategy
-def complex_number_dtypes(
-    *, endianness: str = "?", sizes: Sequenceint = (64, 128)
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for complex-number dtypes.
-
-    sizes is the total size in bits of a complex number, which consists
-    of two floats.  Complex halves (a 16-bit real part) are not supported
-    by numpy and will not be generated by this strategy.
-    """
-    return dtype_factory("c", sizes, (64, 128, 192, 256), endianness)
-
-
-@check_function
-def validate_time_slice(max_period, min_period):
-    check_argument(
-        max_period in TIME_RESOLUTIONS,
-        "max_period {} must be a valid resolution in {}",
-        max_period,
-        TIME_RESOLUTIONS,
-    )
-    check_argument(
-        min_period in TIME_RESOLUTIONS,
-        "min_period {} must be a valid resolution in {}",
-        min_period,
-        TIME_RESOLUTIONS,
-    )
-    start = TIME_RESOLUTIONS.index(max_period)
-    end = TIME_RESOLUTIONS.index(min_period) + 1
-    check_argument(
-        start < end,
-        "max_period {} must be earlier in sequence {} than min_period {}",
-        max_period,
-        TIME_RESOLUTIONS,
-        min_period,
-    )
-    return TIME_RESOLUTIONSstart:end
-
-
-@defines_dtype_strategy
-def datetime64_dtypes(
-    *, max_period: str = "Y", min_period: str = "ns", endianness: str = "?"
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for datetime64 dtypes, with various precisions from
-    year to attosecond."""
-    return dtype_factory(
-        "datetime64{}",
-        validate_time_slice(max_period, min_period),
-        TIME_RESOLUTIONS,
-        endianness,
-    )
-
-
-@defines_dtype_strategy
-def timedelta64_dtypes(
-    *, max_period: str = "Y", min_period: str = "ns", endianness: str = "?"
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for timedelta64 dtypes, with various precisions from
-    year to attosecond."""
-    return dtype_factory(
-        "timedelta64{}",
-        validate_time_slice(max_period, min_period),
-        TIME_RESOLUTIONS,
-        endianness,
-    )
-
-
-@defines_dtype_strategy
-def byte_string_dtypes(
-    *, endianness: str = "?", min_len: int = 1, max_len: int = 16
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for generating bytestring dtypes, of various lengths
-    and byteorder.
-
-    While Hypothesis' string strategies can generate empty strings, string
-    dtypes with length 0 indicate that size is still to be determined, so
-    the minimum length for string dtypes is 1.
-    """
-    order_check("len", 1, min_len, max_len)
-    return dtype_factory("S", list(range(min_len, max_len + 1)), None, endianness)
-
-
-@defines_dtype_strategy
-def unicode_string_dtypes(
-    *, endianness: str = "?", min_len: int = 1, max_len: int = 16
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for generating unicode string dtypes, of various
-    lengths and byteorder.
-
-    While Hypothesis' string strategies can generate empty strings, string
-    dtypes with length 0 indicate that size is still to be determined, so
-    the minimum length for string dtypes is 1.
-    """
-    order_check("len", 1, min_len, max_len)
-    return dtype_factory("U", list(range(min_len, max_len + 1)), None, endianness)
-
-
-def _no_title_is_name_of_a_titled_field(ls):
-    seen = set()
-    for title_and_name, *_ in ls:
-        if isinstance(title_and_name, tuple):
-            if seen.intersection(title_and_name):  # pragma: no cover
-                # Our per-element filters below make this as rare as possible,
-                # so it's not always covered.
-                return False
-            seen.update(title_and_name)
-    return True
-
-
-@defines_dtype_strategy
-def array_dtypes(
-    subtype_strategy: st.SearchStrategynp.dtype = scalar_dtypes(),
-    *,
-    min_size: int = 1,
-    max_size: int = 5,
-    allow_subarrays: bool = False,
-) -> st.SearchStrategynp.dtype:
-    """Return a strategy for generating array (compound) dtypes, with members
-    drawn from the given subtype strategy."""
-    order_check("size", 0, min_size, max_size)
-    # The empty string is replaced by f{idx}; see #1963 for details.  Much easier to
-    # insist that field names be unique and just boost f{idx} strings manually.
-    field_names = st.integers(0, 127).map("f{}".format) | st.text(min_size=1)
-    name_titles = st.one_of(
-        field_names,
-        st.tuples(field_names, field_names).filter(lambda ns: ns0 != ns1),
-    )
-    elements = st.tuples(name_titles, subtype_strategy)
-    if allow_subarrays:
-        elements |= st.tuples(
-            name_titles, subtype_strategy, array_shapes(max_dims=2, max_side=2)
-        )
-    return st.lists(
-        elements=elements,
-        min_size=min_size,
-        max_size=max_size,
-        unique_by=(
-            # Deduplicate by both name and title for efficiency before filtering.
-            # (Field names must be unique, as must titles, and no intersections)
-            lambda d: d0 if isinstance(d0, str) else d00,
-            lambda d: d0 if isinstance(d0, str) else d01,
-        ),
-    ).filter(_no_title_is_name_of_a_titled_field)
-
-
-@defines_strategy()
-def nested_dtypes(
-    subtype_strategy: st.SearchStrategynp.dtype = scalar_dtypes(),
-    *,
-    max_leaves: int = 10,
-    max_itemsize: Optionalint = None,
-) -> st.SearchStrategynp.dtype:
-    """Return the most-general dtype strategy.
-
-    Elements drawn from this strategy may be simple (from the
-    subtype_strategy), or several such values drawn from
-    :func:`array_dtypes` with ``allow_subarrays=True``. Subdtypes in an
-    array dtype may be nested to any depth, subject to the max_leaves
-    argument.
-    """
-    return st.recursive(
-        subtype_strategy,
-        lambda x: array_dtypes(x, allow_subarrays=True),
-        max_leaves=max_leaves,
-    ).filter(lambda d: max_itemsize is None or d.itemsize <= max_itemsize)
-
-
-@proxies(_valid_tuple_axes)
-def valid_tuple_axes(*args, **kwargs):
-    return _valid_tuple_axes(*args, **kwargs)
-
-
-valid_tuple_axes.__doc__ = f"""
-    Return a strategy for generating permissible tuple-values for the
-    ``axis`` argument for a numpy sequential function (e.g.
-    :func:`numpy:numpy.sum`), given an array of the specified
-    dimensionality.
-
-    {_valid_tuple_axes.__doc__}
-    """
-
-
-@proxies(_mutually_broadcastable_shapes)
-def mutually_broadcastable_shapes(*args, **kwargs):
-    return _mutually_broadcastable_shapes(*args, **kwargs)
-
-
-mutually_broadcastable_shapes.__doc__ = f"""
-    {_mutually_broadcastable_shapes.__doc__}
-
-    **Use with Generalised Universal Function signatures**
-
-    A :doc:`universal function <numpy:reference/ufuncs>` (or ufunc for short) is a function
-    that operates on ndarrays in an element-by-element fashion, supporting array
-    broadcasting, type casting, and several other standard features.
-    A :doc:`generalised ufunc <numpy:reference/c-api/generalized-ufuncs>` operates on
-    sub-arrays rather than elements, based on the "signature" of the function.
-    Compare e.g. :obj:`numpy.add() <numpy:numpy.add>` (ufunc) to
-    :obj:`numpy.matmul() <numpy:numpy.matmul>` (gufunc).
-
-    To generate shapes for a gufunc, you can pass the ``signature`` argument instead of
-    ``num_shapes``.  This must be a gufunc signature string; which you can write by
-    hand or access as e.g. ``np.matmul.signature`` on generalised ufuncs.
-
-    In this case, the ``side`` arguments are applied to the 'core dimensions' as well,
-    ignoring any frozen dimensions.  ``base_shape``  and the ``dims`` arguments are
-    applied to the 'loop dimensions', and if necessary, the dimensionality of each
-    shape is silently capped to respect the 32-dimension limit.
-
-    The generated ``result_shape`` is the real result shape of applying the gufunc
-    to arrays of the generated ``input_shapes``, even where this is different to
-    broadcasting the loop dimensions.
-
-    gufunc-compatible shapes shrink their loop dimensions as above, towards omitting
-    optional core dimensions, and smaller-size core dimensions.
-
-    .. code-block:: pycon
-
-        >>> # np.matmul.signature == "(m?,n),(n,p?)->(m?,p?)"
-        >>> for _ in range(3):
-        ...     mutually_broadcastable_shapes(signature=np.matmul.signature).example()
-        BroadcastableShapes(input_shapes=((2,), (2,)), result_shape=())
-        BroadcastableShapes(input_shapes=((3, 4, 2), (1, 2)), result_shape=(3, 4))
-        BroadcastableShapes(input_shapes=((4, 2), (1, 2, 3)), result_shape=(4, 3))
-
-    """
-
-
-@defines_strategy()
-def basic_indices(
-    shape: Shape,
-    *,
-    min_dims: int = 0,
-    max_dims: Optionalint = None,
-    allow_newaxis: bool = False,
-    allow_ellipsis: bool = True,
-) -> st.SearchStrategyBasicIndex:
-    """Return a strategy for :doc:`basic indexes <numpy:reference/arrays.indexing>` of
-    arrays with the specified shape, which may include dimensions of size zero.
-
-    It generates tuples containing some mix of integers, :obj:`python:slice`
-    objects, ``...`` (an ``Ellipsis``), and ``None``. When a length-one tuple
-    would be generated, this strategy may instead return the element which will
-    index the first axis, e.g. ``5`` instead of ``(5,)``.
-
-    * ``shape`` is the shape of the array that will be indexed, as a tuple of
-      positive integers. This must be at least two-dimensional for a tuple to be
-      a valid index; for one-dimensional arrays use
-      :func:`~hypothesis.strategies.slices` instead.
-    * ``min_dims`` is the minimum dimensionality of the resulting array from use
-      of the generated index. When ``min_dims == 0``, scalars and zero-dimensional
-      arrays are both allowed.
-    * ``max_dims`` is the the maximum dimensionality of the resulting array,
-      defaulting to ``len(shape) if not allow_newaxis else
-      max(len(shape), min_dims) + 2``.
-    * ``allow_newaxis`` specifies whether ``None`` is allowed in the index.
-    * ``allow_ellipsis`` specifies whether ``...`` is allowed in the index.
-    """
-    # Arguments to exclude scalars, zero-dim arrays, and dims of size zero were
-    # all considered and rejected.  We want users to explicitly consider those
-    # cases if they're dealing in general indexers, and while it's fiddly we can
-    # back-compatibly add them later (hence using kwonlyargs).
-    check_type(tuple, shape, "shape")
-    check_argument(
-        all(isinstance(x, int) and x >= 0 for x in shape),
-        f"shape={shape!r}, but all dimensions must be non-negative integers.",
-    )
-    check_type(bool, allow_ellipsis, "allow_ellipsis")
-    check_type(bool, allow_newaxis, "allow_newaxis")
-    check_type(int, min_dims, "min_dims")
-    if min_dims > len(shape) and not allow_newaxis:
-        note_deprecation(
-            f"min_dims={min_dims} is larger than len(shape)={len(shape)}, "
-            "but allow_newaxis=False makes it impossible for an indexing "
-            "operation to add dimensions.",
-            since="2021-09-15",
-            has_codemod=False,
-        )
-    check_valid_dims(min_dims, "min_dims")
-
-    if max_dims is None:
-        if allow_newaxis:
-            max_dims = min(max(len(shape), min_dims) + 2, NDIM_MAX)
-        else:
-            max_dims = min(len(shape), NDIM_MAX)
-    else:
-        check_type(int, max_dims, "max_dims")
-        if max_dims > len(shape) and not allow_newaxis:
-            note_deprecation(
-                f"max_dims={max_dims} is larger than len(shape)={len(shape)}, "
-                "but allow_newaxis=False makes it impossible for an indexing "
-                "operation to add dimensions.",
-                since="2021-09-15",
-                has_codemod=False,
-            )
-    check_valid_dims(max_dims, "max_dims")
-
-    order_check("dims", 0, min_dims, max_dims)
-
-    return BasicIndexStrategy(
-        shape,
-        min_dims=min_dims,
-        max_dims=max_dims,
-        allow_ellipsis=allow_ellipsis,
-        allow_newaxis=allow_newaxis,
-        allow_fewer_indices_than_dims=True,
-    )
-
-
-@defines_strategy()
-def integer_array_indices(
-    shape: Shape,
-    *,
-    result_shape: st.SearchStrategyShape = array_shapes(),
-    dtype: np.dtype = "int",
-) -> st.SearchStrategyTuplenp.ndarray, ...:
-    """Return a search strategy for tuples of integer-arrays that, when used
-    to index into an array of shape ``shape``, given an array whose shape
-    was drawn from ``result_shape``.
-
-    Examples from this strategy shrink towards the tuple of index-arrays::
-
-        len(shape) * (np.zeros(drawn_result_shape, dtype), )
-
-    * ``shape`` a tuple of integers that indicates the shape of the array,
-      whose indices are being generated.
-    * ``result_shape`` a strategy for generating tuples of integers, which
-      describe the shape of the resulting index arrays. The default is
-      :func:`~hypothesis.extra.numpy.array_shapes`.  The shape drawn from
-      this strategy determines the shape of the array that will be produced
-      when the corresponding example from ``integer_array_indices`` is used
-      as an index.
-    * ``dtype`` the integer data type of the generated index-arrays. Negative
-      integer indices can be generated if a signed integer type is specified.
-
-    Recall that an array can be indexed using a tuple of integer-arrays to
-    access its members in an arbitrary order, producing an array with an
-    arbitrary shape. For example:
-
-    .. code-block:: pycon
-
-        >>> from numpy import array
-        >>> x = array(-0, -1, -2, -3, -4)
-        >>> ind = (array(4, 0, 0, 1),)  # a tuple containing a 2D integer-array
-        >>> xind  # the resulting array is commensurate with the indexing array(s)
-        array(-4,  0,
-               0, -1)
-
-    Note that this strategy does not accommodate all variations of so-called
-    'advanced indexing', as prescribed by NumPy's nomenclature.  Combinations
-    of basic and advanced indexes are too complex to usefully define in a
-    standard strategy; we leave application-specific strategies to the user.
-    Advanced-boolean indexing can be defined as ``arrays(shape=..., dtype=bool)``,
-    and is similarly left to the user.
-    """
-    check_type(tuple, shape, "shape")
-    check_argument(
-        shape and all(isinstance(x, int) and x > 0 for x in shape),
-        f"shape={shape!r} must be a non-empty tuple of integers > 0",
-    )
-    check_strategy(result_shape, "result_shape")
-    check_argument(
-        np.issubdtype(dtype, np.integer), f"dtype={dtype!r} must be an integer dtype"
-    )
-    signed = np.issubdtype(dtype, np.signedinteger)
-
-    def array_for(index_shape, size):
-        return arrays(
-            dtype=dtype,
-            shape=index_shape,
-            elements=st.integers(-size if signed else 0, size - 1),
-        )
-
-    return result_shape.flatmap(
-        lambda index_shape: st.tuples(*(array_for(index_shape, size) for size in shape))
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/pandas Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/pandas/impl.py Deleted

@@ -1,719 +0,0 @@
-# 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/.
-
-from collections import OrderedDict, abc
-from copy import copy
-from datetime import datetime, timedelta
-from typing import Any, List, Optional, Sequence, Set, Union
-
-import attr
-import numpy as np
-import pandas
-
-from hypothesis import strategies as st
-from hypothesis._settings import note_deprecation
-from hypothesis.control import reject
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra import numpy as npst
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.coverage import check, check_function
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.internal.validation import (
-    check_type,
-    check_valid_interval,
-    check_valid_size,
-    try_convert,
-)
-from hypothesis.strategies._internal.strategies import Ex, check_strategy
-from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-
-try:
-    from pandas.api.types import is_categorical_dtype
-except ImportError:
-
-    def is_categorical_dtype(dt):
-        if isinstance(dt, np.dtype):
-            return False
-        return dt == "category"
-
-
-def dtype_for_elements_strategy(s):
-    return st.shared(
-        s.map(lambda x: pandas.Series(x).dtype),
-        key=("hypothesis.extra.pandas.dtype_for_elements_strategy", s),
-    )
-
-
-def infer_dtype_if_necessary(dtype, values, elements, draw):
-    if dtype is None and not values:
-        return draw(dtype_for_elements_strategy(elements))
-    return dtype
-
-
-@check_function
-def elements_and_dtype(elements, dtype, source=None):
-
-    if source is None:
-        prefix = ""
-    else:
-        prefix = f"{source}."
-
-    if elements is not None:
-        check_strategy(elements, f"{prefix}elements")
-    else:
-        with check("dtype is not None"):
-            if dtype is None:
-                raise InvalidArgument(
-                    f"At least one of {prefix}elements or {prefix}dtype must be provided."
-                )
-
-    with check("is_categorical_dtype"):
-        if is_categorical_dtype(dtype):
-            raise InvalidArgument(
-                f"{prefix}dtype is categorical, which is currently unsupported"
-            )
-
-    if isinstance(dtype, type) and np.dtype(dtype).kind == "O" and dtype is not object:
-        note_deprecation(
-            f"Passed dtype={dtype!r} is not a valid Pandas dtype.  We'll treat it as "
-            "dtype=object for now, but this will be an error in a future version.",
-            since="2021-12-31",
-            has_codemod=False,
-        )
-
-    dtype = try_convert(np.dtype, dtype, "dtype")
-
-    if elements is None:
-        elements = npst.from_dtype(dtype)
-    elif dtype is not None:
-
-        def convert_element(value):
-            name = f"draw({prefix}elements)"
-            try:
-                return np.array(value, dtype=dtype)0
-            except TypeError:
-                raise InvalidArgument(
-                    "Cannot convert %s=%r of type %s to dtype %s"
-                    % (name, value, type(value).__name__, dtype.str)
-                ) from None
-            except ValueError:
-                raise InvalidArgument(
-                    f"Cannot convert {name}={value!r} to type {dtype.str}"
-                ) from None
-
-        elements = elements.map(convert_element)
-    assert elements is not None
-
-    return elements, dtype
-
-
-class ValueIndexStrategy(st.SearchStrategy):
-    def __init__(self, elements, dtype, min_size, max_size, unique, name):
-        super().__init__()
-        self.elements = elements
-        self.dtype = dtype
-        self.min_size = min_size
-        self.max_size = max_size
-        self.unique = unique
-        self.name = name
-
-    def do_draw(self, data):
-        result = 
-        seen = set()
-
-        iterator = cu.many(
-            data,
-            min_size=self.min_size,
-            max_size=self.max_size,
-            average_size=(self.min_size + self.max_size) / 2,
-        )
-
-        while iterator.more():
-            elt = data.draw(self.elements)
-
-            if self.unique:
-                if elt in seen:
-                    iterator.reject()
-                    continue
-                seen.add(elt)
-            result.append(elt)
-
-        dtype = infer_dtype_if_necessary(
-            dtype=self.dtype, values=result, elements=self.elements, draw=data.draw
-        )
-        return pandas.Index(
-            result, dtype=dtype, tupleize_cols=False, name=data.draw(self.name)
-        )
-
-
-DEFAULT_MAX_SIZE = 10
-
-
-@cacheable
-@defines_strategy()
-def range_indexes(
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> st.SearchStrategypandas.RangeIndex:
-    """Provides a strategy which generates an :class:`~pandas.Index` whose
-    values are 0, 1, ..., n for some n.
-
-    Arguments:
-
-    * min_size is the smallest number of elements the index can have.
-    * max_size is the largest number of elements the index can have. If None
-      it will default to some suitable value based on min_size.
-    """
-    check_valid_size(min_size, "min_size")
-    check_valid_size(max_size, "max_size")
-    if max_size is None:
-        max_size = min(min_size + DEFAULT_MAX_SIZE, 2**63 - 1)
-    check_valid_interval(min_size, max_size, "min_size", "max_size")
-    return st.integers(min_size, max_size).map(pandas.RangeIndex)
-
-
-@cacheable
-@defines_strategy()
-def indexes(
-    *,
-    elements: Optionalst.SearchStrategyEx = None,
-    dtype: Any = None,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-    unique: bool = True,
-    name: st.SearchStrategyOptionalstr = st.none(),
-) -> st.SearchStrategypandas.Index:
-    """Provides a strategy for producing a :class:`pandas.Index`.
-
-    Arguments:
-
-    * elements is a strategy which will be used to generate the individual
-      values of the index. If None, it will be inferred from the dtype. Note:
-      even if the elements strategy produces tuples, the generated value
-      will not be a MultiIndex, but instead be a normal index whose elements
-      are tuples.
-    * dtype is the dtype of the resulting index. If None, it will be inferred
-      from the elements strategy. At least one of dtype or elements must be
-      provided.
-    * min_size is the minimum number of elements in the index.
-    * max_size is the maximum number of elements in the index. If None then it
-      will default to a suitable small size. If you want larger indexes you
-      should pass a max_size explicitly.
-    * unique specifies whether all of the elements in the resulting index
-      should be distinct.
-    * name is a strategy for strings or ``None``, which will be passed to
-      the :class:`pandas.Index` constructor.
-    """
-    check_valid_size(min_size, "min_size")
-    check_valid_size(max_size, "max_size")
-    check_valid_interval(min_size, max_size, "min_size", "max_size")
-    check_type(bool, unique, "unique")
-
-    elements, dtype = elements_and_dtype(elements, dtype)
-
-    if max_size is None:
-        max_size = min_size + DEFAULT_MAX_SIZE
-    return ValueIndexStrategy(elements, dtype, min_size, max_size, unique, name)
-
-
-@defines_strategy()
-def series(
-    *,
-    elements: Optionalst.SearchStrategyEx = None,
-    dtype: Any = None,
-    index: Optionalst.SearchStrategyUnionSequence, pandas.Index = None,
-    fill: Optionalst.SearchStrategyEx = None,
-    unique: bool = False,
-    name: st.SearchStrategyOptionalstr = st.none(),
-) -> st.SearchStrategypandas.Series:
-    """Provides a strategy for producing a :class:`pandas.Series`.
-
-    Arguments:
-
-    * elements: a strategy that will be used to generate the individual
-      values in the series. If None, we will attempt to infer a suitable
-      default from the dtype.
-
-    * dtype: the dtype of the resulting series and may be any value
-      that can be passed to :class:`numpy.dtype`. If None, will use
-      pandas's standard behaviour to infer it from the type of the elements
-      values. Note that if the type of values that comes out of your
-      elements strategy varies, then so will the resulting dtype of the
-      series.
-
-    * index: If not None, a strategy for generating indexes for the
-      resulting Series. This can generate either :class:`pandas.Index`
-      objects or any sequence of values (which will be passed to the
-      Index constructor).
-
-      You will probably find it most convenient to use the
-      :func:`~hypothesis.extra.pandas.indexes` or
-      :func:`~hypothesis.extra.pandas.range_indexes` function to produce
-      values for this argument.
-
-    * name: is a strategy for strings or ``None``, which will be passed to
-      the :class:`pandas.Series` constructor.
-
-    Usage:
-
-    .. code-block:: pycon
-
-        >>> series(dtype=int).example()
-        0   -2001747478
-        1    1153062837
-    """
-    if index is None:
-        index = range_indexes()
-    else:
-        check_strategy(index, "index")
-
-    elements, dtype = elements_and_dtype(elements, dtype)
-    index_strategy = index
-
-    @st.composite
-    def result(draw):
-        index = draw(index_strategy)
-
-        if len(index) > 0:
-            if dtype is not None:
-                result_data = draw(
-                    npst.arrays(
-                        dtype=dtype,
-                        elements=elements,
-                        shape=len(index),
-                        fill=fill,
-                        unique=unique,
-                    )
-                )
-            else:
-                result_data = list(
-                    draw(
-                        npst.arrays(
-                            dtype=object,
-                            elements=elements,
-                            shape=len(index),
-                            fill=fill,
-                            unique=unique,
-                        )
-                    )
-                )
-
-            return pandas.Series(result_data, index=index, dtype=dtype, name=draw(name))
-        else:
-            return pandas.Series(
-                (),
-                index=index,
-                dtype=dtype
-                if dtype is not None
-                else draw(dtype_for_elements_strategy(elements)),
-                name=draw(name),
-            )
-
-    return result()
-
-
-@attr.s(slots=True)
-class column:
-    """Data object for describing a column in a DataFrame.
-
-    Arguments:
-
-    * name: the column name, or None to default to the column position. Must
-      be hashable, but can otherwise be any value supported as a pandas column
-      name.
-    * elements: the strategy for generating values in this column, or None
-      to infer it from the dtype.
-    * dtype: the dtype of the column, or None to infer it from the element
-      strategy. At least one of dtype or elements must be provided.
-    * fill: A default value for elements of the column. See
-      :func:`~hypothesis.extra.numpy.arrays` for a full explanation.
-    * unique: If all values in this column should be distinct.
-    """
-
-    name = attr.ib(default=None)
-    elements = attr.ib(default=None)
-    dtype = attr.ib(default=None, repr=get_pretty_function_description)
-    fill = attr.ib(default=None)
-    unique = attr.ib(default=False)
-
-
-def columns(
-    names_or_number: Unionint, Sequencestr,
-    *,
-    dtype: Any = None,
-    elements: Optionalst.SearchStrategyEx = None,
-    fill: Optionalst.SearchStrategyEx = None,
-    unique: bool = False,
-) -> Listcolumn:
-    """A convenience function for producing a list of :class:`column` objects
-    of the same general shape.
-
-    The names_or_number argument is either a sequence of values, the
-    elements of which will be used as the name for individual column
-    objects, or a number, in which case that many unnamed columns will
-    be created. All other arguments are passed through verbatim to
-    create the columns.
-    """
-    if isinstance(names_or_number, (int, float)):
-        names: ListUnionint, str, None = None * names_or_number
-    else:
-        names = list(names_or_number)
-    return 
-        column(name=n, dtype=dtype, elements=elements, fill=fill, unique=unique)
-        for n in names
-    
-
-
-@defines_strategy()
-def data_frames(
-    columns: OptionalSequencecolumn = None,
-    *,
-    rows: Optionalst.SearchStrategyUniondict, SequenceAny = None,
-    index: Optionalst.SearchStrategyEx = None,
-) -> st.SearchStrategypandas.DataFrame:
-    """Provides a strategy for producing a :class:`pandas.DataFrame`.
-
-    Arguments:
-
-    * columns: An iterable of :class:`column` objects describing the shape
-      of the generated DataFrame.
-
-    * rows: A strategy for generating a row object. Should generate
-      either dicts mapping column names to values or a sequence mapping
-      column position to the value in that position (note that unlike the
-      :class:`pandas.DataFrame` constructor, single values are not allowed
-      here. Passing e.g. an integer is an error, even if there is only one
-      column).
-
-      At least one of rows and columns must be provided. If both are
-      provided then the generated rows will be validated against the
-      columns and an error will be raised if they don't match.
-
-      Caveats on using rows:
-
-      * In general you should prefer using columns to rows, and only use
-        rows if the columns interface is insufficiently flexible to
-        describe what you need - you will get better performance and
-        example quality that way.
-      * If you provide rows and not columns, then the shape and dtype of
-        the resulting DataFrame may vary. e.g. if you have a mix of int
-        and float in the values for one column in your row entries, the
-        column will sometimes have an integral dtype and sometimes a float.
-
-    * index: If not None, a strategy for generating indexes for the
-      resulting DataFrame. This can generate either :class:`pandas.Index`
-      objects or any sequence of values (which will be passed to the
-      Index constructor).
-
-      You will probably find it most convenient to use the
-      :func:`~hypothesis.extra.pandas.indexes` or
-      :func:`~hypothesis.extra.pandas.range_indexes` function to produce
-      values for this argument.
-
-    Usage:
-
-    The expected usage pattern is that you use :class:`column` and
-    :func:`columns` to specify a fixed shape of the DataFrame you want as
-    follows. For example the following gives a two column data frame:
-
-    .. code-block:: pycon
-
-        >>> from hypothesis.extra.pandas import column, data_frames
-        >>> data_frames(
-        ... column('A', dtype=int), column('B', dtype=float)).example()
-                    A              B
-        0  2021915903  1.793898e+232
-        1  1146643993            inf
-        2 -2096165693   1.000000e+07
-
-    If you want the values in different columns to interact in some way you
-    can use the rows argument. For example the following gives a two column
-    DataFrame where the value in the first column is always at most the value
-    in the second:
-
-    .. code-block:: pycon
-
-        >>> from hypothesis.extra.pandas import column, data_frames
-        >>> import hypothesis.strategies as st
-        >>> data_frames(
-        ...     rows=st.tuples(st.floats(allow_nan=False),
-        ...                    st.floats(allow_nan=False)).map(sorted)
-        ... ).example()
-                       0             1
-        0  -3.402823e+38  9.007199e+15
-        1 -1.562796e-298  5.000000e-01
-
-    You can also combine the two:
-
-    .. code-block:: pycon
-
-        >>> from hypothesis.extra.pandas import columns, data_frames
-        >>> import hypothesis.strategies as st
-        >>> data_frames(
-        ...     columns=columns("lo", "hi", dtype=float),
-        ...     rows=st.tuples(st.floats(allow_nan=False),
-        ...                    st.floats(allow_nan=False)).map(sorted)
-        ... ).example()
-                 lo            hi
-        0   9.314723e-49  4.353037e+45
-        1  -9.999900e-01  1.000000e+07
-        2 -2.152861e+134 -1.069317e-73
-
-    (Note that the column dtype must still be specified and will not be
-    inferred from the rows. This restriction may be lifted in future).
-
-    Combining rows and columns has the following behaviour:
-
-    * The column names and dtypes will be used.
-    * If the column is required to be unique, this will be enforced.
-    * Any values missing from the generated rows will be provided using the
-      column's fill.
-    * Any values in the row not present in the column specification (if
-      dicts are passed, if there are keys with no corresponding column name,
-      if sequences are passed if there are too many items) will result in
-      InvalidArgument being raised.
-    """
-    if index is None:
-        index = range_indexes()
-    else:
-        check_strategy(index, "index")
-
-    index_strategy = index
-
-    if columns is None:
-        if rows is None:
-            raise InvalidArgument("At least one of rows and columns must be provided")
-        else:
-
-            @st.composite
-            def rows_only(draw):
-                index = draw(index_strategy)
-
-                @check_function
-                def row():
-                    result = draw(rows)
-                    check_type(abc.Iterable, result, "draw(row)")
-                    return result
-
-                if len(index) > 0:
-                    return pandas.DataFrame(row() for _ in index, index=index)
-                else:
-                    # If we haven't drawn any rows we need to draw one row and
-                    # then discard it so that we get a consistent shape for the
-                    # DataFrame.
-                    base = pandas.DataFrame(row())
-                    return base.drop(0)
-
-            return rows_only()
-
-    assert columns is not None
-    cols = try_convert(tuple, columns, "columns")
-
-    rewritten_columns = 
-    column_names: Setstr = set()
-
-    for i, c in enumerate(cols):
-        check_type(column, c, f"columns{i}")
-
-        c = copy(c)
-        if c.name is None:
-            label = f"columns{i}"
-            c.name = i
-        else:
-            label = c.name
-            try:
-                hash(c.name)
-            except TypeError:
-                raise InvalidArgument(
-                    "Column names must be hashable, but columns%d.name was "
-                    "%r of type %s, which cannot be hashed."
-                    % (i, c.name, type(c.name).__name__)
-                ) from None
-
-        if c.name in column_names:
-            raise InvalidArgument(f"duplicate definition of column name {c.name!r}")
-
-        column_names.add(c.name)
-
-        c.elements, c.dtype = elements_and_dtype(c.elements, c.dtype, label)
-
-        if c.dtype is None and rows is not None:
-            raise InvalidArgument(
-                "Must specify a dtype for all columns when combining rows with columns."
-            )
-
-        c.fill = npst.fill_for(
-            fill=c.fill, elements=c.elements, unique=c.unique, name=label
-        )
-
-        rewritten_columns.append(c)
-
-    if rows is None:
-
-        @st.composite
-        def just_draw_columns(draw):
-            index = draw(index_strategy)
-            local_index_strategy = st.just(index)
-
-            data = OrderedDict((c.name, None) for c in rewritten_columns)
-
-            # Depending on how the columns are going to be generated we group
-            # them differently to get better shrinking. For columns with fill
-            # enabled, the elements can be shrunk independently of the size,
-            # so we can just shrink by shrinking the index then shrinking the
-            # length and are generally much more free to move data around.
-
-            # For columns with no filling the problem is harder, and drawing
-            # them like that would result in rows being very far apart from
-            # each other in the underlying data stream, which gets in the way
-            # of shrinking. So what we do is reorder and draw those columns
-            # row wise, so that the values of each row are next to each other.
-            # This makes life easier for the shrinker when deleting blocks of
-            # data.
-            columns_without_fill = c for c in rewritten_columns if c.fill.is_empty
-
-            if columns_without_fill:
-                for c in columns_without_fill:
-                    datac.name = pandas.Series(
-                        np.zeros(shape=len(index), dtype=c.dtype), index=index
-                    )
-                seen = {c.name: set() for c in columns_without_fill if c.unique}
-
-                for i in range(len(index)):
-                    for c in columns_without_fill:
-                        if c.unique:
-                            for _ in range(5):
-                                value = draw(c.elements)
-                                if value not in seenc.name:
-                                    seenc.name.add(value)
-                                    break
-                            else:
-                                reject()
-                        else:
-                            value = draw(c.elements)
-                        try:
-                            datac.namei = value
-                        except ValueError as err:  # pragma: no cover
-                            # This just works in Pandas 1.4 and later, but gives
-                            # a confusing error on previous versions.
-                            if c.dtype is None and not isinstance(
-                                value, (float, int, str, bool, datetime, timedelta)
-                            ):
-                                raise ValueError(
-                                    f"Failed to add value={value!r} to column "
-                                    f"{c.name} with dtype=None.  Maybe passing "
-                                    "dtype=object would help?"
-                                ) from err
-                            # Unclear how this could happen, but users find a way...
-                            raise
-
-            for c in rewritten_columns:
-                if not c.fill.is_empty:
-                    datac.name = draw(
-                        series(
-                            index=local_index_strategy,
-                            dtype=c.dtype,
-                            elements=c.elements,
-                            fill=c.fill,
-                            unique=c.unique,
-                        )
-                    )
-
-            return pandas.DataFrame(data, index=index)
-
-        return just_draw_columns()
-    else:
-
-        @st.composite
-        def assign_rows(draw):
-            index = draw(index_strategy)
-
-            result = pandas.DataFrame(
-                OrderedDict(
-                    (
-                        c.name,
-                        pandas.Series(
-                            np.zeros(dtype=c.dtype, shape=len(index)), dtype=c.dtype
-                        ),
-                    )
-                    for c in rewritten_columns
-                ),
-                index=index,
-            )
-
-            fills = {}
-
-            any_unique = any(c.unique for c in rewritten_columns)
-
-            if any_unique:
-                all_seen = set() if c.unique else None for c in rewritten_columns
-                while all_seen-1 is None:
-                    all_seen.pop()
-
-            for row_index in range(len(index)):
-                for _ in range(5):
-                    original_row = draw(rows)
-                    row = original_row
-                    if isinstance(row, dict):
-                        as_list = None * len(rewritten_columns)
-                        for i, c in enumerate(rewritten_columns):
-                            try:
-                                as_listi = rowc.name
-                            except KeyError:
-                                try:
-                                    as_listi = fillsi
-                                except KeyError:
-                                    if c.fill.is_empty:
-                                        raise InvalidArgument(
-                                            f"Empty fill strategy in {c!r} cannot "
-                                            f"complete row {original_row!r}"
-                                        ) from None
-                                    fillsi = draw(c.fill)
-                                    as_listi = fillsi
-                        for k in row:
-                            if k not in column_names:
-                                raise InvalidArgument(
-                                    "Row %r contains column %r not in columns %r)"
-                                    % (row, k, c.name for c in rewritten_columns)
-                                )
-                        row = as_list
-                    if any_unique:
-                        has_duplicate = False
-                        for seen, value in zip(all_seen, row):
-                            if seen is None:
-                                continue
-                            if value in seen:
-                                has_duplicate = True
-                                break
-                            seen.add(value)
-                        if has_duplicate:
-                            continue
-                    row = list(try_convert(tuple, row, "draw(rows)"))
-
-                    if len(row) > len(rewritten_columns):
-                        raise InvalidArgument(
-                            f"Row {original_row!r} contains too many entries. Has "
-                            f"{len(row)} but expected at most {len(rewritten_columns)}"
-                        )
-                    while len(row) < len(rewritten_columns):
-                        c = rewritten_columnslen(row)
-                        if c.fill.is_empty:
-                            raise InvalidArgument(
-                                f"Empty fill strategy in {c!r} cannot "
-                                f"complete row {original_row!r}"
-                            )
-                        row.append(draw(c.fill))
-                    result.ilocrow_index = row
-                    break
-                else:
-                    reject()
-            return result
-
-        return assign_rows()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/extra/pytz.py Deleted

@@ -1,54 +0,0 @@
-# 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/.
-
-"""
-----------------
-hypothesispytz
-----------------
-
-This module provides :pypi:`pytz` timezones.
-
-You can use this strategy to make
-:py:func:`hypothesis.strategies.datetimes` and
-:py:func:`hypothesis.strategies.times` produce timezone-aware values.
-"""
-
-import datetime as dt
-
-import pytz
-from pytz.tzfile import StaticTzInfo
-
-from hypothesis import strategies as st
-from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-
-__all__ = "timezones"
-
-
-@cacheable
-@defines_strategy()
-def timezones() -> st.SearchStrategydt.tzinfo:
-    """Any timezone in the Olsen database, as a pytz tzinfo object.
-
-    This strategy minimises to UTC, or the smallest possible fixed
-    offset, and is designed for use with
-    :py:func:`hypothesis.strategies.datetimes`.
-    """
-    all_timezones = pytz.timezone(tz) for tz in pytz.all_timezones
-    # Some timezones have always had a constant offset from UTC.  This makes
-    # them simpler than timezones with daylight savings, and the smaller the
-    # absolute offset the simpler they are.  Of course, UTC is even simpler!
-    static: list = pytz.UTC
-    static += sorted(
-        (t for t in all_timezones if isinstance(t, StaticTzInfo)),
-        key=lambda tz: abs(tz.utcoffset(dt.datetime(2000, 1, 1))),
-    )
-    # Timezones which have changed UTC offset; best ordered by name.
-    dynamic = tz for tz in all_timezones if tz not in static
-    return st.sampled_from(static + dynamic)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/charmap.py Deleted

@@ -1,369 +0,0 @@
-# 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 gzip
-import json
-import os
-import sys
-import tempfile
-import unicodedata
-from typing import Dict, Tuple
-
-from hypothesis.configuration import mkdir_p, storage_directory
-from hypothesis.errors import InvalidArgument
-
-intervals = TupleTupleint, int, ...
-cache_type = DictTupleTuplestr, ..., int, int, intervals, intervals
-
-
-def charmap_file():
-    return storage_directory(
-        "unicode_data", unicodedata.unidata_version, "charmap.json.gz"
-    )
-
-
-_charmap = None
-
-
-def charmap():
-    """Return a dict that maps a Unicode category, to a tuple of 2-tuples
-    covering the codepoint intervals for characters in that category.
-
-    >>> charmap()'Co'
-    ((57344, 63743), (983040, 1048573), (1048576, 1114109))
-    """
-    global _charmap
-    # Best-effort caching in the face of missing files and/or unwritable
-    # filesystems is fairly simple: check if loaded, else try loading,
-    # else calculate and try writing the cache.
-    if _charmap is None:
-        f = charmap_file()
-        try:
-            with gzip.GzipFile(f, "rb") as i:
-                tmp_charmap = dict(json.load(i))
-
-        except Exception:
-            # This loop is reduced to using only local variables for performance;
-            # indexing and updating containers is a ~3x slowdown.  This doesn't fix
-            # https://github.com/HypothesisWorks/hypothesis/issues/2108 but it helps.
-            category = unicodedata.category  # Local variable -> ~20% speedup!
-            tmp_charmap = {}
-            last_cat = category(chr(0))
-            last_start = 0
-            for i in range(1, sys.maxunicode + 1):
-                cat = category(chr(i))
-                if cat != last_cat:
-                    tmp_charmap.setdefault(last_cat, ).append(last_start, i - 1)
-                    last_cat, last_start = cat, i
-            tmp_charmap.setdefault(last_cat, ).append(last_start, sys.maxunicode)
-
-            try:
-                # Write the Unicode table atomically
-                tmpdir = storage_directory("tmp")
-                mkdir_p(tmpdir)
-                fd, tmpfile = tempfile.mkstemp(dir=tmpdir)
-                os.close(fd)
-                # Explicitly set the mtime to get reproducible output
-                with gzip.GzipFile(tmpfile, "wb", mtime=1) as o:
-                    result = json.dumps(sorted(tmp_charmap.items()))
-                    o.write(result.encode())
-
-                os.renames(tmpfile, f)
-            except Exception:
-                pass
-
-        # convert between lists and tuples
-        _charmap = {
-            k: tuple(tuple(pair) for pair in pairs) for k, pairs in tmp_charmap.items()
-        }
-        # each value is a tuple of 2-tuples (that is, tuples of length 2)
-        # and that both elements of that tuple are integers.
-        for vs in _charmap.values():
-            ints = list(sum(vs, ()))
-            assert all(isinstance(x, int) for x in ints)
-            assert ints == sorted(ints)
-            assert all(len(tup) == 2 for tup in vs)
-
-    assert _charmap is not None
-    return _charmap
-
-
-_categories = None
-
-
-def categories():
-    """Return a tuple of Unicode categories in a normalised order.
-
-    >>> categories() # doctest: +ELLIPSIS
-    ('Zl', 'Zp', 'Co', 'Me', 'Pc', ..., 'Cc', 'Cs')
-    """
-    global _categories
-    if _categories is None:
-        cm = charmap()
-        _categories = sorted(cm.keys(), key=lambda c: len(cmc))
-        _categories.remove("Cc")  # Other, Control
-        _categories.remove("Cs")  # Other, Surrogate
-        _categories.append("Cc")
-        _categories.append("Cs")
-    return tuple(_categories)
-
-
-def as_general_categories(cats, name="cats"):
-    """Return a tuple of Unicode categories in a normalised order.
-
-    This function expands one-letter designations of a major class to include
-    all subclasses:
-
-    >>> as_general_categories('N')
-    ('Nd', 'Nl', 'No')
-
-    See section 4.5 of the Unicode standard for more on classes:
-    https://www.unicode.org/versions/Unicode10.0.0/ch04.pdf
-
-    If the collection ``cats`` includes any elements that do not represent a
-    major class or a class with subclass, a deprecation warning is raised.
-    """
-    if cats is None:
-        return None
-    major_classes = ("L", "M", "N", "P", "S", "Z", "C")
-    cs = categories()
-    out = set(cats)
-    for c in cats:
-        if c in major_classes:
-            out.discard(c)
-            out.update(x for x in cs if x.startswith(c))
-        elif c not in cs:
-            raise InvalidArgument(
-                f"In {name}={cats!r}, {c!r} is not a valid Unicode category."
-            )
-    return tuple(c for c in cs if c in out)
-
-
-def _union_intervals(x, y):
-    """Merge two sequences of intervals into a single tuple of intervals.
-
-    Any integer bounded by `x` or `y` is also bounded by the result.
-
-    >>> _union_intervals((3, 10), (1, 2), (5, 17))
-    ((1, 17),)
-    """
-    if not x:
-        return tuple((u, v) for u, v in y)
-    if not y:
-        return tuple((u, v) for u, v in x)
-    intervals = sorted(x + y, reverse=True)
-    result = intervals.pop()
-    while intervals:
-        # 1. intervals is in descending order
-        # 2. pop() takes from the RHS.
-        # 3. (a, b) was popped 1st, then (u, v) was popped 2nd
-        # 4. Therefore: a <= u
-        # 5. We assume that u <= v and a <= b
-        # 6. So we need to handle 2 cases of overlap, and one disjoint case
-        #    |   u--v     |   u----v   |       u--v  |
-        #    |   a----b   |   a--b     |  a--b       |
-        u, v = intervals.pop()
-        a, b = result-1
-        if u <= b + 1:
-            # Overlap cases
-            result-1 = (a, max(v, b))
-        else:
-            # Disjoint case
-            result.append((u, v))
-    return tuple(result)
-
-
-def _subtract_intervals(x, y):
-    """Set difference for lists of intervals. That is, returns a list of
-    intervals that bounds all values bounded by x that are not also bounded by
-    y. x and y are expected to be in sorted order.
-
-    For example _subtract_intervals((1, 10), (2, 3), (9, 15)) would
-    return (1, 1), (4, 8), removing the values 2, 3, 9 and 10 from the
-    interval.
-    """
-    if not y:
-        return tuple(x)
-    x = list(map(list, x))
-    i = 0
-    j = 0
-    result = 
-    while i < len(x) and j < len(y):
-        # Iterate in parallel over x and y. j stays pointing at the smallest
-        # interval in the left hand side that could still overlap with some
-        # element of x at index >= i.
-        # Similarly, i is not incremented until we know that it does not
-        # overlap with any element of y at index >= j.
-
-        xl, xr = xi
-        assert xl <= xr
-        yl, yr = yj
-        assert yl <= yr
-
-        if yr < xl:
-            # The interval at yj is strictly to the left of the interval at
-            # xi, so will not overlap with it or any later interval of x.
-            j += 1
-        elif yl > xr:
-            # The interval at yj is strictly to the right of the interval at
-            # xi, so all of xi goes into the result as no further intervals
-            # in y will intersect it.
-            result.append(xi)
-            i += 1
-        elif yl <= xl:
-            if yr >= xr:
-                # xi is contained entirely in yj, so we just skip over it
-                # without adding it to the result.
-                i += 1
-            else:
-                # The beginning of xi is contained in yj, so we update the
-                # left endpoint of xi to remove this, and increment j as we
-                # now have moved past it. Note that this is not added to the
-                # result as is, as more intervals from y may intersect it so it
-                # may need updating further.
-                xi0 = yr + 1
-                j += 1
-        else:
-            # yl > xl, so the left hand part of xi is not contained in yj,
-            # so there are some values we should add to the result.
-            result.append((xl, yl - 1))
-
-            if yr + 1 <= xr:
-                # If yj finishes before xi does, there may be some values
-                # in xi left that should go in the result (or they may be
-                # removed by a later interval in y), so we update xi to
-                # reflect that and increment j because it no longer overlaps
-                # with any remaining element of x.
-                xi0 = yr + 1
-                j += 1
-            else:
-                # Every element of xi other than the initial part we have
-                # already added is contained in yj, so we move to the next
-                # interval.
-                i += 1
-    # Any remaining intervals in x do not overlap with any of y, as if they did
-    # we would not have incremented j to the end, so can be added to the result
-    # as they are.
-    result.extend(xi:)
-    return tuple(map(tuple, result))
-
-
-def _intervals(s):
-    """Return a tuple of intervals, covering the codepoints of characters in
-    `s`.
-
-    >>> _intervals('abcdef0123456789')
-    ((48, 57), (97, 102))
-    """
-    intervals = tuple((ord(c), ord(c)) for c in sorted(s))
-    return _union_intervals(intervals, intervals)
-
-
-category_index_cache = {(): ()}
-
-
-def _category_key(exclude, include):
-    """Return a normalised tuple of all Unicode categories that are in
-    `include`, but not in `exclude`.
-
-    If include is None then default to including all categories.
-    Any item in include that is not a unicode character will be excluded.
-
-    >>> _category_key(exclude='So', include='Lu', 'Me', 'Cs', 'So')
-    ('Me', 'Lu', 'Cs')
-    """
-    cs = categories()
-    if include is None:
-        include = set(cs)
-    else:
-        include = set(include)
-    exclude = set(exclude or ())
-    assert include.issubset(cs)
-    assert exclude.issubset(cs)
-    include -= exclude
-    return tuple(c for c in cs if c in include)
-
-
-def _query_for_key(key):
-    """Return a tuple of codepoint intervals covering characters that match one
-    or more categories in the tuple of categories `key`.
-
-    >>> _query_for_key(categories())
-    ((0, 1114111),)
-    >>> _query_for_key(('Zl', 'Zp', 'Co'))
-    ((8232, 8233), (57344, 63743), (983040, 1048573), (1048576, 1114109))
-    """
-    try:
-        return category_index_cachekey
-    except KeyError:
-        pass
-    assert key
-    if set(key) == set(categories()):
-        result = ((0, sys.maxunicode),)
-    else:
-        result = _union_intervals(_query_for_key(key:-1), charmap()key-1)
-    category_index_cachekey = result
-    return result
-
-
-limited_category_index_cache: cache_type = {}
-
-
-def query(
-    exclude_categories=(),
-    include_categories=None,
-    min_codepoint=None,
-    max_codepoint=None,
-    include_characters="",
-    exclude_characters="",
-):
-    """Return a tuple of intervals covering the codepoints for all characters
-    that meet the criteria (min_codepoint <= codepoint(c) <= max_codepoint and
-    any(cat in include_categories for cat in categories(c)) and all(cat not in
-    exclude_categories for cat in categories(c)) or (c in include_characters)
-
-    >>> query()
-    ((0, 1114111),)
-    >>> query(min_codepoint=0, max_codepoint=128)
-    ((0, 128),)
-    >>> query(min_codepoint=0, max_codepoint=128, include_categories='Lu')
-    ((65, 90),)
-    >>> query(min_codepoint=0, max_codepoint=128, include_categories='Lu',
-    ...       include_characters=u'☃')
-    ((65, 90), (9731, 9731))
-    """
-    if min_codepoint is None:
-        min_codepoint = 0
-    if max_codepoint is None:
-        max_codepoint = sys.maxunicode
-    catkey = _category_key(exclude_categories, include_categories)
-    character_intervals = _intervals(include_characters or "")
-    exclude_intervals = _intervals(exclude_characters or "")
-    qkey = (
-        catkey,
-        min_codepoint,
-        max_codepoint,
-        character_intervals,
-        exclude_intervals,
-    )
-    try:
-        return limited_category_index_cacheqkey
-    except KeyError:
-        pass
-    base = _query_for_key(catkey)
-    result = 
-    for u, v in base:
-        if v >= min_codepoint and u <= max_codepoint:
-            result.append((max(u, min_codepoint), min(v, max_codepoint)))
-    result = tuple(result)
-    result = _union_intervals(result, character_intervals)
-    result = _subtract_intervals(result, exclude_intervals)
-    limited_category_index_cacheqkey = result
-    return result

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/compat.py Deleted

@@ -1,182 +0,0 @@
-# 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 codecs
-import inspect
-import platform
-import sys
-import typing
-
-try:
-    BaseExceptionGroup = BaseExceptionGroup
-except NameError:  # pragma: no cover
-    try:
-        from exceptiongroup import BaseExceptionGroup as BaseExceptionGroup  # for mypy
-    except ImportError:
-        BaseExceptionGroup = ()  # valid in isinstance and except clauses!
-
-PYPY = platform.python_implementation() == "PyPy"
-WINDOWS = platform.system() == "Windows"
-
-
-def escape_unicode_characters(s):
-    return codecs.encode(s, "unicode_escape").decode("ascii")
-
-
-def int_from_bytes(data):
-    return int.from_bytes(data, "big")
-
-
-def int_to_bytes(i, size):
-    return i.to_bytes(size, "big")
-
-
-def int_to_byte(i):
-    return bytes(i)
-
-
-def is_typed_named_tuple(cls):
-    """Return True if cls is probably a subtype of `typing.NamedTuple`.
-
-    Unfortunately types created with `class T(NamedTuple):` actually
-    subclass `tuple` directly rather than NamedTuple.  This is annoying,
-    and means we just have to hope that nobody defines a different tuple
-    subclass with similar attributes.
-    """
-    return (
-        issubclass(cls, tuple)
-        and hasattr(cls, "_fields")
-        and (hasattr(cls, "_field_types") or hasattr(cls, "__annotations__"))
-    )
-
-
-def get_type_hints(thing):
-    """Like the typing version, but tries harder and never errors.
-
-    Tries harder: if the thing to inspect is a class but typing.get_type_hints
-    raises an error or returns no hints, then this function will try calling it
-    on the __init__ method. This second step often helps with user-defined
-    classes on older versions of Python. The third step we take is trying
-    to fetch types from the __signature__ property.
-    They override any other ones we found earlier.
-
-    Never errors: instead of raising TypeError for uninspectable objects, or
-    NameError for unresolvable forward references, just return an empty dict.
-    """
-    kwargs = {} if sys.version_info:2 < (3, 9) else {"include_extras": True}
-
-    try:
-        hints = typing.get_type_hints(thing, **kwargs)
-    except (AttributeError, TypeError, NameError):
-        hints = {}
-
-    if inspect.isclass(thing):
-        try:
-            hints.update(typing.get_type_hints(thing.__init__, **kwargs))
-        except (TypeError, NameError, AttributeError):
-            pass
-
-    try:
-        if hasattr(thing, "__signature__"):
-            # It is possible for the signature and annotations attributes to
-            # differ on an object due to renamed arguments.
-            from hypothesis.internal.reflection import get_signature
-            from hypothesis.strategies._internal.types import is_a_type
-
-            vkinds = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
-            for p in get_signature(thing).parameters.values():
-                if (
-                    p.kind not in vkinds
-                    and is_a_type(p.annotation)
-                    and p.annotation is not p.empty
-                ):
-                    if p.default is None:
-                        hintsp.name = typing.Optionalp.annotation
-                    else:
-                        hintsp.name = p.annotation
-    except (AttributeError, TypeError, NameError):  # pragma: no cover
-        pass
-
-    return hints
-
-
-def update_code_location(code, newfile, newlineno):
-    """Take a code object and lie shamelessly about where it comes from.
-
-    Why do we want to do this? It's for really shallow reasons involving
-    hiding the hypothesis_temporary_module code from test runners like
-    pytest's verbose mode. This is a vastly disproportionate terrible
-    hack that I've done purely for vanity, and if you're reading this
-    code you're probably here because it's broken something and now
-    you're angry at me. Sorry.
-    """
-    if hasattr(code, "replace"):
-        # Python 3.8 added positional-only params (PEP 570), and thus changed
-        # the layout of code objects.  In beta1, the `.replace()` method was
-        # added to facilitate future-proof code.  See BPO-37032 for details.
-        return code.replace(co_filename=newfile, co_firstlineno=newlineno)
-
-    else:  # pragma: no cover
-        # This field order is accurate for 3.5 - 3.7, but not 3.8 when a new field
-        # was added for positional-only arguments.  However it also added a .replace()
-        # method that we use instead of field indices, so they're fine as-is.
-        CODE_FIELD_ORDER = 
-            "co_argcount",
-            "co_kwonlyargcount",
-            "co_nlocals",
-            "co_stacksize",
-            "co_flags",
-            "co_code",
-            "co_consts",
-            "co_names",
-            "co_varnames",
-            "co_filename",
-            "co_name",
-            "co_firstlineno",
-            "co_lnotab",
-            "co_freevars",
-            "co_cellvars",
-        
-        unpacked = getattr(code, name) for name in CODE_FIELD_ORDER
-        unpackedCODE_FIELD_ORDER.index("co_filename") = newfile
-        unpackedCODE_FIELD_ORDER.index("co_firstlineno") = newlineno
-        return type(code)(*unpacked)
-
-
-# Under Python 2, math.floor and math.ceil returned floats, which cannot
-# represent large integers - eg `float(2**53) == float(2**53 + 1)`.
-# We therefore implement them entirely in (long) integer operations.
-# We still use the same trick on Python 3, because Numpy values and other
-# custom __floor__ or __ceil__ methods may convert via floats.
-# See issue #1667, Numpy issue 9068.
-def floor(x):
-    y = int(x)
-    if y != x and x < 0:
-        return y - 1
-    return y
-
-
-def ceil(x):
-    y = int(x)
-    if y != x and x > 0:
-        return y + 1
-    return y
-
-
-def bad_django_TestCase(runner):
-    if runner is None or "django.test" not in sys.modules:
-        return False
-    else:  # pragma: no cover
-        if not isinstance(runner, sys.modules"django.test".TransactionTestCase):
-            return False
-
-        from hypothesis.extra.django._impl import HypothesisTestCase
-
-        return not isinstance(runner, HypothesisTestCase)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/choicetree.py Deleted

@@ -1,160 +0,0 @@
-# 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/.
-
-from collections import defaultdict
-from random import Random
-from typing import Callable, Dict, Iterable, List, Optional, Sequence
-
-from hypothesis.internal.conjecture.junkdrawer import LazySequenceCopy, pop_random
-
-
-def prefix_selection_order(
-    prefix: Sequenceint,
-) -> Callableint, int, Iterableint:
-    """Select choices starting from ``prefix```,
-    preferring to move left then wrapping around
-    to the right."""
-
-    def selection_order(depth: int, n: int) -> Iterableint:
-        if depth < len(prefix):
-            i = prefixdepth
-            if i >= n:
-                i = n - 1
-            yield from range(i, -1, -1)
-            yield from range(n - 1, i, -1)
-        else:
-            yield from range(n - 1, -1, -1)
-
-    return selection_order
-
-
-def random_selection_order(random: Random) -> Callableint, int, Iterableint:
-    """Select choices uniformly at random."""
-
-    def selection_order(depth: int, n: int) -> Iterableint:
-        pending = LazySequenceCopy(range(n))
-        while pending:
-            yield pop_random(random, pending)
-
-    return selection_order
-
-
-class Chooser:
-    """A source of nondeterminism for use in shrink passes."""
-
-    def __init__(
-        self,
-        tree: "ChoiceTree",
-        selection_order: Callableint, int, Iterableint,
-    ):
-        self.__selection_order = selection_order
-        self.__node_trail = tree.root
-        self.__choices: "Listint" = 
-        self.__finished = False
-
-    def choose(
-        self,
-        values: Sequenceint,
-        condition: Callableint, bool = lambda x: True,
-    ) -> int:
-        """Return some element of values satisfying the condition
-        that will not lead to an exhausted branch, or raise DeadBranch
-        if no such element exist".
-        """
-        assert not self.__finished
-        node = self.__node_trail-1
-        if node.live_child_count is None:
-            node.live_child_count = len(values)
-            node.n = len(values)
-
-        assert node.live_child_count > 0 or len(values) == 0
-
-        for i in self.__selection_order(len(self.__choices), len(values)):
-            if node.live_child_count == 0:
-                break
-            if not node.childreni.exhausted:
-                v = valuesi
-                if condition(v):
-                    self.__choices.append(i)
-                    self.__node_trail.append(node.childreni)
-                    return v
-                else:
-                    node.childreni = DeadNode
-                    node.live_child_count -= 1
-        assert node.live_child_count == 0
-        raise DeadBranch()
-
-    def finish(self) -> Sequenceint:
-        """Record the decisions made in the underlying tree and return
-        a prefix that can be used for the next Chooser to be used."""
-        self.__finished = True
-        assert len(self.__node_trail) == len(self.__choices) + 1
-
-        result = tuple(self.__choices)
-
-        self.__node_trail-1.live_child_count = 0
-        while len(self.__node_trail) > 1 and self.__node_trail-1.exhausted:
-            self.__node_trail.pop()
-            assert len(self.__node_trail) == len(self.__choices)
-            i = self.__choices.pop()
-            target = self.__node_trail-1
-            target.childreni = DeadNode
-            assert target.live_child_count is not None
-            target.live_child_count -= 1
-
-        return result
-
-
-class ChoiceTree:
-    """Records sequences of choices made during shrinking so that we
-    can track what parts of a pass has run. Used to create Chooser
-    objects that are the main interface that a pass uses to make
-    decisions about what to do.
-    """
-
-    def __init__(self) -> None:
-        self.root = TreeNode()
-
-    @property
-    def exhausted(self) -> bool:
-        return self.root.exhausted
-
-    def step(
-        self,
-        selection_order: Callableint, int, Iterableint,
-        f: CallableChooser, None,
-    ) -> Sequenceint:
-        assert not self.exhausted
-
-        chooser = Chooser(self, selection_order)
-        try:
-            f(chooser)
-        except DeadBranch:
-            pass
-        return chooser.finish()
-
-
-class TreeNode:
-    def __init__(self):
-        self.children: Dictint, TreeNode = defaultdict(TreeNode)
-        self.live_child_count: "Optionalint" = None
-        self.n: "Optionalint" = None
-
-    @property
-    def exhausted(self):
-        return self.live_child_count == 0
-
-
-DeadNode = TreeNode()
-DeadNode.live_child_count = 0
-
-
-class DeadBranch(Exception):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/data.py Deleted

@@ -1,1136 +0,0 @@
-# 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 time
-from collections import defaultdict
-from enum import IntEnum
-from random import Random
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    FrozenSet,
-    Hashable,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
-
-import attr
-
-from hypothesis.errors import Frozen, InvalidArgument, StopTest
-from hypothesis.internal.compat import int_from_bytes, int_to_bytes
-from hypothesis.internal.conjecture.junkdrawer import IntList, uniform
-from hypothesis.internal.conjecture.utils import calc_label_from_name
-
-if TYPE_CHECKING:
-    from typing_extensions import dataclass_transform
-
-    from hypothesis.strategies import SearchStrategy
-else:
-
-    def dataclass_transform():
-        def wrapper(tp):
-            return tp
-
-        return wrapper
-
-
-TOP_LABEL = calc_label_from_name("top")
-DRAW_BYTES_LABEL = calc_label_from_name("draw_bytes() in ConjectureData")
-
-
-InterestingOrigin = Tuple
-    TypeBaseException, str, int, TupleAny, ..., TupleTupleAny, ..., ...
-
-TargetObservations = DictOptionalstr, Unionint, float
-
-
-class ExtraInformation:
-    """A class for holding shared state on a ``ConjectureData`` that should
-    be added to the final ``ConjectureResult``."""
-
-    def __repr__(self) -> str:
-        return "ExtraInformation({})".format(
-            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
-        )
-
-    def has_information(self) -> bool:
-        return bool(self.__dict__)
-
-
-class Status(IntEnum):
-    OVERRUN = 0
-    INVALID = 1
-    VALID = 2
-    INTERESTING = 3
-
-    def __repr__(self) -> str:
-        return f"Status.{self.name}"
-
-
-@dataclass_transform()
-@attr.s(frozen=True, slots=True, auto_attribs=True)
-class StructuralCoverageTag:
-    label: int
-
-
-STRUCTURAL_COVERAGE_CACHE: Dictint, StructuralCoverageTag = {}
-
-
-def structural_coverage(label: int) -> StructuralCoverageTag:
-    try:
-        return STRUCTURAL_COVERAGE_CACHElabel
-    except KeyError:
-        return STRUCTURAL_COVERAGE_CACHE.setdefault(label, StructuralCoverageTag(label))
-
-
-class Example:
-    """Examples track the hierarchical structure of draws from the byte stream,
-    within a single test run.
-
-    Examples are created to mark regions of the byte stream that might be
-    useful to the shrinker, such as:
-    - The bytes used by a single draw from a strategy.
-    - Useful groupings within a strategy, such as individual list elements.
-    - Strategy-like helper functions that aren't first-class strategies.
-    - Each lowest-level draw of bits or bytes from the byte stream.
-    - A single top-level example that spans the entire input.
-
-    Example-tracking allows the shrinker to try "high-level" transformations,
-    such as rearranging or deleting the elements of a list, without having
-    to understand their exact representation in the byte stream.
-
-    Rather than store each ``Example`` as a rich object, it is actually
-    just an index into the ``Examples`` class defined below. This has two
-    purposes: Firstly, for most properties of examples we will never need
-    to allocate storage at all, because most properties are not used on
-    most examples. Secondly, by storing the properties as compact lists
-    of integers, we save a considerable amount of space compared to
-    Python's normal object size.
-
-    This does have the downside that it increases the amount of allocation
-    we do, and slows things down as a result, in some usage patterns because
-    we repeatedly allocate the same Example or int objects, but it will
-    often dramatically reduce our memory usage, so is worth it.
-    """
-
-    __slots__ = ("owner", "index")
-
-    def __init__(self, owner: "Examples", index: int) -> None:
-        self.owner = owner
-        self.index = index
-
-    def __eq__(self, other: object) -> bool:
-        if self is other:
-            return True
-        if not isinstance(other, Example):
-            return NotImplemented
-        return (self.owner is other.owner) and (self.index == other.index)
-
-    def __ne__(self, other: object) -> bool:
-        if self is other:
-            return False
-        if not isinstance(other, Example):
-            return NotImplemented
-        return (self.owner is not other.owner) or (self.index != other.index)
-
-    def __repr__(self) -> str:
-        return f"examples{self.index}"
-
-    @property
-    def label(self) -> int:
-        """A label is an opaque value that associates each example with its
-        approximate origin, such as a particular strategy class or a particular
-        kind of draw."""
-        return self.owner.labelsself.owner.label_indicesself.index
-
-    @property
-    def parent(self):
-        """The index of the example that this one is nested directly within."""
-        if self.index == 0:
-            return None
-        return self.owner.parentageself.index
-
-    @property
-    def start(self) -> int:
-        """The position of the start of this example in the byte stream."""
-        return self.owner.startsself.index
-
-    @property
-    def end(self) -> int:
-        """The position directly after the last byte in this byte stream.
-        i.e. the example corresponds to the half open region start, end).
-        """
-        return self.owner.endsself.index
-
-    @property
-    def depth(self):
-        """Depth of this example in the example tree. The top-level example has a
-        depth of 0."""
-        return self.owner.depthsself.index
-
-    @property
-    def trivial(self):
-        """An example is "trivial" if it only contains forced bytes and zero bytes.
-        All examples start out as trivial, and then get marked non-trivial when
-        we see a byte that is neither forced nor zero."""
-        return self.index in self.owner.trivial
-
-    @property
-    def discarded(self) -> bool:
-        """True if this is example's ``stop_example`` call had ``discard`` set to
-        ``True``. This means we believe that the shrinker should be able to delete
-        this example completely, without affecting the value produced by its enclosing
-        strategy. Typically set when a rejection sampler decides to reject a
-        generated value and try again."""
-        return self.index in self.owner.discarded
-
-    @property
-    def length(self) -> int:
-        """The number of bytes in this example."""
-        return self.end - self.start
-
-    @property
-    def children(self) -> "ListExample":
-        """The list of all examples with this as a parent, in increasing index
-        order."""
-        return self.owneri for i in self.owner.childrenself.index
-
-
-class ExampleProperty:
-    """There are many properties of examples that we calculate by
-    essentially rerunning the test case multiple times based on the
-    calls which we record in ExampleRecord.
-
-    This class defines a visitor, subclasses of which can be used
-    to calculate these properties.
-    """
-
-    def __init__(self, examples: "Examples"):
-        self.example_stack: "Listint" = 
-        self.examples = examples
-        self.bytes_read = 0
-        self.example_count = 0
-        self.block_count = 0
-
-    def run(self) -> Any:
-        """Rerun the test case with this visitor and return the
-        results of ``self.finish()``."""
-        self.begin()
-        blocks = self.examples.blocks
-        for record in self.examples.trail:
-            if record == DRAW_BITS_RECORD:
-                self.__push(0)
-                self.bytes_read = blocks.endpointsself.block_count
-                self.block(self.block_count)
-                self.block_count += 1
-                self.__pop(False)
-            elif record >= START_EXAMPLE_RECORD:
-                self.__push(record - START_EXAMPLE_RECORD)
-            else:
-                assert record in (
-                    STOP_EXAMPLE_DISCARD_RECORD,
-                    STOP_EXAMPLE_NO_DISCARD_RECORD,
-                )
-                self.__pop(record == STOP_EXAMPLE_DISCARD_RECORD)
-        return self.finish()
-
-    def __push(self, label_index: int) -> None:
-        i = self.example_count
-        assert i < len(self.examples)
-        self.start_example(i, label_index)
-        self.example_count += 1
-        self.example_stack.append(i)
-
-    def __pop(self, discarded: bool) -> None:
-        i = self.example_stack.pop()
-        self.stop_example(i, discarded)
-
-    def begin(self) -> None:
-        """Called at the beginning of the run to initialise any
-        relevant state."""
-        self.result = IntList.of_length(len(self.examples))
-
-    def start_example(self, i: int, label_index: int) -> None:
-        """Called at the start of each example, with ``i`` the
-        index of the example and ``label_index`` the index of
-        its label in ``self.examples.labels``."""
-
-    def block(self, i: int) -> None:
-        """Called with each ``draw_bits`` call, with ``i`` the index of the
-        corresponding block in ``self.examples.blocks``"""
-
-    def stop_example(self, i: int, discarded: bool) -> None:
-        """Called at the end of each example, with ``i`` the
-        index of the example and ``discarded`` being ``True`` if ``stop_example``
-        was called with ``discard=True``."""
-
-    def finish(self) -> Any:
-        return self.result
-
-
-def calculated_example_property(cls: TypeExampleProperty) -> Any:
-    """Given an ``ExampleProperty`` as above we use this decorator
-    to transform it into a lazy property on the ``Examples`` class,
-    which has as its value the result of calling ``cls.run()``,
-    computed the first time the property is accessed.
-
-    This has the slightly weird result that we are defining nested
-    classes which get turned into properties."""
-    name = cls.__name__
-    cache_name = "__" + name
-
-    def lazy_calculate(self: "Examples") -> IntList:
-        result = getattr(self, cache_name, None)
-        if result is None:
-            result = cls(self).run()
-            setattr(self, cache_name, result)
-        return result
-
-    lazy_calculate.__name__ = cls.__name__
-    lazy_calculate.__qualname__ = cls.__qualname__
-    return property(lazy_calculate)
-
-
-DRAW_BITS_RECORD = 0
-STOP_EXAMPLE_DISCARD_RECORD = 1
-STOP_EXAMPLE_NO_DISCARD_RECORD = 2
-START_EXAMPLE_RECORD = 3
-
-
-class ExampleRecord:
-    """Records the series of ``start_example``, ``stop_example``, and
-    ``draw_bits`` calls so that these may be stored in ``Examples`` and
-    replayed when we need to know about the structure of individual
-    ``Example`` objects.
-
-    Note that there is significant similarity between this class and
-    ``DataObserver``, and the plan is to eventually unify them, but
-    they currently have slightly different functions and implementations.
-    """
-
-    def __init__(self) -> None:
-        self.labels = DRAW_BYTES_LABEL
-        self.__index_of_labels: "OptionalDictint, int" = {DRAW_BYTES_LABEL: 0}
-        self.trail = IntList()
-
-    def freeze(self) -> None:
-        self.__index_of_labels = None
-
-    def start_example(self, label: int) -> None:
-        assert self.__index_of_labels is not None
-        try:
-            i = self.__index_of_labelslabel
-        except KeyError:
-            i = self.__index_of_labels.setdefault(label, len(self.labels))
-            self.labels.append(label)
-        self.trail.append(START_EXAMPLE_RECORD + i)
-
-    def stop_example(self, discard: bool) -> None:
-        if discard:
-            self.trail.append(STOP_EXAMPLE_DISCARD_RECORD)
-        else:
-            self.trail.append(STOP_EXAMPLE_NO_DISCARD_RECORD)
-
-    def draw_bits(self, n: int, forced: Optionalint) -> None:
-        self.trail.append(DRAW_BITS_RECORD)
-
-
-class Examples:
-    """A lazy collection of ``Example`` objects, derived from
-    the record of recorded behaviour in ``ExampleRecord``.
-
-    Behaves logically as if it were a list of ``Example`` objects,
-    but actually mostly exists as a compact store of information
-    for them to reference into. All properties on here are best
-    understood as the backing storage for ``Example`` and are
-    described there.
-    """
-
-    def __init__(self, record: ExampleRecord, blocks: "Blocks") -> None:
-        self.trail = record.trail
-        self.labels = record.labels
-        self.__length = (
-            self.trail.count(STOP_EXAMPLE_DISCARD_RECORD)
-            + record.trail.count(STOP_EXAMPLE_NO_DISCARD_RECORD)
-            + record.trail.count(DRAW_BITS_RECORD)
-        )
-        self.blocks = blocks
-        self.__children: "OptionalListSequenceint" = None
-
-    class _starts_and_ends(ExampleProperty):
-        def begin(self):
-            self.starts = IntList.of_length(len(self.examples))
-            self.ends = IntList.of_length(len(self.examples))
-
-        def start_example(self, i: int, label_index: int) -> None:
-            self.startsi = self.bytes_read
-
-        def stop_example(self, i: int, discarded: bool) -> None:
-            self.endsi = self.bytes_read
-
-        def finish(self) -> TupleIntList, IntList:
-            return (self.starts, self.ends)
-
-    starts_and_ends: "TupleIntList, IntList" = calculated_example_property(
-        _starts_and_ends
-    )
-
-    @property
-    def starts(self) -> IntList:
-        return self.starts_and_ends0
-
-    @property
-    def ends(self) -> IntList:
-        return self.starts_and_ends1
-
-    class _discarded(ExampleProperty):
-        def begin(self):
-            self.result: "Setint" = set()
-
-        def finish(self):
-            return frozenset(self.result)
-
-        def stop_example(self, i: int, discarded: bool) -> None:
-            if discarded:
-                self.result.add(i)
-
-    discarded: FrozenSetint = calculated_example_property(_discarded)
-
-    class _trivial(ExampleProperty):
-        def begin(self):
-            self.nontrivial = IntList.of_length(len(self.examples))
-            self.result: "Setint" = set()
-
-        def block(self, i: int) -> None:
-            if not self.examples.blocks.trivial(i):
-                self.nontrivialself.example_stack-1 = 1
-
-        def stop_example(self, i: int, discarded: bool) -> None:
-            if self.nontriviali:
-                if self.example_stack:
-                    self.nontrivialself.example_stack-1 = 1
-            else:
-                self.result.add(i)
-
-        def finish(self):
-            return frozenset(self.result)
-
-    trivial: FrozenSetint = calculated_example_property(_trivial)
-
-    class _parentage(ExampleProperty):
-        def stop_example(self, i: int, discarded: bool) -> None:
-            if i > 0:
-                self.resulti = self.example_stack-1
-
-    parentage: IntList = calculated_example_property(_parentage)
-
-    class _depths(ExampleProperty):
-        def begin(self):
-            self.result = IntList.of_length(len(self.examples))
-
-        def start_example(self, i: int, label_index: int) -> None:
-            self.resulti = len(self.example_stack)
-
-    depths: IntList = calculated_example_property(_depths)
-
-    class _label_indices(ExampleProperty):
-        def start_example(self, i: int, label_index: int) -> None:
-            self.resulti = label_index
-
-    label_indices: IntList = calculated_example_property(_label_indices)
-
-    class _mutator_groups(ExampleProperty):
-        def begin(self):
-            self.groups: "DictTupleint, int, Listint" = defaultdict(list)
-
-        def start_example(self, i: int, label_index: int) -> None:
-            depth = len(self.example_stack)
-            self.groupslabel_index, depth.append(i)
-
-        def finish(self) -> IterableIterableint:
-            # Discard groups with only one example, since the mutator can't
-            # do anything useful with them.
-            return g for g in self.groups.values() if len(g) >= 2
-
-    mutator_groups: ListListint = calculated_example_property(_mutator_groups)
-
-    @property
-    def children(self) -> ListSequenceint:
-        if self.__children is None:
-            children = IntList() for _ in range(len(self))
-            for i, p in enumerate(self.parentage):
-                if i > 0:
-                    childrenp.append(i)
-            # Replace empty children lists with a tuple to reduce
-            # memory usage.
-            for i, c in enumerate(children):
-                if not c:
-                    childreni = ()  # type: ignore
-            self.__children = children  # type: ignore
-        return self.__children  # type: ignore
-
-    def __len__(self) -> int:
-        return self.__length
-
-    def __getitem__(self, i: int) -> Example:
-        assert isinstance(i, int)
-        n = len(self)
-        if i < -n or i >= n:
-            raise IndexError(f"Index {i} out of range -{n}, {n})")
-        if i < 0:
-            i += n
-        return Example(self, i)
-
-
-@dataclass_transform()
-@attr.s(slots=True, frozen=True)
-class Block:
-    """Blocks track the flat list of lowest-level draws from the byte stream,
-    within a single test run.
-
-    Block-tracking allows the shrinker to try "low-level"
-    transformations, such as minimizing the numeric value of an
-    individual call to ``draw_bits``.
-    """
-
-    start: int = attr.ib()
-    end: int = attr.ib()
-
-    # Index of this block inside the overall list of blocks.
-    index: int = attr.ib()
-
-    # True if this block's byte values were forced by a write operation.
-    # As long as the bytes before this block remain the same, modifying this
-    # block's bytes will have no effect.
-    forced: bool = attr.ib(repr=False)
-
-    # True if this block's byte values are all 0. Reading this flag can be
-    # more convenient than explicitly checking a slice for non-zero bytes.
-    all_zero: bool = attr.ib(repr=False)
-
-    @property
-    def bounds(self) -> Tupleint, int:
-        return (self.start, self.end)
-
-    @property
-    def length(self) -> int:
-        return self.end - self.start
-
-    @property
-    def trivial(self) -> bool:
-        return self.forced or self.all_zero
-
-
-class Blocks:
-    """A lazily calculated list of blocks for a particular ``ConjectureResult``
-    or ``ConjectureData`` object.
-
-    Pretends to be a list containing ``Block`` objects but actually only
-    contains their endpoints right up until the point where you want to
-    access the actual block, at which point it is constructed.
-
-    This is designed to be as space efficient as possible, so will at
-    various points silently transform its representation into one
-    that is better suited for the current access pattern.
-
-    In addition, it has a number of convenience methods for accessing
-    properties of the block object at index ``i`` that should generally
-    be preferred to using the Block objects directly, as it will not
-    have to allocate the actual object."""
-
-    __slots__ = ("endpoints", "owner", "__blocks", "__count", "__sparse")
-    owner: "UnionConjectureData, ConjectureResult, None"
-    __blocks: UnionDictint, Block, ListOptionalBlock
-
-    def __init__(self, owner: "ConjectureData") -> None:
-        self.owner = owner
-        self.endpoints = IntList()
-        self.__blocks = {}
-        self.__count = 0
-        self.__sparse = True
-
-    def add_endpoint(self, n: int) -> None:
-        """Add n to the list of endpoints."""
-        assert isinstance(self.owner, ConjectureData)
-        self.endpoints.append(n)
-
-    def transfer_ownership(self, new_owner: "ConjectureResult") -> None:
-        """Used to move ``Blocks`` over to a ``ConjectureResult`` object
-        when that is read to be used and we no longer want to keep the
-        whole ``ConjectureData`` around."""
-        assert isinstance(new_owner, ConjectureResult)
-        self.owner = new_owner
-        self.__check_completion()
-
-    def start(self, i: int) -> int:
-        """Equivalent to selfi.start."""
-        i = self._check_index(i)
-
-        if i == 0:
-            return 0
-        else:
-            return self.end(i - 1)
-
-    def end(self, i: int) -> int:
-        """Equivalent to selfi.end."""
-        return self.endpointsi
-
-    def bounds(self, i: int) -> Tupleint, int:
-        """Equivalent to selfi.bounds."""
-        return (self.start(i), self.end(i))
-
-    def all_bounds(self) -> IterableTupleint, int:
-        """Equivalent to (b.start, b.end) for b in self."""
-        prev = 0
-        for e in self.endpoints:
-            yield (prev, e)
-            prev = e
-
-    @property
-    def last_block_length(self):
-        return self.end(-1) - self.start(-1)
-
-    def __len__(self) -> int:
-        return len(self.endpoints)
-
-    def __known_block(self, i: int) -> OptionalBlock:
-        try:
-            return self.__blocksi
-        except (KeyError, IndexError):
-            return None
-
-    def trivial(self, i: int) -> Any:
-        """Equivalent to self.blocksi.trivial."""
-        if self.owner is not None:
-            return self.start(i) in self.owner.forced_indices or not any(
-                self.owner.bufferself.start(i) : self.end(i)
-            )
-        else:
-            return selfi.trivial
-
-    def _check_index(self, i: int) -> int:
-        n = len(self)
-        if i < -n or i >= n:
-            raise IndexError(f"Index {i} out of range -{n}, {n})")
-        if i < 0:
-            i += n
-        return i
-
-    def __getitem__(self, i: int) -> Block:
-        i = self._check_index(i)
-        assert i >= 0
-        result = self.__known_block(i)
-        if result is not None:
-            return result
-
-        # We store the blocks as a sparse dict mapping indices to the
-        # actual result, but this isn't the best representation once we
-        # stop being sparse and want to use most of the blocks. Switch
-        # over to a list at that point.
-        if self.__sparse and len(self.__blocks) * 2 >= len(self):
-            new_blocks: "ListOptionalBlock" = None * len(self)
-            assert isinstance(self.__blocks, dict)
-            for k, v in self.__blocks.items():
-                new_blocksk = v
-            self.__sparse = False
-            self.__blocks = new_blocks
-            assert self.__blocksi is None
-
-        start = self.start(i)
-        end = self.end(i)
-
-        # We keep track of the number of blocks that have actually been
-        # instantiated so that when every block that could be instantiated
-        # has been we know that the list is complete and can throw away
-        # some data that we no longer need.
-        self.__count += 1
-
-        # Integrity check: We can't have allocated more blocks than we have
-        # positions for blocks.
-        assert self.__count <= len(self)
-        assert self.owner is not None
-        result = Block(
-            start=start,
-            end=end,
-            index=i,
-            forced=start in self.owner.forced_indices,
-            all_zero=not any(self.owner.bufferstart:end),
-        )
-        try:
-            self.__blocksi = result
-        except IndexError:
-            assert isinstance(self.__blocks, list)
-            assert len(self.__blocks) < len(self)
-            self.__blocks.extend(None * (len(self) - len(self.__blocks)))
-            self.__blocksi = result
-
-        self.__check_completion()
-
-        return result
-
-    def __check_completion(self):
-        """The list of blocks is complete if we have created every ``Block``
-        object that we currently good and know that no more will be created.
-
-        If this happens then we don't need to keep the reference to the
-        owner around, and delete it so that there is no circular reference.
-        The main benefit of this is that the gc doesn't need to run to collect
-        this because normal reference counting is enough.
-        """
-        if self.__count == len(self) and isinstance(self.owner, ConjectureResult):
-            self.owner = None
-
-    def __iter__(self) -> IteratorBlock:
-        for i in range(len(self)):
-            yield selfi
-
-    def __repr__(self) -> str:
-        parts: "Liststr" = 
-        for i in range(len(self)):
-            b = self.__known_block(i)
-            if b is None:
-                parts.append("...")
-            else:
-                parts.append(repr(b))
-        return "Block({})".format(", ".join(parts))
-
-
-class _Overrun:
-    status = Status.OVERRUN
-
-    def __repr__(self):
-        return "Overrun"
-
-    def as_result(self) -> "_Overrun":
-        return self
-
-
-Overrun = _Overrun()
-
-global_test_counter = 0
-
-
-MAX_DEPTH = 100
-
-
-class DataObserver:
-    """Observer class for recording the behaviour of a
-    ConjectureData object, primarily used for tracking
-    the behaviour in the tree cache."""
-
-    def conclude_test(
-        self,
-        status: Status,
-        interesting_origin: OptionalInterestingOrigin,
-    ) -> None:
-        """Called when ``conclude_test`` is called on the
-        observed ``ConjectureData``, with the same arguments.
-
-        Note that this is called after ``freeze`` has completed.
-        """
-
-    def draw_bits(self, n_bits: int, forced: bool, value: int) -> None:
-        """Called when ``draw_bits`` is called on on the
-        observed ``ConjectureData``.
-        * ``n_bits`` is the number of bits drawn.
-        *  ``forced`` is True if the corresponding
-           draw was forced or ``False`` otherwise.
-        * ``value`` is the result that ``draw_bits`` returned.
-        """
-
-    def kill_branch(self) -> None:
-        """Mark this part of the tree as not worth re-exploring."""
-
-
-@dataclass_transform()
-@attr.s(slots=True)
-class ConjectureResult:
-    """Result class storing the parts of ConjectureData that we
-    will care about after the original ConjectureData has outlived its
-    usefulness."""
-
-    status: Status = attr.ib()
-    interesting_origin: OptionalInterestingOrigin = attr.ib()
-    buffer: bytes = attr.ib()
-    blocks: Blocks = attr.ib()
-    output: str = attr.ib()
-    extra_information: OptionalExtraInformation = attr.ib()
-    has_discards: bool = attr.ib()
-    target_observations: TargetObservations = attr.ib()
-    tags: FrozenSetStructuralCoverageTag = attr.ib()
-    forced_indices: FrozenSetint = attr.ib(repr=False)
-    examples: Examples = attr.ib(repr=False)
-
-    index: int = attr.ib(init=False)
-
-    def __attrs_post_init__(self) -> None:
-        self.index = len(self.buffer)
-        self.forced_indices = frozenset(self.forced_indices)
-
-    def as_result(self) -> "ConjectureResult":
-        return self
-
-
-# Masks for masking off the first byte of an n-bit buffer.
-# The appropriate mask is stored at position n % 8.
-BYTE_MASKS = (1 << n) - 1 for n in range(8)
-BYTE_MASKS0 = 255
-
-
-class ConjectureData:
-    @classmethod
-    def for_buffer(
-        cls,
-        buffer: UnionListint, bytes,
-        observer: OptionalDataObserver = None,
-    ) -> "ConjectureData":
-        return cls(len(buffer), buffer, random=None, observer=observer)
-
-    def __init__(
-        self,
-        max_length: int,
-        prefix: UnionListint, bytes, bytearray,
-        random: OptionalRandom,
-        observer: OptionalDataObserver = None,
-    ) -> None:
-        if observer is None:
-            observer = DataObserver()
-        assert isinstance(observer, DataObserver)
-        self.__bytes_drawn = 0
-        self.observer = observer
-        self.max_length = max_length
-        self.is_find = False
-        self.overdraw = 0
-        self.__prefix = prefix
-        self.__random = random
-
-        assert random is not None or max_length <= len(prefix)
-
-        self.blocks = Blocks(self)
-        self.buffer: "Unionbytes, bytearray" = bytearray()
-        self.index = 0
-        self.output = ""
-        self.status = Status.VALID
-        self.frozen = False
-        global global_test_counter
-        self.testcounter = global_test_counter
-        global_test_counter += 1
-        self.start_time = time.perf_counter()
-        self.events: "UnionSetHashable, FrozenSetHashable" = set()
-        self.forced_indices: "Setint" = set()
-        self.interesting_origin: OptionalInterestingOrigin = None
-        self.draw_times: "Listfloat" = 
-        self.max_depth = 0
-        self.has_discards = False
-
-        self.__result: "OptionalConjectureResult" = None
-
-        # Observations used for targeted search.  They'll be aggregated in
-        # ConjectureRunner.generate_new_examples and fed to TargetSelector.
-        self.target_observations: TargetObservations = {}
-
-        # Tags which indicate something about which part of the search space
-        # this example is in. These are used to guide generation.
-        self.tags: "SetStructuralCoverageTag" = set()
-        self.labels_for_structure_stack: "ListSetint" = 
-
-        # Normally unpopulated but we need this in the niche case
-        # that self.as_result() is Overrun but we still want the
-        # examples for reporting purposes.
-        self.__examples: "OptionalExamples" = None
-
-        # We want the top level example to have depth 0, so we start
-        # at -1.
-        self.depth = -1
-        self.__example_record = ExampleRecord()
-
-        self.extra_information = ExtraInformation()
-
-        self.start_example(TOP_LABEL)
-
-    def __repr__(self):
-        return "ConjectureData(%s, %d bytes%s)" % (
-            self.status.name,
-            len(self.buffer),
-            ", frozen" if self.frozen else "",
-        )
-
-    def as_result(self) -> UnionConjectureResult, _Overrun:
-        """Convert the result of running this test into
-        either an Overrun object or a ConjectureResult."""
-
-        assert self.frozen
-        if self.status == Status.OVERRUN:
-            return Overrun
-        if self.__result is None:
-            self.__result = ConjectureResult(
-                status=self.status,
-                interesting_origin=self.interesting_origin,
-                buffer=self.buffer,
-                examples=self.examples,
-                blocks=self.blocks,
-                output=self.output,
-                extra_information=self.extra_information
-                if self.extra_information.has_information()
-                else None,
-                has_discards=self.has_discards,
-                target_observations=self.target_observations,
-                tags=frozenset(self.tags),
-                forced_indices=frozenset(self.forced_indices),
-            )
-            assert self.__result is not None
-            self.blocks.transfer_ownership(self.__result)
-        return self.__result
-
-    def __assert_not_frozen(self, name: str) -> None:
-        if self.frozen:
-            raise Frozen(f"Cannot call {name} on frozen ConjectureData")
-
-    def note(self, value: Any) -> None:
-        self.__assert_not_frozen("note")
-        if not isinstance(value, str):
-            value = repr(value)
-        self.output += value
-
-    def draw(self, strategy: "SearchStrategyAny", label: Optionalint = None) -> Any:
-        if self.is_find and not strategy.supports_find:
-            raise InvalidArgument(
-                f"Cannot use strategy {strategy!r} within a call to find "
-                "(presumably because it would be invalid after the call had ended)."
-            )
-
-        at_top_level = self.depth == 0
-        start_time = None
-        if at_top_level:
-            # We start this timer early, because accessing attributes on a LazyStrategy
-            # can be almost arbitrarily slow.  In cases like characters() and text()
-            # where we cache something expensive, this led to Flaky deadline errors!
-            # See https://github.com/HypothesisWorks/hypothesis/issues/2108
-            start_time = time.perf_counter()
-
-        strategy.validate()
-
-        if strategy.is_empty:
-            self.mark_invalid()
-
-        if self.depth >= MAX_DEPTH:
-            self.mark_invalid()
-
-        if label is None:
-            assert isinstance(strategy.label, int)
-            label = strategy.label
-        self.start_example(label=label)
-        try:
-            if not at_top_level:
-                return strategy.do_draw(self)
-            else:
-                assert start_time is not None
-                strategy.validate()
-                try:
-                    return strategy.do_draw(self)
-                finally:
-                    self.draw_times.append(time.perf_counter() - start_time)
-        finally:
-            self.stop_example()
-
-    def start_example(self, label: int) -> None:
-        self.__assert_not_frozen("start_example")
-        self.depth += 1
-        # Logically it would make sense for this to just be
-        # ``self.depth = max(self.depth, self.max_depth)``, which is what it used to
-        # be until we ran the code under tracemalloc and found a rather significant
-        # chunk of allocation was happening here. This was presumably due to varargs
-        # or the like, but we didn't investigate further given that it was easy
-        # to fix with this check.
-        if self.depth > self.max_depth:
-            self.max_depth = self.depth
-        self.__example_record.start_example(label)
-        self.labels_for_structure_stack.append({label})
-
-    def stop_example(self, discard: bool = False) -> None:
-        if self.frozen:
-            return
-        if discard:
-            self.has_discards = True
-        self.depth -= 1
-        assert self.depth >= -1
-        self.__example_record.stop_example(discard)
-
-        labels_for_structure = self.labels_for_structure_stack.pop()
-
-        if not discard:
-            if self.labels_for_structure_stack:
-                self.labels_for_structure_stack-1.update(labels_for_structure)
-            else:
-                self.tags.update(structural_coverage(l) for l in labels_for_structure)
-
-        if discard:
-            # Once we've discarded an example, every test case starting with
-            # this prefix contains discards. We prune the tree at that point so
-            # as to avoid future test cases bothering with this region, on the
-            # assumption that some example that you could have used instead
-            # there would *not* trigger the discard. This greatly speeds up
-            # test case generation in some cases, because it allows us to
-            # ignore large swathes of the search space that are effectively
-            # redundant.
-            #
-            # A scenario that can cause us problems but which we deliberately
-            # have decided not to support is that if there are side effects
-            # during data generation then you may end up with a scenario where
-            # every good test case generates a discard because the discarded
-            # section sets up important things for later. This is not terribly
-            # likely and all that you see in this case is some degradation in
-            # quality of testing, so we don't worry about it.
-            #
-            # Note that killing the branch does *not* mean we will never
-            # explore below this point, and in particular we may do so during
-            # shrinking. Any explicit request for a data object that starts
-            # with the branch here will work just fine, but novel prefix
-            # generation will avoid it, and we can use it to detect when we
-            # have explored the entire tree (up to redundancy).
-
-            self.observer.kill_branch()
-
-    def note_event(self, event: Hashable) -> None:
-        assert isinstance(self.events, set)
-        self.events.add(event)
-
-    @property
-    def examples(self) -> Examples:
-        assert self.frozen
-        if self.__examples is None:
-            self.__examples = Examples(record=self.__example_record, blocks=self.blocks)
-        return self.__examples
-
-    def freeze(self) -> None:
-        if self.frozen:
-            assert isinstance(self.buffer, bytes)
-            return
-        self.finish_time = time.perf_counter()
-        assert len(self.buffer) == self.index
-
-        # Always finish by closing all remaining examples so that we have a
-        # valid tree.
-        while self.depth >= 0:
-            self.stop_example()
-
-        self.__example_record.freeze()
-
-        self.frozen = True
-
-        self.buffer = bytes(self.buffer)
-        self.events = frozenset(self.events)
-        self.observer.conclude_test(self.status, self.interesting_origin)
-
-    def draw_bits(self, n: int, *, forced: Optionalint = None) -> int:
-        """Return an ``n``-bit integer from the underlying source of
-        bytes. If ``forced`` is set to an integer will instead
-        ignore the underlying source and simulate a draw as if it had
-        returned that integer."""
-        self.__assert_not_frozen("draw_bits")
-        if n == 0:
-            return 0
-        assert n > 0
-        n_bytes = bits_to_bytes(n)
-        self.__check_capacity(n_bytes)
-
-        if forced is not None:
-            buf = int_to_bytes(forced, n_bytes)
-        elif self.__bytes_drawn < len(self.__prefix):
-            index = self.__bytes_drawn
-            buf = self.__prefixindex : index + n_bytes
-            if len(buf) < n_bytes:
-                assert self.__random is not None
-                buf += uniform(self.__random, n_bytes - len(buf))
-        else:
-            assert self.__random is not None
-            buf = uniform(self.__random, n_bytes)
-        buf = bytearray(buf)
-        self.__bytes_drawn += n_bytes
-
-        assert len(buf) == n_bytes
-
-        # If we have a number of bits that is not a multiple of 8
-        # we have to mask off the high bits.
-        buf0 &= BYTE_MASKSn % 8
-        buf = bytes(buf)
-        result = int_from_bytes(buf)
-
-        self.observer.draw_bits(n, forced is not None, result)
-        self.__example_record.draw_bits(n, forced)
-
-        initial = self.index
-
-        assert isinstance(self.buffer, bytearray)
-        self.buffer.extend(buf)
-        self.index = len(self.buffer)
-
-        if forced is not None:
-            self.forced_indices.update(range(initial, self.index))
-
-        self.blocks.add_endpoint(self.index)
-
-        assert result.bit_length() <= n
-        return result
-
-    def draw_bytes(self, n: int) -> bytes:
-        """Draw n bytes from the underlying source."""
-        return int_to_bytes(self.draw_bits(8 * n), n)
-
-    def write(self, string: bytes) -> Optionalbytes:
-        """Write ``string`` to the output buffer."""
-        self.__assert_not_frozen("write")
-        string = bytes(string)
-        if not string:
-            return None
-        self.draw_bits(len(string) * 8, forced=int_from_bytes(string))
-        return self.buffer-len(string) :
-
-    def __check_capacity(self, n: int) -> None:
-        if self.index + n > self.max_length:
-            self.mark_overrun()
-
-    def conclude_test(
-        self,
-        status: Status,
-        interesting_origin: OptionalInterestingOrigin = None,
-    ) -> None:
-        assert (interesting_origin is None) or (status == Status.INTERESTING)
-        self.__assert_not_frozen("conclude_test")
-        self.interesting_origin = interesting_origin
-        self.status = status
-        self.freeze()
-        raise StopTest(self.testcounter)
-
-    def mark_interesting(
-        self, interesting_origin: OptionalInterestingOrigin = None
-    ) -> None:
-        self.conclude_test(Status.INTERESTING, interesting_origin)
-
-    def mark_invalid(self):
-        self.conclude_test(Status.INVALID)
-
-    def mark_overrun(self):
-        self.conclude_test(Status.OVERRUN)
-
-
-def bits_to_bytes(n: int) -> int:
-    """The number of bytes required to represent an n-bit number.
-    Equivalent to (n + 7) // 8, but slightly faster. This really is
-    called enough times that that matters."""
-    return (n + 7) >> 3

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/dfa Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/dfa/lstar.py Deleted

@@ -1,498 +0,0 @@
-# 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/.
-
-from bisect import bisect_right, insort
-from collections import Counter
-
-from hypothesis.errors import InvalidState
-from hypothesis.internal.conjecture.dfa import DFA, cached
-from hypothesis.internal.conjecture.junkdrawer import (
-    IntList,
-    NotFound,
-    SelfOrganisingList,
-    find_integer,
-)
-
-"""
-This module contains an implementation of the L* algorithm
-for learning a deterministic finite automaton based on an
-unknown membership function and a series of examples of
-strings that may or may not satisfy it.
-
-The two relevant papers for understanding this are:
-
-* Angluin, Dana. "Learning regular sets from queries and counterexamples."
-  Information and computation 75.2 (1987): 87-106.
-* Rivest, Ronald L., and Robert E. Schapire. "Inference of finite automata
-  using homing sequences." Information and Computation 103.2 (1993): 299-347.
-  Note that we only use the material from section 4.5 "Improving Angluin's L*
-  algorithm" (page 318), and all of the rest of the material on homing
-  sequences can be skipped.
-
-The former explains the core algorithm, the latter a modification
-we use (which we have further modified) which allows it to
-be implemented more efficiently.
-
-Although we continue to call this L*, we in fact depart heavily from it to the
-point where honestly this is an entirely different algorithm and we should come
-up with a better name.
-
-We have several major departures from the papers:
-
-1. We learn the automaton lazily as we traverse it. This is particularly
-   valuable because if we make many corrections on the same string we only
-   have to learn the transitions that correspond to the string we are
-   correcting on.
-2. We make use of our ``find_integer`` method rather than a binary search
-   as proposed in the Rivest and Schapire paper, as we expect that
-   usually most strings will be mispredicted near the beginning.
-3. We try to learn a smaller alphabet of "interestingly distinct"
-   values. e.g. if all bytes larger than two result in an invalid
-   string, there is no point in distinguishing those bytes. In aid
-   of this we learn a single canonicalisation table which maps integers
-   to smaller integers that we currently think are equivalent, and learn
-   their inequivalence where necessary. This may require more learning
-   steps, as at each stage in the process we might learn either an
-   inequivalent pair of integers or a new experiment, but it may greatly
-   reduce the number of membership queries we have to make.
-
-
-In addition, we have a totally different approach for mapping a string to its
-canonical representative, which will be explained below inline. The general gist
-is that our implementation is much more willing to make mistakes: It will often
-create a DFA that is demonstrably wrong, based on information that it already
-has, but where it is too expensive to discover that before it causes us to
-make a mistake.
-
-A note on performance: This code is not really fast enough for
-us to ever want to run in production on large strings, and this
-is somewhat intrinsic. We should only use it in testing or for
-learning languages offline that we can record for later use.
-
-"""
-
-import attr
-
-
-@attr.s(slots=True)
-class DistinguishedState:
-    """Relevant information for a state that we have witnessed as definitely
-    distinct from ones we have previously seen so far."""
-
-    # Index of this state in the learner's list of states
-    index = attr.ib()
-
-    # A string that witnesses this state (i.e. when starting from the origin
-    # and following this string you will end up in this state).
-    label = attr.ib()
-
-    # A boolean as to whether this is an accepting state.
-    accepting = attr.ib()
-
-    # A list of experiments that it is necessary to run to determine whether
-    # a string is in this state. This is stored as a dict mapping experiments
-    # to their expected result. A string is only considered to lead to this
-    # state if ``all(learner.member(s + experiment) == result for experiment,
-    # result in self.experiments.items())``.
-    experiments = attr.ib()
-
-    # A cache of transitions out of this state, mapping bytes to the states
-    # that they lead to.
-    transitions = attr.ib(default=attr.Factory(dict))
-
-
-class LStar:
-    """This class holds the state for learning a DFA. The current DFA can be
-    accessed as the ``dfa`` member of this class. Such a DFA becomes invalid
-    as soon as ``learn`` has been called, and should only be used until the
-    next call to ``learn``.
-
-    Note that many of the DFA methods are on this class, but it is not itself
-    a DFA. The reason for this is that it stores mutable state which can cause
-    the structure of the learned DFA to change in potentially arbitrary ways,
-    making all cached properties become nonsense.
-    """
-
-    def __init__(self, member):
-        self.experiments = 
-        self.__experiment_set = set()
-        self.normalizer = IntegerNormalizer()
-
-        self.__member_cache = {}
-        self.__member = member
-        self.__generation = 0
-
-        # A list of all state objects that correspond to strings we have
-        # seen and can demonstrate map to unique states.
-        self.__states = 
-            DistinguishedState(
-                index=0,
-                label=b"",
-                accepting=self.member(b""),
-                experiments={b"": self.member(b"")},
-            )
-        
-
-        # When we're trying to figure out what state a string leads to we will
-        # end up searching to find a suitable candidate. By putting states in
-        # a self-organisating list we ideally minimise the number of lookups.
-        self.__self_organising_states = SelfOrganisingList(self.__states)
-
-        self.start = 0
-
-        self.__dfa_changed()
-
-    def __dfa_changed(self):
-        """Note that something has changed, updating the generation
-        and resetting any cached state."""
-        self.__generation += 1
-        self.dfa = LearnedDFA(self)
-
-    def is_accepting(self, i):
-        """Equivalent to ``self.dfa.is_accepting(i)``"""
-        return self.__statesi.accepting
-
-    def label(self, i):
-        """Returns the string label for state ``i``."""
-        return self.__statesi.label
-
-    def transition(self, i, c):
-        """Equivalent to ``self.dfa.transition(i, c)```"""
-        c = self.normalizer.normalize(c)
-        state = self.__statesi
-        try:
-            return state.transitionsc
-        except KeyError:
-            pass
-
-        # The state that we transition to when reading ``c`` is reached by
-        # this string, because this state is reached by state.label. We thus
-        # want our candidate for the transition to be some state with a label
-        # equivalent to this string.
-        #
-        # We find such a state by looking for one such that all of its listed
-        # experiments agree on the result for its state label and this string.
-        string = state.label + bytes(c)
-
-        # We keep track of some useful experiments for distinguishing this
-        # string from other states, as this both allows us to more accurately
-        # select the state to map to and, if necessary, create the new state
-        # that this string corresponds to with a decent set of starting
-        # experiments.
-        accumulated = {}
-        counts = Counter()
-
-        def equivalent(t):
-            """Checks if ``string`` could possibly lead to state ``t``."""
-            for e, expected in accumulated.items():
-                if self.member(t.label + e) != expected:
-                    countse += 1
-                    return False
-
-            for e, expected in t.experiments.items():
-                result = self.member(string + e)
-                if result != expected:
-                    # We expect most experiments to return False so if we add
-                    # only True ones to our collection of essential experiments
-                    # we keep the size way down and select only ones that are
-                    # likely to provide useful information in future.
-                    if result:
-                        accumulatede = result
-                    return False
-            return True
-
-        try:
-            destination = self.__self_organising_states.find(equivalent)
-        except NotFound:
-            i = len(self.__states)
-            destination = DistinguishedState(
-                index=i,
-                label=string,
-                experiments=accumulated,
-                accepting=self.member(string),
-            )
-            self.__states.append(destination)
-            self.__self_organising_states.add(destination)
-        state.transitionsc = destination.index
-        return destination.index
-
-    def member(self, s):
-        """Check whether this string is a member of the language
-        to be learned."""
-        try:
-            return self.__member_caches
-        except KeyError:
-            result = self.__member(s)
-            self.__member_caches = result
-            return result
-
-    @property
-    def generation(self):
-        """Return an integer value that will be incremented
-        every time the DFA we predict changes."""
-        return self.__generation
-
-    def learn(self, string):
-        """Learn to give the correct answer on this string.
-        That is, after this method completes we will have
-        ``self.dfa.matches(s) == self.member(s)``.
-
-        Note that we do not guarantee that this will remain
-        true in the event that learn is called again with
-        a different string. It is in principle possible that
-        future learning will cause us to make a mistake on
-        this string. However, repeatedly calling learn on
-        each of a set of strings until the generation stops
-        changing is guaranteed to terminate.
-        """
-        string = bytes(string)
-        correct_outcome = self.member(string)
-
-        # We don't want to check this inside the loop because it potentially
-        # causes us to evaluate more of the states than we actually need to,
-        # but if our model is mostly correct then this will be faster because
-        # we only need to evaluate strings that are of the form
-        # ``state + experiment``, which will generally be cached and/or needed
-        # later.
-        if self.dfa.matches(string) == correct_outcome:
-            return
-
-        # In the papers they assume that we only run this process
-        # once, but this is silly - often when you've got a messy
-        # string it will be wrong for many different reasons.
-        #
-        # Thus we iterate this to a fixed point where we repair
-        # the DFA by repeatedly adding experiments until the DFA
-        # agrees with the membership function on this string.
-
-        # First we make sure that normalization is not the source of the
-        # failure to match.
-        while True:
-            normalized = bytes(self.normalizer.normalize(c) for c in string)
-            # We can correctly replace the string with its normalized version
-            # so normalization is not the problem here.
-            if self.member(normalized) == correct_outcome:
-                string = normalized
-                break
-            alphabet = sorted(set(string), reverse=True)
-            target = string
-            for a in alphabet:
-
-                def replace(b):
-                    if a == b:
-                        return target
-                    return bytes(b if c == a else c for c in target)
-
-                self.normalizer.distinguish(a, lambda x: self.member(replace(x)))
-                target = replace(self.normalizer.normalize(a))
-                assert self.member(target) == correct_outcome
-            assert target != normalized
-            self.__dfa_changed()
-
-        if self.dfa.matches(string) == correct_outcome:
-            return
-
-        # Now we know normalization is correct we can attempt to determine if
-        # any of our transitions are wrong.
-        while True:
-            dfa = self.dfa
-
-            states = dfa.start
-
-            def seems_right(n):
-                """After reading n characters from s, do we seem to be
-                in the right state?
-
-                We determine this by replacing the first n characters
-                of s with the label of the state we expect to be in.
-                If we are in the right state, that will replace a substring
-                with an equivalent one so must produce the same answer.
-                """
-                if n > len(string):
-                    return False
-
-                # Populate enough of the states list to know where we are.
-                while n >= len(states):
-                    states.append(dfa.transition(states-1, stringlen(states) - 1))
-
-                return self.member(dfa.label(statesn) + stringn:) == correct_outcome
-
-            assert seems_right(0)
-
-            n = find_integer(seems_right)
-
-            # We got to the end without ever finding ourself in a bad
-            # state, so we must correctly match this string.
-            if n == len(string):
-                assert dfa.matches(string) == correct_outcome
-                break
-
-            # Reading n characters does not put us in a bad state but
-            # reading n + 1 does. This means that the remainder of
-            # the string that we have not read yet is an experiment
-            # that allows us to distinguish the state that we ended
-            # up in from the state that we should have ended up in.
-
-            source = statesn
-            character = stringn
-            wrong_destination = statesn + 1
-
-            # We've made an error in transitioning from ``source`` to
-            # ``wrong_destination`` via ``character``. We now need to update
-            # the DFA so that this transition no longer occurs. Note that we
-            # do not guarantee that the transition is *correct* after this,
-            # only that we don't make this particular error.
-            assert self.transition(source, character) == wrong_destination
-
-            labels_wrong_destination = self.dfa.label(wrong_destination)
-            labels_correct_destination = self.dfa.label(source) + bytes(character)
-
-            ex = stringn + 1 :
-
-            assert self.member(labels_wrong_destination + ex) != self.member(
-                labels_correct_destination + ex
-            )
-
-            # Adding this experiment causes us to distinguish the wrong
-            # destination from the correct one.
-            self.__stateswrong_destination.experimentsex = self.member(
-                labels_wrong_destination + ex
-            )
-
-            # We now clear the cached details that caused us to make this error
-            # so that when we recalculate this transition we get to a
-            # (hopefully now correct) different state.
-            del self.__statessource.transitionscharacter
-            self.__dfa_changed()
-
-            # We immediately recalculate the transition so that we can check
-            # that it has changed as we expect it to have.
-            new_destination = self.transition(source, stringn)
-            assert new_destination != wrong_destination
-
-
-class LearnedDFA(DFA):
-    """This implements a lazily calculated DFA where states
-    are labelled by some string that reaches them, and are
-    distinguished by a membership test and a set of experiments."""
-
-    def __init__(self, lstar):
-        super().__init__()
-        self.__lstar = lstar
-        self.__generation = lstar.generation
-
-    def __check_changed(self):
-        if self.__generation != self.__lstar.generation:
-            raise InvalidState(
-                "The underlying L* model has changed, so this DFA is no longer valid. "
-                "If you want to preserve a previously learned DFA for posterity, call "
-                "canonicalise() on it first."
-            )
-
-    def label(self, i):
-        self.__check_changed()
-        return self.__lstar.label(i)
-
-    @property
-    def start(self):
-        self.__check_changed()
-        return self.__lstar.start
-
-    def is_accepting(self, i):
-        self.__check_changed()
-        return self.__lstar.is_accepting(i)
-
-    def transition(self, i, c):
-        self.__check_changed()
-
-        return self.__lstar.transition(i, c)
-
-    @cached
-    def successor_states(self, state):
-        """Returns all of the distinct states that can be reached via one
-        transition from ``state``, in the lexicographic order of the
-        smallest character that reaches them."""
-        seen = set()
-        result = 
-        for c in self.__lstar.normalizer.representatives():
-            j = self.transition(state, c)
-            if j not in seen:
-                seen.add(j)
-                result.append(j)
-        return tuple(result)
-
-
-class IntegerNormalizer:
-    """A class for replacing non-negative integers with a
-    "canonical" value that is equivalent for all relevant
-    purposes."""
-
-    def __init__(self):
-        # We store canonical values as a sorted list of integers
-        # with each value being treated as equivalent to the largest
-        # integer in the list that is below it.
-        self.__values = IntList(0)
-        self.__cache = {}
-
-    def __repr__(self):
-        return f"IntegerNormalizer({list(self.__values)!r})"
-
-    def __copy__(self):
-        result = IntegerNormalizer()
-        result.__values = IntList(self.__values)
-        return result
-
-    def representatives(self):
-        yield from self.__values
-
-    def normalize(self, value):
-        """Return the canonical integer considered equivalent
-        to ``value``."""
-        try:
-            return self.__cachevalue
-        except KeyError:
-            pass
-        i = bisect_right(self.__values, value) - 1
-        assert i >= 0
-        return self.__cache.setdefault(value, self.__valuesi)
-
-    def distinguish(self, value, test):
-        """Checks whether ``test`` gives the same answer for
-        ``value`` and ``self.normalize(value)``. If it does
-        not, updates the list of canonical values so that
-        it does.
-
-        Returns True if and only if this makes a change to
-        the underlying canonical values."""
-        canonical = self.normalize(value)
-        if canonical == value:
-            return False
-
-        value_test = test(value)
-
-        if test(canonical) == value_test:
-            return False
-
-        self.__cache.clear()
-
-        def can_lower(k):
-            new_canon = value - k
-            if new_canon <= canonical:
-                return False
-            return test(new_canon) == value_test
-
-        new_canon = value - find_integer(can_lower)
-
-        assert new_canon not in self.__values
-
-        insort(self.__values, new_canon)
-
-        assert self.normalize(value) == new_canon
-        return True

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/engine.py Deleted

@@ -1,1074 +0,0 @@
-# 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 math
-import sys
-import time
-from collections import defaultdict
-from contextlib import contextmanager
-from enum import Enum
-from random import Random, getrandbits
-from weakref import WeakKeyDictionary
-
-import attr
-
-from hypothesis import HealthCheck, Phase, Verbosity, settings as Settings
-from hypothesis._settings import local_settings
-from hypothesis.errors import StopTest
-from hypothesis.internal.cache import LRUReusedCache
-from hypothesis.internal.compat import ceil, int_from_bytes
-from hypothesis.internal.conjecture.data import (
-    ConjectureData,
-    ConjectureResult,
-    DataObserver,
-    Overrun,
-    Status,
-)
-from hypothesis.internal.conjecture.datatree import (
-    DataTree,
-    PreviouslyUnseenBehaviour,
-    TreeRecordingObserver,
-)
-from hypothesis.internal.conjecture.junkdrawer import clamp, stack_depth_of_caller
-from hypothesis.internal.conjecture.pareto import NO_SCORE, ParetoFront, ParetoOptimiser
-from hypothesis.internal.conjecture.shrinker import Shrinker, sort_key
-from hypothesis.internal.healthcheck import fail_health_check
-from hypothesis.reporting import base_report, report
-
-MAX_SHRINKS = 500
-CACHE_SIZE = 10000
-MUTATION_POOL_SIZE = 100
-MIN_TEST_CALLS = 10
-BUFFER_SIZE = 8 * 1024
-
-
-@attr.s
-class HealthCheckState:
-    valid_examples = attr.ib(default=0)
-    invalid_examples = attr.ib(default=0)
-    overrun_examples = attr.ib(default=0)
-    draw_times = attr.ib(default=attr.Factory(list))
-
-
-class ExitReason(Enum):
-    max_examples = "settings.max_examples={s.max_examples}"
-    max_iterations = (
-        "settings.max_examples={s.max_examples}, "
-        "but < 10% of examples satisfied assumptions"
-    )
-    max_shrinks = f"shrunk example {MAX_SHRINKS} times"
-    finished = "nothing left to do"
-    flaky = "test was flaky"
-    very_slow_shrinking = "shrinking was very slow"
-
-    def describe(self, settings):
-        return self.value.format(s=settings)
-
-
-class RunIsComplete(Exception):
-    pass
-
-
-class ConjectureRunner:
-    def __init__(
-        self,
-        test_function,
-        settings=None,
-        random=None,
-        database_key=None,
-        ignore_limits=False,
-    ):
-        self._test_function = test_function
-        self.settings = settings or Settings()
-        self.shrinks = 0
-        self.finish_shrinking_deadline = None
-        self.call_count = 0
-        self.valid_examples = 0
-        self.random = random or Random(getrandbits(128))
-        self.database_key = database_key
-        self.ignore_limits = ignore_limits
-
-        # Global dict of per-phase statistics, and a list of per-call stats
-        # which transfer to the global dict at the end of each phase.
-        self.statistics = {}
-        self.stats_per_test_case = 
-
-        self.events_to_strings = WeakKeyDictionary()
-
-        self.interesting_examples = {}
-        # We use call_count because there may be few possible valid_examples.
-        self.first_bug_found_at = None
-        self.last_bug_found_at = None
-
-        self.shrunk_examples = set()
-
-        self.health_check_state = None
-
-        self.tree = DataTree()
-
-        self.best_observed_targets = defaultdict(lambda: NO_SCORE)
-        self.best_examples_of_observed_targets = {}
-
-        # We keep the pareto front in the example database if we have one. This
-        # is only marginally useful at present, but speeds up local development
-        # because it means that large targets will be quickly surfaced in your
-        # testing.
-        if self.database_key is not None and self.settings.database is not None:
-            self.pareto_front = ParetoFront(self.random)
-            self.pareto_front.on_evict(self.on_pareto_evict)
-        else:
-            self.pareto_front = None
-
-        # We want to be able to get the ConjectureData object that results
-        # from running a buffer without recalculating, especially during
-        # shrinking where we need to know about the structure of the
-        # executed test case.
-        self.__data_cache = LRUReusedCache(CACHE_SIZE)
-
-        # We ensure that the test has this much stack space remaining, no matter
-        # the size of the stack when called, to de-flake RecursionErrors (#2494).
-        self.__recursion_limit = sys.getrecursionlimit()
-        self.__pending_call_explanation = None
-
-    def explain_next_call_as(self, explanation):
-        self.__pending_call_explanation = explanation
-
-    def clear_call_explanation(self):
-        self.__pending_call_explanation = None
-
-    @contextmanager
-    def _log_phase_statistics(self, phase):
-        self.stats_per_test_case.clear()
-        start_time = time.perf_counter()
-        try:
-            yield
-        finally:
-            self.statisticsphase + "-phase" = {
-                "duration-seconds": time.perf_counter() - start_time,
-                "test-cases": list(self.stats_per_test_case),
-                "distinct-failures": len(self.interesting_examples),
-                "shrinks-successful": self.shrinks,
-            }
-
-    @property
-    def should_optimise(self):
-        return Phase.target in self.settings.phases
-
-    def __tree_is_exhausted(self):
-        return self.tree.is_exhausted
-
-    def __stoppable_test_function(self, data):
-        """Run ``self._test_function``, but convert a ``StopTest`` exception
-        into a normal return and avoid raising Flaky for RecursionErrors.
-        """
-        depth = stack_depth_of_caller()
-        # Because we add to the recursion limit, to be good citizens we also add
-        # a check for unbounded recursion.  The default limit is 1000, so this can
-        # only ever trigger if something really strange is happening and it's hard
-        # to imagine an intentionally-deeply-recursive use of this code.
-        assert depth <= 1000, (
-            "Hypothesis would usually add %d to the stack depth of %d here, "
-            "but we are already much deeper than expected.  Aborting now, to "
-            "avoid extending the stack limit in an infinite loop..."
-            % (self.__recursion_limit, depth)
-        )
-        try:
-            sys.setrecursionlimit(depth + self.__recursion_limit)
-            self._test_function(data)
-        except StopTest as e:
-            if e.testcounter == data.testcounter:
-                # This StopTest has successfully stopped its test, and can now
-                # be discarded.
-                pass
-            else:
-                # This StopTest was raised by a different ConjectureData. We
-                # need to re-raise it so that it will eventually reach the
-                # correct engine.
-                raise
-        finally:
-            sys.setrecursionlimit(self.__recursion_limit)
-
-    def test_function(self, data):
-        if self.__pending_call_explanation is not None:
-            self.debug(self.__pending_call_explanation)
-            self.__pending_call_explanation = None
-
-        assert isinstance(data.observer, TreeRecordingObserver)
-        self.call_count += 1
-
-        interrupted = False
-        try:
-            self.__stoppable_test_function(data)
-        except KeyboardInterrupt:
-            interrupted = True
-            raise
-        except BaseException:
-            self.save_buffer(data.buffer)
-            raise
-        finally:
-            # No branch, because if we're interrupted we always raise
-            # the KeyboardInterrupt, never continue to the code below.
-            if not interrupted:  # pragma: no branch
-                data.freeze()
-                call_stats = {
-                    "status": data.status.name.lower(),
-                    "runtime": data.finish_time - data.start_time,
-                    "drawtime": math.fsum(data.draw_times),
-                    "events": sorted({self.event_to_string(e) for e in data.events}),
-                }
-                self.stats_per_test_case.append(call_stats)
-                self.__data_cachedata.buffer = data.as_result()
-
-        self.debug_data(data)
-
-        if self.pareto_front is not None and self.pareto_front.add(data.as_result()):
-            self.save_buffer(data.buffer, sub_key=b"pareto")
-
-        assert len(data.buffer) <= BUFFER_SIZE
-
-        if data.status >= Status.VALID:
-            for k, v in data.target_observations.items():
-                self.best_observed_targetsk = max(self.best_observed_targetsk, v)
-
-                if k not in self.best_examples_of_observed_targets:
-                    self.best_examples_of_observed_targetsk = data.as_result()
-                    continue
-
-                existing_example = self.best_examples_of_observed_targetsk
-                existing_score = existing_example.target_observationsk
-
-                if v < existing_score:
-                    continue
-
-                if v > existing_score or sort_key(data.buffer) < sort_key(
-                    existing_example.buffer
-                ):
-                    self.best_examples_of_observed_targetsk = data.as_result()
-
-        if data.status == Status.VALID:
-            self.valid_examples += 1
-
-        if data.status == Status.INTERESTING:
-            key = data.interesting_origin
-            changed = False
-            try:
-                existing = self.interesting_exampleskey
-            except KeyError:
-                changed = True
-                self.last_bug_found_at = self.call_count
-                if self.first_bug_found_at is None:
-                    self.first_bug_found_at = self.call_count
-            else:
-                if sort_key(data.buffer) < sort_key(existing.buffer):
-                    self.shrinks += 1
-                    self.downgrade_buffer(existing.buffer)
-                    self.__data_cache.unpin(existing.buffer)
-                    changed = True
-
-            if changed:
-                self.save_buffer(data.buffer)
-                self.interesting_exampleskey = data.as_result()
-                self.__data_cache.pin(data.buffer)
-                self.shrunk_examples.discard(key)
-
-            if self.shrinks >= MAX_SHRINKS:
-                self.exit_with(ExitReason.max_shrinks)
-
-        if (
-            not self.ignore_limits
-            and self.finish_shrinking_deadline is not None
-            and self.finish_shrinking_deadline < time.perf_counter()
-        ):
-            # See https://github.com/HypothesisWorks/hypothesis/issues/2340
-            report(
-                "WARNING: Hypothesis has spent more than five minutes working to shrink"
-                " a failing example, and stopped because it is making very slow"
-                " progress.  When you re-run your tests, shrinking will resume and may"
-                " take this long before aborting again.\nPLEASE REPORT THIS if you can"
-                " provide a reproducing example, so that we can improve shrinking"
-                " performance for everyone."
-            )
-            self.exit_with(ExitReason.very_slow_shrinking)
-
-        if not self.interesting_examples:
-            # Note that this logic is reproduced to end the generation phase when
-            # we have interesting examples.  Update that too if you change this!
-            # (The doubled implementation is because here we exit the engine entirely,
-            #  while in the other case below we just want to move on to shrinking.)
-            if self.valid_examples >= self.settings.max_examples:
-                self.exit_with(ExitReason.max_examples)
-            if self.call_count >= max(
-                self.settings.max_examples * 10,
-                # We have a high-ish default max iterations, so that tests
-                # don't become flaky when max_examples is too low.
-                1000,
-            ):
-                self.exit_with(ExitReason.max_iterations)
-
-        if self.__tree_is_exhausted():
-            self.exit_with(ExitReason.finished)
-
-        self.record_for_health_check(data)
-
-    def on_pareto_evict(self, data):
-        self.settings.database.delete(self.pareto_key, data.buffer)
-
-    def generate_novel_prefix(self):
-        """Uses the tree to proactively generate a starting sequence of bytes
-        that we haven't explored yet for this test.
-
-        When this method is called, we assume that there must be at
-        least one novel prefix left to find. If there were not, then the
-        test run should have already stopped due to tree exhaustion.
-        """
-        return self.tree.generate_novel_prefix(self.random)
-
-    def record_for_health_check(self, data):
-        # Once we've actually found a bug, there's no point in trying to run
-        # health checks - they'll just mask the actually important information.
-        if data.status == Status.INTERESTING:
-            self.health_check_state = None
-
-        state = self.health_check_state
-
-        if state is None:
-            return
-
-        state.draw_times.extend(data.draw_times)
-
-        if data.status == Status.VALID:
-            state.valid_examples += 1
-        elif data.status == Status.INVALID:
-            state.invalid_examples += 1
-        else:
-            assert data.status == Status.OVERRUN
-            state.overrun_examples += 1
-
-        max_valid_draws = 10
-        max_invalid_draws = 50
-        max_overrun_draws = 20
-
-        assert state.valid_examples <= max_valid_draws
-
-        if state.valid_examples == max_valid_draws:
-            self.health_check_state = None
-            return
-
-        if state.overrun_examples == max_overrun_draws:
-            fail_health_check(
-                self.settings,
-                "Examples routinely exceeded the max allowable size. "
-                f"({state.overrun_examples} examples overran while generating "
-                f"{state.valid_examples} valid ones). Generating examples this large "
-                "will usually lead to bad results. You could try setting max_size "
-                "parameters on your collections and turning max_leaves down on "
-                "recursive() calls.",
-                HealthCheck.data_too_large,
-            )
-        if state.invalid_examples == max_invalid_draws:
-            fail_health_check(
-                self.settings,
-                "It looks like your strategy is filtering out a lot of data. Health "
-                f"check found {state.invalid_examples} filtered examples but only "
-                f"{state.valid_examples} good ones. This will make your tests much "
-                "slower, and also will probably distort the data generation quite a "
-                "lot. You should adapt your strategy to filter less. This can also "
-                "be caused by a low max_leaves parameter in recursive() calls",
-                HealthCheck.filter_too_much,
-            )
-
-        draw_time = sum(state.draw_times)
-
-        if draw_time > 1.0:
-            fail_health_check(
-                self.settings,
-                "Data generation is extremely slow: Only produced "
-                f"{state.valid_examples} valid examples in {draw_time:.2f} seconds "
-                f"({state.invalid_examples} invalid ones and {state.overrun_examples} "
-                "exceeded maximum size). Try decreasing size of the data you're "
-                "generating (with e.g. max_size or max_leaves parameters).",
-                HealthCheck.too_slow,
-            )
-
-    def save_buffer(self, buffer, sub_key=None):
-        if self.settings.database is not None:
-            key = self.sub_key(sub_key)
-            if key is None:
-                return
-            self.settings.database.save(key, bytes(buffer))
-
-    def downgrade_buffer(self, buffer):
-        if self.settings.database is not None and self.database_key is not None:
-            self.settings.database.move(self.database_key, self.secondary_key, buffer)
-
-    def sub_key(self, sub_key):
-        if self.database_key is None:
-            return None
-        if sub_key is None:
-            return self.database_key
-        return b".".join((self.database_key, sub_key))
-
-    @property
-    def secondary_key(self):
-        return self.sub_key(b"secondary")
-
-    @property
-    def pareto_key(self):
-        return self.sub_key(b"pareto")
-
-    def debug(self, message):
-        if self.settings.verbosity >= Verbosity.debug:
-            base_report(message)
-
-    @property
-    def report_debug_info(self):
-        return self.settings.verbosity >= Verbosity.debug
-
-    def debug_data(self, data):
-        if not self.report_debug_info:
-            return
-
-        stack = 
-
-        def go(ex):
-            if ex.length == 0:
-                return
-            if len(ex.children) == 0:
-                stack-1.append(int_from_bytes(data.bufferex.start : ex.end))
-            else:
-                node = 
-                stack.append(node)
-
-                for v in ex.children:
-                    go(v)
-                stack.pop()
-                if len(node) == 1:
-                    stack-1.extend(node)
-                else:
-                    stack-1.append(node)
-
-        go(data.examples0)
-        assert len(stack) == 1
-
-        status = repr(data.status)
-
-        if data.status == Status.INTERESTING:
-            status = f"{status} ({data.interesting_origin!r})"
-
-        self.debug(f"{data.index} bytes {stack0!r} -> {status}, {data.output}")
-
-    def run(self):
-        with local_settings(self.settings):
-            try:
-                self._run()
-            except RunIsComplete:
-                pass
-            for v in self.interesting_examples.values():
-                self.debug_data(v)
-            self.debug(
-                "Run complete after %d examples (%d valid) and %d shrinks"
-                % (self.call_count, self.valid_examples, self.shrinks)
-            )
-
-    @property
-    def database(self):
-        if self.database_key is None:
-            return None
-        return self.settings.database
-
-    def has_existing_examples(self):
-        return self.database is not None and Phase.reuse in self.settings.phases
-
-    def reuse_existing_examples(self):
-        """If appropriate (we have a database and have been told to use it),
-        try to reload existing examples from the database.
-
-        If there are a lot we don't try all of them. We always try the
-        smallest example in the database (which is guaranteed to be the
-        last failure) and the largest (which is usually the seed example
-        which the last failure came from but we don't enforce that). We
-        then take a random sampling of the remainder and try those. Any
-        examples that are no longer interesting are cleared out.
-        """
-        if self.has_existing_examples():
-            self.debug("Reusing examples from database")
-            # We have to do some careful juggling here. We have two database
-            # corpora: The primary and secondary. The primary corpus is a
-            # small set of minimized examples each of which has at one point
-            # demonstrated a distinct bug. We want to retry all of these.
-
-            # We also have a secondary corpus of examples that have at some
-            # point demonstrated interestingness (currently only ones that
-            # were previously non-minimal examples of a bug, but this will
-            # likely expand in future). These are a good source of potentially
-            # interesting examples, but there are a lot of them, so we down
-            # sample the secondary corpus to a more manageable size.
-
-            corpus = sorted(
-                self.settings.database.fetch(self.database_key), key=sort_key
-            )
-            factor = 0.1 if (Phase.generate in self.settings.phases) else 1
-            desired_size = max(2, ceil(factor * self.settings.max_examples))
-
-            if len(corpus) < desired_size:
-                extra_corpus = list(self.settings.database.fetch(self.secondary_key))
-
-                shortfall = desired_size - len(corpus)
-
-                if len(extra_corpus) <= shortfall:
-                    extra = extra_corpus
-                else:
-                    extra = self.random.sample(extra_corpus, shortfall)
-                extra.sort(key=sort_key)
-                corpus.extend(extra)
-
-            for existing in corpus:
-                data = self.cached_test_function(existing)
-                if data.status != Status.INTERESTING:
-                    self.settings.database.delete(self.database_key, existing)
-                    self.settings.database.delete(self.secondary_key, existing)
-
-            # If we've not found any interesting examples so far we try some of
-            # the pareto front from the last run.
-            if len(corpus) < desired_size and not self.interesting_examples:
-                desired_extra = desired_size - len(corpus)
-                pareto_corpus = list(self.settings.database.fetch(self.pareto_key))
-                if len(pareto_corpus) > desired_extra:
-                    pareto_corpus = self.random.sample(pareto_corpus, desired_extra)
-                pareto_corpus.sort(key=sort_key)
-
-                for existing in pareto_corpus:
-                    data = self.cached_test_function(existing)
-                    if data not in self.pareto_front:
-                        self.settings.database.delete(self.pareto_key, existing)
-                    if data.status == Status.INTERESTING:
-                        break
-
-    def exit_with(self, reason):
-        if self.ignore_limits:
-            return
-        self.statistics"stopped-because" = reason.describe(self.settings)
-        if self.best_observed_targets:
-            self.statistics"targets" = dict(self.best_observed_targets)
-        self.debug(f"exit_with({reason.name})")
-        self.exit_reason = reason
-        raise RunIsComplete()
-
-    def should_generate_more(self):
-        # End the generation phase where we would have ended it if no bugs had
-        # been found.  This reproduces the exit logic in `self.test_function`,
-        # but with the important distinction that this clause will move on to
-        # the shrinking phase having found one or more bugs, while the other
-        # will exit having found zero bugs.
-        if self.valid_examples >= self.settings.max_examples or self.call_count >= max(
-            self.settings.max_examples * 10, 1000
-        ):  # pragma: no cover
-            return False
-
-        # If we haven't found a bug, keep looking - if we hit any limits on
-        # the number of tests to run that will raise an exception and stop
-        # the run.
-        if not self.interesting_examples:
-            return True
-        # Users who disable shrinking probably want to exit as fast as possible.
-        # If we've found a bug and won't report more than one, stop looking.
-        elif (
-            Phase.shrink not in self.settings.phases
-            or not self.settings.report_multiple_bugs
-        ):
-            return False
-        assert self.first_bug_found_at <= self.last_bug_found_at <= self.call_count
-        # Otherwise, keep searching for between ten and 'a heuristic' calls.
-        # We cap 'calls after first bug' so errors are reported reasonably
-        # soon even for tests that are allowed to run for a very long time,
-        # or sooner if the latest half of our test effort has been fruitless.
-        return self.call_count < MIN_TEST_CALLS or self.call_count < min(
-            self.first_bug_found_at + 1000, self.last_bug_found_at * 2
-        )
-
-    def generate_new_examples(self):
-        if Phase.generate not in self.settings.phases:
-            return
-        if self.interesting_examples:
-            # The example database has failing examples from a previous run,
-            # so we'd rather report that they're still failing ASAP than take
-            # the time to look for additional failures.
-            return
-
-        self.debug("Generating new examples")
-
-        assert self.should_generate_more()
-        zero_data = self.cached_test_function(bytes(BUFFER_SIZE))
-        if zero_data.status > Status.OVERRUN:
-            self.__data_cache.pin(zero_data.buffer)
-
-        if zero_data.status == Status.OVERRUN or (
-            zero_data.status == Status.VALID and len(zero_data.buffer) * 2 > BUFFER_SIZE
-        ):
-            fail_health_check(
-                self.settings,
-                "The smallest natural example for your test is extremely "
-                "large. This makes it difficult for Hypothesis to generate "
-                "good examples, especially when trying to reduce failing ones "
-                "at the end. Consider reducing the size of your data if it is "
-                "of a fixed size. You could also fix this by improving how "
-                "your data shrinks (see https://hypothesis.readthedocs.io/en/"
-                "latest/data.html#shrinking for details), or by introducing "
-                "default values inside your strategy. e.g. could you replace "
-                "some arguments with their defaults by using "
-                "one_of(none(), some_complex_strategy)?",
-                HealthCheck.large_base_example,
-            )
-
-        self.health_check_state = HealthCheckState()
-
-        # We attempt to use the size of the minimal generated test case starting
-        # from a given novel prefix as a guideline to generate smaller test
-        # cases for an initial period, by restriscting ourselves to test cases
-        # that are not much larger than it.
-        #
-        # Calculating the actual minimal generated test case is hard, so we
-        # take a best guess that zero extending a prefix produces the minimal
-        # test case starting with that prefix (this is true for our built in
-        # strategies). This is only a reasonable thing to do if the resulting
-        # test case is valid. If we regularly run into situations where it is
-        # not valid then this strategy is a waste of time, so we want to
-        # abandon it early. In order to do this we track how many times in a
-        # row it has failed to work, and abort small test case generation when
-        # it has failed too many times in a row.
-        consecutive_zero_extend_is_invalid = 0
-
-        # We control growth during initial example generation, for two
-        # reasons:
-        #
-        # * It gives us an opportunity to find small examples early, which
-        #   gives us a fast path for easy to find bugs.
-        # * It avoids low probability events where we might end up
-        #   generating very large examples during health checks, which
-        #   on slower machines can trigger HealthCheck.too_slow.
-        #
-        # The heuristic we use is that we attempt to estimate the smallest
-        # extension of this prefix, and limit the size to no more than
-        # an order of magnitude larger than that. If we fail to estimate
-        # the size accurately, we skip over this prefix and try again.
-        #
-        # We need to tune the example size based on the initial prefix,
-        # because any fixed size might be too small, and any size based
-        # on the strategy in general can fall afoul of strategies that
-        # have very different sizes for different prefixes.
-        small_example_cap = clamp(10, self.settings.max_examples // 10, 50)
-
-        optimise_at = max(self.settings.max_examples // 2, small_example_cap + 1)
-        ran_optimisations = False
-
-        while self.should_generate_more():
-            prefix = self.generate_novel_prefix()
-            assert len(prefix) <= BUFFER_SIZE
-            if (
-                self.valid_examples <= small_example_cap
-                and self.call_count <= 5 * small_example_cap
-                and not self.interesting_examples
-                and consecutive_zero_extend_is_invalid < 5
-            ):
-                minimal_example = self.cached_test_function(
-                    prefix + bytes(BUFFER_SIZE - len(prefix))
-                )
-
-                if minimal_example.status < Status.VALID:
-                    consecutive_zero_extend_is_invalid += 1
-                    continue
-
-                consecutive_zero_extend_is_invalid = 0
-
-                minimal_extension = len(minimal_example.buffer) - len(prefix)
-
-                max_length = min(len(prefix) + minimal_extension * 10, BUFFER_SIZE)
-
-                # We could end up in a situation where even though the prefix was
-                # novel when we generated it, because we've now tried zero extending
-                # it not all possible continuations of it will be novel. In order to
-                # avoid making redundant test calls, we rerun it in simulation mode
-                # first. If this has a predictable result, then we don't bother
-                # running the test function for real here. If however we encounter
-                # some novel behaviour, we try again with the real test function,
-                # starting from the new novel prefix that has discovered.
-                try:
-                    trial_data = self.new_conjecture_data(
-                        prefix=prefix, max_length=max_length
-                    )
-                    self.tree.simulate_test_function(trial_data)
-                    continue
-                except PreviouslyUnseenBehaviour:
-                    pass
-
-                # If the simulation entered part of the tree that has been killed,
-                # we don't want to run this.
-                if trial_data.observer.killed:
-                    continue
-
-                # We might have hit the cap on number of examples we should
-                # run when calculating the minimal example.
-                if not self.should_generate_more():
-                    break
-
-                prefix = trial_data.buffer
-            else:
-                max_length = BUFFER_SIZE
-
-            data = self.new_conjecture_data(prefix=prefix, max_length=max_length)
-
-            self.test_function(data)
-
-            self.generate_mutations_from(data)
-
-            # Although the optimisations are logically a distinct phase, we
-            # actually normally run them as part of example generation. The
-            # reason for this is that we cannot guarantee that optimisation
-            # actually exhausts our budget: It might finish running and we
-            # discover that actually we still could run a bunch more test cases
-            # if we want.
-            if (
-                self.valid_examples >= max(small_example_cap, optimise_at)
-                and not ran_optimisations
-            ):
-                ran_optimisations = True
-                self.optimise_targets()
-
-    def generate_mutations_from(self, data):
-        # A thing that is often useful but rarely happens by accident is
-        # to generate the same value at multiple different points in the
-        # test case.
-        #
-        # Rather than make this the responsibility of individual strategies
-        # we implement a small mutator that just takes parts of the test
-        # case with the same label and tries replacing one of them with a
-        # copy of the other and tries running it. If we've made a good
-        # guess about what to put where, this will run a similar generated
-        # test case with more duplication.
-        if (
-            # An OVERRUN doesn't have enough information about the test
-            # case to mutate, so we just skip those.
-            data.status >= Status.INVALID
-            # This has a tendency to trigger some weird edge cases during
-            # generation so we don't let it run until we're done with the
-            # health checks.
-            and self.health_check_state is None
-        ):
-            initial_calls = self.call_count
-            failed_mutations = 0
-
-            while (
-                self.should_generate_more()
-                # We implement fairly conservative checks for how long we
-                # we should run mutation for, as it's generally not obvious
-                # how helpful it is for any given test case.
-                and self.call_count <= initial_calls + 5
-                and failed_mutations <= 5
-            ):
-                groups = data.examples.mutator_groups
-                if not groups:
-                    break
-
-                group = self.random.choice(groups)
-
-                ex1, ex2 = (
-                    data.examplesi for i in sorted(self.random.sample(group, 2))
-                )
-                assert ex1.end <= ex2.start
-
-                replacements = data.buffere.start : e.end for e in ex1, ex2
-
-                replacement = self.random.choice(replacements)
-
-                try:
-                    # We attempt to replace both the the examples with
-                    # whichever choice we made. Note that this might end
-                    # up messing up and getting the example boundaries
-                    # wrong - labels matching are only a best guess as to
-                    # whether the two are equivalent - but it doesn't
-                    # really matter. It may not achieve the desired result
-                    # but it's still a perfectly acceptable choice sequence.
-                    # to try.
-                    new_data = self.cached_test_function(
-                        data.buffer: ex1.start
-                        + replacement
-                        + data.bufferex1.end : ex2.start
-                        + replacement
-                        + data.bufferex2.end :,
-                        # We set error_on_discard so that we don't end up
-                        # entering parts of the tree we consider redundant
-                        # and not worth exploring.
-                        error_on_discard=True,
-                        extend=BUFFER_SIZE,
-                    )
-                except ContainsDiscard:
-                    failed_mutations += 1
-                    continue
-
-                if (
-                    new_data.status >= data.status
-                    and data.buffer != new_data.buffer
-                    and all(
-                        k in new_data.target_observations
-                        and new_data.target_observationsk >= v
-                        for k, v in data.target_observations.items()
-                    )
-                ):
-                    data = new_data
-                    failed_mutations = 0
-                else:
-                    failed_mutations += 1
-
-    def optimise_targets(self):
-        """If any target observations have been made, attempt to optimise them
-        all."""
-        if not self.should_optimise:
-            return
-        from hypothesis.internal.conjecture.optimiser import Optimiser
-
-        # We want to avoid running the optimiser for too long in case we hit
-        # an unbounded target score. We start this off fairly conservatively
-        # in case interesting examples are easy to find and then ramp it up
-        # on an exponential schedule so we don't hamper the optimiser too much
-        # if it needs a long time to find good enough improvements.
-        max_improvements = 10
-        while True:
-            prev_calls = self.call_count
-
-            any_improvements = False
-
-            for target, data in list(self.best_examples_of_observed_targets.items()):
-                optimiser = Optimiser(
-                    self, data, target, max_improvements=max_improvements
-                )
-                optimiser.run()
-                if optimiser.improvements > 0:
-                    any_improvements = True
-
-            if self.interesting_examples:
-                break
-
-            max_improvements *= 2
-
-            if any_improvements:
-                continue
-
-            self.pareto_optimise()
-
-            if prev_calls == self.call_count:
-                break
-
-    def pareto_optimise(self):
-        if self.pareto_front is not None:
-            ParetoOptimiser(self).run()
-
-    def _run(self):
-        with self._log_phase_statistics("reuse"):
-            self.reuse_existing_examples()
-        with self._log_phase_statistics("generate"):
-            self.generate_new_examples()
-            # We normally run the targeting phase mixed in with the generate phase,
-            # but if we've been asked to run it but not generation then we have to
-            # run it explciitly on its own here.
-            if Phase.generate not in self.settings.phases:
-                self.optimise_targets()
-        with self._log_phase_statistics("shrink"):
-            self.shrink_interesting_examples()
-        self.exit_with(ExitReason.finished)
-
-    def new_conjecture_data(self, prefix, max_length=BUFFER_SIZE, observer=None):
-        return ConjectureData(
-            prefix=prefix,
-            max_length=max_length,
-            random=self.random,
-            observer=observer or self.tree.new_observer(),
-        )
-
-    def new_conjecture_data_for_buffer(self, buffer):
-        return ConjectureData.for_buffer(buffer, observer=self.tree.new_observer())
-
-    def shrink_interesting_examples(self):
-        """If we've found interesting examples, try to replace each of them
-        with a minimal interesting example with the same interesting_origin.
-
-        We may find one or more examples with a new interesting_origin
-        during the shrink process. If so we shrink these too.
-        """
-        if Phase.shrink not in self.settings.phases or not self.interesting_examples:
-            return
-
-        self.debug("Shrinking interesting examples")
-
-        # If the shrinking phase takes more than five minutes, abort it early and print
-        # a warning.   Many CI systems will kill a build after around ten minutes with
-        # no output, and appearing to hang isn't great for interactive use either -
-        # showing partially-shrunk examples is better than quitting with no examples!
-        self.finish_shrinking_deadline = time.perf_counter() + 300
-
-        for prev_data in sorted(
-            self.interesting_examples.values(), key=lambda d: sort_key(d.buffer)
-        ):
-            assert prev_data.status == Status.INTERESTING
-            data = self.new_conjecture_data_for_buffer(prev_data.buffer)
-            self.test_function(data)
-            if data.status != Status.INTERESTING:
-                self.exit_with(ExitReason.flaky)
-
-        self.clear_secondary_key()
-
-        while len(self.shrunk_examples) < len(self.interesting_examples):
-            target, example = min(
-                (
-                    (k, v)
-                    for k, v in self.interesting_examples.items()
-                    if k not in self.shrunk_examples
-                ),
-                key=lambda kv: (sort_key(kv1.buffer), sort_key(repr(kv0))),
-            )
-            self.debug(f"Shrinking {target!r}")
-
-            if not self.settings.report_multiple_bugs:
-                # If multi-bug reporting is disabled, we shrink our currently-minimal
-                # failure, allowing 'slips' to any bug with a smaller minimal example.
-                self.shrink(example, lambda d: d.status == Status.INTERESTING)
-                return
-
-            def predicate(d):
-                if d.status < Status.INTERESTING:
-                    return False
-                return d.interesting_origin == target
-
-            self.shrink(example, predicate)
-
-            self.shrunk_examples.add(target)
-
-    def clear_secondary_key(self):
-        if self.has_existing_examples():
-            # If we have any smaller examples in the secondary corpus, now is
-            # a good time to try them to see if they work as shrinks. They
-            # probably won't, but it's worth a shot and gives us a good
-            # opportunity to clear out the database.
-
-            # It's not worth trying the primary corpus because we already
-            # tried all of those in the initial phase.
-            corpus = sorted(
-                self.settings.database.fetch(self.secondary_key), key=sort_key
-            )
-            for c in corpus:
-                primary = {v.buffer for v in self.interesting_examples.values()}
-
-                cap = max(map(sort_key, primary))
-
-                if sort_key(c) > cap:
-                    break
-                else:
-                    self.cached_test_function(c)
-                    # We unconditionally remove c from the secondary key as it
-                    # is either now primary or worse than our primary example
-                    # of this reason for interestingness.
-                    self.settings.database.delete(self.secondary_key, c)
-
-    def shrink(self, example, predicate=None, allow_transition=None):
-        s = self.new_shrinker(example, predicate, allow_transition)
-        s.shrink()
-        return s.shrink_target
-
-    def new_shrinker(self, example, predicate=None, allow_transition=None):
-        return Shrinker(self, example, predicate, allow_transition)
-
-    def cached_test_function(self, buffer, error_on_discard=False, extend=0):
-        """Checks the tree to see if we've tested this buffer, and returns the
-        previous result if we have.
-
-        Otherwise we call through to ``test_function``, and return a
-        fresh result.
-
-        If ``error_on_discard`` is set to True this will raise ``ContainsDiscard``
-        in preference to running the actual test function. This is to allow us
-        to skip test cases we expect to be redundant in some cases. Note that
-        it may be the case that we don't raise ``ContainsDiscard`` even if the
-        result has discards if we cannot determine from previous runs whether
-        it will have a discard.
-        """
-        buffer = bytes(buffer):BUFFER_SIZE
-
-        max_length = min(BUFFER_SIZE, len(buffer) + extend)
-
-        def check_result(result):
-            assert result is Overrun or (
-                isinstance(result, ConjectureResult) and result.status != Status.OVERRUN
-            )
-            return result
-
-        try:
-            cached = check_result(self.__data_cachebuffer)
-            if cached.status > Status.OVERRUN or extend == 0:
-                return cached
-        except KeyError:
-            pass
-
-        if error_on_discard:
-
-            class DiscardObserver(DataObserver):
-                def kill_branch(self):
-                    raise ContainsDiscard()
-
-            observer = DiscardObserver()
-        else:
-            observer = DataObserver()
-
-        dummy_data = self.new_conjecture_data(
-            prefix=buffer, max_length=max_length, observer=observer
-        )
-
-        try:
-            self.tree.simulate_test_function(dummy_data)
-        except PreviouslyUnseenBehaviour:
-            pass
-        else:
-            if dummy_data.status > Status.OVERRUN:
-                dummy_data.freeze()
-                try:
-                    return self.__data_cachedummy_data.buffer
-                except KeyError:
-                    pass
-            else:
-                self.__data_cachebuffer = Overrun
-                return Overrun
-
-        # We didn't find a match in the tree, so we need to run the test
-        # function normally. Note that test_function will automatically
-        # add this to the tree so we don't need to update the cache.
-
-        result = None
-
-        data = self.new_conjecture_data(
-            prefix=max((buffer, dummy_data.buffer), key=len), max_length=max_length
-        )
-        self.test_function(data)
-        result = check_result(data.as_result())
-        if extend == 0 or (result is not Overrun and len(result.buffer) <= len(buffer)):
-            self.__data_cachebuffer = result
-        return result
-
-    def event_to_string(self, event):
-        if isinstance(event, str):
-            return event
-        try:
-            return self.events_to_stringsevent
-        except KeyError:
-            pass
-        result = str(event)
-        self.events_to_stringsevent = result
-        return result
-
-
-class ContainsDiscard(Exception):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py Deleted

@@ -1,1472 +0,0 @@
-# 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/.
-
-from collections import defaultdict
-from typing import Dict
-
-import attr
-
-from hypothesis.internal.compat import int_from_bytes, int_to_bytes
-from hypothesis.internal.conjecture.choicetree import (
-    ChoiceTree,
-    prefix_selection_order,
-    random_selection_order,
-)
-from hypothesis.internal.conjecture.data import ConjectureResult, Status
-from hypothesis.internal.conjecture.floats import (
-    DRAW_FLOAT_LABEL,
-    float_to_lex,
-    lex_to_float,
-)
-from hypothesis.internal.conjecture.junkdrawer import (
-    binary_search,
-    find_integer,
-    replace_all,
-)
-from hypothesis.internal.conjecture.shrinking import Float, Integer, Lexical, Ordering
-from hypothesis.internal.conjecture.shrinking.learned_dfas import SHRINKING_DFAS
-
-
-def sort_key(buffer):
-    """Returns a sort key such that "simpler" buffers are smaller than
-    "more complicated" ones.
-
-    We define sort_key so that x is simpler than y if x is shorter than y or if
-    they have the same length and x < y lexicographically. This is called the
-    shortlex order.
-
-    The reason for using the shortlex order is:
-
-    1. If x is shorter than y then that means we had to make fewer decisions
-       in constructing the test case when we ran x than we did when we ran y.
-    2. If x is the same length as y then replacing a byte with a lower byte
-       corresponds to reducing the value of an integer we drew with draw_bits
-       towards zero.
-    3. We want a total order, and given (2) the natural choices for things of
-       the same size are either the lexicographic or colexicographic orders
-       (the latter being the lexicographic order of the reverse of the string).
-       Because values drawn early in generation potentially get used in more
-       places they potentially have a more significant impact on the final
-       result, so it makes sense to prioritise reducing earlier values over
-       later ones. This makes the lexicographic order the more natural choice.
-    """
-    return (len(buffer), buffer)
-
-
-SHRINK_PASS_DEFINITIONS: Dictstr, "ShrinkPassDefinition" = {}
-
-
-@attr.s()
-class ShrinkPassDefinition:
-    """A shrink pass bundles together a large number of local changes to
-    the current shrink target.
-
-    Each shrink pass is defined by some function and some arguments to that
-    function. The ``generate_arguments`` function returns all arguments that
-    might be useful to run on the current shrink target.
-
-    The guarantee made by methods defined this way is that after they are
-    called then *either* the shrink target has changed *or* each of
-    ``fn(*args)`` has been called for every ``args`` in ``generate_arguments(self)``.
-    No guarantee is made that all of these will be called if the shrink target
-    changes.
-    """
-
-    run_with_chooser = attr.ib()
-
-    @property
-    def name(self):
-        return self.run_with_chooser.__name__
-
-    def __attrs_post_init__(self):
-        assert self.name not in SHRINK_PASS_DEFINITIONS, self.name
-        SHRINK_PASS_DEFINITIONSself.name = self
-
-
-def defines_shrink_pass():
-    """A convenient decorator for defining shrink passes."""
-
-    def accept(run_step):
-        ShrinkPassDefinition(run_with_chooser=run_step)
-
-        def run(self):
-            raise NotImplementedError("Shrink passes should not be run directly")
-
-        run.__name__ = run_step.__name__
-        run.is_shrink_pass = True
-        return run
-
-    return accept
-
-
-class Shrinker:
-    """A shrinker is a child object of a ConjectureRunner which is designed to
-    manage the associated state of a particular shrink problem. That is, we
-    have some initial ConjectureData object and some property of interest
-    that it satisfies, and we want to find a ConjectureData object with a
-    shortlex (see sort_key above) smaller buffer that exhibits the same
-    property.
-
-    Currently the only property of interest we use is that the status is
-    INTERESTING and the interesting_origin takes on some fixed value, but we
-    may potentially be interested in other use cases later.
-    However we assume that data with a status < VALID never satisfies the predicate.
-
-    The shrinker keeps track of a value shrink_target which represents the
-    current best known ConjectureData object satisfying the predicate.
-    It refines this value by repeatedly running *shrink passes*, which are
-    methods that perform a series of transformations to the current shrink_target
-    and evaluate the underlying test function to find new ConjectureData
-    objects. If any of these satisfy the predicate, the shrink_target
-    is updated automatically. Shrinking runs until no shrink pass can
-    improve the shrink_target, at which point it stops. It may also be
-    terminated if the underlying engine throws RunIsComplete, but that
-    is handled by the calling code rather than the Shrinker.
-
-    =======================
-    Designing Shrink Passes
-    =======================
-
-    Generally a shrink pass is just any function that calls
-    cached_test_function and/or incorporate_new_buffer a number of times,
-    but there are a couple of useful things to bear in mind.
-
-    A shrink pass *makes progress* if running it changes self.shrink_target
-    (i.e. it tries a shortlex smaller ConjectureData object satisfying
-    the predicate). The desired end state of shrinking is to find a
-    value such that no shrink pass can make progress, i.e. that we
-    are at a local minimum for each shrink pass.
-
-    In aid of this goal, the main invariant that a shrink pass much
-    satisfy is that whether it makes progress must be deterministic.
-    It is fine (encouraged even) for the specific progress it makes
-    to be non-deterministic, but if you run a shrink pass, it makes
-    no progress, and then you immediately run it again, it should
-    never succeed on the second time. This allows us to stop as soon
-    as we have run each shrink pass and seen no progress on any of
-    them.
-
-    This means that e.g. it's fine to try each of N deletions
-    or replacements in a random order, but it's not OK to try N random
-    deletions (unless you have already shrunk at least once, though we
-    don't currently take advantage of this loophole).
-
-    Shrink passes need to be written so as to be robust against
-    change in the underlying shrink target. It is generally safe
-    to assume that the shrink target does not change prior to the
-    point of first modification - e.g. if you change no bytes at
-    index ``i``, all examples whose start is ``<= i`` still exist,
-    as do all blocks, and the data object is still of length
-    ``>= i + 1``. This can only be violated by bad user code which
-    relies on an external source of non-determinism.
-
-    When the underlying shrink_target changes, shrink
-    passes should not run substantially more test_function calls
-    on success than they do on failure. Say, no more than a constant
-    factor more. In particular shrink passes should not iterate to a
-    fixed point.
-
-    This means that shrink passes are often written with loops that
-    are carefully designed to do the right thing in the case that no
-    shrinks occurred and try to adapt to any changes to do a reasonable
-    job. e.g. say we wanted to write a shrink pass that tried deleting
-    each individual byte (this isn't an especially good choice,
-    but it leads to a simple illustrative example), we might do it
-    by iterating over the buffer like so:
-
-    .. code-block:: python
-
-        i = 0
-        while i < len(self.shrink_target.buffer):
-            if not self.incorporate_new_buffer(
-                self.shrink_target.buffer:i + self.shrink_target.bufferi + 1 :
-            ):
-                i += 1
-
-    The reason for writing the loop this way is that i is always a
-    valid index into the current buffer, even if the current buffer
-    changes as a result of our actions. When the buffer changes,
-    we leave the index where it is rather than restarting from the
-    beginning, and carry on. This means that the number of steps we
-    run in this case is always bounded above by the number of steps
-    we would run if nothing works.
-
-    Another thing to bear in mind about shrink pass design is that
-    they should prioritise *progress*. If you have N operations that
-    you need to run, you should try to order them in such a way as
-    to avoid stalling, where you have long periods of test function
-    invocations where no shrinks happen. This is bad because whenever
-    we shrink we reduce the amount of work the shrinker has to do
-    in future, and often speed up the test function, so we ideally
-    wanted those shrinks to happen much earlier in the process.
-
-    Sometimes stalls are inevitable of course - e.g. if the pass
-    makes no progress, then the entire thing is just one long stall,
-    but it's helpful to design it so that stalls are less likely
-    in typical behaviour.
-
-    The two easiest ways to do this are:
-
-    * Just run the N steps in random order. As long as a
-      reasonably large proportion of the operations succeed, this
-      guarantees the expected stall length is quite short. The
-      book keeping for making sure this does the right thing when
-      it succeeds can be quite annoying.
-    * When you have any sort of nested loop, loop in such a way
-      that both loop variables change each time. This prevents
-      stalls which occur when one particular value for the outer
-      loop is impossible to make progress on, rendering the entire
-      inner loop into a stall.
-
-    However, although progress is good, too much progress can be
-    a bad sign! If you're *only* seeing successful reductions,
-    that's probably a sign that you are making changes that are
-    too timid. Two useful things to offset this:
-
-    * It's worth writing shrink passes which are *adaptive*, in
-      the sense that when operations seem to be working really
-      well we try to bundle multiple of them together. This can
-      often be used to turn what would be O(m) successful calls
-      into O(log(m)).
-    * It's often worth trying one or two special minimal values
-      before trying anything more fine grained (e.g. replacing
-      the whole thing with zero).
-
-    """
-
-    def derived_value(fn):  # noqa: B902
-        """It's useful during shrinking to have access to derived values of
-        the current shrink target.
-
-        This decorator allows you to define these as cached properties. They
-        are calculated once, then cached until the shrink target changes, then
-        recalculated the next time they are used."""
-
-        def accept(self):
-            try:
-                return self.__derived_valuesfn.__name__
-            except KeyError:
-                return self.__derived_values.setdefault(fn.__name__, fn(self))
-
-        accept.__name__ = fn.__name__
-        return property(accept)
-
-    def __init__(self, engine, initial, predicate, allow_transition):
-        """Create a shrinker for a particular engine, with a given starting
-        point and predicate. When shrink() is called it will attempt to find an
-        example for which predicate is True and which is strictly smaller than
-        initial.
-
-        Note that initial is a ConjectureData object, and predicate
-        takes ConjectureData objects.
-        """
-        assert predicate is not None or allow_transition is not None
-        self.engine = engine
-        self.__predicate = predicate or (lambda data: True)
-        self.__allow_transition = allow_transition or (lambda source, destination: True)
-        self.__derived_values = {}
-        self.__pending_shrink_explanation = None
-
-        self.initial_size = len(initial.buffer)
-
-        # We keep track of the current best example on the shrink_target
-        # attribute.
-        self.shrink_target = None
-        self.update_shrink_target(initial)
-        self.shrinks = 0
-
-        # We terminate shrinks that seem to have reached their logical
-        # conclusion: If we've called the underlying test function at
-        # least self.max_stall times since the last time we shrunk,
-        # it's time to stop shrinking.
-        self.max_stall = 200
-        self.initial_calls = self.engine.call_count
-        self.calls_at_last_shrink = self.initial_calls
-
-        self.passes_by_name = {}
-        self.passes = 
-
-        # Extra DFAs that may be installed. This is used solely for
-        # testing and learning purposes.
-        self.extra_dfas = {}
-
-    @derived_value  # type: ignore
-    def cached_calculations(self):
-        return {}
-
-    def cached(self, *keys):
-        def accept(f):
-            cache_key = (f.__name__,) + keys
-            try:
-                return self.cached_calculationscache_key
-            except KeyError:
-                return self.cached_calculations.setdefault(cache_key, f())
-
-        return accept
-
-    def add_new_pass(self, run):
-        """Creates a shrink pass corresponding to calling ``run(self)``"""
-
-        definition = SHRINK_PASS_DEFINITIONSrun
-
-        p = ShrinkPass(
-            run_with_chooser=definition.run_with_chooser,
-            shrinker=self,
-            index=len(self.passes),
-        )
-        self.passes.append(p)
-        self.passes_by_namep.name = p
-        return p
-
-    def shrink_pass(self, name):
-        """Return the ShrinkPass object for the pass with the given name."""
-        if isinstance(name, ShrinkPass):
-            return name
-        if name not in self.passes_by_name:
-            self.add_new_pass(name)
-        return self.passes_by_namename
-
-    @derived_value  # type: ignore
-    def match_cache(self):
-        return {}
-
-    def matching_regions(self, dfa):
-        """Returns all pairs (u, v) such that self.bufferu:v is accepted
-        by this DFA."""
-
-        try:
-            return self.match_cachedfa
-        except KeyError:
-            pass
-        results = dfa.all_matching_regions(self.buffer)
-        results.sort(key=lambda t: (t1 - t0, t1))
-        assert all(dfa.matches(self.bufferu:v) for u, v in results)
-        self.match_cachedfa = results
-        return results
-
-    @property
-    def calls(self):
-        """Return the number of calls that have been made to the underlying
-        test function."""
-        return self.engine.call_count
-
-    def consider_new_buffer(self, buffer):
-        """Returns True if after running this buffer the result would be
-        the current shrink_target."""
-        buffer = bytes(buffer)
-        return buffer.startswith(self.buffer) or self.incorporate_new_buffer(buffer)
-
-    def incorporate_new_buffer(self, buffer):
-        """Either runs the test function on this buffer and returns True if
-        that changed the shrink_target, or determines that doing so would
-        be useless and returns False without running it."""
-
-        buffer = bytes(buffer: self.shrink_target.index)
-        # Sometimes an attempt at lexicographic minimization will do the wrong
-        # thing because the buffer has changed under it (e.g. something has
-        # turned into a write, the bit size has changed). The result would be
-        # an invalid string, but it's better for us to just ignore it here as
-        # it turns out to involve quite a lot of tricky book-keeping to get
-        # this right and it's better to just handle it in one place.
-        if sort_key(buffer) >= sort_key(self.shrink_target.buffer):
-            return False
-
-        if self.shrink_target.buffer.startswith(buffer):
-            return False
-
-        previous = self.shrink_target
-        self.cached_test_function(buffer)
-        return previous is not self.shrink_target
-
-    def incorporate_test_data(self, data):
-        """Takes a ConjectureData or Overrun object updates the current
-        shrink_target if this data represents an improvement over it."""
-        if data.status < Status.VALID or data is self.shrink_target:
-            return
-        if (
-            self.__predicate(data)
-            and sort_key(data.buffer) < sort_key(self.shrink_target.buffer)
-            and self.__allow_transition(self.shrink_target, data)
-        ):
-            self.update_shrink_target(data)
-
-    def cached_test_function(self, buffer):
-        """Returns a cached version of the underlying test function, so
-        that the result is either an Overrun object (if the buffer is
-        too short to be a valid test case) or a ConjectureData object
-        with status >= INVALID that would result from running this buffer."""
-
-        buffer = bytes(buffer)
-        result = self.engine.cached_test_function(buffer)
-        self.incorporate_test_data(result)
-        if self.calls - self.calls_at_last_shrink >= self.max_stall:
-            raise StopShrinking()
-        return result
-
-    def debug(self, msg):
-        self.engine.debug(msg)
-
-    @property
-    def random(self):
-        return self.engine.random
-
-    def shrink(self):
-        """Run the full set of shrinks and update shrink_target.
-
-        This method is "mostly idempotent" - calling it twice is unlikely to
-        have any effect, though it has a non-zero probability of doing so.
-        """
-        # We assume that if an all-zero block of bytes is an interesting
-        # example then we're not going to do better than that.
-        # This might not technically be true: e.g. for integers() | booleans()
-        # the simplest example is actually 1, 0. Missing this case is fairly
-        # harmless and this allows us to make various simplifying assumptions
-        # about the structure of the data (principally that we're never
-        # operating on a block of all zero bytes so can use non-zeroness as a
-        # signpost of complexity).
-        if not any(self.shrink_target.buffer) or self.incorporate_new_buffer(
-            bytes(len(self.shrink_target.buffer))
-        ):
-            return
-
-        try:
-            self.greedy_shrink()
-        except StopShrinking:
-            pass
-        finally:
-            if self.engine.report_debug_info:
-
-                def s(n):
-                    return "s" if n != 1 else ""
-
-                total_deleted = self.initial_size - len(self.shrink_target.buffer)
-
-                self.debug("---------------------")
-                self.debug("Shrink pass profiling")
-                self.debug("---------------------")
-                self.debug("")
-                calls = self.engine.call_count - self.initial_calls
-                self.debug(
-                    "Shrinking made a total of %d call%s "
-                    "of which %d shrank. This deleted %d byte%s out of %d."
-                    % (
-                        calls,
-                        s(calls),
-                        self.shrinks,
-                        total_deleted,
-                        s(total_deleted),
-                        self.initial_size,
-                    )
-                )
-                for useful in True, False:
-                    self.debug("")
-                    if useful:
-                        self.debug("Useful passes:")
-                    else:
-                        self.debug("Useless passes:")
-                    self.debug("")
-                    for p in sorted(
-                        self.passes, key=lambda t: (-t.calls, t.deletions, t.shrinks)
-                    ):
-                        if p.calls == 0:
-                            continue
-                        if (p.shrinks != 0) != useful:
-                            continue
-
-                        self.debug(
-                            "  * %s made %d call%s of which "
-                            "%d shrank, deleting %d byte%s."
-                            % (
-                                p.name,
-                                p.calls,
-                                s(p.calls),
-                                p.shrinks,
-                                p.deletions,
-                                s(p.deletions),
-                            )
-                        )
-                self.debug("")
-
-    def greedy_shrink(self):
-        """Run a full set of greedy shrinks (that is, ones that will only ever
-        move to a better target) and update shrink_target appropriately.
-
-        This method iterates to a fixed point and so is idempontent - calling
-        it twice will have exactly the same effect as calling it once.
-        """
-        self.fixate_shrink_passes(
-            
-                block_program("X" * 5),
-                block_program("X" * 4),
-                block_program("X" * 3),
-                block_program("X" * 2),
-                block_program("X" * 1),
-                "pass_to_descendant",
-                "reorder_examples",
-                "minimize_floats",
-                "minimize_duplicated_blocks",
-                block_program("-XX"),
-                "minimize_individual_blocks",
-                block_program("--X"),
-                "redistribute_block_pairs",
-                "lower_blocks_together",
-            
-            + dfa_replacement(n) for n in SHRINKING_DFAS
-        )
-
-    @derived_value  # type: ignore
-    def shrink_pass_choice_trees(self):
-        return defaultdict(ChoiceTree)
-
-    def fixate_shrink_passes(self, passes):
-        """Run steps from each pass in ``passes`` until the current shrink target
-        is a fixed point of all of them."""
-        passes = list(map(self.shrink_pass, passes))
-
-        any_ran = True
-        while any_ran:
-            any_ran = False
-
-            reordering = {}
-
-            # We run remove_discarded after every pass to do cleanup
-            # keeping track of whether that actually works. Either there is
-            # no discarded data and it is basically free, or it reliably works
-            # and deletes data, or it doesn't work. In that latter case we turn
-            # it off for the rest of this loop through the passes, but will
-            # try again once all of the passes have been run.
-            can_discard = self.remove_discarded()
-
-            calls_at_loop_start = self.calls
-
-            # We keep track of how many calls can be made by a single step
-            # without making progress and use this to test how much to pad
-            # out self.max_stall by as we go along.
-            max_calls_per_failing_step = 1
-
-            for sp in passes:
-                if can_discard:
-                    can_discard = self.remove_discarded()
-
-                before_sp = self.shrink_target
-
-                # Run the shrink pass until it fails to make any progress
-                # max_failures times in a row. This implicitly boosts shrink
-                # passes that are more likely to work.
-                failures = 0
-                max_failures = 20
-                while failures < max_failures:
-                    # We don't allow more than max_stall consecutive failures
-                    # to shrink, but this means that if we're unlucky and the
-                    # shrink passes are in a bad order where only the ones at
-                    # the end are useful, if we're not careful this heuristic
-                    # might stop us before we've tried everything. In order to
-                    # avoid that happening, we make sure that there's always
-                    # plenty of breathing room to make it through a single
-                    # iteration of the fixate_shrink_passes loop.
-                    self.max_stall = max(
-                        self.max_stall,
-                        2 * max_calls_per_failing_step
-                        + (self.calls - calls_at_loop_start),
-                    )
-
-                    prev = self.shrink_target
-                    initial_calls = self.calls
-                    # It's better for us to run shrink passes in a deterministic
-                    # order, to avoid repeat work, but this can cause us to create
-                    # long stalls when there are a lot of steps which fail to do
-                    # anything useful. In order to avoid this, once we've noticed
-                    # we're in a stall (i.e. half of max_failures calls have failed
-                    # to do anything) we switch to randomly jumping around. If we
-                    # find a success then we'll resume deterministic order from
-                    # there which, with any luck, is in a new good region.
-                    if not sp.step(random_order=failures >= max_failures // 2):
-                        # step returns False when there is nothing to do because
-                        # the entire choice tree is exhausted. If this happens
-                        # we break because we literally can't run this pass any
-                        # more than we already have until something else makes
-                        # progress.
-                        break
-                    any_ran = True
-
-                    # Don't count steps that didn't actually try to do
-                    # anything as failures. Otherwise, this call is a failure
-                    # if it failed to make any changes to the shrink target.
-                    if initial_calls != self.calls:
-                        if prev is not self.shrink_target:
-                            failures = 0
-                        else:
-                            max_calls_per_failing_step = max(
-                                max_calls_per_failing_step, self.calls - initial_calls
-                            )
-                            failures += 1
-
-                # We reorder the shrink passes so that on our next run through
-                # we try good ones first. The rule is that shrink passes that
-                # did nothing useful are the worst, shrink passes that reduced
-                # the length are the best.
-                if self.shrink_target is before_sp:
-                    reorderingsp = 1
-                elif len(self.buffer) < len(before_sp.buffer):
-                    reorderingsp = -1
-                else:
-                    reorderingsp = 0
-
-            passes.sort(key=reordering.__getitem__)
-
-    @property
-    def buffer(self):
-        return self.shrink_target.buffer
-
-    @property
-    def blocks(self):
-        return self.shrink_target.blocks
-
-    @property
-    def examples(self):
-        return self.shrink_target.examples
-
-    def all_block_bounds(self):
-        return self.shrink_target.blocks.all_bounds()
-
-    @derived_value  # type: ignore
-    def examples_by_label(self):
-        """An index of all examples grouped by their label, with
-        the examples stored in their normal index order."""
-
-        examples_by_label = defaultdict(list)
-        for ex in self.examples:
-            examples_by_labelex.label.append(ex)
-        return dict(examples_by_label)
-
-    @derived_value  # type: ignore
-    def distinct_labels(self):
-        return sorted(self.examples_by_label, key=str)
-
-    @defines_shrink_pass()
-    def pass_to_descendant(self, chooser):
-        """Attempt to replace each example with a descendant example.
-
-        This is designed to deal with strategies that call themselves
-        recursively. For example, suppose we had:
-
-        binary_tree = st.deferred(
-            lambda: st.one_of(
-                st.integers(), st.tuples(binary_tree, binary_tree)))
-
-        This pass guarantees that we can replace any binary tree with one of
-        its subtrees - each of those will create an interval that the parent
-        could validly be replaced with, and this pass will try doing that.
-
-        This is pretty expensive - it takes O(len(intervals)^2) - so we run it
-        late in the process when we've got the number of intervals as far down
-        as possible.
-        """
-
-        label = chooser.choose(
-            self.distinct_labels, lambda l: len(self.examples_by_labell) >= 2
-        )
-
-        ls = self.examples_by_labellabel
-
-        i = chooser.choose(range(len(ls) - 1))
-
-        ancestor = lsi
-
-        if i + 1 == len(ls) or lsi + 1.start >= ancestor.end:
-            return
-
-        @self.cached(label, i)
-        def descendants():
-            lo = i + 1
-            hi = len(ls)
-            while lo + 1 < hi:
-                mid = (lo + hi) // 2
-                if lsmid.start >= ancestor.end:
-                    hi = mid
-                else:
-                    lo = mid
-            return t for t in lsi + 1 : hi if t.length < ancestor.length
-
-        descendant = chooser.choose(descendants, lambda ex: ex.length > 0)
-
-        assert ancestor.start <= descendant.start
-        assert ancestor.end >= descendant.end
-        assert descendant.length < ancestor.length
-
-        self.incorporate_new_buffer(
-            self.buffer: ancestor.start
-            + self.bufferdescendant.start : descendant.end
-            + self.bufferancestor.end :
-        )
-
-    def lower_common_block_offset(self):
-        """Sometimes we find ourselves in a situation where changes to one part
-        of the byte stream unlock changes to other parts. Sometimes this is
-        good, but sometimes this can cause us to exhibit exponential slow
-        downs!
-
-        e.g. suppose we had the following:
-
-        m = draw(integers(min_value=0))
-        n = draw(integers(min_value=0))
-        assert abs(m - n) > 1
-
-        If this fails then we'll end up with a loop where on each iteration we
-        reduce each of m and n by 2 - m can't go lower because of n, then n
-        can't go lower because of m.
-
-        This will take us O(m) iterations to complete, which is exponential in
-        the data size, as we gradually zig zag our way towards zero.
-
-        This can only happen if we're failing to reduce the size of the byte
-        stream: The number of iterations that reduce the length of the byte
-        stream is bounded by that length.
-
-        So what we do is this: We keep track of which blocks are changing, and
-        then if there's some non-zero common offset to them we try and minimize
-        them all at once by lowering that offset.
-
-        This may not work, and it definitely won't get us out of all possible
-        exponential slow downs (an example of where it doesn't is where the
-        shape of the blocks changes as a result of this bouncing behaviour),
-        but it fails fast when it doesn't work and gets us out of a really
-        nastily slow case when it does.
-        """
-        if len(self.__changed_blocks) <= 1:
-            return
-
-        current = self.shrink_target
-
-        blocked = current.bufferu:v for u, v in self.all_block_bounds()
-
-        changed = 
-            i
-            for i in sorted(self.__changed_blocks)
-            if not self.shrink_target.blocksi.trivial
-        
-
-        if not changed:
-            return
-
-        ints = int_from_bytes(blockedi) for i in changed
-        offset = min(ints)
-        assert offset > 0
-
-        for i in range(len(ints)):
-            intsi -= offset
-
-        def reoffset(o):
-            new_blocks = list(blocked)
-            for i, v in zip(changed, ints):
-                new_blocksi = int_to_bytes(v + o, len(blockedi))
-            return self.incorporate_new_buffer(b"".join(new_blocks))
-
-        Integer.shrink(offset, reoffset, random=self.random)
-        self.clear_change_tracking()
-
-    def clear_change_tracking(self):
-        self.__last_checked_changed_at = self.shrink_target
-        self.__all_changed_blocks = set()
-
-    def mark_changed(self, i):
-        self.__changed_blocks.add(i)
-
-    @property
-    def __changed_blocks(self):
-        if self.__last_checked_changed_at is not self.shrink_target:
-            prev_target = self.__last_checked_changed_at
-            new_target = self.shrink_target
-            assert prev_target is not new_target
-            prev = prev_target.buffer
-            new = new_target.buffer
-            assert sort_key(new) < sort_key(prev)
-
-            if (
-                len(new_target.blocks) != len(prev_target.blocks)
-                or new_target.blocks.endpoints != prev_target.blocks.endpoints
-            ):
-                self.__all_changed_blocks = set()
-            else:
-                blocks = new_target.blocks
-
-                # Index of last block whose contents have been modified, found
-                # by checking if the tail past this point has been modified.
-                last_changed = binary_search(
-                    0,
-                    len(blocks),
-                    lambda i: prevblocks.start(i) : != newblocks.start(i) :,
-                )
-
-                # Index of the first block whose contents have been changed,
-                # because we know that this predicate is true for zero (because
-                # the prefix from the start is empty), so the result must be True
-                # for the bytes from the start of this block and False for the
-                # bytes from the end, hence the change is in this block.
-                first_changed = binary_search(
-                    0,
-                    len(blocks),
-                    lambda i: prev: blocks.start(i) == new: blocks.start(i),
-                )
-
-                # Between these two changed regions we now do a linear scan to
-                # check if any specific block values have changed.
-                for i in range(first_changed, last_changed + 1):
-                    u, v = blocks.bounds(i)
-                    if i not in self.__all_changed_blocks and prevu:v != newu:v:
-                        self.__all_changed_blocks.add(i)
-            self.__last_checked_changed_at = new_target
-        assert self.__last_checked_changed_at is self.shrink_target
-        return self.__all_changed_blocks
-
-    def update_shrink_target(self, new_target):
-        assert isinstance(new_target, ConjectureResult)
-        if self.shrink_target is not None:
-            self.shrinks += 1
-            # If we are just taking a long time to shrink we don't want to
-            # trigger this heuristic, so whenever we shrink successfully
-            # we give ourselves a bit of breathing room to make sure we
-            # would find a shrink that took that long to find the next time.
-            # The case where we're taking a long time but making steady
-            # progress is handled by `finish_shrinking_deadline` in engine.py
-            self.max_stall = max(
-                self.max_stall, (self.calls - self.calls_at_last_shrink) * 2
-            )
-            self.calls_at_last_shrink = self.calls
-        else:
-            self.__all_changed_blocks = set()
-            self.__last_checked_changed_at = new_target
-
-        self.shrink_target = new_target
-        self.__derived_values = {}
-
-    def try_shrinking_blocks(self, blocks, b):
-        """Attempts to replace each block in the blocks list with b. Returns
-        True if it succeeded (which may include some additional modifications
-        to shrink_target).
-
-        In current usage it is expected that each of the blocks currently have
-        the same value, although this is not essential. Note that b must be
-        < the block at min(blocks) or this is not a valid shrink.
-
-        This method will attempt to do some small amount of work to delete data
-        that occurs after the end of the blocks. This is useful for cases where
-        there is some size dependency on the value of a block.
-        """
-        initial_attempt = bytearray(self.shrink_target.buffer)
-        for i, block in enumerate(blocks):
-            if block >= len(self.blocks):
-                blocks = blocks:i
-                break
-            u, v = self.blocksblock.bounds
-            n = min(self.blocksblock.length, len(b))
-            initial_attemptv - n : v = b-n:
-
-        if not blocks:
-            return False
-
-        start = self.shrink_target.blocksblocks0.start
-        end = self.shrink_target.blocksblocks-1.end
-
-        initial_data = self.cached_test_function(initial_attempt)
-
-        if initial_data is self.shrink_target:
-            self.lower_common_block_offset()
-            return True
-
-        # If this produced something completely invalid we ditch it
-        # here rather than trying to persevere.
-        if initial_data.status < Status.VALID:
-            return False
-
-        # We've shrunk inside our group of blocks, so we have no way to
-        # continue. (This only happens when shrinking more than one block at
-        # a time).
-        if len(initial_data.buffer) < v:
-            return False
-
-        lost_data = len(self.shrink_target.buffer) - len(initial_data.buffer)
-
-        # If this did not in fact cause the data size to shrink we
-        # bail here because it's not worth trying to delete stuff from
-        # the remainder.
-        if lost_data <= 0:
-            return False
-
-        # We now look for contiguous regions to delete that might help fix up
-        # this failed shrink. We only look for contiguous regions of the right
-        # lengths because doing anything more than that starts to get very
-        # expensive. See minimize_individual_blocks for where we
-        # try to be more aggressive.
-        regions_to_delete = {(end, end + lost_data)}
-
-        for j in (blocks-1 + 1, blocks-1 + 2):
-            if j >= min(len(initial_data.blocks), len(self.blocks)):
-                continue
-            # We look for a block very shortly after the last one that has
-            # lost some of its size, and try to delete from the beginning so
-            # that it retains the same integer value. This is a bit of a hyper
-            # specific trick designed to make our integers() strategy shrink
-            # well.
-            r1, s1 = self.shrink_target.blocksj.bounds
-            r2, s2 = initial_data.blocksj.bounds
-            lost = (s1 - r1) - (s2 - r2)
-            # Apparently a coverage bug? An assert False in the body of this
-            # will reliably fail, but it shows up as uncovered.
-            if lost <= 0 or r1 != r2:  # pragma: no cover
-                continue
-            regions_to_delete.add((r1, r1 + lost))
-
-        for ex in self.shrink_target.examples:
-            if ex.start > start:
-                continue
-            if ex.end <= end:
-                continue
-
-            replacement = initial_data.examplesex.index
-
-            in_original = c for c in ex.children if c.start >= end
-
-            in_replaced = c for c in replacement.children if c.start >= end
-
-            if len(in_replaced) >= len(in_original) or not in_replaced:
-                continue
-
-            # We've found an example where some of the children went missing
-            # as a result of this change, and just replacing it with the data
-            # it would have had and removing the spillover didn't work. This
-            # means that some of its children towards the right must be
-            # important, so we try to arrange it so that it retains its
-            # rightmost children instead of its leftmost.
-            regions_to_delete.add(
-                (in_original0.start, in_original-len(in_replaced).start)
-            )
-
-        for u, v in sorted(regions_to_delete, key=lambda x: x1 - x0, reverse=True):
-            try_with_deleted = bytearray(initial_attempt)
-            del try_with_deletedu:v
-            if self.incorporate_new_buffer(try_with_deleted):
-                return True
-        return False
-
-    def remove_discarded(self):
-        """Try removing all bytes marked as discarded.
-
-        This is primarily to deal with data that has been ignored while
-        doing rejection sampling - e.g. as a result of an integer range, or a
-        filtered strategy.
-
-        Such data will also be handled by the adaptive_example_deletion pass,
-        but that pass is necessarily more conservative and will try deleting
-        each interval individually. The common case is that all data drawn and
-        rejected can just be thrown away immediately in one block, so this pass
-        will be much faster than trying each one individually when it works.
-
-        returns False if there is discarded data and removing it does not work,
-        otherwise returns True.
-        """
-        while self.shrink_target.has_discards:
-            discarded = 
-
-            for ex in self.shrink_target.examples:
-                if (
-                    ex.length > 0
-                    and ex.discarded
-                    and (not discarded or ex.start >= discarded-1-1)
-                ):
-                    discarded.append((ex.start, ex.end))
-
-            # This can happen if we have discards but they are all of
-            # zero length. This shouldn't happen very often so it's
-            # faster to check for it here than at the point of example
-            # generation.
-            if not discarded:
-                break
-
-            attempt = bytearray(self.shrink_target.buffer)
-            for u, v in reversed(discarded):
-                del attemptu:v
-
-            if not self.incorporate_new_buffer(attempt):
-                return False
-        return True
-
-    @derived_value  # type: ignore
-    def blocks_by_non_zero_suffix(self):
-        """Returns a list of blocks grouped by their non-zero suffix,
-        as a list of (suffix, indices) pairs, skipping all groupings
-        where there is only one index.
-
-        This is only used for the arguments of minimize_duplicated_blocks.
-        """
-        duplicates = defaultdict(list)
-        for block in self.blocks:
-            duplicatesnon_zero_suffix(self.bufferblock.start : block.end).append(
-                block.index
-            )
-        return duplicates
-
-    @derived_value  # type: ignore
-    def duplicated_block_suffixes(self):
-        return sorted(self.blocks_by_non_zero_suffix)
-
-    @defines_shrink_pass()
-    def minimize_duplicated_blocks(self, chooser):
-        """Find blocks that have been duplicated in multiple places and attempt
-        to minimize all of the duplicates simultaneously.
-
-        This lets us handle cases where two values can't be shrunk
-        independently of each other but can easily be shrunk together.
-        For example if we had something like:
-
-        ls = data.draw(lists(integers()))
-        y = data.draw(integers())
-        assert y not in ls
-
-        Suppose we drew y = 3 and after shrinking we have ls = 3. If we were
-        to replace both 3s with 0, this would be a valid shrink, but if we were
-        to replace either 3 with 0 on its own the test would start passing.
-
-        It is also useful for when that duplication is accidental and the value
-        of the blocks doesn't matter very much because it allows us to replace
-        more values at once.
-        """
-        block = chooser.choose(self.duplicated_block_suffixes)
-        targets = self.blocks_by_non_zero_suffixblock
-        if len(targets) <= 1:
-            return
-        Lexical.shrink(
-            block,
-            lambda b: self.try_shrinking_blocks(targets, b),
-            random=self.random,
-            full=False,
-        )
-
-    @defines_shrink_pass()
-    def minimize_floats(self, chooser):
-        """Some shrinks that we employ that only really make sense for our
-        specific floating point encoding that are hard to discover from any
-        sort of reasonable general principle. This allows us to make
-        transformations like replacing a NaN with an Infinity or replacing
-        a float with its nearest integers that we would otherwise not be
-        able to due to them requiring very specific transformations of
-        the bit sequence.
-
-        We only apply these transformations to blocks that "look like" our
-        standard float encodings because they are only really meaningful
-        there. The logic for detecting this is reasonably precise, but
-        it doesn't matter if it's wrong. These are always valid
-        transformations to make, they just don't necessarily correspond to
-        anything particularly meaningful for non-float values.
-        """
-
-        ex = chooser.choose(
-            self.examples,
-            lambda ex: (
-                ex.label == DRAW_FLOAT_LABEL
-                and len(ex.children) == 2
-                and ex.children1.length == 8
-            ),
-        )
-
-        u = ex.children1.start
-        v = ex.children1.end
-        buf = self.shrink_target.buffer
-        b = bufu:v
-        f = lex_to_float(int_from_bytes(b))
-        b2 = int_to_bytes(float_to_lex(f), 8)
-        if b == b2 or self.consider_new_buffer(buf:u + b2 + bufv:):
-            Float.shrink(
-                f,
-                lambda x: self.consider_new_buffer(
-                    self.shrink_target.buffer:u
-                    + int_to_bytes(float_to_lex(x), 8)
-                    + self.shrink_target.bufferv:
-                ),
-                random=self.random,
-            )
-
-    @defines_shrink_pass()
-    def redistribute_block_pairs(self, chooser):
-        """If there is a sum of generated integers that we need their sum
-        to exceed some bound, lowering one of them requires raising the
-        other. This pass enables that."""
-
-        block = chooser.choose(self.blocks, lambda b: not b.all_zero)
-
-        for j in range(block.index + 1, len(self.blocks)):
-            next_block = self.blocksj
-            if next_block.length == block.length:
-                break
-        else:
-            return
-
-        buffer = self.buffer
-
-        m = int_from_bytes(bufferblock.start : block.end)
-        n = int_from_bytes(buffernext_block.start : next_block.end)
-
-        def boost(k):
-            if k > m:
-                return False
-            attempt = bytearray(buffer)
-            attemptblock.start : block.end = int_to_bytes(m - k, block.length)
-            try:
-                attemptnext_block.start : next_block.end = int_to_bytes(
-                    n + k, next_block.length
-                )
-            except OverflowError:
-                return False
-            return self.consider_new_buffer(attempt)
-
-        find_integer(boost)
-
-    @defines_shrink_pass()
-    def lower_blocks_together(self, chooser):
-        block = chooser.choose(self.blocks, lambda b: not b.all_zero)
-
-        # Choose the next block to be up to eight blocks onwards. We don't
-        # want to go too far (to avoid quadratic time) but it's worth a
-        # reasonable amount of lookahead, especially as we expect most
-        # blocks are zero by this point anyway.
-        next_block = self.blocks
-            chooser.choose(
-                range(block.index + 1, min(len(self.blocks), block.index + 9)),
-                lambda j: not self.blocksj.all_zero,
-            )
-        
-
-        buffer = self.buffer
-
-        m = int_from_bytes(bufferblock.start : block.end)
-        n = int_from_bytes(buffernext_block.start : next_block.end)
-
-        def lower(k):
-            if k > min(m, n):
-                return False
-            attempt = bytearray(buffer)
-            attemptblock.start : block.end = int_to_bytes(m - k, block.length)
-            attemptnext_block.start : next_block.end = int_to_bytes(
-                n - k, next_block.length
-            )
-            assert len(attempt) == len(buffer)
-            return self.consider_new_buffer(attempt)
-
-        find_integer(lower)
-
-    @defines_shrink_pass()
-    def minimize_individual_blocks(self, chooser):
-        """Attempt to minimize each block in sequence.
-
-        This is the pass that ensures that e.g. each integer we draw is a
-        minimum value. So it's the part that guarantees that if we e.g. do
-
-        x = data.draw(integers())
-        assert x < 10
-
-        then in our shrunk example, x = 10 rather than say 97.
-
-        If we are unsuccessful at minimizing a block of interest we then
-        check if that's because it's changing the size of the test case and,
-        if so, we also make an attempt to delete parts of the test case to
-        see if that fixes it.
-
-        We handle most of the common cases in try_shrinking_blocks which is
-        pretty good at clearing out large contiguous blocks of dead space,
-        but it fails when there is data that has to stay in particular places
-        in the list.
-        """
-        block = chooser.choose(self.blocks, lambda b: not b.trivial)
-
-        initial = self.shrink_target
-        u, v = block.bounds
-        i = block.index
-        Lexical.shrink(
-            self.shrink_target.bufferu:v,
-            lambda b: self.try_shrinking_blocks((i,), b),
-            random=self.random,
-            full=False,
-        )
-
-        if self.shrink_target is not initial:
-            return
-
-        lowered = (
-            self.buffer: block.start
-            + int_to_bytes(
-                int_from_bytes(self.bufferblock.start : block.end) - 1, block.length
-            )
-            + self.bufferblock.end :
-        )
-        attempt = self.cached_test_function(lowered)
-        if (
-            attempt.status < Status.VALID
-            or len(attempt.buffer) == len(self.buffer)
-            or len(attempt.buffer) == block.end
-        ):
-            return
-
-        # If it were then the lexical shrink should have worked and we could
-        # never have got here.
-        assert attempt is not self.shrink_target
-
-        @self.cached(block.index)
-        def first_example_after_block():
-            lo = 0
-            hi = len(self.examples)
-            while lo + 1 < hi:
-                mid = (lo + hi) // 2
-                ex = self.examplesmid
-                if ex.start >= block.end:
-                    hi = mid
-                else:
-                    lo = mid
-            return hi
-
-        ex = self.examples
-            chooser.choose(
-                range(first_example_after_block, len(self.examples)),
-                lambda i: self.examplesi.length > 0,
-            )
-        
-
-        u, v = block.bounds
-
-        buf = bytearray(lowered)
-        del bufex.start : ex.end
-        self.incorporate_new_buffer(buf)
-
-    @defines_shrink_pass()
-    def reorder_examples(self, chooser):
-        """This pass allows us to reorder the children of each example.
-
-        For example, consider the following:
-
-        .. code-block:: python
-
-            import hypothesis.strategies as st
-            from hypothesis import given
-
-
-            @given(st.text(), st.text())
-            def test_not_equal(x, y):
-                assert x != y
-
-        Without the ability to reorder x and y this could fail either with
-        ``x=""``, ``y="0"``, or the other way around. With reordering it will
-        reliably fail with ``x=""``, ``y="0"``.
-        """
-        ex = chooser.choose(self.examples)
-        label = chooser.choose(ex.children).label
-
-        group = c for c in ex.children if c.label == label
-        if len(group) <= 1:
-            return
-
-        st = self.shrink_target
-        pieces = st.bufferex.start : ex.end for ex in group
-        endpoints = (ex.start, ex.end) for ex in group
-
-        Ordering.shrink(
-            pieces,
-            lambda ls: self.consider_new_buffer(
-                replace_all(st.buffer, (u, v, r) for (u, v), r in zip(endpoints, ls))
-            ),
-            random=self.random,
-        )
-
-    def run_block_program(self, i, description, original, repeats=1):
-        """Block programs are a mini-DSL for block rewriting, defined as a sequence
-        of commands that can be run at some index into the blocks
-
-        Commands are:
-
-            * "-", subtract one from this block.
-            * "X", delete this block
-
-        If a command does not apply (currently only because it's - on a zero
-        block) the block will be silently skipped over.
-
-        This method runs the block program in ``description`` at block index
-        ``i`` on the ConjectureData ``original``. If ``repeats > 1`` then it
-        will attempt to approximate the results of running it that many times.
-
-        Returns True if this successfully changes the underlying shrink target,
-        else False.
-        """
-        if i + len(description) > len(original.blocks) or i < 0:
-            return False
-        attempt = bytearray(original.buffer)
-        for _ in range(repeats):
-            for k, d in reversed(list(enumerate(description))):
-                j = i + k
-                u, v = original.blocksj.bounds
-                if v > len(attempt):
-                    return False
-                if d == "-":
-                    value = int_from_bytes(attemptu:v)
-                    if value == 0:
-                        return False
-                    else:
-                        attemptu:v = int_to_bytes(value - 1, v - u)
-                elif d == "X":
-                    del attemptu:v
-                else:
-                    raise NotImplementedError(f"Unrecognised command {d!r}")
-        return self.incorporate_new_buffer(attempt)
-
-
-def shrink_pass_family(f):
-    def accept(*args):
-        name = "{}({})".format(f.__name__, ", ".join(map(repr, args)))
-        if name not in SHRINK_PASS_DEFINITIONS:
-
-            def run(self, chooser):
-                return f(self, chooser, *args)
-
-            run.__name__ = name
-            defines_shrink_pass()(run)
-        assert name in SHRINK_PASS_DEFINITIONS
-        return name
-
-    return accept
-
-
-@shrink_pass_family
-def block_program(self, chooser, description):
-    """Mini-DSL for block rewriting. A sequence of commands that will be run
-    over all contiguous sequences of blocks of the description length in order.
-    Commands are:
-
-        * ".", keep this block unchanged
-        * "-", subtract one from this block.
-        * "0", replace this block with zero
-        * "X", delete this block
-
-    If a command does not apply (currently only because it's - on a zero
-    block) the block will be silently skipped over. As a side effect of
-    running a block program its score will be updated.
-    """
-    n = len(description)
-
-    """Adaptively attempt to run the block program at the current
-    index. If this successfully applies the block program ``k`` times
-    then this runs in ``O(log(k))`` test function calls."""
-    i = chooser.choose(range(len(self.shrink_target.blocks) - n))
-    # First, run the block program at the chosen index. If this fails,
-    # don't do any extra work, so that failure is as cheap as possible.
-    if not self.run_block_program(i, description, original=self.shrink_target):
-        return
-
-    # Because we run in a random order we will often find ourselves in the middle
-    # of a region where we could run the block program. We thus start by moving
-    # left to the beginning of that region if possible in order to to start from
-    # the beginning of that region.
-    def offset_left(k):
-        return i - k * n
-
-    i = offset_left(
-        find_integer(
-            lambda k: self.run_block_program(
-                offset_left(k), description, original=self.shrink_target
-            )
-        )
-    )
-
-    original = self.shrink_target
-
-    # Now try to run the block program multiple times here.
-    find_integer(
-        lambda k: self.run_block_program(i, description, original=original, repeats=k)
-    )
-
-
-@shrink_pass_family
-def dfa_replacement(self, chooser, dfa_name):
-    """Use one of our previously learned shrinking DFAs to reduce
-    the current test case. This works by finding a match of the DFA in the
-    current buffer that is not already minimal and attempting to replace it
-    with the minimal string matching that DFA.
-    """
-
-    try:
-        dfa = SHRINKING_DFASdfa_name
-    except KeyError:
-        dfa = self.extra_dfasdfa_name
-
-    matching_regions = self.matching_regions(dfa)
-    minimal = next(dfa.all_matching_strings())
-    u, v = chooser.choose(
-        matching_regions, lambda t: self.buffert0 : t1 != minimal
-    )
-    p = self.bufferu:v
-    assert sort_key(minimal) < sort_key(p)
-    replaced = self.buffer:u + minimal + self.bufferv:
-
-    assert sort_key(replaced) < sort_key(self.buffer)
-
-    self.consider_new_buffer(replaced)
-
-
-@attr.s(slots=True, eq=False)
-class ShrinkPass:
-    run_with_chooser = attr.ib()
-    index = attr.ib()
-    shrinker = attr.ib()
-
-    last_prefix = attr.ib(default=())
-    successes = attr.ib(default=0)
-    calls = attr.ib(default=0)
-    shrinks = attr.ib(default=0)
-    deletions = attr.ib(default=0)
-
-    def step(self, random_order=False):
-        tree = self.shrinker.shrink_pass_choice_treesself
-        if tree.exhausted:
-            return False
-
-        initial_shrinks = self.shrinker.shrinks
-        initial_calls = self.shrinker.calls
-        size = len(self.shrinker.shrink_target.buffer)
-        self.shrinker.engine.explain_next_call_as(self.name)
-
-        if random_order:
-            selection_order = random_selection_order(self.shrinker.random)
-        else:
-            selection_order = prefix_selection_order(self.last_prefix)
-
-        try:
-            self.last_prefix = tree.step(
-                selection_order,
-                lambda chooser: self.run_with_chooser(self.shrinker, chooser),
-            )
-        finally:
-            self.calls += self.shrinker.calls - initial_calls
-            self.shrinks += self.shrinker.shrinks - initial_shrinks
-            self.deletions += size - len(self.shrinker.shrink_target.buffer)
-            self.shrinker.engine.clear_call_explanation()
-        return True
-
-    @property
-    def name(self):
-        return self.run_with_chooser.__name__
-
-
-def non_zero_suffix(b):
-    """Returns the longest suffix of b that starts with a non-zero
-    byte."""
-    i = 0
-    while i < len(b) and bi == 0:
-        i += 1
-    return bi:
-
-
-class StopShrinking(Exception):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/shrinking Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/shrinking/dfas.py Deleted

@@ -1,337 +0,0 @@
-# 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 hashlib
-import math
-from itertools import islice
-
-from hypothesis import HealthCheck, settings
-from hypothesis.errors import HypothesisException
-from hypothesis.internal.conjecture.data import ConjectureResult, Status
-from hypothesis.internal.conjecture.dfa.lstar import LStar
-from hypothesis.internal.conjecture.shrinking.learned_dfas import (
-    SHRINKING_DFAS,
-    __file__ as learned_dfa_file,
-)
-
-"""
-This is a module for learning new DFAs that help normalize test
-functions. That is, given a test function that sometimes shrinks
-to one thing and sometimes another, this module is designed to
-help learn new DFA-based shrink passes that will cause it to
-always shrink to the same thing.
-"""
-
-
-class FailedToNormalise(HypothesisException):
-    pass
-
-
-def update_learned_dfas():
-    """Write any modifications to the SHRINKING_DFAS dictionary
-    back to the learned DFAs file."""
-
-    with open(learned_dfa_file) as i:
-        source = i.read()
-
-    lines = source.splitlines()
-
-    i = lines.index("# AUTOGENERATED BEGINS")
-
-    del linesi + 1 :
-
-    lines.append("")
-    lines.append("# fmt: off")
-    lines.append("")
-
-    for k, v in sorted(SHRINKING_DFAS.items()):
-        lines.append(f"SHRINKING_DFAS{k!r} = {v!r}  # noqa: E501")
-
-    lines.append("")
-    lines.append("# fmt: on")
-
-    new_source = "\n".join(lines) + "\n"
-
-    if new_source != source:
-        with open(learned_dfa_file, "w") as o:
-            o.write(new_source)
-
-
-def learn_a_new_dfa(runner, u, v, predicate):
-    """Given two buffers ``u`` and ``v```, learn a DFA that will
-    allow the shrinker to normalise them better. ``u`` and ``v``
-    should not currently shrink to the same test case when calling
-    this function."""
-    from hypothesis.internal.conjecture.shrinker import dfa_replacement, sort_key
-
-    assert predicate(runner.cached_test_function(u))
-    assert predicate(runner.cached_test_function(v))
-
-    u_shrunk = fully_shrink(runner, u, predicate)
-    v_shrunk = fully_shrink(runner, v, predicate)
-
-    u, v = sorted((u_shrunk.buffer, v_shrunk.buffer), key=sort_key)
-
-    assert u != v
-
-    assert not v.startswith(u)
-
-    # We would like to avoid using LStar on large strings as its
-    # behaviour can be quadratic or worse. In order to help achieve
-    # this we peel off a common prefix and suffix of the two final
-    # results and just learn the internal bit where they differ.
-    #
-    # This potentially reduces the length quite far if there's
-    # just one tricky bit of control flow we're struggling to
-    # reduce inside a strategy somewhere and the rest of the
-    # test function reduces fine.
-    if v.endswith(u):
-        prefix = b""
-        suffix = u
-        u_core = b""
-        assert len(u) > 0
-        v_core = v: -len(u)
-    else:
-        i = 0
-        while ui == vi:
-            i += 1
-        prefix = u:i
-        assert u.startswith(prefix)
-        assert v.startswith(prefix)
-
-        i = 1
-        while u-i == v-i:
-            i += 1
-
-        suffix = umax(len(prefix), len(u) + 1 - i) :
-        assert u.endswith(suffix)
-        assert v.endswith(suffix)
-
-        u_core = ulen(prefix) : len(u) - len(suffix)
-        v_core = vlen(prefix) : len(v) - len(suffix)
-
-    assert u == prefix + u_core + suffix, (list(u), list(v))
-    assert v == prefix + v_core + suffix, (list(u), list(v))
-
-    better = runner.cached_test_function(u)
-    worse = runner.cached_test_function(v)
-
-    allow_discards = worse.has_discards or better.has_discards
-
-    def is_valid_core(s):
-        if not (len(u_core) <= len(s) <= len(v_core)):
-            return False
-        buf = prefix + s + suffix
-        result = runner.cached_test_function(buf)
-        return (
-            predicate(result)
-            # Because we're often using this to learn strategies
-            # rather than entire complex test functions, it's
-            # important that our replacements are precise and
-            # don't leave the rest of the test case in a weird
-            # state.
-            and result.buffer == buf
-            # Because the shrinker is good at removing discarded
-            # data, unless we need discards to allow one or both
-            # of u and v to result in valid shrinks, we don't
-            # count attempts that have them as valid. This will
-            # cause us to match fewer strings, which will make
-            # the resulting shrink pass more efficient when run
-            # on test functions it wasn't really intended for.
-            and (allow_discards or not result.has_discards)
-        )
-
-    assert sort_key(u_core) < sort_key(v_core)
-
-    assert is_valid_core(u_core)
-    assert is_valid_core(v_core)
-
-    learner = LStar(is_valid_core)
-
-    prev = -1
-    while learner.generation != prev:
-        prev = learner.generation
-        learner.learn(u_core)
-        learner.learn(v_core)
-
-        # L* has a tendency to learn DFAs which wrap around to
-        # the beginning. We don't want to it to do that unless
-        # it's accurate, so we use these as examples to show
-        # check going around the DFA twice.
-        learner.learn(u_core * 2)
-        learner.learn(v_core * 2)
-
-        if learner.dfa.max_length(learner.dfa.start) > len(v_core):
-            # The language we learn is finite and bounded above
-            # by the length of v_core. This is important in order
-            # to keep our shrink passes reasonably efficient -
-            # otherwise they can match far too much. So whenever
-            # we learn a DFA that could match a string longer
-            # than len(v_core) we fix it by finding the first
-            # string longer than v_core and learning that as
-            # a correction.
-            x = next(learner.dfa.all_matching_strings(min_length=len(v_core) + 1))
-            assert not is_valid_core(x)
-            learner.learn(x)
-            assert not learner.dfa.matches(x)
-            assert learner.generation != prev
-        else:
-            # We mostly care about getting the right answer on the
-            # minimal test case, but because we're doing this offline
-            # anyway we might as well spend a little more time trying
-            # small examples to make sure the learner gets them right.
-            for x in islice(learner.dfa.all_matching_strings(), 100):
-                if not is_valid_core(x):
-                    learner.learn(x)
-                    assert learner.generation != prev
-                    break
-
-    # We've now successfully learned a DFA that works for shrinking
-    # our failed normalisation further. Canonicalise it into a concrete
-    # DFA so we can save it for later.
-    new_dfa = learner.dfa.canonicalise()
-
-    assert math.isfinite(new_dfa.max_length(new_dfa.start))
-
-    shrinker = runner.new_shrinker(runner.cached_test_function(v), predicate)
-
-    assert (len(prefix), len(v) - len(suffix)) in shrinker.matching_regions(new_dfa)
-
-    name = "tmp-dfa-" + repr(new_dfa)
-
-    shrinker.extra_dfasname = new_dfa
-
-    shrinker.fixate_shrink_passes(dfa_replacement(name))
-
-    assert sort_key(shrinker.buffer) < sort_key(v)
-
-    return new_dfa
-
-
-def fully_shrink(runner, test_case, predicate):
-    if not isinstance(test_case, ConjectureResult):
-        test_case = runner.cached_test_function(test_case)
-    while True:
-        shrunk = runner.shrink(test_case, predicate)
-        if shrunk.buffer == test_case.buffer:
-            break
-        test_case = shrunk
-    return test_case
-
-
-def normalize(
-    base_name,
-    test_function,
-    *,
-    required_successes=100,
-    allowed_to_update=False,
-    max_dfas=10,
-    random=None,
-):
-    """Attempt to ensure that this test function successfully normalizes - i.e.
-    whenever it declares a test case to be interesting, we are able
-    to shrink that to the same interesting test case (which logically should
-    be the shortlex minimal interesting test case, though we may not be able
-    to detect if it is).
-
-    Will run until we have seen ``required_successes`` many interesting test
-    cases in a row normalize to the same value.
-
-    If ``allowed_to_update`` is True, whenever we fail to normalize we will
-    learn a new DFA-based shrink pass that allows us to make progress. Any
-    learned DFAs will be written back into the learned DFA file at the end
-    of this function. If ``allowed_to_update`` is False, this will raise an
-    error as soon as it encounters a failure to normalize.
-
-    Additionally, if more than ``max_dfas` DFAs are required to normalize
-    this test function, this function will raise an error - it's essentially
-    designed for small patches that other shrink passes don't cover, and
-    if it's learning too many patches then you need a better shrink pass
-    than this can provide.
-    """
-    # Need import inside the function to avoid circular imports
-    from hypothesis.internal.conjecture.engine import BUFFER_SIZE, ConjectureRunner
-
-    runner = ConjectureRunner(
-        test_function,
-        settings=settings(database=None, suppress_health_check=HealthCheck.all()),
-        ignore_limits=True,
-        random=random,
-    )
-
-    seen = set()
-
-    dfas_added = 0
-
-    found_interesting = False
-    consecutive_successes = 0
-    failures_to_find_interesting = 0
-    while consecutive_successes < required_successes:
-        attempt = runner.cached_test_function(b"", extend=BUFFER_SIZE)
-        if attempt.status < Status.INTERESTING:
-            failures_to_find_interesting += 1
-            assert (
-                found_interesting or failures_to_find_interesting <= 1000
-            ), "Test function seems to have no interesting test cases"
-            continue
-
-        found_interesting = True
-
-        target = attempt.interesting_origin
-
-        def shrinking_predicate(d):
-            return d.status == Status.INTERESTING and d.interesting_origin == target
-
-        if target not in seen:
-            seen.add(target)
-            runner.shrink(attempt, shrinking_predicate)
-            continue
-
-        previous = fully_shrink(
-            runner, runner.interesting_examplestarget, shrinking_predicate
-        )
-        current = fully_shrink(runner, attempt, shrinking_predicate)
-
-        if current.buffer == previous.buffer:
-            consecutive_successes += 1
-            continue
-
-        consecutive_successes = 0
-
-        if not allowed_to_update:
-            raise FailedToNormalise(
-                f"Shrinker failed to normalize {previous.buffer!r} to "
-                f"{current.buffer!r} and we are not allowed to learn new DFAs."
-            )
-
-        if dfas_added >= max_dfas:
-            raise FailedToNormalise(
-                f"Test function is too hard to learn: Added {dfas_added} "
-                "DFAs and still not done."
-            )
-
-        dfas_added += 1
-
-        new_dfa = learn_a_new_dfa(
-            runner, previous.buffer, current.buffer, shrinking_predicate
-        )
-
-        name = base_name + "-" + hashlib.sha256(repr(new_dfa).encode()).hexdigest():10
-
-        # If there is a name collision this DFA should already be being
-        # used for shrinking, so we should have already been able to shrink
-        # v further.
-        assert name not in SHRINKING_DFAS
-        SHRINKING_DFASname = new_dfa
-
-    if dfas_added > 0:
-        # We've learned one or more DFAs in the course of normalising, so now
-        # we update the file to record those for posterity.
-        update_learned_dfas()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/conjecture/utils.py Deleted

@@ -1,513 +0,0 @@
-# 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 enum
-import hashlib
-import heapq
-import math
-import sys
-from collections import OrderedDict, abc
-from functools import lru_cache
-from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple, Type, TypeVar, Union
-
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.compat import floor, int_from_bytes
-from hypothesis.internal.floats import int_to_float, next_up
-
-if TYPE_CHECKING:
-    from hypothesis.internal.conjecture.data import ConjectureData
-
-
-LABEL_MASK = 2**64 - 1
-
-
-def calc_label_from_name(name: str) -> int:
-    hashed = hashlib.sha384(name.encode()).digest()
-    return int_from_bytes(hashed:8)
-
-
-def calc_label_from_cls(cls: type) -> int:
-    return calc_label_from_name(cls.__qualname__)
-
-
-def combine_labels(*labels: int) -> int:
-    label = 0
-    for l in labels:
-        label = (label << 1) & LABEL_MASK
-        label ^= l
-    return label
-
-
-INTEGER_RANGE_DRAW_LABEL = calc_label_from_name("another draw in integer_range()")
-BIASED_COIN_LABEL = calc_label_from_name("biased_coin()")
-BIASED_COIN_INNER_LABEL = calc_label_from_name("inside biased_coin()")
-SAMPLE_IN_SAMPLER_LABEL = calc_label_from_name("a sample() in Sampler")
-ONE_FROM_MANY_LABEL = calc_label_from_name("one more from many()")
-
-
-def unbounded_integers(data: "ConjectureData") -> int:
-    size = INT_SIZESINT_SIZES_SAMPLER.sample(data)
-    r = data.draw_bits(size)
-    sign = r & 1
-    r >>= 1
-    if sign:
-        r = -r
-    return int(r)
-
-
-def integer_range(
-    data: "ConjectureData", lower: int, upper: int, center: Optionalint = None
-) -> int:
-    assert lower <= upper
-    if lower == upper:
-        # Write a value even when this is trivial so that when a bound depends
-        # on other values we don't suddenly disappear when the gap shrinks to
-        # zero - if that happens then often the data stream becomes misaligned
-        # and we fail to shrink in cases where we really should be able to.
-        data.draw_bits(1, forced=0)
-        return int(lower)
-
-    if center is None:
-        center = lower
-    center = min(max(center, lower), upper)
-
-    if center == upper:
-        above = False
-    elif center == lower:
-        above = True
-    else:
-        above = not boolean(data)
-
-    if above:
-        gap = upper - center
-    else:
-        gap = center - lower
-
-    assert gap > 0
-
-    bits = gap.bit_length()
-    probe = gap + 1
-
-    if bits > 24 and data.draw_bits(3):
-        # For large ranges, we combine the uniform random distribution from draw_bits
-        # with a weighting scheme with moderate chance.  Cutoff at 2 ** 24 so that our
-        # choice of unicode characters is uniform but the 32bit distribution is not.
-        idx = INT_SIZES_SAMPLER.sample(data)
-        bits = min(bits, INT_SIZESidx)
-
-    while probe > gap:
-        data.start_example(INTEGER_RANGE_DRAW_LABEL)
-        probe = data.draw_bits(bits)
-        data.stop_example(discard=probe > gap)
-
-    if above:
-        result = center + probe
-    else:
-        result = center - probe
-
-    assert lower <= result <= upper
-    return int(result)
-
-
-T = TypeVar("T")
-
-
-def check_sample(
-    values: UnionTypeenum.Enum, SequenceT, strategy_name: str
-) -> SequenceT:
-    if "numpy" in sys.modules and isinstance(values, sys.modules"numpy".ndarray):
-        if values.ndim != 1:
-            raise InvalidArgument(
-                "Only one-dimensional arrays are supported for sampling, "
-                f"and the given value has {values.ndim} dimensions (shape "
-                f"{values.shape}).  This array would give samples of array slices "
-                "instead of elements!  Use np.ravel(values) to convert "
-                "to a one-dimensional array, or tuple(values) if you "
-                "want to sample slices."
-            )
-    elif not isinstance(values, (OrderedDict, abc.Sequence, enum.EnumMeta)):
-        raise InvalidArgument(
-            f"Cannot sample from {values!r}, not an ordered collection. "
-            f"Hypothesis goes to some length to ensure that the {strategy_name} "
-            "strategy has stable results between runs. To replay a saved "
-            "example, the sampled values must have the same iteration order "
-            "on every run - ruling out sets, dicts, etc due to hash "
-            "randomization. Most cases can simply use `sorted(values)`, but "
-            "mixed types or special values such as math.nan require careful "
-            "handling - and note that when simplifying an example, "
-            "Hypothesis treats earlier values as simpler."
-        )
-    if isinstance(values, range):
-        return values
-    return tuple(values)
-
-
-def choice(data: "ConjectureData", values: SequenceT) -> T:
-    return valuesinteger_range(data, 0, len(values) - 1)
-
-
-FLOAT_PREFIX = 0b1111111111 << 52
-FULL_FLOAT = int_to_float(FLOAT_PREFIX | ((2 << 53) - 1)) - 1
-
-
-def fractional_float(data: "ConjectureData") -> float:
-    return (int_to_float(FLOAT_PREFIX | data.draw_bits(52)) - 1) / FULL_FLOAT
-
-
-def boolean(data: "ConjectureData") -> bool:
-    return bool(data.draw_bits(1))
-
-
-def biased_coin(
-    data: "ConjectureData", p: float, *, forced: Optionalbool = None
-) -> bool:
-    """Return True with probability p (assuming a uniform generator),
-    shrinking towards False. If ``forced`` is set to a non-None value, this
-    will always return that value but will write choices appropriate to having
-    drawn that value randomly."""
-
-    # NB this function is vastly more complicated than it may seem reasonable
-    # for it to be. This is because it is used in a lot of places and it's
-    # important for it to shrink well, so it's worth the engineering effort.
-
-    if p <= 0 or p >= 1:
-        bits = 1
-    else:
-        # When there is a meaningful draw, in order to shrink well we will
-        # set things up so that 0 and 1 always correspond to False and True
-        # respectively. This means we want enough bits available that in a
-        # draw we will always have at least one truthy value and one falsey
-        # value.
-        bits = math.ceil(-math.log(min(p, 1 - p), 2))
-    # In order to avoid stupidly large draws where the probability is
-    # effectively zero or one, we treat probabilities of under 2^-64 to be
-    # effectively zero.
-    if bits > 64:
-        # There isn't enough precision near one for this to occur for values
-        # far from 0.
-        p = 0.0
-        bits = 1
-
-    size = 2**bits
-
-    data.start_example(BIASED_COIN_LABEL)
-    while True:
-        # The logic here is a bit complicated and special cased to make it
-        # play better with the shrinker.
-
-        # We imagine partitioning the real interval 0, 1 into 256 equal parts
-        # and looking at each part and whether its interior is wholly <= p
-        # or wholly >= p. At most one part can be neither.
-
-        # We then pick a random part. If it's wholly on one side or the other
-        # of p then we use that as the answer. If p is contained in the
-        # interval then we start again with a new probability that is given
-        # by the fraction of that interval that was <= our previous p.
-
-        # We then take advantage of the fact that we have control of the
-        # labelling to make this shrink better, using the following tricks:
-
-        # If p is <= 0 or >= 1 the result of this coin is certain. We make sure
-        # to write a byte to the data stream anyway so that these don't cause
-        # difficulties when shrinking.
-        if p <= 0:
-            data.draw_bits(1, forced=0)
-            result = False
-        elif p >= 1:
-            data.draw_bits(1, forced=1)
-            result = True
-        else:
-            falsey = floor(size * (1 - p))
-            truthy = floor(size * p)
-            remainder = size * p - truthy
-
-            if falsey + truthy == size:
-                partial = False
-            else:
-                partial = True
-
-            if forced is None:
-                # We want to get to the point where True is represented by
-                # 1 and False is represented by 0 as quickly as possible, so
-                # we use the remove_discarded machinery in the shrinker to
-                # achieve that by discarding any draws that are > 1 and writing
-                # a suitable draw into the choice sequence at the end of the
-                # loop.
-                data.start_example(BIASED_COIN_INNER_LABEL)
-                i = data.draw_bits(bits)
-                data.stop_example(discard=i > 1)
-            else:
-                i = data.draw_bits(bits, forced=int(forced))
-
-            # We always label the region that causes us to repeat the loop as
-            # 255 so that shrinking this byte never causes us to need to draw
-            # more data.
-            if partial and i == size - 1:
-                p = remainder
-                continue
-            if falsey == 0:
-                # Every other partition is truthy, so the result is true
-                result = True
-            elif truthy == 0:
-                # Every other partition is falsey, so the result is false
-                result = False
-            elif i <= 1:
-                # We special case so that zero is always false and 1 is always
-                # true which makes shrinking easier because we can always
-                # replace a truthy block with 1. This has the slightly weird
-                # property that shrinking from 2 to 1 can cause the result to
-                # grow, but the shrinker always tries 0 and 1 first anyway, so
-                # this will usually be fine.
-                result = bool(i)
-            else:
-                # Originally everything in the region 0 <= i < falsey was false
-                # and everything above was true. We swapped one truthy element
-                # into this region, so the region becomes 0 <= i <= falsey
-                # except for i = 1. We know i > 1 here, so the test for truth
-                # becomes i > falsey.
-                result = i > falsey
-
-            if i > 1:  # pragma: no branch
-                # Thanks to bytecode optimisations on CPython >= 3.7 and PyPy
-                # (see https://bugs.python.org/issue2506), coverage incorrectly
-                # thinks that this condition is always true.  You can trivially
-                # check by adding `else: assert False` and running the tests.
-                data.draw_bits(bits, forced=int(result))
-        break
-    data.stop_example()
-    return result
-
-
-class Sampler:
-    """Sampler based on Vose's algorithm for the alias method. See
-    http://www.keithschwarz.com/darts-dice-coins/ for a good explanation.
-
-    The general idea is that we store a table of triples (base, alternate, p).
-    base. We then pick a triple uniformly at random, and choose its alternate
-    value with probability p and else choose its base value. The triples are
-    chosen so that the resulting mixture has the right distribution.
-
-    We maintain the following invariants to try to produce good shrinks:
-
-    1. The table is in lexicographic (base, alternate) order, so that choosing
-       an earlier value in the list always lowers (or at least leaves
-       unchanged) the value.
-    2. basei < alternatei, so that shrinking the draw always results in
-       shrinking the chosen element.
-    """
-
-    table: ListTupleint, int, float  # (base_idx, alt_idx, alt_chance)
-
-    def __init__(self, weights: Sequencefloat):
-
-        n = len(weights)
-
-        table: "listlistint | float | None" = i, None, None for i in range(n)
-
-        total = sum(weights)
-
-        num_type = type(total)
-
-        zero = num_type(0)
-        one = num_type(1)
-
-        small: "Listint" = 
-        large: "Listint" = 
-
-        probabilities = w / total for w in weights
-        scaled_probabilities: "Listfloat" = 
-
-        for i, alternate_chance in enumerate(probabilities):
-            scaled = alternate_chance * n
-            scaled_probabilities.append(scaled)
-            if scaled == 1:
-                tablei2 = zero
-            elif scaled < 1:
-                small.append(i)
-            else:
-                large.append(i)
-        heapq.heapify(small)
-        heapq.heapify(large)
-
-        while small and large:
-            lo = heapq.heappop(small)
-            hi = heapq.heappop(large)
-
-            assert lo != hi
-            assert scaled_probabilitieshi > one
-            assert tablelo1 is None
-            tablelo1 = hi
-            tablelo2 = one - scaled_probabilitieslo
-            scaled_probabilitieshi = (
-                scaled_probabilitieshi + scaled_probabilitieslo
-            ) - one
-
-            if scaled_probabilitieshi < 1:
-                heapq.heappush(small, hi)
-            elif scaled_probabilitieshi == 1:
-                tablehi2 = zero
-            else:
-                heapq.heappush(large, hi)
-        while large:
-            tablelarge.pop()2 = zero
-        while small:
-            tablesmall.pop()2 = zero
-
-        self.table: "ListTupleint, int, float" = 
-        for base, alternate, alternate_chance in table:  # type: ignore
-            assert isinstance(base, int)
-            assert isinstance(alternate, int) or alternate is None
-            if alternate is None:
-                self.table.append((base, base, alternate_chance))
-            elif alternate < base:
-                self.table.append((alternate, base, one - alternate_chance))
-            else:
-                self.table.append((base, alternate, alternate_chance))
-        self.table.sort()
-
-    def sample(self, data: "ConjectureData") -> int:
-        data.start_example(SAMPLE_IN_SAMPLER_LABEL)
-        base, alternate, alternate_chance = choice(data, self.table)
-        use_alternate = biased_coin(data, alternate_chance)
-        data.stop_example()
-        if use_alternate:
-            return alternate
-        else:
-            return base
-
-
-INT_SIZES = (8, 16, 32, 64, 128)
-INT_SIZES_SAMPLER = Sampler((4.0, 8.0, 1.0, 1.0, 0.5))
-
-
-class many:
-    """Utility class for collections. Bundles up the logic we use for "should I
-    keep drawing more values?" and handles starting and stopping examples in
-    the right place.
-
-    Intended usage is something like:
-
-    elements = many(data, ...)
-    while elements.more():
-        add_stuff_to_result()
-    """
-
-    def __init__(
-        self,
-        data: "ConjectureData",
-        min_size: int,
-        max_size: Unionint, float,
-        average_size: Unionint, float,
-    ) -> None:
-        assert 0 <= min_size <= average_size <= max_size
-        self.min_size = min_size
-        self.max_size = max_size
-        self.data = data
-        self.p_continue = _calc_p_continue(average_size - min_size, max_size - min_size)
-        self.count = 0
-        self.rejections = 0
-        self.drawn = False
-        self.force_stop = False
-        self.rejected = False
-
-    def more(self) -> bool:
-        """Should I draw another element to add to the collection?"""
-        if self.drawn:
-            self.data.stop_example(discard=self.rejected)
-
-        self.drawn = True
-        self.rejected = False
-
-        self.data.start_example(ONE_FROM_MANY_LABEL)
-
-        if self.min_size == self.max_size:
-            should_continue = self.count < self.min_size
-        else:
-            forced_result = None
-            if self.force_stop:
-                forced_result = False
-            elif self.count < self.min_size:
-                forced_result = True
-            elif self.count >= self.max_size:
-                forced_result = False
-            should_continue = biased_coin(
-                self.data, self.p_continue, forced=forced_result
-            )
-
-        if should_continue:
-            self.count += 1
-            return True
-        else:
-            self.data.stop_example()
-            return False
-
-    def reject(self):
-        """Reject the last example (i.e. don't count it towards our budget of
-        elements because it's not going to go in the final collection)."""
-        assert self.count > 0
-        self.count -= 1
-        self.rejections += 1
-        self.rejected = True
-        # We set a minimum number of rejections before we give up to avoid
-        # failing too fast when we reject the first draw.
-        if self.rejections > max(3, 2 * self.count):
-            if self.count < self.min_size:
-                self.data.mark_invalid()
-            else:
-                self.force_stop = True
-
-
-SMALLEST_POSITIVE_FLOAT: float = next_up(0.0) or sys.float_info.min
-
-
-@lru_cache()
-def _calc_p_continue(desired_avg: float, max_size: int) -> float:
-    """Return the p_continue which will generate the desired average size."""
-    assert desired_avg <= max_size, (desired_avg, max_size)
-    if desired_avg == max_size:
-        return 1.0
-    p_continue = 1 - 1.0 / (1 + desired_avg)
-    if p_continue == 0 or max_size == float("inf"):
-        assert 0 <= p_continue < 1, p_continue
-        return p_continue
-    assert 0 < p_continue < 1, p_continue
-    # For small max_size, the infinite-series p_continue is a poor approximation,
-    # and while we can't solve the polynomial a few rounds of iteration quickly
-    # gets us a good approximate solution in almost all cases (sometimes exact!).
-    while _p_continue_to_avg(p_continue, max_size) > desired_avg:
-        # This is impossible over the reals, but *can* happen with floats.
-        p_continue -= 0.0001
-        # If we've reached zero or gone negative, we want to break out of this loop,
-        # and do so even if we're on a system with the unsafe denormals-are-zero flag.
-        # We make that an explicit error in st.floats(), but here we'd prefer to
-        # just get somewhat worse precision on collection lengths.
-        if p_continue < SMALLEST_POSITIVE_FLOAT:
-            p_continue = SMALLEST_POSITIVE_FLOAT
-            break
-    # Let's binary-search our way to a better estimate!  We tried fancier options
-    # like gradient descent, but this is numerically stable and works better.
-    hi = 1.0
-    while desired_avg - _p_continue_to_avg(p_continue, max_size) > 0.01:
-        assert 0 < p_continue < hi, (p_continue, hi)
-        mid = (p_continue + hi) / 2
-        if _p_continue_to_avg(mid, max_size) <= desired_avg:
-            p_continue = mid
-        else:
-            hi = mid
-    assert 0 < p_continue < 1, p_continue
-    assert _p_continue_to_avg(p_continue, max_size) <= desired_avg
-    return p_continue
-
-
-def _p_continue_to_avg(p_continue: float, max_size: int) -> float:
-    """Return the average_size generated by this p_continue and max_size."""
-    if p_continue >= 1:
-        return max_size
-    return (1.0 / (1 - p_continue) - 1) * (1 - p_continue**max_size)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/entropy.py Deleted

@@ -1,114 +0,0 @@
-# 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 contextlib
-import random
-import sys
-from itertools import count
-from weakref import WeakValueDictionary
-
-import hypothesis.core
-from hypothesis.errors import InvalidArgument
-
-# This is effectively a WeakSet, which allows us to associate the saved states
-# with their respective Random instances even as new ones are registered and old
-# ones go out of scope and get garbage collected.  Keys are ascending integers.
-_RKEY = count()
-RANDOMS_TO_MANAGE: WeakValueDictionary = WeakValueDictionary({next(_RKEY): random})
-
-
-class NumpyRandomWrapper:
-    def __init__(self):
-        assert "numpy" in sys.modules
-        # This class provides a shim that matches the numpy to stdlib random,
-        # and lets us avoid importing Numpy until it's already in use.
-        import numpy.random
-
-        self.seed = numpy.random.seed
-        self.getstate = numpy.random.get_state
-        self.setstate = numpy.random.set_state
-
-
-NP_RANDOM = None
-
-
-def register_random(r: random.Random) -> None:
-    """Register the given Random instance for management by Hypothesis.
-
-    You can pass ``random.Random`` instances (or other objects with seed,
-    getstate, and setstate methods) to ``register_random(r)`` to have their
-    states seeded and restored in the same way as the global PRNGs from the
-    ``random`` and ``numpy.random`` modules.
-
-    All global PRNGs, from e.g. simulation or scheduling frameworks, should
-    be registered to prevent flaky tests.  Hypothesis will ensure that the
-    PRNG state is consistent for all test runs, or reproducibly varied if you
-    choose to use the :func:`~hypothesis.strategies.random_module` strategy.
-    """
-    if not (hasattr(r, "seed") and hasattr(r, "getstate") and hasattr(r, "setstate")):
-        raise InvalidArgument(f"r={r!r} does not have all the required methods")
-    if r not in RANDOMS_TO_MANAGE.values():
-        RANDOMS_TO_MANAGEnext(_RKEY) = r
-
-
-def get_seeder_and_restorer(seed=0):
-    """Return a pair of functions which respectively seed all and restore
-    the state of all registered PRNGs.
-
-    This is used by the core engine via `deterministic_PRNG`, and by users
-    via `register_random`.  We support registration of additional random.Random
-    instances (or other objects with seed, getstate, and setstate methods)
-    to force determinism on simulation or scheduling frameworks which avoid
-    using the global random state.  See e.g. #1709.
-    """
-    assert isinstance(seed, int) and 0 <= seed < 2**32
-    states: dict = {}
-
-    if "numpy" in sys.modules:
-        global NP_RANDOM
-        if NP_RANDOM is None:
-            # Protect this from garbage-collection by adding it to global scope
-            NP_RANDOM = RANDOMS_TO_MANAGEnext(_RKEY) = NumpyRandomWrapper()
-
-    def seed_all():
-        assert not states
-        for k, r in RANDOMS_TO_MANAGE.items():
-            statesk = r.getstate()
-            r.seed(seed)
-
-    def restore_all():
-        for k, state in states.items():
-            r = RANDOMS_TO_MANAGE.get(k)
-            if r is not None:  # i.e., hasn't been garbage-collected
-                r.setstate(state)
-        states.clear()
-
-    return seed_all, restore_all
-
-
-@contextlib.contextmanager
-def deterministic_PRNG(seed=0):
-    """Context manager that handles random.seed without polluting global state.
-
-    See issue #1255 and PR #1295 for details and motivation - in short,
-    leaving the global pseudo-random number generator (PRNG) seeded is a very
-    bad idea in principle, and breaks all kinds of independence assumptions
-    in practice.
-    """
-    if hypothesis.core._hypothesis_global_random is None:  # pragma: no cover
-        hypothesis.core._hypothesis_global_random = random.Random()
-        register_random(hypothesis.core._hypothesis_global_random)
-
-    seed_all, restore_all = get_seeder_and_restorer(seed)
-    seed_all()
-    try:
-        yield
-    finally:
-        restore_all()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/escalation.py Deleted

@@ -1,160 +0,0 @@
-# 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 contextlib
-import os
-import sys
-import traceback
-from inspect import getframeinfo
-from pathlib import Path
-from typing import Dict
-
-import hypothesis
-from hypothesis.errors import (
-    DeadlineExceeded,
-    HypothesisException,
-    StopTest,
-    UnsatisfiedAssumption,
-    _Trimmable,
-)
-from hypothesis.internal.compat import BaseExceptionGroup
-from hypothesis.utils.dynamicvariables import DynamicVariable
-
-
-def belongs_to(package):
-    if not hasattr(package, "__file__"):  # pragma: no cover
-        return lambda filepath: False
-
-    root = Path(package.__file__).resolve().parent
-    cache = {str: {}, bytes: {}}
-
-    def accept(filepath):
-        ftype = type(filepath)
-        try:
-            return cacheftypefilepath
-        except KeyError:
-            pass
-        try:
-            Path(filepath).resolve().relative_to(root)
-            result = True
-        except Exception:
-            result = False
-        cacheftypefilepath = result
-        return result
-
-    accept.__name__ = f"is_{package.__name__}_file"
-    return accept
-
-
-PREVENT_ESCALATION = os.getenv("HYPOTHESIS_DO_NOT_ESCALATE") == "true"
-
-FILE_CACHE: Dictbytes, bool = {}
-
-
-is_hypothesis_file = belongs_to(hypothesis)
-
-HYPOTHESIS_CONTROL_EXCEPTIONS = (DeadlineExceeded, StopTest, UnsatisfiedAssumption)
-
-
-def escalate_hypothesis_internal_error():
-    if PREVENT_ESCALATION:
-        return
-
-    error_type, e, tb = sys.exc_info()
-
-    if getattr(e, "hypothesis_internal_never_escalate", False):
-        return
-
-    filepath = traceback.extract_tb(tb)-10
-    if is_hypothesis_file(filepath) and not isinstance(
-        e, (HypothesisException,) + HYPOTHESIS_CONTROL_EXCEPTIONS
-    ):
-        raise
-
-
-def get_trimmed_traceback(exception=None):
-    """Return the current traceback, minus any frames added by Hypothesis."""
-    if exception is None:
-        _, exception, tb = sys.exc_info()
-    else:
-        tb = exception.__traceback__
-    # Avoid trimming the traceback if we're in verbose mode, or the error
-    # was raised inside Hypothesis (and is not a MultipleFailures)
-    if hypothesis.settings.default.verbosity >= hypothesis.Verbosity.debug or (
-        is_hypothesis_file(traceback.extract_tb(tb)-10)
-        and not isinstance(exception, _Trimmable)
-    ):
-        return tb
-    while tb.tb_next is not None and (
-        # If the frame is from one of our files, it's been added by Hypothesis.
-        is_hypothesis_file(getframeinfo(tb.tb_frame).filename)
-        # But our `@proxies` decorator overrides the source location,
-        # so we check for an attribute it injects into the frame too.
-        or tb.tb_frame.f_globals.get("__hypothesistracebackhide__") is True
-    ):
-        tb = tb.tb_next
-    return tb
-
-
-def get_interesting_origin(exception):
-    # The `interesting_origin` is how Hypothesis distinguishes between multiple
-    # failures, for reporting and also to replay from the example database (even
-    # if report_multiple_bugs=False).  We traditionally use the exception type and
-    # location, but have extracted this logic in order to see through `except ...:`
-    # blocks and understand the __cause__ (`raise x from y`) or __context__ that
-    # first raised an exception as well as PEP-654 exception groups.
-    tb = get_trimmed_traceback(exception)
-    filename, lineno, *_ = traceback.extract_tb(tb)-1
-    return (
-        type(exception),
-        filename,
-        lineno,
-        # Note that if __cause__ is set it is always equal to __context__, explicitly
-        # to support introspection when debugging, so we can use that unconditionally.
-        get_interesting_origin(exception.__context__) if exception.__context__ else (),
-        # We distinguish exception groups by the inner exceptions, as for __context__
-        tuple(
-            map(get_interesting_origin, exception.exceptions)
-            if isinstance(exception, BaseExceptionGroup)
-            else 
-        ),
-    )
-
-
-current_pytest_item = DynamicVariable(None)
-
-
-def _get_exceptioninfo():
-    # ExceptionInfo was moved to the top-level namespace in Pytest 7.0
-    if "pytest" in sys.modules:
-        with contextlib.suppress(Exception):
-            # From Pytest 7, __init__ warns on direct calls.
-            return sys.modules"pytest".ExceptionInfo.from_exc_info
-    if "_pytest._code" in sys.modules:  # pragma: no cover  # old versions only
-        with contextlib.suppress(Exception):
-            return sys.modules"_pytest._code".ExceptionInfo
-    return None  # pragma: no cover  # coverage tests always use pytest
-
-
-def format_exception(err, tb):
-    # Try using Pytest to match the currently configured traceback style
-    ExceptionInfo = _get_exceptioninfo()
-    if current_pytest_item.value is not None and ExceptionInfo is not None:
-        item = current_pytest_item.value
-        return str(item.repr_failure(ExceptionInfo((type(err), err, tb)))) + "\n"
-
-    # Or use better_exceptions, if that's installed and enabled
-    if "better_exceptions" in sys.modules:
-        better_exceptions = sys.modules"better_exceptions"
-        if sys.excepthook is better_exceptions.excepthook:
-            return "".join(better_exceptions.format_exception(type(err), err, tb))
-
-    # If all else fails, use the standard-library formatting tools
-    return "".join(traceback.format_exception(type(err), err, tb))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/filtering.py Deleted

@@ -1,276 +0,0 @@
-# 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/.
-
-"""Tools for understanding predicates, to satisfy them by construction.
-
-For example::
-
-    integers().filter(lamda x: x >= 0) -> integers(min_value=0)
-
-This is intractable in general, but reasonably easy for simple cases involving
-numeric bounds, strings with length or regex constraints, and collection lengths -
-and those are precisely the most common cases.  When they arise in e.g. Pandas
-dataframes, it's also pretty painful to do the constructive version by hand in
-a library; so we prefer to share all the implementation effort here.
-See https://github.com/HypothesisWorks/hypothesis/issues/2701 for details.
-"""
-
-import ast
-import inspect
-import math
-import operator
-from decimal import Decimal
-from fractions import Fraction
-from functools import partial
-from typing import Any, Callable, Dict, NamedTuple, Optional, TypeVar
-
-from hypothesis.internal.compat import ceil, floor
-from hypothesis.internal.reflection import extract_lambda_source
-
-Ex = TypeVar("Ex")
-Predicate = CallableEx, bool
-
-
-class ConstructivePredicate(NamedTuple):
-    """Return kwargs to the appropriate strategy, and the predicate if needed.
-
-    For example::
-
-        integers().filter(lambda x: x >= 0)
-        -> {"min_value": 0"}, None
-
-        integers().filter(lambda x: x >= 0 and x % 7)
-        -> {"min_value": 0}, lambda x: x % 7
-
-    At least in principle - for now we usually return the predicate unchanged
-    if needed.
-
-    We have a separate get-predicate frontend for each "group" of strategies; e.g.
-    for each numeric type, for strings, for bytes, for collection sizes, etc.
-    """
-
-    kwargs: Dictstr, Any
-    predicate: OptionalPredicate
-
-    @classmethod
-    def unchanged(cls, predicate):
-        return cls({}, predicate)
-
-
-ARG = object()
-
-
-def convert(node: ast.AST, argname: str) -> object:
-    if isinstance(node, ast.Name):
-        if node.id != argname:
-            raise ValueError("Non-local variable")
-        return ARG
-    return ast.literal_eval(node)
-
-
-def comp_to_kwargs(x: ast.AST, op: ast.AST, y: ast.AST, *, argname: str) -> dict:
-    a = convert(x, argname)
-    b = convert(y, argname)
-    num = (int, float)
-    if not (a is ARG and isinstance(b, num)) and not (isinstance(a, num) and b is ARG):
-        # It would be possible to work out if comparisons between two literals
-        # are always true or false, but it's too rare to be worth the complexity.
-        # (and we can't even do `arg == arg`, because what if it's NaN?)
-        raise ValueError("Can't analyse this comparison")
-
-    if isinstance(op, ast.Lt):
-        if a is ARG:
-            return {"max_value": b, "exclude_max": True}
-        return {"min_value": a, "exclude_min": True}
-    elif isinstance(op, ast.LtE):
-        if a is ARG:
-            return {"max_value": b}
-        return {"min_value": a}
-    elif isinstance(op, ast.Eq):
-        if a is ARG:
-            return {"min_value": b, "max_value": b}
-        return {"min_value": a, "max_value": a}
-    elif isinstance(op, ast.GtE):
-        if a is ARG:
-            return {"min_value": b}
-        return {"max_value": a}
-    elif isinstance(op, ast.Gt):
-        if a is ARG:
-            return {"min_value": b, "exclude_min": True}
-        return {"max_value": a, "exclude_max": True}
-    raise ValueError("Unhandled comparison operator")  # e.g. ast.Ne
-
-
-def merge_preds(*con_predicates: ConstructivePredicate) -> ConstructivePredicate:
-    # This function is just kinda messy.  Unfortunately the neatest way
-    # to do this is just to roll out each case and handle them in turn.
-    base = {
-        "min_value": -math.inf,
-        "max_value": math.inf,
-        "exclude_min": False,
-        "exclude_max": False,
-    }
-    predicate = None
-    for kw, p in con_predicates:
-        predicate = p or predicate
-        if "min_value" in kw:
-            if kw"min_value" > base"min_value":
-                base"exclude_min" = kw.get("exclude_min", False)
-                base"min_value" = kw"min_value"
-            elif kw"min_value" == base"min_value":
-                base"exclude_min" |= kw.get("exclude_min", False)
-        if "max_value" in kw:
-            if kw"max_value" < base"max_value":
-                base"exclude_max" = kw.get("exclude_max", False)
-                base"max_value" = kw"max_value"
-            elif kw"max_value" == base"max_value":
-                base"exclude_max" |= kw.get("exclude_max", False)
-
-    if not base"exclude_min":
-        del base"exclude_min"
-        if base"min_value" == -math.inf:
-            del base"min_value"
-    if not base"exclude_max":
-        del base"exclude_max"
-        if base"max_value" == math.inf:
-            del base"max_value"
-    return ConstructivePredicate(base, predicate)
-
-
-def numeric_bounds_from_ast(
-    tree: ast.AST, argname: str, fallback: ConstructivePredicate
-) -> ConstructivePredicate:
-    """Take an AST; return a ConstructivePredicate.
-
-    >>> lambda x: x >= 0
-    {"min_value": 0}, None
-    >>> lambda x: x < 10
-    {"max_value": 10, "exclude_max": True}, None
-    >>> lambda x: x >= y
-    {}, lambda x: x >= y
-
-    See also https://greentreesnakes.readthedocs.io/en/latest/
-    """
-    if isinstance(tree, ast.Compare):
-        ops = tree.ops
-        vals = tree.comparators
-        comparisons = (tree.left, ops0, vals0)
-        for i, (op, val) in enumerate(zip(ops1:, vals1:), start=1):
-            comparisons.append((valsi - 1, op, val))
-        bounds = 
-        for comp in comparisons:
-            try:
-                kwargs = comp_to_kwargs(*comp, argname=argname)
-                bounds.append(ConstructivePredicate(kwargs, None))
-            except ValueError:
-                bounds.append(fallback)
-        return merge_preds(*bounds)
-
-    if isinstance(tree, ast.BoolOp) and isinstance(tree.op, ast.And):
-        return merge_preds(
-            *(numeric_bounds_from_ast(node, argname, fallback) for node in tree.values)
-        )
-
-    return fallback
-
-
-UNSATISFIABLE = ConstructivePredicate.unchanged(lambda _: False)
-
-
-def get_numeric_predicate_bounds(predicate: Predicate) -> ConstructivePredicate:
-    """Shared logic for understanding numeric bounds.
-
-    We then specialise this in the other functions below, to ensure that e.g.
-    all the values are representable in the types that we're planning to generate
-    so that the strategy validation doesn't complain.
-    """
-    unchanged = ConstructivePredicate.unchanged(predicate)
-    if (
-        isinstance(predicate, partial)
-        and len(predicate.args) == 1
-        and not predicate.keywords
-    ):
-        arg = predicate.args0
-        if (
-            (isinstance(arg, Decimal) and Decimal.is_snan(arg))
-            or not isinstance(arg, (int, float, Fraction, Decimal))
-            or math.isnan(arg)
-        ):
-            return unchanged
-        options = {
-            # We're talking about op(arg, x) - the reverse of our usual intuition!
-            operator.lt: {"min_value": arg, "exclude_min": True},  # lambda x: arg < x
-            operator.le: {"min_value": arg},  # lambda x: arg <= x
-            operator.eq: {"min_value": arg, "max_value": arg},  # lambda x: arg == x
-            operator.ge: {"max_value": arg},  # lambda x: arg >= x
-            operator.gt: {"max_value": arg, "exclude_max": True},  # lambda x: arg > x
-        }
-        if predicate.func in options:
-            return ConstructivePredicate(optionspredicate.func, None)
-
-    # This section is a little complicated, but stepping through with comments should
-    # help to clarify it.  We start by finding the source code for our predicate and
-    # parsing it to an abstract syntax tree; if this fails for any reason we bail out
-    # and fall back to standard rejection sampling (a running theme).
-    try:
-        if predicate.__name__ == "<lambda>":
-            source = extract_lambda_source(predicate)
-        else:
-            source = inspect.getsource(predicate)
-        tree: ast.AST = ast.parse(source)
-    except Exception:
-        return unchanged
-
-    # Dig down to the relevant subtree - our tree is probably a Module containing
-    # either a FunctionDef, or an Expr which in turn contains a lambda definition.
-    while isinstance(tree, ast.Module) and len(tree.body) == 1:
-        tree = tree.body0
-    while isinstance(tree, ast.Expr):
-        tree = tree.value
-
-    if isinstance(tree, ast.Lambda) and len(tree.args.args) == 1:
-        return numeric_bounds_from_ast(tree.body, tree.args.args0.arg, unchanged)
-    elif isinstance(tree, ast.FunctionDef) and len(tree.args.args) == 1:
-        if len(tree.body) != 1 or not isinstance(tree.body0, ast.Return):
-            # If the body of the function is anything but `return <expr>`,
-            # i.e. as simple as a lambda, we can't process it (yet).
-            return unchanged
-        argname = tree.args.args0.arg
-        body = tree.body0.value
-        assert isinstance(body, ast.AST)
-        return numeric_bounds_from_ast(body, argname, unchanged)
-    return unchanged
-
-
-def get_integer_predicate_bounds(predicate: Predicate) -> ConstructivePredicate:
-    kwargs, predicate = get_numeric_predicate_bounds(predicate)  # type: ignore
-
-    if "min_value" in kwargs:
-        if kwargs"min_value" == -math.inf:
-            del kwargs"min_value"
-        elif math.isinf(kwargs"min_value"):
-            return UNSATISFIABLE
-        elif kwargs"min_value" != int(kwargs"min_value"):
-            kwargs"min_value" = ceil(kwargs"min_value")
-        elif kwargs.get("exclude_min", False):
-            kwargs"min_value" = int(kwargs"min_value") + 1
-
-    if "max_value" in kwargs:
-        if kwargs"max_value" == math.inf:
-            del kwargs"max_value"
-        elif math.isinf(kwargs"max_value"):
-            return UNSATISFIABLE
-        elif kwargs"max_value" != int(kwargs"max_value"):
-            kwargs"max_value" = floor(kwargs"max_value")
-        elif kwargs.get("exclude_max", False):
-            kwargs"max_value" = int(kwargs"max_value") - 1
-
-    kwargs = {k: v for k, v in kwargs.items() if k in {"min_value", "max_value"}}
-    return ConstructivePredicate(kwargs, predicate)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/floats.py Deleted

@@ -1,154 +0,0 @@
-# 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 math
-import struct
-from sys import float_info
-from typing import Callable, Optional
-
-# Format codes for (int, float) sized types, used for byte-wise casts.
-# See https://docs.python.org/3/library/struct.html#format-characters
-STRUCT_FORMATS = {
-    16: ("!H", "!e"),
-    32: ("!I", "!f"),
-    64: ("!Q", "!d"),
-}
-
-
-def reinterpret_bits(x, from_, to):
-    return struct.unpack(to, struct.pack(from_, x))0
-
-
-def float_of(x, width):
-    assert width in (16, 32, 64)
-    if width == 64:
-        return float(x)
-    elif width == 32:
-        return reinterpret_bits(float(x), "!f", "!f")
-    else:
-        return reinterpret_bits(float(x), "!e", "!e")
-
-
-def sign(x):
-    try:
-        return math.copysign(1.0, x)
-    except TypeError:
-        raise TypeError(
-            f"Expected float but got {x!r} of type {type(x).__name__}"
-        ) from None
-
-
-def is_negative(x):
-    return sign(x) < 0
-
-
-def count_between_floats(x, y, width=64):
-    assert x <= y
-    if is_negative(x):
-        if is_negative(y):
-            return float_to_int(x, width) - float_to_int(y, width) + 1
-        else:
-            return count_between_floats(x, -0.0, width) + count_between_floats(
-                0.0, y, width
-            )
-    else:
-        assert not is_negative(y)
-        return float_to_int(y, width) - float_to_int(x, width) + 1
-
-
-def float_to_int(value, width=64):
-    fmt_int, fmt_flt = STRUCT_FORMATSwidth
-    return reinterpret_bits(value, fmt_flt, fmt_int)
-
-
-def int_to_float(value, width=64):
-    fmt_int, fmt_flt = STRUCT_FORMATSwidth
-    return reinterpret_bits(value, fmt_int, fmt_flt)
-
-
-def next_up(value, width=64):
-    """Return the first float larger than finite `val` - IEEE 754's `nextUp`.
-
-    From https://stackoverflow.com/a/10426033, with thanks to Mark Dickinson.
-    """
-    assert isinstance(value, float), f"{value!r} of type {type(value)}"
-    if math.isnan(value) or (math.isinf(value) and value > 0):
-        return value
-    if value == 0.0 and is_negative(value):
-        return 0.0
-    fmt_int, fmt_flt = STRUCT_FORMATSwidth
-    # Note: n is signed; float_to_int returns unsigned
-    fmt_int = fmt_int.lower()
-    n = reinterpret_bits(value, fmt_flt, fmt_int)
-    if n >= 0:
-        n += 1
-    else:
-        n -= 1
-    return reinterpret_bits(n, fmt_int, fmt_flt)
-
-
-def next_down(value, width=64):
-    return -next_up(-value, width)
-
-
-def next_down_normal(value, width, allow_subnormal):
-    value = next_down(value, width)
-    if (not allow_subnormal) and 0 < abs(value) < width_smallest_normalswidth:
-        return 0.0 if value > 0 else -width_smallest_normalswidth
-    return value
-
-
-def next_up_normal(value, width, allow_subnormal):
-    return -next_down_normal(-value, width, allow_subnormal)
-
-
-# Smallest positive non-zero numbers that is fully representable by an
-# IEEE-754 float, calculated with the width's associated minimum exponent.
-# Values from https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats
-width_smallest_normals = {
-    16: 2 ** -(2 ** (5 - 1) - 2),
-    32: 2 ** -(2 ** (8 - 1) - 2),
-    64: 2 ** -(2 ** (11 - 1) - 2),
-}
-assert width_smallest_normals64 == float_info.min
-
-
-def make_float_clamper(
-    min_float: float = 0.0,
-    max_float: float = math.inf,
-    allow_zero: bool = False,  # Allows +0.0 (even if minfloat > 0)
-) -> OptionalCallablefloat, float:
-    """
-    Return a function that clamps positive floats into the given bounds.
-
-    Returns None when no values are allowed (min > max and zero is not allowed).
-    """
-    if max_float < min_float:
-        if allow_zero:
-            min_float = max_float = 0.0
-        else:
-            return None
-
-    range_size = min(max_float - min_float, float_info.max)
-    mantissa_mask = (1 << 52) - 1
-
-    def float_clamper(float_val: float) -> float:
-        if min_float <= float_val <= max_float:
-            return float_val
-        if float_val == 0.0 and allow_zero:
-            return float_val
-        # Outside bounds; pick a new value, sampled from the allowed range,
-        # using the mantissa bits.
-        mant = float_to_int(float_val) & mantissa_mask
-        float_val = min_float + range_size * (mant / mantissa_mask)
-        # Re-enforce the bounds (just in case of floating point arithmetic error)
-        return max(min_float, min(max_float, float_val))
-
-    return float_clamper

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/healthcheck.py Deleted

@@ -1,27 +0,0 @@
-# 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/.
-
-from hypothesis.errors import FailedHealthCheck
-
-
-def fail_health_check(settings, message, label):
-    # Tell pytest to omit the body of this function from tracebacks
-    # https://docs.pytest.org/en/latest/example/simple.html#writing-well-integrated-assertion-helpers
-    __tracebackhide__ = True
-
-    if label in settings.suppress_health_check:
-        return
-    message += (
-        "\nSee https://hypothesis.readthedocs.io/en/latest/health"
-        "checks.html for more information about this. "
-        f"If you want to disable just this health check, add {label} "
-        "to the suppress_health_check settings for this test."
-    )
-    raise FailedHealthCheck(message, label)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/reflection.py Deleted

@@ -1,723 +0,0 @@
-# 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/.
-
-"""This file can approximately be considered the collection of hypothesis going
-to really unreasonable lengths to produce pretty output."""
-
-import ast
-import hashlib
-import inspect
-import os
-import re
-import sys
-import types
-from functools import wraps
-from keyword import iskeyword
-from tokenize import detect_encoding
-from types import ModuleType
-from typing import TYPE_CHECKING, Callable
-from unittest.mock import _patch as PatchType
-
-from hypothesis.internal.compat import is_typed_named_tuple, update_code_location
-from hypothesis.utils.conventions import not_set
-from hypothesis.vendor.pretty import pretty
-
-if TYPE_CHECKING:
-    from hypothesis.strategies._internal.strategies import T
-
-READTHEDOCS = os.environ.get("READTHEDOCS", None) == "True"
-
-
-def is_mock(obj):
-    """Determine if the given argument is a mock type."""
-
-    # We want to be able to detect these when dealing with various test
-    # args. As they are sneaky and can look like almost anything else,
-    # we'll check this by looking for an attribute with a name that it's really
-    # unlikely to implement accidentally, and that anyone who implements it
-    # deliberately should know what they're doing. This is more robust than
-    # looking for types.
-    return hasattr(obj, "hypothesis_internal_is_this_a_mock_check")
-
-
-def getfullargspec_except_self(target):
-    spec = inspect.getfullargspec(target)
-    if inspect.ismethod(target):
-        del spec.args0
-    return spec
-
-
-def function_digest(function):
-    """Returns a string that is stable across multiple invocations across
-    multiple processes and is prone to changing significantly in response to
-    minor changes to the function.
-
-    No guarantee of uniqueness though it usually will be.
-    """
-    hasher = hashlib.sha384()
-    try:
-        hasher.update(inspect.getsource(function).encode())
-    except (OSError, TypeError):
-        pass
-    try:
-        hasher.update(function.__name__.encode())
-    except AttributeError:
-        pass
-    try:
-        hasher.update(function.__module__.__name__.encode())
-    except AttributeError:
-        pass
-    try:
-        hasher.update(repr(getfullargspec_except_self(function)).encode())
-    except TypeError:
-        pass
-    try:
-        hasher.update(function._hypothesis_internal_add_digest)
-    except AttributeError:
-        pass
-    return hasher.digest()
-
-
-def check_signature(sig: inspect.Signature) -> None:
-    # Backport from Python 3.11; see https://github.com/python/cpython/pull/92065
-    for p in sig.parameters.values():
-        if iskeyword(p.name) and p.kind is not p.POSITIONAL_ONLY:
-            raise ValueError(
-                f"Signature {sig!r} contains a parameter named {p.name!r}, "
-                f"but this is a SyntaxError because `{p.name}` is a keyword. "
-                "You, or a library you use, must have manually created an "
-                "invalid signature - this will be an error in Python 3.11+"
-            )
-
-
-def get_signature(target, *, follow_wrapped=True):
-    # Special case for use of `@unittest.mock.patch` decorator, mimicking the
-    # behaviour of getfullargspec instead of reporting unusable arguments.
-    patches = getattr(target, "patchings", None)
-    if isinstance(patches, list) and all(isinstance(p, PatchType) for p in patches):
-        P = inspect.Parameter
-        return inspect.Signature(
-            P("args", P.VAR_POSITIONAL), P("keywargs", P.VAR_KEYWORD)
-        )
-
-    if isinstance(getattr(target, "__signature__", None), inspect.Signature):
-        # This special case covers unusual codegen like Pydantic models
-        sig = target.__signature__
-        check_signature(sig)
-        # And *this* much more complicated block ignores the `self` argument
-        # if that's been (incorrectly) included in the custom signature.
-        if sig.parameters and (inspect.isclass(target) or inspect.ismethod(target)):
-            selfy = next(iter(sig.parameters.values()))
-            if (
-                selfy.name == "self"
-                and selfy.default is inspect.Parameter.empty
-                and selfy.kind.name.startswith("POSITIONAL_")
-            ):
-                return sig.replace(
-                    parameters=v for k, v in sig.parameters.items() if k != "self"
-                )
-        return sig
-    if sys.version_info:2 <= (3, 8) and inspect.isclass(target):
-        # Workaround for subclasses of typing.Generic on Python <= 3.8
-        from hypothesis.strategies._internal.types import is_generic_type
-
-        if is_generic_type(target):
-            sig = inspect.signature(target.__init__)
-            check_signature(sig)
-            return sig.replace(
-                parameters=v for k, v in sig.parameters.items() if k != "self"
-            )
-    sig = inspect.signature(target, follow_wrapped=follow_wrapped)
-    check_signature(sig)
-    return sig
-
-
-def arg_is_required(param):
-    return param.default is inspect.Parameter.empty and param.kind in (
-        inspect.Parameter.POSITIONAL_OR_KEYWORD,
-        inspect.Parameter.KEYWORD_ONLY,
-    )
-
-
-def required_args(target, args=(), kwargs=()):
-    """Return a set of names of required args to target that were not supplied
-    in args or kwargs.
-
-    This is used in builds() to determine which arguments to attempt to
-    fill from type hints.  target may be any callable (including classes
-    and bound methods).  args and kwargs should be as they are passed to
-    builds() - that is, a tuple of values and a dict of names: values.
-    """
-    # We start with a workaround for NamedTuples, which don't have nice inits
-    if inspect.isclass(target) and is_typed_named_tuple(target):
-        provided = set(kwargs) | set(target._fields: len(args))
-        return set(target._fields) - provided
-    # Then we try to do the right thing with inspect.signature
-    try:
-        sig = get_signature(target)
-    except (ValueError, TypeError):
-        return set()
-    return {
-        name
-        for name, param in list(sig.parameters.items())len(args) :
-        if arg_is_required(param) and name not in kwargs
-    }
-
-
-def convert_keyword_arguments(function, args, kwargs):
-    """Returns a pair of a tuple and a dictionary which would be equivalent
-    passed as positional and keyword args to the function. Unless function has
-    kwonlyargs or **kwargs the dictionary will always be empty.
-    """
-    argspec = getfullargspec_except_self(function)
-    new_args = 
-    kwargs = dict(kwargs)
-
-    defaults = dict(argspec.kwonlydefaults or {})
-
-    if argspec.defaults:
-        for name, value in zip(
-            argspec.args-len(argspec.defaults) :, argspec.defaults
-        ):
-            defaultsname = value
-
-    n = max(len(args), len(argspec.args))
-
-    for i in range(n):
-        if i < len(args):
-            new_args.append(argsi)
-        else:
-            arg_name = argspec.argsi
-            if arg_name in kwargs:
-                new_args.append(kwargs.pop(arg_name))
-            elif arg_name in defaults:
-                new_args.append(defaultsarg_name)
-            else:
-                raise TypeError(f"No value provided for argument {arg_name!r}")
-
-    if kwargs and not (argspec.varkw or argspec.kwonlyargs):
-        if len(kwargs) > 1:
-            raise TypeError(
-                "%s() got unexpected keyword arguments %s"
-                % (function.__name__, ", ".join(map(repr, kwargs)))
-            )
-        else:
-            bad_kwarg = next(iter(kwargs))
-            raise TypeError(
-                f"{function.__name__}() got an unexpected keyword argument {bad_kwarg!r}"
-            )
-    return tuple(new_args), kwargs
-
-
-def convert_positional_arguments(function, args, kwargs):
-    """Return a tuple (new_args, new_kwargs) where all possible arguments have
-    been moved to kwargs.
-
-    new_args will only be non-empty if function has a variadic argument.
-    """
-    argspec = getfullargspec_except_self(function)
-    new_kwargs = dict(argspec.kwonlydefaults or {})
-    new_kwargs.update(kwargs)
-    if not argspec.varkw:
-        for k in new_kwargs.keys():
-            if k not in argspec.args and k not in argspec.kwonlyargs:
-                raise TypeError(
-                    f"{function.__name__}() got an unexpected keyword argument {k!r}"
-                )
-    if len(args) < len(argspec.args):
-        for i in range(len(args), len(argspec.args) - len(argspec.defaults or ())):
-            if argspec.argsi not in kwargs:
-                raise TypeError(f"No value provided for argument {argspec.argsi}")
-    for kw in argspec.kwonlyargs:
-        if kw not in new_kwargs:
-            raise TypeError(f"No value provided for argument {kw}")
-
-    if len(args) > len(argspec.args) and not argspec.varargs:
-        raise TypeError(
-            f"{function.__name__}() takes at most {len(argspec.args)} "
-            f"positional arguments ({len(args)} given)"
-        )
-
-    for arg, name in zip(args, argspec.args):
-        if name in new_kwargs:
-            raise TypeError(
-                f"{function.__name__}() got multiple values for keyword argument {name!r}"
-            )
-        else:
-            new_kwargsname = arg
-
-    return (tuple(argslen(argspec.args) :), new_kwargs)
-
-
-def ast_arguments_matches_signature(args, sig):
-    assert isinstance(args, ast.arguments)
-    assert isinstance(sig, inspect.Signature)
-    expected = 
-    for node in getattr(args, "posonlyargs", ()):  # New in Python 3.8
-        expected.append((node.arg, inspect.Parameter.POSITIONAL_ONLY))
-    for node in args.args:
-        expected.append((node.arg, inspect.Parameter.POSITIONAL_OR_KEYWORD))
-    if args.vararg is not None:
-        expected.append((args.vararg.arg, inspect.Parameter.VAR_POSITIONAL))
-    for node in args.kwonlyargs:
-        expected.append((node.arg, inspect.Parameter.KEYWORD_ONLY))
-    if args.kwarg is not None:
-        expected.append((args.kwarg.arg, inspect.Parameter.VAR_KEYWORD))
-    return expected == (p.name, p.kind) for p in sig.parameters.values()
-
-
-def extract_all_lambdas(tree, matching_signature):
-    lambdas = 
-
-    class Visitor(ast.NodeVisitor):
-        def visit_Lambda(self, node):
-            if ast_arguments_matches_signature(node.args, matching_signature):
-                lambdas.append(node)
-
-    Visitor().visit(tree)
-
-    return lambdas
-
-
-LINE_CONTINUATION = re.compile(r"\\\n")
-WHITESPACE = re.compile(r"\s+")
-PROBABLY_A_COMMENT = re.compile("""#^'"*$""")
-SPACE_FOLLOWS_OPEN_BRACKET = re.compile(r"$ ")
-SPACE_PRECEDES_CLOSE_BRACKET = re.compile(r" $")
-
-
-def extract_lambda_source(f):
-    """Extracts a single lambda expression from the string source. Returns a
-    string indicating an unknown body if it gets confused in any way.
-
-    This is not a good function and I am sorry for it. Forgive me my
-    sins, oh lord
-    """
-    sig = inspect.signature(f)
-    assert sig.return_annotation is inspect.Parameter.empty
-    if sig.parameters:
-        if_confused = f"lambda {str(sig)1:-1}: <unknown>"
-    else:
-        if_confused = "lambda: <unknown>"
-    try:
-        source = inspect.getsource(f)
-    except OSError:
-        return if_confused
-
-    source = LINE_CONTINUATION.sub(" ", source)
-    source = WHITESPACE.sub(" ", source)
-    source = source.strip()
-    assert "lambda" in source
-
-    tree = None
-
-    try:
-        tree = ast.parse(source)
-    except SyntaxError:
-        for i in range(len(source) - 1, len("lambda"), -1):
-            prefix = source:i
-            if "lambda" not in prefix:
-                break
-            try:
-                tree = ast.parse(prefix)
-                source = prefix
-                break
-            except SyntaxError:
-                continue
-    if tree is None and source.startswith("@"):
-        # This will always eventually find a valid expression because
-        # the decorator must be a valid Python function call, so will
-        # eventually be syntactically valid and break out of the loop.
-        # Thus, this loop can never terminate normally.
-        for i in range(len(source) + 1):
-            p = source1:i
-            if "lambda" in p:
-                try:
-                    tree = ast.parse(p)
-                    source = p
-                    break
-                except SyntaxError:
-                    pass
-        else:
-            raise NotImplementedError("expected to be unreachable")
-
-    if tree is None:
-        return if_confused
-
-    aligned_lambdas = extract_all_lambdas(tree, matching_signature=sig)
-    if len(aligned_lambdas) != 1:
-        return if_confused
-    lambda_ast = aligned_lambdas0
-    assert lambda_ast.lineno == 1
-
-    # If the source code contains Unicode characters, the bytes of the original
-    # file don't line up with the string indexes, and `col_offset` doesn't match
-    # the string we're using.  We need to convert the source code into bytes
-    # before slicing.
-    #
-    # Under the hood, the inspect module is using `tokenize.detect_encoding` to
-    # detect the encoding of the original source file.  We'll use the same
-    # approach to get the source code as bytes.
-    #
-    # See https://github.com/HypothesisWorks/hypothesis/issues/1700 for an
-    # example of what happens if you don't correct for this.
-    #
-    # Note: if the code doesn't come from a file (but, for example, a doctest),
-    # `getsourcefile` will return `None` and the `open()` call will fail with
-    # an OSError.  Or if `f` is a built-in function, in which case we get a
-    # TypeError.  In both cases, fall back to splitting the Unicode string.
-    # It's not perfect, but it's the best we can do.
-    try:
-        with open(inspect.getsourcefile(f), "rb") as src_f:
-            encoding, _ = detect_encoding(src_f.readline)
-
-        source_bytes = source.encode(encoding)
-        source_bytes = source_byteslambda_ast.col_offset :.strip()
-        source = source_bytes.decode(encoding)
-    except (OSError, TypeError):
-        source = sourcelambda_ast.col_offset :.strip()
-
-    # This ValueError can be thrown in Python 3 if:
-    #
-    #  - There's a Unicode character in the line before the Lambda, and
-    #  - For some reason we can't detect the source encoding of the file
-    #
-    # because slicing on `lambda_ast.col_offset` will account for bytes, but
-    # the slice will be on Unicode characters.
-    #
-    # In practice this seems relatively rare, so we just give up rather than
-    # trying to recover.
-    try:
-        source = sourcesource.index("lambda") :
-    except ValueError:
-        return if_confused
-
-    for i in range(len(source), len("lambda"), -1):  # pragma: no branch
-        try:
-            parsed = ast.parse(source:i)
-            assert len(parsed.body) == 1
-            assert parsed.body
-            if isinstance(parsed.body0.value, ast.Lambda):
-                source = source:i
-                break
-        except SyntaxError:
-            pass
-    lines = source.split("\n")
-    lines = PROBABLY_A_COMMENT.sub("", l) for l in lines
-    source = "\n".join(lines)
-
-    source = WHITESPACE.sub(" ", source)
-    source = SPACE_FOLLOWS_OPEN_BRACKET.sub("(", source)
-    source = SPACE_PRECEDES_CLOSE_BRACKET.sub(")", source)
-    source = source.strip()
-    return source
-
-
-def get_pretty_function_description(f):
-    if not hasattr(f, "__name__"):
-        return repr(f)
-    name = f.__name__
-    if name == "<lambda>":
-        return extract_lambda_source(f)
-    elif isinstance(f, (types.MethodType, types.BuiltinMethodType)):
-        self = f.__self__
-        # Some objects, like `builtins.abs` are of BuiltinMethodType but have
-        # their module as __self__.  This might include c-extensions generally?
-        if not (self is None or inspect.isclass(self) or inspect.ismodule(self)):
-            return f"{self!r}.{name}"
-    elif isinstance(name, str) and getattr(dict, name, object()) is f:
-        # special case for keys/values views in from_type() / ghostwriter output
-        return f"dict.{name}"
-    return name
-
-
-def nicerepr(v):
-    if inspect.isfunction(v):
-        return get_pretty_function_description(v)
-    elif isinstance(v, type):
-        return v.__name__
-    else:
-        # With TypeVar T, show ListT instead of TypeError on List~T
-        return re.sub(r"(\)~(A-Za-z*\)", r"\g<1>\g<2>", pretty(v))
-
-
-def repr_call(f, args, kwargs, reorder=True):
-    if reorder:
-        args, kwargs = convert_positional_arguments(f, args, kwargs)
-
-    bits = nicerepr(x) for x in args
-
-    for p in get_signature(f).parameters.values():
-        if p.name in kwargs and not p.kind.name.startswith("VAR_"):
-            bits.append(f"{p.name}={nicerepr(kwargs.pop(p.name))}")
-    if kwargs:
-        for a in sorted(kwargs):
-            bits.append(f"{a}={nicerepr(kwargsa)}")
-
-    rep = nicerepr(f)
-    if rep.startswith("lambda") and ":" in rep:
-        rep = f"({rep})"
-    return rep + "(" + ", ".join(bits) + ")"
-
-
-def check_valid_identifier(identifier):
-    if not identifier.isidentifier():
-        raise ValueError(f"{identifier!r} is not a valid python identifier")
-
-
-eval_cache: dict = {}
-
-
-def source_exec_as_module(source):
-    try:
-        return eval_cachesource
-    except KeyError:
-        pass
-
-    hexdigest = hashlib.sha384(source.encode()).hexdigest()
-    result = ModuleType("hypothesis_temporary_module_" + hexdigest)
-    assert isinstance(source, str)
-    exec(source, result.__dict__)
-    eval_cachesource = result
-    return result
-
-
-COPY_ARGSPEC_SCRIPT = """
-from hypothesis.utils.conventions import not_set
-
-def accept({funcname}):
-    def {name}({argspec}):
-        return {funcname}({invocation})
-    return {name}
-""".lstrip()
-
-
-def define_function_signature(name, docstring, argspec):
-    """A decorator which sets the name, argspec and docstring of the function
-    passed into it."""
-    if name == "<lambda>":
-        name = "_lambda_"
-    check_valid_identifier(name)
-    for a in argspec.args:
-        check_valid_identifier(a)
-    if argspec.varargs is not None:
-        check_valid_identifier(argspec.varargs)
-    if argspec.varkw is not None:
-        check_valid_identifier(argspec.varkw)
-    n_defaults = len(argspec.defaults or ())
-    if n_defaults:
-        parts = 
-        for a in argspec.args:-n_defaults:
-            parts.append(a)
-        for a in argspec.args-n_defaults::
-            parts.append(f"{a}=not_set")
-    else:
-        parts = list(argspec.args)
-    used_names = list(argspec.args) + list(argspec.kwonlyargs)
-    used_names.append(name)
-
-    for a in argspec.kwonlyargs:
-        check_valid_identifier(a)
-
-    def accept(f):
-        fargspec = getfullargspec_except_self(f)
-        must_pass_as_kwargs = 
-        invocation_parts = 
-        for a in argspec.args:
-            if a not in fargspec.args and not fargspec.varargs:
-                must_pass_as_kwargs.append(a)  # pragma: no cover
-            else:
-                invocation_parts.append(a)
-        if argspec.varargs:
-            used_names.append(argspec.varargs)
-            parts.append("*" + argspec.varargs)
-            invocation_parts.append("*" + argspec.varargs)
-        elif argspec.kwonlyargs:
-            parts.append("*")
-        for k in must_pass_as_kwargs:
-            invocation_parts.append(f"{k}={k}")  # pragma: no cover
-
-        for k in argspec.kwonlyargs:
-            invocation_parts.append(f"{k}={k}")
-            if k in (argspec.kwonlydefaults or ):
-                parts.append(f"{k}=not_set")
-            else:
-                parts.append(k)
-        if argspec.varkw:
-            used_names.append(argspec.varkw)
-            parts.append("**" + argspec.varkw)
-            invocation_parts.append("**" + argspec.varkw)
-
-        candidate_names = "f" + f"f_{i}" for i in range(1, len(used_names) + 2)
-
-        for funcname in candidate_names:  # pragma: no branch
-            if funcname not in used_names:
-                break
-
-        source = COPY_ARGSPEC_SCRIPT.format(
-            name=name,
-            funcname=funcname,
-            argspec=", ".join(parts),
-            invocation=", ".join(invocation_parts),
-        )
-        result = source_exec_as_module(source).accept(f)
-        result.__doc__ = docstring
-        result.__defaults__ = argspec.defaults
-        if argspec.kwonlydefaults:
-            result.__kwdefaults__ = argspec.kwonlydefaults
-        if argspec.annotations:
-            result.__annotations__ = argspec.annotations
-        return result
-
-    return accept
-
-
-COPY_SIGNATURE_SCRIPT = """
-from hypothesis.utils.conventions import not_set
-
-def accept({funcname}):
-    def {name}{signature}:
-        return {funcname}({invocation})
-    return {name}
-""".lstrip()
-
-
-def get_varargs(sig, kind=inspect.Parameter.VAR_POSITIONAL):
-    for p in sig.parameters.values():
-        if p.kind is kind:
-            return p
-    return None
-
-
-def define_function_signature_from_signature(name, docstring, signature):
-    """A decorator which sets the name, argspec and docstring of the function
-    passed into it."""
-    # TODO: we will (eventually...) replace the last few uses of getfullargspec
-    # with this version, and then delete the one above.  For now though, this
-    # works for @proxies() and @given() is under stricter constraints anyway.
-
-    check_valid_identifier(name)
-    for a in signature.parameters:
-        check_valid_identifier(a)
-
-    used_names = list(signature.parameters) + name
-
-    newsig = signature.replace(
-        parameters=
-            p if p.default is signature.empty else p.replace(default=not_set)
-            for p in (
-                p.replace(annotation=signature.empty)
-                for p in signature.parameters.values()
-            )
-        ,
-        return_annotation=signature.empty,
-    )
-
-    pos_args = 
-        p
-        for p in signature.parameters.values()
-        if p.kind.name.startswith("POSITIONAL_")
-    
-
-    def accept(f):
-        fsig = inspect.signature(f, follow_wrapped=False)
-        must_pass_as_kwargs = 
-        invocation_parts = 
-        for p in pos_args:
-            if p.name not in fsig.parameters and get_varargs(fsig) is None:
-                must_pass_as_kwargs.append(p.name)
-            else:
-                invocation_parts.append(p.name)
-        if get_varargs(signature) is not None:
-            invocation_parts.append("*" + get_varargs(signature).name)
-        for k in must_pass_as_kwargs:
-            invocation_parts.append(f"{k}={k}")
-        for p in signature.parameters.values():
-            if p.kind is p.KEYWORD_ONLY:
-                invocation_parts.append(f"{p.name}={p.name}")
-        varkw = get_varargs(signature, kind=inspect.Parameter.VAR_KEYWORD)
-        if varkw:
-            invocation_parts.append("**" + varkw.name)
-
-        candidate_names = "f" + f"f_{i}" for i in range(1, len(used_names) + 2)
-
-        for funcname in candidate_names:  # pragma: no branch
-            if funcname not in used_names:
-                break
-
-        source = COPY_SIGNATURE_SCRIPT.format(
-            name=name,
-            funcname=funcname,
-            signature=str(newsig),
-            invocation=", ".join(invocation_parts),
-        )
-        result = source_exec_as_module(source).accept(f)
-        result.__doc__ = docstring
-        result.__defaults__ = tuple(
-            p.default
-            for p in signature.parameters.values()
-            if p.default is not signature.empty and "POSITIONAL" in p.kind.name
-        )
-        kwdefaults = {
-            p.name: p.default
-            for p in signature.parameters.values()
-            if p.default is not signature.empty and p.kind is p.KEYWORD_ONLY
-        }
-        if kwdefaults:
-            result.__kwdefaults__ = kwdefaults
-        annotations = {
-            p.name: p.annotation
-            for p in signature.parameters.values()
-            if p.annotation is not signature.empty
-        }
-        if annotations:
-            result.__annotations__ = annotations
-        return result
-
-    return accept
-
-
-def impersonate(target):
-    """Decorator to update the attributes of a function so that to external
-    introspectors it will appear to be the target function.
-
-    Note that this updates the function in place, it doesn't return a
-    new one.
-    """
-
-    def accept(f):
-        f.__code__ = update_code_location(
-            f.__code__, target.__code__.co_filename, target.__code__.co_firstlineno
-        )
-        f.__name__ = target.__name__
-        f.__module__ = target.__module__
-        f.__doc__ = target.__doc__
-        f.__globals__"__hypothesistracebackhide__" = True
-        return f
-
-    return accept
-
-
-def proxies(target: "T") -> CallableCallable, "T":
-    replace_sig = define_function_signature_from_signature(
-        target.__name__.replace("<lambda>", "_lambda_"),  # type: ignore
-        target.__doc__,
-        get_signature(target, follow_wrapped=False),
-    )
-
-    def accept(proxy):
-        return impersonate(target)(wraps(target)(replace_sig(proxy)))
-
-    return accept
-
-
-def is_identity_function(f):
-    # TODO: pattern-match the AST to handle `def ...` identity functions too
-    return bool(re.fullmatch(r"lambda (\w+): \1", get_pretty_function_description(f)))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/internal/scrutineer.py Deleted

@@ -1,122 +0,0 @@
-# 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 sys
-from collections import defaultdict
-from functools import lru_cache, reduce
-from itertools import groupby
-from pathlib import Path
-
-from hypothesis._settings import Phase, Verbosity
-from hypothesis.internal.escalation import is_hypothesis_file
-
-
-@lru_cache(maxsize=None)
-def should_trace_file(fname):
-    # fname.startswith("<") indicates runtime code-generation via compile,
-    # e.g. compile("def ...", "<string>", "exec") in e.g. attrs methods.
-    return not (is_hypothesis_file(fname) or fname.startswith("<"))
-
-
-class Tracer:
-    """A super-simple branch coverage tracer."""
-
-    __slots__ = ("branches", "_previous_location")
-
-    def __init__(self):
-        self.branches = set()
-        self._previous_location = None
-
-    def trace(self, frame, event, arg):
-        if event == "call":
-            return self.trace
-        elif event == "line":
-            fname = frame.f_code.co_filename
-            if should_trace_file(fname):
-                current_location = (fname, frame.f_lineno)
-                self.branches.add((self._previous_location, current_location))
-                self._previous_location = current_location
-
-
-def get_explaining_locations(traces):
-    # Traces is a dictinteresting_origin | None, setfrozensettuplestr, int
-    # Each trace in the set might later become a Counter instead of frozenset.
-    if not traces:
-        return {}
-
-    unions = {origin: set().union(*values) for origin, values in traces.items()}
-    seen_passing = {None}.union(*unions.pop(None, set()))
-
-    always_failing_never_passing = {
-        origin: reduce(set.intersection, set().union(*v) for v in values)
-        - seen_passing
-        for origin, values in traces.items()
-        if origin is not None
-    }
-
-    # Build the observed parts of the control-flow graph for each origin
-    cf_graphs = {origin: defaultdict(set) for origin in unions}
-    for origin, seen_arcs in unions.items():
-        for src, dst in seen_arcs:
-            cf_graphsoriginsrc.add(dst)
-        assert cf_graphsoriginNone, "Expected start node with >=1 successor"
-
-    # For each origin, our explanation is the always_failing_never_passing lines
-    # which are reachable from the start node (None) without passing through another
-    # AFNP line.  So here's a whatever-first search with early stopping:
-    explanations = defaultdict(set)
-    for origin in unions:
-        queue = {None}
-        seen = set()
-        while queue:
-            assert queue.isdisjoint(seen), f"Intersection: {queue & seen}"
-            src = queue.pop()
-            seen.add(src)
-            if src in always_failing_never_passingorigin:
-                explanationsorigin.add(src)
-            else:
-                queue.update(cf_graphsoriginsrc - seen)
-
-    return explanations
-
-
-LIB_DIR = str(Path(sys.executable).parent / "lib")
-EXPLANATION_STUB = (
-    "Explanation:",
-    "    These lines were always and only run by failing examples:",
-)
-HAD_TRACE = "    We didn't try to explain this, because sys.gettrace()="
-
-
-def make_report(explanations, cap_lines_at=5):
-    report = defaultdict(list)
-    for origin, locations in explanations.items():
-        assert locations  # or else we wouldn't have stored the key, above.
-        report_lines = 
-            "        {}:{}".format(k, ", ".join(map(str, sorted(l for _, l in v))))
-            for k, v in groupby(locations, lambda kv: kv0)
-        
-        report_lines.sort(key=lambda line: (line.startswith(LIB_DIR), line))
-        if len(report_lines) > cap_lines_at + 1:
-            msg = "        (and {} more with settings.verbosity >= verbose)"
-            report_linescap_lines_at: = msg.format(len(report_linescap_lines_at:))
-        reportorigin = list(EXPLANATION_STUB) + report_lines
-    return report
-
-
-def explanatory_lines(traces, settings):
-    if Phase.explain in settings.phases and sys.gettrace() and not traces:
-        return defaultdict(
-            lambda: EXPLANATION_STUB0, HAD_TRACE + repr(sys.gettrace())
-        )
-    # Return human-readable report lines summarising the traces
-    explanations = get_explaining_locations(traces)
-    max_lines = 5 if settings.verbosity <= Verbosity.normal else 100
-    return make_report(explanations, cap_lines_at=max_lines)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/provisional.py Deleted

@@ -1,173 +0,0 @@
-# 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/.
-
-"""This module contains various provisional APIs and strategies.
-
-It is intended for internal use, to ease code reuse, and is not stable.
-Point releases may move or break the contents at any time!
-
-Internet strategies should conform to :rfc:`3986` or the authoritative
-definitions it links to.  If not, report the bug!
-"""
-# https://tools.ietf.org/html/rfc3696
-
-import string
-from importlib import resources
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.strategies._internal.utils import defines_strategy
-
-URL_SAFE_CHARACTERS = frozenset(string.ascii_letters + string.digits + "$-_.+!*'(),~")
-FRAGMENT_SAFE_CHARACTERS = URL_SAFE_CHARACTERS | {"?", "/"}
-
-
-# This file is sourced from http://data.iana.org/TLD/tlds-alpha-by-domain.txt
-# The file contains additional information about the date that it was last updated.
-try:  # pragma: no cover
-    traversable = resources.files("hypothesis.vendor") / "tlds-alpha-by-domain.txt"
-    _tlds = traversable.read_text().splitlines()
-except (AttributeError, ValueError):  # .files() was added in Python 3.9
-    _tlds = resources.read_text(
-        "hypothesis.vendor", "tlds-alpha-by-domain.txt"
-    ).splitlines()
-
-assert _tlds0.startswith("#")
-TOP_LEVEL_DOMAINS = "COM" + sorted(_tlds1:, key=len)
-
-
-class DomainNameStrategy(st.SearchStrategy):
-    @staticmethod
-    def clean_inputs(minimum, maximum, value, variable_name):
-        if value is None:
-            value = maximum
-        elif not isinstance(value, int):
-            raise InvalidArgument(
-                f"Expected integer but {variable_name} is a {type(value).__name__}"
-            )
-        elif not minimum <= value <= maximum:
-            raise InvalidArgument(
-                f"Invalid value {minimum!r} < {variable_name}={value!r} < {maximum!r}"
-            )
-        return value
-
-    def __init__(self, max_length=None, max_element_length=None):
-        """
-        A strategy for :rfc:`1035` fully qualified domain names.
-
-        The upper limit for max_length is 255 in accordance with :rfc:`1035#section-2.3.4`
-        The lower limit for max_length is 4, corresponding to a two letter domain
-        with a single letter subdomain.
-        The upper limit for max_element_length is 63 in accordance with :rfc:`1035#section-2.3.4`
-        The lower limit for max_element_length is 1 in accordance with :rfc:`1035#section-2.3.4`
-        """
-        # https://tools.ietf.org/html/rfc1035#section-2.3.4
-
-        max_length = self.clean_inputs(4, 255, max_length, "max_length")
-        max_element_length = self.clean_inputs(
-            1, 63, max_element_length, "max_element_length"
-        )
-
-        super().__init__()
-        self.max_length = max_length
-        self.max_element_length = max_element_length
-
-        # These regular expressions are constructed to match the documented
-        # information in https://tools.ietf.org/html/rfc1035#section-2.3.1
-        # which defines the allowed syntax of a subdomain string.
-        if self.max_element_length == 1:
-            self.label_regex = r"a-zA-Z"
-        elif self.max_element_length == 2:
-            self.label_regex = r"a-zA-Za-zA-Z0-9?"
-        else:
-            maximum_center_character_pattern_repetitions = self.max_element_length - 2
-            self.label_regex = r"a-zA-Z(a-zA-Z0-9\-{0,%d}a-zA-Z0-9)?" % (
-                maximum_center_character_pattern_repetitions,
-            )
-
-    def do_draw(self, data):
-        # 1 - Select a valid top-level domain (TLD) name
-        # 2 - Check that the number of characters in our selected TLD won't
-        # prevent us from generating at least a 1 character subdomain.
-        # 3 - Randomize the TLD between upper and lower case characters.
-        domain = data.draw(
-            st.sampled_from(TOP_LEVEL_DOMAINS)
-            .filter(lambda tld: len(tld) + 2 <= self.max_length)
-            .flatmap(
-                lambda tld: st.tuples(
-                    *(st.sampled_from(c.lower(), c.upper()) for c in tld)
-                ).map("".join)
-            )
-        )
-        # The maximum possible number of subdomains is 126,
-        # 1 character subdomain + 1 '.' character, * 126 = 252,
-        # with a max of 255, that leaves 3 characters for a TLD.
-        # Allowing any more subdomains would not leave enough
-        # characters for even the shortest possible TLDs.
-        elements = cu.many(data, min_size=1, average_size=3, max_size=126)
-        while elements.more():
-            # Generate a new valid subdomain using the regex strategy.
-            sub_domain = data.draw(st.from_regex(self.label_regex, fullmatch=True))
-            if len(domain) + len(sub_domain) >= self.max_length:
-                data.stop_example(discard=True)
-                break
-            domain = sub_domain + "." + domain
-        return domain
-
-
-@defines_strategy(force_reusable_values=True)
-def domains(
-    *, max_length: int = 255, max_element_length: int = 63
-) -> st.SearchStrategystr:
-    """Generate :rfc:`1035` compliant fully qualified domain names."""
-    return DomainNameStrategy(
-        max_length=max_length, max_element_length=max_element_length
-    )
-
-
-# The `urls()` strategy uses this to generate URL fragments (e.g. "#foo").
-# It has been extracted to top-level so that we can test it independently
-# of `urls()`, which helps with getting non-flaky coverage of the lambda.
-_url_fragments_strategy = (
-    st.lists(
-        st.builds(
-            lambda char, encode: f"%{ord(char):02X}"
-            if (encode or char not in FRAGMENT_SAFE_CHARACTERS)
-            else char,
-            st.characters(min_codepoint=0, max_codepoint=255),
-            st.booleans(),
-        ),
-        min_size=1,
-    )
-    .map("".join)
-    .map("#{}".format)
-)
-
-
-@defines_strategy(force_reusable_values=True)
-def urls() -> st.SearchStrategystr:
-    """A strategy for :rfc:`3986`, generating http/https URLs."""
-
-    def url_encode(s):
-        return "".join(c if c in URL_SAFE_CHARACTERS else "%%%02X" % ord(c) for c in s)
-
-    schemes = st.sampled_from("http", "https")
-    ports = st.integers(min_value=0, max_value=2**16 - 1).map(":{}".format)
-    paths = st.lists(st.text(string.printable).map(url_encode)).map("/".join)
-
-    return st.builds(
-        "{}://{}{}/{}{}".format,
-        schemes,
-        domains(),
-        st.just("") | ports,
-        paths,
-        st.just("") | _url_fragments_strategy,
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/py.typed Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/reporting.py Deleted

@@ -1,68 +0,0 @@
-# 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 inspect
-
-from hypothesis._settings import Verbosity, settings
-from hypothesis.internal.compat import escape_unicode_characters
-from hypothesis.utils.dynamicvariables import DynamicVariable
-
-
-def silent(value):
-    pass
-
-
-def default(value):
-    try:
-        print(value)
-    except UnicodeEncodeError:
-        print(escape_unicode_characters(value))
-
-
-reporter = DynamicVariable(default)
-
-
-def current_reporter():
-    return reporter.value
-
-
-def with_reporter(new_reporter):
-    return reporter.with_value(new_reporter)
-
-
-def current_verbosity():
-    return settings.default.verbosity
-
-
-def to_text(textish):
-    if inspect.isfunction(textish):
-        textish = textish()
-    if isinstance(textish, bytes):
-        textish = textish.decode()
-    return textish
-
-
-def verbose_report(text):
-    if current_verbosity() >= Verbosity.verbose:
-        base_report(text)
-
-
-def debug_report(text):
-    if current_verbosity() >= Verbosity.debug:
-        base_report(text)
-
-
-def report(text):
-    if current_verbosity() >= Verbosity.normal:
-        base_report(text)
-
-
-def base_report(text):
-    current_reporter()(to_text(text))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/stateful.py Deleted

@@ -1,948 +0,0 @@
-# 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/.
-
-"""This module provides support for a stateful style of testing, where tests
-attempt to find a sequence of operations that cause a breakage rather than just
-a single value.
-
-Notably, the set of steps available at any point may depend on the
-execution to date.
-"""
-
-import inspect
-from copy import copy
-from functools import lru_cache
-from io import StringIO
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Union,
-    overload,
-)
-from unittest import TestCase
-
-import attr
-
-from hypothesis import strategies as st
-from hypothesis._settings import (
-    HealthCheck,
-    Verbosity,
-    note_deprecation,
-    settings as Settings,
-)
-from hypothesis.control import current_build_context
-from hypothesis.core import TestFunc, given
-from hypothesis.errors import InvalidArgument, InvalidDefinition
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.healthcheck import fail_health_check
-from hypothesis.internal.reflection import (
-    function_digest,
-    get_pretty_function_description,
-    nicerepr,
-    proxies,
-)
-from hypothesis.internal.validation import check_type
-from hypothesis.reporting import current_verbosity, report
-from hypothesis.strategies._internal.featureflags import FeatureStrategy
-from hypothesis.strategies._internal.strategies import (
-    Ex,
-    Ex_Inv,
-    OneOfStrategy,
-    SearchStrategy,
-    check_strategy,
-)
-from hypothesis.vendor.pretty import RepresentationPrinter
-
-STATE_MACHINE_RUN_LABEL = cu.calc_label_from_name("another state machine step")
-SHOULD_CONTINUE_LABEL = cu.calc_label_from_name("should we continue drawing")
-
-
-class _OmittedArgument:
-    """Sentinel class to prevent overlapping overloads in type hints. See comments
-    above the overloads of @rule."""
-
-
-class TestCaseProperty:  # pragma: no cover
-    def __get__(self, obj, typ=None):
-        if obj is not None:
-            typ = type(obj)
-        return typ._to_test_case()
-
-    def __set__(self, obj, value):
-        raise AttributeError("Cannot set TestCase")
-
-    def __delete__(self, obj):
-        raise AttributeError("Cannot delete TestCase")
-
-
-def run_state_machine_as_test(state_machine_factory, *, settings=None):
-    """Run a state machine definition as a test, either silently doing nothing
-    or printing a minimal breaking program and raising an exception.
-
-    state_machine_factory is anything which returns an instance of
-    RuleBasedStateMachine when called with no arguments - it can be a class or a
-    function. settings will be used to control the execution of the test.
-    """
-    if settings is None:
-        try:
-            settings = state_machine_factory.TestCase.settings
-            check_type(Settings, settings, "state_machine_factory.TestCase.settings")
-        except AttributeError:
-            settings = Settings(deadline=None, suppress_health_check=HealthCheck.all())
-    check_type(Settings, settings, "settings")
-
-    @settings
-    @given(st.data())
-    def run_state_machine(factory, data):
-        cd = data.conjecture_data
-        machine = factory()
-        check_type(RuleBasedStateMachine, machine, "state_machine_factory()")
-        cd.hypothesis_runner = machine
-
-        print_steps = (
-            current_build_context().is_final or current_verbosity() >= Verbosity.debug
-        )
-        try:
-            if print_steps:
-                report(f"state = {machine.__class__.__name__}()")
-            machine.check_invariants(settings)
-            max_steps = settings.stateful_step_count
-            steps_run = 0
-
-            while True:
-                # We basically always want to run the maximum number of steps,
-                # but need to leave a small probability of terminating early
-                # in order to allow for reducing the number of steps once we
-                # find a failing test case, so we stop with probability of
-                # 2 ** -16 during normal operation but force a stop when we've
-                # generated enough steps.
-                cd.start_example(STATE_MACHINE_RUN_LABEL)
-                if steps_run == 0:
-                    cd.draw_bits(16, forced=1)
-                elif steps_run >= max_steps:
-                    cd.draw_bits(16, forced=0)
-                    break
-                else:
-                    # All we really care about is whether this value is zero
-                    # or non-zero, so if it's > 1 we discard it and insert a
-                    # replacement value after
-                    cd.start_example(SHOULD_CONTINUE_LABEL)
-                    should_continue_value = cd.draw_bits(16)
-                    if should_continue_value > 1:
-                        cd.stop_example(discard=True)
-                        cd.draw_bits(16, forced=int(bool(should_continue_value)))
-                    else:
-                        cd.stop_example()
-                        if should_continue_value == 0:
-                            break
-                steps_run += 1
-
-                # Choose a rule to run, preferring an initialize rule if there are
-                # any which have not been run yet.
-                if machine._initialize_rules_to_run:
-                    init_rules = 
-                        st.tuples(st.just(rule), st.fixed_dictionaries(rule.arguments))
-                        for rule in machine._initialize_rules_to_run
-                    
-                    rule, data = cd.draw(st.one_of(init_rules))
-                    machine._initialize_rules_to_run.remove(rule)
-                else:
-                    rule, data = cd.draw(machine._rules_strategy)
-
-                # Pretty-print the values this rule was called with *before* calling
-                # _add_result_to_targets, to avoid printing arguments which are also
-                # a return value using the variable name they are assigned to.
-                # See https://github.com/HypothesisWorks/hypothesis/issues/2341
-                if print_steps:
-                    data_to_print = {
-                        k: machine._pretty_print(v) for k, v in data.items()
-                    }
-
-                # Assign 'result' here in case executing the rule fails below
-                result = multiple()
-                try:
-                    data = dict(data)
-                    for k, v in list(data.items()):
-                        if isinstance(v, VarReference):
-                            datak = machine.names_to_valuesv.name
-                    result = rule.function(machine, **data)
-                    if rule.targets:
-                        if isinstance(result, MultipleResults):
-                            for single_result in result.values:
-                                machine._add_result_to_targets(
-                                    rule.targets, single_result
-                                )
-                        else:
-                            machine._add_result_to_targets(rule.targets, result)
-                    elif result is not None:
-                        fail_health_check(
-                            settings,
-                            "Rules should return None if they have no target bundle, "
-                            f"but {rule.function.__qualname__} returned {result!r}",
-                            HealthCheck.return_value,
-                        )
-                finally:
-                    if print_steps:
-                        # 'result' is only used if the step has target bundles.
-                        # If it does, and the result is a 'MultipleResult',
-                        # then 'print_step' prints a multi-variable assignment.
-                        machine._print_step(rule, data_to_print, result)
-                machine.check_invariants(settings)
-                cd.stop_example()
-        finally:
-            if print_steps:
-                report("state.teardown()")
-            machine.teardown()
-
-    # Use a machine digest to identify stateful tests in the example database
-    run_state_machine.hypothesis.inner_test._hypothesis_internal_add_digest = (
-        function_digest(state_machine_factory)
-    )
-    # Copy some attributes so @seed and @reproduce_failure "just work"
-    run_state_machine._hypothesis_internal_use_seed = getattr(
-        state_machine_factory, "_hypothesis_internal_use_seed", None
-    )
-    run_state_machine._hypothesis_internal_use_reproduce_failure = getattr(
-        state_machine_factory, "_hypothesis_internal_use_reproduce_failure", None
-    )
-    run_state_machine._hypothesis_internal_print_given_args = False
-
-    run_state_machine(state_machine_factory)
-
-
-class StateMachineMeta(type):
-    def __setattr__(cls, name, value):
-        if name == "settings" and isinstance(value, Settings):
-            raise AttributeError(
-                (
-                    "Assigning {cls}.settings = {value} does nothing. Assign "
-                    "to {cls}.TestCase.settings, or use @{value} as a decorator "
-                    "on the {cls} class."
-                ).format(cls=cls.__name__, value=value)
-            )
-        return super().__setattr__(name, value)
-
-
-class RuleBasedStateMachine(metaclass=StateMachineMeta):
-    """A RuleBasedStateMachine gives you a structured way to define state machines.
-
-    The idea is that a state machine carries a bunch of types of data
-    divided into Bundles, and has a set of rules which may read data
-    from bundles (or just from normal strategies) and push data onto
-    bundles. At any given point a random applicable rule will be
-    executed.
-    """
-
-    _rules_per_class: Dicttype, Listclassmethod = {}
-    _invariants_per_class: Dicttype, Listclassmethod = {}
-    _initializers_per_class: Dicttype, Listclassmethod = {}
-
-    def __init__(self):
-        if not self.rules():
-            raise InvalidDefinition(f"Type {type(self).__name__} defines no rules")
-        self.bundles: Dictstr, list = {}
-        self.name_counter = 1
-        self.names_to_values: Dictstr, Any = {}
-        self.__stream = StringIO()
-        self.__printer = RepresentationPrinter(self.__stream)
-        self._initialize_rules_to_run = copy(self.initialize_rules())
-        self._rules_strategy = RuleStrategy(self)
-
-    def _pretty_print(self, value):
-        if isinstance(value, VarReference):
-            return value.name
-        self.__stream.seek(0)
-        self.__stream.truncate(0)
-        self.__printer.output_width = 0
-        self.__printer.buffer_width = 0
-        self.__printer.buffer.clear()
-        self.__printer.pretty(value)
-        self.__printer.flush()
-        return self.__stream.getvalue()
-
-    def __repr__(self):
-        return f"{type(self).__name__}({nicerepr(self.bundles)})"
-
-    def _new_name(self):
-        result = f"v{self.name_counter}"
-        self.name_counter += 1
-        return result
-
-    def _last_names(self, n):
-        assert self.name_counter > n
-        count = self.name_counter
-        return f"v{i}" for i in range(count - n, count)
-
-    def bundle(self, name):
-        return self.bundles.setdefault(name, )
-
-    @classmethod
-    def initialize_rules(cls):
-        try:
-            return cls._initializers_per_classcls
-        except KeyError:
-            pass
-
-        cls._initializers_per_classcls = 
-        for _, v in inspect.getmembers(cls):
-            r = getattr(v, INITIALIZE_RULE_MARKER, None)
-            if r is not None:
-                cls._initializers_per_classcls.append(r)
-        return cls._initializers_per_classcls
-
-    @classmethod
-    def rules(cls):
-        try:
-            return cls._rules_per_classcls
-        except KeyError:
-            pass
-
-        cls._rules_per_classcls = 
-        for _, v in inspect.getmembers(cls):
-            r = getattr(v, RULE_MARKER, None)
-            if r is not None:
-                cls._rules_per_classcls.append(r)
-        return cls._rules_per_classcls
-
-    @classmethod
-    def invariants(cls):
-        try:
-            return cls._invariants_per_classcls
-        except KeyError:
-            pass
-
-        target = 
-        for _, v in inspect.getmembers(cls):
-            i = getattr(v, INVARIANT_MARKER, None)
-            if i is not None:
-                target.append(i)
-        cls._invariants_per_classcls = target
-        return cls._invariants_per_classcls
-
-    def _print_step(self, rule, data, result):
-        self.step_count = getattr(self, "step_count", 0) + 1
-        output_assignment = ""
-        if rule.targets:
-            if isinstance(result, MultipleResults):
-                if len(result.values) == 1:
-                    output_assignment = f"({self._last_names(1)0},) = "
-                elif result.values:
-                    output_names = self._last_names(len(result.values))
-                    output_assignment = ", ".join(output_names) + " = "
-            else:
-                output_assignment = self._last_names(1)0 + " = "
-        report(
-            "{}state.{}({})".format(
-                output_assignment,
-                rule.function.__name__,
-                ", ".join("%s=%s" % kv for kv in data.items()),
-            )
-        )
-
-    def _add_result_to_targets(self, targets, result):
-        name = self._new_name()
-        self.__printer.singleton_pprinters.setdefault(
-            id(result), lambda obj, p, cycle: p.text(name)
-        )
-        self.names_to_valuesname = result
-        for target in targets:
-            self.bundles.setdefault(target, ).append(VarReference(name))
-
-    def check_invariants(self, settings):
-        for invar in self.invariants():
-            if self._initialize_rules_to_run and not invar.check_during_init:
-                continue
-            if not all(precond(self) for precond in invar.preconditions):
-                continue
-            if (
-                current_build_context().is_final
-                or settings.verbosity >= Verbosity.debug
-            ):
-                report(f"state.{invar.function.__name__}()")
-            result = invar.function(self)
-            if result is not None:
-                fail_health_check(
-                    settings,
-                    "The return value of an @invariant is always ignored, but "
-                    f"{invar.function.__qualname__} returned {result!r} "
-                    "instead of None",
-                    HealthCheck.return_value,
-                )
-
-    def teardown(self):
-        """Called after a run has finished executing to clean up any necessary
-        state.
-
-        Does nothing by default.
-        """
-
-    TestCase = TestCaseProperty()
-
-    @classmethod
-    @lru_cache()
-    def _to_test_case(cls):
-        class StateMachineTestCase(TestCase):
-            settings = Settings(deadline=None, suppress_health_check=HealthCheck.all())
-
-            def runTest(self):
-                run_state_machine_as_test(cls)
-
-            runTest.is_hypothesis_test = True
-
-        StateMachineTestCase.__name__ = cls.__name__ + ".TestCase"
-        StateMachineTestCase.__qualname__ = cls.__qualname__ + ".TestCase"
-        return StateMachineTestCase
-
-
-@attr.s()
-class Rule:
-    targets = attr.ib()
-    function = attr.ib(repr=get_pretty_function_description)
-    arguments = attr.ib()
-    preconditions = attr.ib()
-    bundles = attr.ib(init=False)
-
-    def __attrs_post_init__(self):
-        arguments = {}
-        bundles = 
-        for k, v in sorted(self.arguments.items()):
-            assert not isinstance(v, BundleReferenceStrategy)
-            if isinstance(v, Bundle):
-                bundles.append(v)
-                consume = isinstance(v, BundleConsumer)
-                argumentsk = BundleReferenceStrategy(v.name, consume)
-            else:
-                argumentsk = v
-        self.bundles = tuple(bundles)
-        self.arguments_strategy = st.fixed_dictionaries(arguments)
-
-
-self_strategy = st.runner()
-
-
-class BundleReferenceStrategy(SearchStrategy):
-    def __init__(self, name, consume=False):
-        self.name = name
-        self.consume = consume
-
-    def do_draw(self, data):
-        machine = data.draw(self_strategy)
-        bundle = machine.bundle(self.name)
-        if not bundle:
-            data.mark_invalid()
-        # Shrink towards the right rather than the left. This makes it easier
-        # to delete data generated earlier, as when the error is towards the
-        # end there can be a lot of hard to remove padding.
-        position = cu.integer_range(data, 0, len(bundle) - 1, center=len(bundle))
-        if self.consume:
-            return bundle.pop(position)
-        else:
-            return bundleposition
-
-
-class Bundle(SearchStrategyEx):
-    def __init__(self, name: str, consume: bool = False) -> None:
-        self.name = name
-        self.__reference_strategy = BundleReferenceStrategy(name, consume)
-
-    def do_draw(self, data):
-        machine = data.draw(self_strategy)
-        reference = data.draw(self.__reference_strategy)
-        return machine.names_to_valuesreference.name
-
-    def __repr__(self):
-        consume = self.__reference_strategy.consume
-        if consume is False:
-            return f"Bundle(name={self.name!r})"
-        return f"Bundle(name={self.name!r}, consume={consume!r})"
-
-    def calc_is_empty(self, recur):
-        # We assume that a bundle will grow over time
-        return False
-
-    def available(self, data):
-        # ``self_strategy`` is an instance of the ``st.runner()`` strategy.
-        # Hence drawing from it only returns the current state machine without
-        # modifying the underlying buffer.
-        machine = data.draw(self_strategy)
-        return bool(machine.bundle(self.name))
-
-
-class BundleConsumer(BundleEx):
-    def __init__(self, bundle: BundleEx) -> None:
-        super().__init__(bundle.name, consume=True)
-
-
-def consumes(bundle: BundleEx) -> SearchStrategyEx:
-    """When introducing a rule in a RuleBasedStateMachine, this function can
-    be used to mark bundles from which each value used in a step with the
-    given rule should be removed. This function returns a strategy object
-    that can be manipulated and combined like any other.
-
-    For example, a rule declared with
-
-    ``@rule(value1=b1, value2=consumes(b2), value3=lists(consumes(b3)))``
-
-    will consume a value from Bundle ``b2`` and several values from Bundle
-    ``b3`` to populate ``value2`` and ``value3`` each time it is executed.
-    """
-    if not isinstance(bundle, Bundle):
-        raise TypeError("Argument to be consumed must be a bundle.")
-    return BundleConsumer(bundle)
-
-
-@attr.s()
-class MultipleResults(IterableEx):
-    values = attr.ib()
-
-    def __iter__(self):
-        return iter(self.values)
-
-
-# We need to use an invariant typevar here to avoid a mypy error, as covariant
-# typevars cannot be used as parameters.
-def multiple(*args: Ex_Inv) -> MultipleResultsEx_Inv:
-    """This function can be used to pass multiple results to the target(s) of
-    a rule. Just use ``return multiple(result1, result2, ...)`` in your rule.
-
-    It is also possible to use ``return multiple()`` with no arguments in
-    order to end a rule without passing any result.
-    """
-    return MultipleResults(args)
-
-
-def _convert_targets(targets, target):
-    """Single validator and converter for target arguments."""
-    if target is not None:
-        if targets:
-            raise InvalidArgument(
-                "Passing both targets=%r and target=%r is redundant - pass "
-                "targets=%r instead." % (targets, target, tuple(targets) + (target,))
-            )
-        targets = (target,)
-
-    converted_targets = 
-    for t in targets:
-        if not isinstance(t, Bundle):
-            msg = "Got invalid target %r of type %r, but all targets must be Bundles."
-            if isinstance(t, OneOfStrategy):
-                msg += (
-                    "\nIt looks like you passed `one_of(a, b)` or `a | b` as "
-                    "a target.  You should instead pass `targets=(a, b)` to "
-                    "add the return value of this rule to both the `a` and "
-                    "`b` bundles, or define a rule for each target if it "
-                    "should be added to exactly one."
-                )
-            raise InvalidArgument(msg % (t, type(t)))
-        while isinstance(t, Bundle):
-            if isinstance(t, BundleConsumer):
-                note_deprecation(
-                    f"Using consumes({t.name}) doesn't makes sense in this context.  "
-                    "This will be an error in a future version of Hypothesis.",
-                    since="2021-09-08",
-                    has_codemod=False,
-                )
-            t = t.name
-        converted_targets.append(t)
-    return tuple(converted_targets)
-
-
-RULE_MARKER = "hypothesis_stateful_rule"
-INITIALIZE_RULE_MARKER = "hypothesis_stateful_initialize_rule"
-PRECONDITIONS_MARKER = "hypothesis_stateful_preconditions"
-INVARIANT_MARKER = "hypothesis_stateful_invariant"
-
-
-_RuleType = Callable..., UnionMultipleResultsEx, Ex
-_RuleWrapper = Callable_RuleTypeEx, _RuleTypeEx
-
-
-# We cannot exclude `target` or `targets` from any of these signatures because
-# otherwise they would be matched against the `kwargs`, either leading to
-# overlapping overloads of incompatible return types, or a concrete
-# implementation that does not accept all overloaded variant signatures.
-# Although it is possible to reorder the variants to fix the former, it will
-# always lead to the latter, as then the omitted parameter could be typed as
-# a `SearchStrategy`, which the concrete implementation does not accept.
-#
-# Omitted `targets` parameters, where the default value is used, are typed with
-# a special `_OmittedArgument` type. We cannot type them as `Tuple()`, because
-# `Tuple()` is a subtype of `SequenceBundleEx`, leading to signature
-# overlaps with incompatible return types. The `_OmittedArgument` type will never be
-# encountered at runtime, and exists solely to annotate the default of `targets`.
-# PEP 661 (Sentinel Values) might provide a more elegant alternative in the future.
-#
-# We could've also annotated `targets` as `Tuple_OmittedArgument`, but then when
-# both `target` and `targets` are provided, mypy describes the type error as an
-# invalid argument type for `targets` (expected `Tuple_OmittedArgument`, got ...).
-# By annotating it as a bare `_OmittedArgument` type, mypy's error will warn that
-# there is no overloaded signature matching the call, which is more descriptive.
-#
-# When `target` xor `targets` is provided, the function to decorate must return
-# a value whose type matches the one stored in the bundle. When neither are
-# provided, the function to decorate must return nothing. There is no variant
-# for providing `target` and `targets`, as these parameters are mutually exclusive.
-@overload
-def rule(
-    *,
-    targets: SequenceBundleEx,
-    target: None = ...,
-    **kwargs: SearchStrategy,
-) -> _RuleWrapperEx:  # pragma: no cover
-    ...
-
-
-@overload
-def rule(
-    *, target: BundleEx, targets: _OmittedArgument = ..., **kwargs: SearchStrategy
-) -> _RuleWrapperEx:  # pragma: no cover
-    ...
-
-
-@overload
-def rule(
-    *,
-    target: None = ...,
-    targets: _OmittedArgument = ...,
-    **kwargs: SearchStrategy,
-) -> CallableCallable..., None, Callable..., None:  # pragma: no cover
-    ...
-
-
-def rule(
-    *,
-    targets: UnionSequenceBundleEx, _OmittedArgument = (),
-    target: OptionalBundleEx = None,
-    **kwargs: SearchStrategy,
-) -> Union_RuleWrapperEx, CallableCallable..., None, Callable..., None:
-    """Decorator for RuleBasedStateMachine. Any Bundle present in ``target`` or
-    ``targets`` will define where the end result of this function should go. If
-    both are empty then the end result will be discarded.
-
-    ``target`` must be a Bundle, or if the result should go to multiple
-    bundles you can pass a tuple of them as the ``targets`` argument.
-    It is invalid to use both arguments for a single rule.  If the result
-    should go to exactly one of several bundles, define a separate rule for
-    each case.
-
-    kwargs then define the arguments that will be passed to the function
-    invocation. If their value is a Bundle, or if it is ``consumes(b)``
-    where ``b`` is a Bundle, then values that have previously been produced
-    for that bundle will be provided. If ``consumes`` is used, the value
-    will also be removed from the bundle.
-
-    Any other kwargs should be strategies and values from them will be
-    provided.
-    """
-    converted_targets = _convert_targets(targets, target)
-    for k, v in kwargs.items():
-        check_strategy(v, name=k)
-
-    def accept(f):
-        if getattr(f, INVARIANT_MARKER, None):
-            raise InvalidDefinition(
-                "A function cannot be used for both a rule and an invariant.",
-                Settings.default,
-            )
-        existing_rule = getattr(f, RULE_MARKER, None)
-        existing_initialize_rule = getattr(f, INITIALIZE_RULE_MARKER, None)
-        if existing_rule is not None or existing_initialize_rule is not None:
-            raise InvalidDefinition(
-                "A function cannot be used for two distinct rules. ", Settings.default
-            )
-        preconditions = getattr(f, PRECONDITIONS_MARKER, ())
-        rule = Rule(
-            targets=converted_targets,
-            arguments=kwargs,
-            function=f,
-            preconditions=preconditions,
-        )
-
-        @proxies(f)
-        def rule_wrapper(*args, **kwargs):
-            return f(*args, **kwargs)
-
-        setattr(rule_wrapper, RULE_MARKER, rule)
-        return rule_wrapper
-
-    return accept
-
-
-# See also comments of `rule`'s overloads.
-@overload
-def initialize(
-    *,
-    targets: SequenceBundleEx,
-    target: None = ...,
-    **kwargs: SearchStrategy,
-) -> _RuleWrapperEx:  # pragma: no cover
-    ...
-
-
-@overload
-def initialize(
-    *, target: BundleEx, targets: _OmittedArgument = ..., **kwargs: SearchStrategy
-) -> _RuleWrapperEx:  # pragma: no cover
-    ...
-
-
-@overload
-def initialize(
-    *,
-    target: None = ...,
-    targets: _OmittedArgument = ...,
-    **kwargs: SearchStrategy,
-) -> CallableCallable..., None, Callable..., None:  # pragma: no cover
-    ...
-
-
-def initialize(
-    *,
-    targets: UnionSequenceBundleEx, _OmittedArgument = (),
-    target: OptionalBundleEx = None,
-    **kwargs: SearchStrategy,
-) -> Union_RuleWrapperEx, CallableCallable..., None, Callable..., None:
-    """Decorator for RuleBasedStateMachine.
-
-    An initialize decorator behaves like a rule, but all ``@initialize()`` decorated
-    methods will be called before any ``@rule()`` decorated methods, in an arbitrary
-    order.  Each ``@initialize()`` method will be called exactly once per run, unless
-    one raises an exception - after which only the ``.teardown()`` method will be run.
-    ``@initialize()`` methods may not have preconditions.
-    """
-    converted_targets = _convert_targets(targets, target)
-    for k, v in kwargs.items():
-        check_strategy(v, name=k)
-
-    def accept(f):
-        if getattr(f, INVARIANT_MARKER, None):
-            raise InvalidDefinition(
-                "A function cannot be used for both a rule and an invariant.",
-                Settings.default,
-            )
-        existing_rule = getattr(f, RULE_MARKER, None)
-        existing_initialize_rule = getattr(f, INITIALIZE_RULE_MARKER, None)
-        if existing_rule is not None or existing_initialize_rule is not None:
-            raise InvalidDefinition(
-                "A function cannot be used for two distinct rules. ", Settings.default
-            )
-        preconditions = getattr(f, PRECONDITIONS_MARKER, ())
-        if preconditions:
-            raise InvalidDefinition(
-                "An initialization rule cannot have a precondition. ", Settings.default
-            )
-        rule = Rule(
-            targets=converted_targets,
-            arguments=kwargs,
-            function=f,
-            preconditions=preconditions,
-        )
-
-        @proxies(f)
-        def rule_wrapper(*args, **kwargs):
-            return f(*args, **kwargs)
-
-        setattr(rule_wrapper, INITIALIZE_RULE_MARKER, rule)
-        return rule_wrapper
-
-    return accept
-
-
-@attr.s()
-class VarReference:
-    name = attr.ib()
-
-
-# There are multiple alternatives for annotating the `precond` type, all of them
-# have drawbacks. See https://github.com/HypothesisWorks/hypothesis/pull/3068#issuecomment-906642371
-def precondition(precond: CallableAny, bool) -> CallableTestFunc, TestFunc:
-    """Decorator to apply a precondition for rules in a RuleBasedStateMachine.
-    Specifies a precondition for a rule to be considered as a valid step in the
-    state machine, which is more efficient than using :func:`~hypothesis.assume`
-    within the rule.  The ``precond`` function will be called with the instance of
-    RuleBasedStateMachine and should return True or False. Usually it will need
-    to look at attributes on that instance.
-
-    For example::
-
-        class MyTestMachine(RuleBasedStateMachine):
-            state = 1
-
-            @precondition(lambda self: self.state != 0)
-            @rule(numerator=integers())
-            def divide_with(self, numerator):
-                self.state = numerator / self.state
-
-    If multiple preconditions are applied to a single rule, it is only considered
-    a valid step when all of them return True.  Preconditions may be applied to
-    invariants as well as rules.
-    """
-
-    def decorator(f):
-        @proxies(f)
-        def precondition_wrapper(*args, **kwargs):
-            return f(*args, **kwargs)
-
-        existing_initialize_rule = getattr(f, INITIALIZE_RULE_MARKER, None)
-        if existing_initialize_rule is not None:
-            raise InvalidDefinition(
-                "An initialization rule cannot have a precondition. ", Settings.default
-            )
-
-        rule = getattr(f, RULE_MARKER, None)
-        invariant = getattr(f, INVARIANT_MARKER, None)
-        if rule is not None:
-            assert invariant is None
-            new_rule = attr.evolve(rule, preconditions=rule.preconditions + (precond,))
-            setattr(precondition_wrapper, RULE_MARKER, new_rule)
-        elif invariant is not None:
-            assert rule is None
-            new_invariant = attr.evolve(
-                invariant, preconditions=invariant.preconditions + (precond,)
-            )
-            setattr(precondition_wrapper, INVARIANT_MARKER, new_invariant)
-        else:
-            setattr(
-                precondition_wrapper,
-                PRECONDITIONS_MARKER,
-                getattr(f, PRECONDITIONS_MARKER, ()) + (precond,),
-            )
-
-        return precondition_wrapper
-
-    return decorator
-
-
-@attr.s()
-class Invariant:
-    function = attr.ib(repr=get_pretty_function_description)
-    preconditions = attr.ib()
-    check_during_init = attr.ib()
-
-
-def invariant(*, check_during_init: bool = False) -> CallableTestFunc, TestFunc:
-    """Decorator to apply an invariant for rules in a RuleBasedStateMachine.
-    The decorated function will be run after every rule and can raise an
-    exception to indicate failed invariants.
-
-    For example::
-
-        class MyTestMachine(RuleBasedStateMachine):
-            state = 1
-
-            @invariant()
-            def is_nonzero(self):
-                assert self.state != 0
-
-    By default, invariants are only checked after all
-    :func:`@initialize() <hypothesis.stateful.initialize>` rules have been run.
-    Pass ``check_during_init=True`` for invariants which can also be checked
-    during initialization.
-    """
-    check_type(bool, check_during_init, "check_during_init")
-
-    def accept(f):
-        if getattr(f, RULE_MARKER, None) or getattr(f, INITIALIZE_RULE_MARKER, None):
-            raise InvalidDefinition(
-                "A function cannot be used for both a rule and an invariant.",
-                Settings.default,
-            )
-        existing_invariant = getattr(f, INVARIANT_MARKER, None)
-        if existing_invariant is not None:
-            raise InvalidDefinition(
-                "A function cannot be used for two distinct invariants.",
-                Settings.default,
-            )
-        preconditions = getattr(f, PRECONDITIONS_MARKER, ())
-        invar = Invariant(
-            function=f,
-            preconditions=preconditions,
-            check_during_init=check_during_init,
-        )
-
-        @proxies(f)
-        def invariant_wrapper(*args, **kwargs):
-            return f(*args, **kwargs)
-
-        setattr(invariant_wrapper, INVARIANT_MARKER, invar)
-        return invariant_wrapper
-
-    return accept
-
-
-LOOP_LABEL = cu.calc_label_from_name("RuleStrategy loop iteration")
-
-
-class RuleStrategy(SearchStrategy):
-    def __init__(self, machine):
-        super().__init__()
-        self.machine = machine
-        self.rules = list(machine.rules())
-
-        self.enabled_rules_strategy = st.shared(
-            FeatureStrategy(), key=("enabled rules", machine)
-        )
-
-        # The order is a bit arbitrary. Primarily we're trying to group rules
-        # that write to the same location together, and to put rules with no
-        # target first as they have less effect on the structure. We order from
-        # fewer to more arguments on grounds that it will plausibly need less
-        # data. This probably won't work especially well and we could be
-        # smarter about it, but it's better than just doing it in definition
-        # order.
-        self.rules.sort(
-            key=lambda rule: (
-                sorted(rule.targets),
-                len(rule.arguments),
-                rule.function.__name__,
-            )
-        )
-
-    def __repr__(self):
-        return "{}(machine={}({{...}}))".format(
-            self.__class__.__name__,
-            self.machine.__class__.__name__,
-        )
-
-    def do_draw(self, data):
-        if not any(self.is_valid(rule) for rule in self.rules):
-            msg = f"No progress can be made from state {self.machine!r}"
-            raise InvalidDefinition(msg) from None
-
-        feature_flags = data.draw(self.enabled_rules_strategy)
-
-        # Note: The order of the filters here is actually quite important,
-        # because checking is_enabled makes choices, so increases the size of
-        # the choice sequence. This means that if we are in a case where many
-        # rules are invalid we will make a lot more choices if we ask if they
-        # are enabled before we ask if they are valid, so our test cases will
-        # be artificially large.
-        rule = data.draw(
-            st.sampled_from(self.rules)
-            .filter(self.is_valid)
-            .filter(lambda r: feature_flags.is_enabled(r.function.__name__))
-        )
-
-        return (rule, data.draw(rule.arguments_strategy))
-
-    def is_valid(self, rule):
-        if not all(precond(self.machine) for precond in rule.preconditions):
-            return False
-
-        for b in rule.bundles:
-            bundle = self.machine.bundle(b.name)
-            if not bundle:
-                return False
-        return True

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/statistics.py Deleted

@@ -1,118 +0,0 @@
-# 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 math
-import statistics
-from collections import Counter
-
-from hypothesis.utils.dynamicvariables import DynamicVariable
-
-collector = DynamicVariable(None)
-
-
-def note_statistics(stats_dict):
-    callback = collector.value
-    if callback is not None:
-        callback(stats_dict)
-
-
-def describe_targets(best_targets):
-    """Return a list of lines describing the results of `target`, if any."""
-    # These lines are included in the general statistics description below,
-    # but also printed immediately below failing examples to alleviate the
-    # "threshold problem" where shrinking can make severe bug look trivial.
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2180
-    if not best_targets:
-        return 
-    elif len(best_targets) == 1:
-        label, score = next(iter(best_targets.items()))
-        return f"Highest target score: {score:g}  (label={label!r})"
-    else:
-        lines = "Highest target scores:"
-        for label, score in sorted(best_targets.items(), key=lambda x: x::-1):
-            lines.append(f"{score:>16g}  (label={label!r})")
-        return lines
-
-
-def describe_statistics(stats_dict):
-    """Return a multi-line string describing the passed run statistics.
-
-    `stats_dict` must be a dictionary of data in the format collected by
-    `hypothesis.internal.conjecture.engine.ConjectureRunner.statistics`.
-
-    We DO NOT promise that this format will be stable or supported over
-    time, but do aim to make it reasonably useful for downstream users.
-    It's also meant to support benchmarking for research purposes.
-
-    This function is responsible for the report which is printed in the
-    terminal for our pytest --hypothesis-show-statistics option.
-    """
-    lines = stats_dict"nodeid" + ":\n" if "nodeid" in stats_dict else 
-    prev_failures = 0
-    for phase in "reuse", "generate", "shrink":
-        d = stats_dict.get(phase + "-phase", {})
-        # Basic information we report for every phase
-        cases = d.get("test-cases", )
-        if not cases:
-            continue
-        statuses = Counter(t"status" for t in cases)
-        runtimes = sorted(t"runtime" for t in cases)
-        n = max(0, len(runtimes) - 1)
-        lower = int(runtimesint(math.floor(n * 0.05)) * 1000)
-        upper = int(runtimesint(math.ceil(n * 0.95)) * 1000)
-        if upper == 0:
-            ms = "< 1ms"
-        elif lower == upper:
-            ms = f"~ {lower}ms"
-        else:
-            ms = f"{lower}-{upper} ms"
-        drawtime_percent = 100 * statistics.mean(
-            t"drawtime" / t"runtime" if t"runtime" > 0 else 0 for t in cases
-        )
-        lines.append(
-            f"  - during {phase} phase ({d'duration-seconds':.2f} seconds):\n"
-            f"    - Typical runtimes: {ms}, ~ {drawtime_percent:.0f}% in data generation\n"
-            f"    - {statuses'valid'} passing examples, {statuses'interesting'} "
-            f"failing examples, {statuses'invalid' + statuses'overrun'} invalid examples"
-        )
-        # If we've found new distinct failures in this phase, report them
-        distinct_failures = d"distinct-failures" - prev_failures
-        if distinct_failures:
-            plural = distinct_failures > 1
-            lines.append(
-                "    - Found {}{} distinct error{} in this phase".format(
-                    distinct_failures, " more" * bool(prev_failures), "s" * plural
-                )
-            )
-        prev_failures = d"distinct-failures"
-        # Report events during the generate phase, if there were any
-        if phase == "generate":
-            events = Counter(sum((t"events" for t in cases), ))
-            if events:
-                lines.append("    - Events:")
-                lines += 
-                    f"      * {100 * v / len(cases):.2f}%, {k}"
-                    for k, v in sorted(events.items(), key=lambda x: (-x1, x0))
-                
-        # Some additional details on the shrinking phase
-        if phase == "shrink":
-            lines.append(
-                "    - Tried {} shrinks of which {} were successful".format(
-                    len(cases), d"shrinks-successful"
-                )
-            )
-        lines.append("")
-
-    target_lines = describe_targets(stats_dict.get("targets", {}))
-    if target_lines:
-        lines.append("  - " + target_lines0)
-        lines.extend("    " + l for l in target_lines1:)
-    lines.append("  - Stopped because " + stats_dict"stopped-because")
-    return "\n".join(lines)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/collections.py Deleted

@@ -1,335 +0,0 @@
-# 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 copy
-from typing import Any, Iterable, Tuple, overload
-
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.conjecture.junkdrawer import LazySequenceCopy
-from hypothesis.internal.conjecture.utils import combine_labels
-from hypothesis.internal.reflection import is_identity_function
-from hypothesis.strategies._internal.strategies import (
-    T3,
-    T4,
-    T5,
-    Ex,
-    MappedSearchStrategy,
-    SearchStrategy,
-    T,
-    check_strategy,
-    filter_not_satisfied,
-)
-from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-
-
-class TupleStrategy(SearchStrategy):
-    """A strategy responsible for fixed length tuples based on heterogeneous
-    strategies for each of their elements."""
-
-    def __init__(self, strategies: IterableSearchStrategyAny):
-        super().__init__()
-        self.element_strategies = tuple(strategies)
-
-    def do_validate(self):
-        for s in self.element_strategies:
-            s.validate()
-
-    def calc_label(self):
-        return combine_labels(
-            self.class_label, *(s.label for s in self.element_strategies)
-        )
-
-    def __repr__(self):
-        tuple_string = ", ".join(map(repr, self.element_strategies))
-        return f"TupleStrategy(({tuple_string}))"
-
-    def calc_has_reusable_values(self, recur):
-        return all(recur(e) for e in self.element_strategies)
-
-    def do_draw(self, data):
-        return tuple(data.draw(e) for e in self.element_strategies)
-
-    def calc_is_empty(self, recur):
-        return any(recur(e) for e in self.element_strategies)
-
-
-@overload
-def tuples() -> SearchStrategyTuple():  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def tuples(__a1: SearchStrategyEx) -> SearchStrategyTupleEx:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def tuples(
-    __a1: SearchStrategyEx, __a2: SearchStrategyT
-) -> SearchStrategyTupleEx, T:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def tuples(
-    __a1: SearchStrategyEx, __a2: SearchStrategyT, __a3: SearchStrategyT3
-) -> SearchStrategyTupleEx, T, T3:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def tuples(
-    __a1: SearchStrategyEx,
-    __a2: SearchStrategyT,
-    __a3: SearchStrategyT3,
-    __a4: SearchStrategyT4,
-) -> SearchStrategyTupleEx, T, T3, T4:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def tuples(
-    __a1: SearchStrategyEx,
-    __a2: SearchStrategyT,
-    __a3: SearchStrategyT3,
-    __a4: SearchStrategyT4,
-    __a5: SearchStrategyT5,
-) -> SearchStrategyTupleEx, T, T3, T4, T5:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def tuples(
-    *args: SearchStrategyAny,
-) -> SearchStrategyTupleAny, ...:  # pragma: no cover
-    ...
-
-
-@cacheable
-@defines_strategy()
-def tuples(*args: SearchStrategyAny) -> SearchStrategyTupleAny, ...:  # noqa: F811
-    """Return a strategy which generates a tuple of the same length as args by
-    generating the value at index i from argsi.
-
-    e.g. tuples(integers(), integers()) would generate a tuple of length
-    two with both values an integer.
-
-    Examples from this strategy shrink by shrinking their component parts.
-    """
-    for arg in args:
-        check_strategy(arg)
-
-    return TupleStrategy(args)
-
-
-class ListStrategy(SearchStrategy):
-    """A strategy for lists which takes a strategy for its elements and the
-    allowed lengths, and generates lists with the correct size and contents."""
-
-    _nonempty_filters: tuple = (bool, len, tuple, list)
-
-    def __init__(self, elements, min_size=0, max_size=float("inf")):
-        super().__init__()
-        self.min_size = min_size or 0
-        self.max_size = max_size if max_size is not None else float("inf")
-        assert 0 <= self.min_size <= self.max_size
-        self.average_size = min(
-            max(self.min_size * 2, self.min_size + 5),
-            0.5 * (self.min_size + self.max_size),
-        )
-        self.element_strategy = elements
-
-    def calc_label(self):
-        return combine_labels(self.class_label, self.element_strategy.label)
-
-    def do_validate(self):
-        self.element_strategy.validate()
-        if self.is_empty:
-            raise InvalidArgument(
-                "Cannot create non-empty lists with elements drawn from "
-                f"strategy {self.element_strategy!r} because it has no values."
-            )
-        if self.element_strategy.is_empty and 0 < self.max_size < float("inf"):
-            raise InvalidArgument(
-                f"Cannot create a collection of max_size={self.max_size!r}, "
-                "because no elements can be drawn from the element strategy "
-                f"{self.element_strategy!r}"
-            )
-
-    def calc_is_empty(self, recur):
-        if self.min_size == 0:
-            return False
-        else:
-            return recur(self.element_strategy)
-
-    def do_draw(self, data):
-        if self.element_strategy.is_empty:
-            assert self.min_size == 0
-            return 
-
-        elements = cu.many(
-            data,
-            min_size=self.min_size,
-            max_size=self.max_size,
-            average_size=self.average_size,
-        )
-        result = 
-        while elements.more():
-            result.append(data.draw(self.element_strategy))
-        return result
-
-    def __repr__(self):
-        return "{}({!r}, min_size={!r}, max_size={!r})".format(
-            self.__class__.__name__, self.element_strategy, self.min_size, self.max_size
-        )
-
-    def filter(self, condition):
-        if condition in self._nonempty_filters or is_identity_function(condition):
-            assert self.max_size >= 1, "Always-empty is special cased in st.lists()"
-            if self.min_size >= 1:
-                return self
-            new = copy.copy(self)
-            new.min_size = 1
-            return new
-        return super().filter(condition)
-
-
-class UniqueListStrategy(ListStrategy):
-    def __init__(self, elements, min_size, max_size, keys, tuple_suffixes):
-        super().__init__(elements, min_size, max_size)
-        self.keys = keys
-        self.tuple_suffixes = tuple_suffixes
-
-    def do_draw(self, data):
-        if self.element_strategy.is_empty:
-            assert self.min_size == 0
-            return 
-
-        elements = cu.many(
-            data,
-            min_size=self.min_size,
-            max_size=self.max_size,
-            average_size=self.average_size,
-        )
-        seen_sets = tuple(set() for _ in self.keys)
-        result = 
-
-        # We construct a filtered strategy here rather than using a check-and-reject
-        # approach because some strategies have special logic for generation under a
-        # filter, and FilteredStrategy can consolidate multiple filters.
-        def not_yet_in_unique_list(val):
-            return all(key(val) not in seen for key, seen in zip(self.keys, seen_sets))
-
-        filtered = self.element_strategy._filter_for_filtered_draw(
-            not_yet_in_unique_list
-        )
-        while elements.more():
-            value = filtered.do_filtered_draw(data)
-            if value is filter_not_satisfied:
-                elements.reject()
-            else:
-                for key, seen in zip(self.keys, seen_sets):
-                    seen.add(key(value))
-                if self.tuple_suffixes is not None:
-                    value = (value,) + data.draw(self.tuple_suffixes)
-                result.append(value)
-        assert self.max_size >= len(result) >= self.min_size
-        return result
-
-
-class UniqueSampledListStrategy(UniqueListStrategy):
-    def do_draw(self, data):
-        should_draw = cu.many(
-            data,
-            min_size=self.min_size,
-            max_size=self.max_size,
-            average_size=self.average_size,
-        )
-        seen_sets = tuple(set() for _ in self.keys)
-        result = 
-
-        remaining = LazySequenceCopy(self.element_strategy.elements)
-
-        while remaining and should_draw.more():
-            i = len(remaining) - 1
-            j = cu.integer_range(data, 0, i)
-            if j != i:
-                remainingi, remainingj = remainingj, remainingi
-            value = self.element_strategy._transform(remaining.pop())
-
-            if value is not filter_not_satisfied and all(
-                key(value) not in seen for key, seen in zip(self.keys, seen_sets)
-            ):
-                for key, seen in zip(self.keys, seen_sets):
-                    seen.add(key(value))
-                if self.tuple_suffixes is not None:
-                    value = (value,) + data.draw(self.tuple_suffixes)
-                result.append(value)
-            else:
-                should_draw.reject()
-        assert self.max_size >= len(result) >= self.min_size
-        return result
-
-
-class FixedKeysDictStrategy(MappedSearchStrategy):
-    """A strategy which produces dicts with a fixed set of keys, given a
-    strategy for each of their equivalent values.
-
-    e.g. {'foo' : some_int_strategy} would generate dicts with the single
-    key 'foo' mapping to some integer.
-    """
-
-    def __init__(self, strategy_dict):
-        self.dict_type = type(strategy_dict)
-        self.keys = tuple(strategy_dict.keys())
-        super().__init__(strategy=TupleStrategy(strategy_dictk for k in self.keys))
-
-    def calc_is_empty(self, recur):
-        return recur(self.mapped_strategy)
-
-    def __repr__(self):
-        return f"FixedKeysDictStrategy({self.keys!r}, {self.mapped_strategy!r})"
-
-    def pack(self, value):
-        return self.dict_type(zip(self.keys, value))
-
-
-class FixedAndOptionalKeysDictStrategy(SearchStrategy):
-    """A strategy which produces dicts with a fixed set of keys, given a
-    strategy for each of their equivalent values.
-
-    e.g. {'foo' : some_int_strategy} would generate dicts with the single
-    key 'foo' mapping to some integer.
-    """
-
-    def __init__(self, strategy_dict, optional):
-        self.required = strategy_dict
-        self.fixed = FixedKeysDictStrategy(strategy_dict)
-        self.optional = optional
-
-    def calc_is_empty(self, recur):
-        return recur(self.fixed)
-
-    def __repr__(self):
-        return f"FixedAndOptionalKeysDictStrategy({self.required!r}, {self.optional!r})"
-
-    def do_draw(self, data):
-        result = data.draw(self.fixed)
-        remaining = k for k, v in self.optional.items() if not v.is_empty
-        should_draw = cu.many(
-            data, min_size=0, max_size=len(remaining), average_size=len(remaining) / 2
-        )
-        while should_draw.more():
-            j = cu.integer_range(data, 0, len(remaining) - 1)
-            remaining-1, remainingj = remainingj, remaining-1
-            key = remaining.pop()
-            resultkey = data.draw(self.optionalkey)
-        return result

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/core.py Deleted

@@ -1,2019 +0,0 @@
-# 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 enum
-import math
-import operator
-import random
-import re
-import string
-import sys
-import typing
-from decimal import Context, Decimal, localcontext
-from fractions import Fraction
-from functools import reduce
-from inspect import Parameter, Signature, isabstract, isclass, signature
-from types import FunctionType
-from typing import (
-    Any,
-    AnyStr,
-    Callable,
-    Dict,
-    FrozenSet,
-    Hashable,
-    Iterable,
-    List,
-    Optional,
-    Pattern,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-from uuid import UUID
-
-import attr
-
-from hypothesis.control import cleanup, note
-from hypothesis.errors import InvalidArgument, ResolutionFailed
-from hypothesis.internal.cathetus import cathetus
-from hypothesis.internal.charmap import as_general_categories
-from hypothesis.internal.compat import ceil, floor, get_type_hints, is_typed_named_tuple
-from hypothesis.internal.conjecture.utils import (
-    calc_label_from_cls,
-    check_sample,
-    integer_range,
-)
-from hypothesis.internal.entropy import get_seeder_and_restorer
-from hypothesis.internal.reflection import (
-    define_function_signature_from_signature,
-    get_pretty_function_description,
-    get_signature,
-    nicerepr,
-    required_args,
-)
-from hypothesis.internal.validation import (
-    check_type,
-    check_valid_integer,
-    check_valid_interval,
-    check_valid_magnitude,
-    check_valid_size,
-    check_valid_sizes,
-    try_convert,
-)
-from hypothesis.strategies._internal import SearchStrategy, check_strategy
-from hypothesis.strategies._internal.collections import (
-    FixedAndOptionalKeysDictStrategy,
-    FixedKeysDictStrategy,
-    ListStrategy,
-    TupleStrategy,
-    UniqueListStrategy,
-    UniqueSampledListStrategy,
-    tuples,
-)
-from hypothesis.strategies._internal.deferred import DeferredStrategy
-from hypothesis.strategies._internal.functions import FunctionStrategy
-from hypothesis.strategies._internal.lazy import LazyStrategy
-from hypothesis.strategies._internal.misc import just, none, nothing
-from hypothesis.strategies._internal.numbers import (
-    IntegersStrategy,
-    Real,
-    floats,
-    integers,
-)
-from hypothesis.strategies._internal.recursive import RecursiveStrategy
-from hypothesis.strategies._internal.shared import SharedStrategy
-from hypothesis.strategies._internal.strategies import (
-    Ex,
-    SampledFromStrategy,
-    T,
-    one_of,
-)
-from hypothesis.strategies._internal.strings import (
-    FixedSizeBytes,
-    OneCharStringStrategy,
-    TextStrategy,
-)
-from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-from hypothesis.utils.conventions import infer, not_set
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from types import EllipsisType as InferType
-
-else:
-    InferType = type(Ellipsis)
-
-
-try:
-    from typing import Protocol
-except ImportError:  # < py3.8
-    Protocol = object  # type: ignoreassignment
-
-
-@cacheable
-@defines_strategy()
-def booleans() -> SearchStrategybool:
-    """Returns a strategy which generates instances of :class:`python:bool`.
-
-    Examples from this strategy will shrink towards ``False`` (i.e.
-    shrinking will replace ``True`` with ``False`` where possible).
-    """
-    return SampledFromStrategy(False, True, repr_="booleans()")
-
-
-@overload
-def sampled_from(elements: SequenceT) -> SearchStrategyT:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def sampled_from(elements: Typeenum.Enum) -> SearchStrategyAny:  # pragma: no cover
-    # `SearchStrategyEnum` is unreliable due to metaclass issues.
-    ...
-
-
-@overload  # noqa: F811
-def sampled_from(
-    elements: UnionTypeenum.Enum, SequenceAny
-) -> SearchStrategyAny:  # pragma: no cover
-    ...
-
-
-@defines_strategy(try_non_lazy=True)  # noqa: F811
-def sampled_from(
-    elements: UnionTypeenum.Enum, SequenceAny
-) -> SearchStrategyAny:
-    """Returns a strategy which generates any value present in ``elements``.
-
-    Note that as with :func:`~hypothesis.strategies.just`, values will not be
-    copied and thus you should be careful of using mutable data.
-
-    ``sampled_from`` supports ordered collections, as well as
-    :class:`~python:enum.Enum` objects.  :class:`~python:enum.Flag` objects
-    may also generate any combination of their members.
-
-    Examples from this strategy shrink by replacing them with values earlier in
-    the list. So e.g. ``sampled_from(10, 1)`` will shrink by trying to replace
-    1 values with 10, and ``sampled_from(1, 10)`` will shrink by trying to
-    replace 10 values with 1.
-
-    It is an error to sample from an empty sequence, because returning :func:`nothing`
-    makes it too easy to silently drop parts of compound strategies.  If you need
-    that behaviour, use ``sampled_from(seq) if seq else nothing()``.
-    """
-    values = check_sample(elements, "sampled_from")
-    if not values:
-        if (
-            isinstance(elements, type)
-            and issubclass(elements, enum.Enum)
-            and vars(elements).get("__annotations__")
-        ):
-            # See https://github.com/HypothesisWorks/hypothesis/issues/2923
-            raise InvalidArgument(
-                f"Cannot sample from {elements.__module__}.{elements.__name__} "
-                "because it contains no elements.  It does however have annotations, "
-                "so maybe you tried to write an enum as if it was a dataclass?"
-            )
-        raise InvalidArgument("Cannot sample from a length-zero sequence.")
-    if len(values) == 1:
-        return just(values0)
-    if isinstance(elements, type) and issubclass(elements, enum.Enum):
-        repr_ = f"sampled_from({elements.__module__}.{elements.__name__})"
-    else:
-        repr_ = f"sampled_from({elements!r})"
-    if isclass(elements) and issubclass(elements, enum.Flag):
-        # Combinations of enum.Flag members are also members.  We generate
-        # these dynamically, because static allocation takes O(2^n) memory.
-        # LazyStrategy is used for the ease of force_repr.
-        inner = sets(sampled_from(list(values)), min_size=1).map(
-            lambda s: reduce(operator.or_, s)
-        )
-        return LazyStrategy(lambda: inner, args=, kwargs={}, force_repr=repr_)
-    return SampledFromStrategy(values, repr_)
-
-
-def identity(x):
-    return x
-
-
-@cacheable
-@defines_strategy()
-def lists(
-    elements: SearchStrategyEx,
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-    unique_by: Union
-        None,
-        CallableEx, Hashable,
-        TupleCallableEx, Hashable, ...,
-     = None,
-    unique: bool = False,
-) -> SearchStrategyListEx:
-    """Returns a list containing values drawn from elements with length in the
-    interval min_size, max_size (no bounds in that direction if these are
-    None). If max_size is 0, only the empty list will be drawn.
-
-    If ``unique`` is True (or something that evaluates to True), we compare direct
-    object equality, as if unique_by was ``lambda x: x``. This comparison only
-    works for hashable types.
-
-    If ``unique_by`` is not None it must be a callable or tuple of callables
-    returning a hashable type when given a value drawn from elements. The
-    resulting list will satisfy the condition that for ``i`` != ``j``,
-    ``unique_by(resulti)`` != ``unique_by(resultj)``.
-
-    If ``unique_by`` is a tuple of callables the uniqueness will be respective
-    to each callable.
-
-    For example, the following will produce two columns of integers with both
-    columns being unique respectively.
-
-    .. code-block:: pycon
-
-        >>> twoints = st.tuples(st.integers(), st.integers())
-        >>> st.lists(twoints, unique_by=(lambda x: x0, lambda x: x1))
-
-    Examples from this strategy shrink by trying to remove elements from the
-    list, and by shrinking each individual element of the list.
-    """
-    check_valid_sizes(min_size, max_size)
-    check_strategy(elements, "elements")
-    if unique:
-        if unique_by is not None:
-            raise InvalidArgument(
-                "cannot specify both unique and unique_by "
-                "(you probably only want to set unique_by)"
-            )
-        else:
-            unique_by = identity
-
-    if max_size == 0:
-        return builds(list)
-    if unique_by is not None:
-        if not (callable(unique_by) or isinstance(unique_by, tuple)):
-            raise InvalidArgument(
-                f"unique_by={unique_by!r} is not a callable or tuple of callables"
-            )
-        if callable(unique_by):
-            unique_by = (unique_by,)
-        if len(unique_by) == 0:
-            raise InvalidArgument("unique_by is empty")
-        for i, f in enumerate(unique_by):
-            if not callable(f):
-                raise InvalidArgument(f"unique_by{i}={f!r} is not a callable")
-        # Note that lazy strategies automatically unwrap when passed to a defines_strategy
-        # function.
-        tuple_suffixes = None
-        if (
-            # We're generating a list of tuples unique by the first element, perhaps
-            # via st.dictionaries(), and this will be more efficient if we rearrange
-            # our strategy somewhat to draw the first element then draw add the rest.
-            isinstance(elements, TupleStrategy)
-            and len(elements.element_strategies) >= 1
-            and len(unique_by) == 1
-            and (
-                # Introspection for either `itemgetter(0)`, or `lambda x: x0`
-                isinstance(unique_by0, operator.itemgetter)
-                and repr(unique_by0) == "operator.itemgetter(0)"
-                or isinstance(unique_by0, FunctionType)
-                and re.fullmatch(
-                    get_pretty_function_description(unique_by0),
-                    r"lambda (a-z+): \1\0\",
-                )
-            )
-        ):
-            unique_by = (identity,)
-            tuple_suffixes = TupleStrategy(elements.element_strategies1:)
-            elements = elements.element_strategies0
-
-        # UniqueSampledListStrategy offers a substantial performance improvement for
-        # unique arrays with few possible elements, e.g. of eight-bit integer types.
-        if (
-            isinstance(elements, IntegersStrategy)
-            and None not in (elements.start, elements.end)
-            and (elements.end - elements.start) <= 255
-        ):
-            elements = SampledFromStrategy(
-                sorted(range(elements.start, elements.end + 1), key=abs)
-                if elements.end < 0 or elements.start > 0
-                else list(range(0, elements.end + 1))
-                + list(range(-1, elements.start - 1, -1))
-            )
-
-        if isinstance(elements, SampledFromStrategy):
-            element_count = len(elements.elements)
-            if min_size > element_count:
-                raise InvalidArgument(
-                    f"Cannot create a collection of min_size={min_size!r} unique "
-                    f"elements with values drawn from only {element_count} distinct "
-                    "elements"
-                )
-
-            if max_size is not None:
-                max_size = min(max_size, element_count)
-            else:
-                max_size = element_count
-
-            return UniqueSampledListStrategy(
-                elements=elements,
-                max_size=max_size,
-                min_size=min_size,
-                keys=unique_by,
-                tuple_suffixes=tuple_suffixes,
-            )
-
-        return UniqueListStrategy(
-            elements=elements,
-            max_size=max_size,
-            min_size=min_size,
-            keys=unique_by,
-            tuple_suffixes=tuple_suffixes,
-        )
-    return ListStrategy(elements, min_size=min_size, max_size=max_size)
-
-
-@cacheable
-@defines_strategy()
-def sets(
-    elements: SearchStrategyEx,
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> SearchStrategySetEx:
-    """This has the same behaviour as lists, but returns sets instead.
-
-    Note that Hypothesis cannot tell if values are drawn from elements
-    are hashable until running the test, so you can define a strategy
-    for sets of an unhashable type but it will fail at test time.
-
-    Examples from this strategy shrink by trying to remove elements from the
-    set, and by shrinking each individual element of the set.
-    """
-    return lists(
-        elements=elements, min_size=min_size, max_size=max_size, unique=True
-    ).map(set)
-
-
-@cacheable
-@defines_strategy()
-def frozensets(
-    elements: SearchStrategyEx,
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> SearchStrategyFrozenSetEx:
-    """This is identical to the sets function but instead returns
-    frozensets."""
-    return lists(
-        elements=elements, min_size=min_size, max_size=max_size, unique=True
-    ).map(frozenset)
-
-
-class PrettyIter:
-    def __init__(self, values):
-        self._values = values
-        self._iter = iter(self._values)
-
-    def __iter__(self):
-        return self._iter
-
-    def __next__(self):
-        return next(self._iter)
-
-    def __repr__(self):
-        return f"iter({self._values!r})"
-
-
-@defines_strategy()
-def iterables(
-    elements: SearchStrategyEx,
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-    unique_by: Union
-        None,
-        CallableEx, Hashable,
-        TupleCallableEx, Hashable, ...,
-     = None,
-    unique: bool = False,
-) -> SearchStrategyIterableEx:
-    """This has the same behaviour as lists, but returns iterables instead.
-
-    Some iterables cannot be indexed (e.g. sets) and some do not have a
-    fixed length (e.g. generators). This strategy produces iterators,
-    which cannot be indexed and do not have a fixed length. This ensures
-    that you do not accidentally depend on sequence behaviour.
-    """
-    return lists(
-        elements=elements,
-        min_size=min_size,
-        max_size=max_size,
-        unique_by=unique_by,
-        unique=unique,
-    ).map(PrettyIter)
-
-
-@defines_strategy()
-def fixed_dictionaries(
-    mapping: DictT, SearchStrategyEx,
-    *,
-    optional: OptionalDictT, SearchStrategyEx = None,
-) -> SearchStrategyDictT, Ex:
-    """Generates a dictionary of the same type as mapping with a fixed set of
-    keys mapping to strategies. ``mapping`` must be a dict subclass.
-
-    Generated values have all keys present in mapping, in iteration order,
-    with the corresponding values drawn from mappingkey.
-
-    If ``optional`` is passed, the generated value *may or may not* contain each
-    key from ``optional`` and a value drawn from the corresponding strategy.
-    Generated values may contain optional keys in an arbitrary order.
-
-    Examples from this strategy shrink by shrinking each individual value in
-    the generated dictionary, and omitting optional key-value pairs.
-    """
-    check_type(dict, mapping, "mapping")
-    for k, v in mapping.items():
-        check_strategy(v, f"mapping{k!r}")
-    if optional is not None:
-        check_type(dict, optional, "optional")
-        for k, v in optional.items():
-            check_strategy(v, f"optional{k!r}")
-        if type(mapping) != type(optional):
-            raise InvalidArgument(
-                "Got arguments of different types: mapping=%s, optional=%s"
-                % (nicerepr(type(mapping)), nicerepr(type(optional)))
-            )
-        if set(mapping) & set(optional):
-            raise InvalidArgument(
-                "The following keys were in both mapping and optional, "
-                f"which is invalid: {set(mapping) & set(optional)!r}"
-            )
-        return FixedAndOptionalKeysDictStrategy(mapping, optional)
-    return FixedKeysDictStrategy(mapping)
-
-
-@cacheable
-@defines_strategy()
-def dictionaries(
-    keys: SearchStrategyEx,
-    values: SearchStrategyT,
-    *,
-    dict_class: type = dict,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> SearchStrategyDictEx, T:
-    # Describing the exact dict_class to Mypy drops the key and value types,
-    # so we report DictK, V instead of MappingAny, Any for now.  Sorry!
-    """Generates dictionaries of type ``dict_class`` with keys drawn from the ``keys``
-    argument and values drawn from the ``values`` argument.
-
-    The size parameters have the same interpretation as for
-    :func:`~hypothesis.strategies.lists`.
-
-    Examples from this strategy shrink by trying to remove keys from the
-    generated dictionary, and by shrinking each generated key and value.
-    """
-    check_valid_sizes(min_size, max_size)
-    if max_size == 0:
-        return fixed_dictionaries(dict_class())
-    check_strategy(keys, "keys")
-    check_strategy(values, "values")
-
-    return lists(
-        tuples(keys, values),
-        min_size=min_size,
-        max_size=max_size,
-        unique_by=operator.itemgetter(0),
-    ).map(dict_class)
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def characters(
-    *,
-    whitelist_categories: OptionalSequencestr = None,
-    blacklist_categories: OptionalSequencestr = None,
-    blacklist_characters: OptionalSequencestr = None,
-    min_codepoint: Optionalint = None,
-    max_codepoint: Optionalint = None,
-    whitelist_characters: OptionalSequencestr = None,
-) -> SearchStrategystr:
-    r"""Generates characters, length-one :class:`python:str`\ ings,
-    following specified filtering rules.
-
-    - When no filtering rules are specified, any character can be produced.
-    - If ``min_codepoint`` or ``max_codepoint`` is specified, then only
-      characters having a codepoint in that range will be produced.
-    - If ``whitelist_categories`` is specified, then only characters from those
-      Unicode categories will be produced. This is a further restriction,
-      characters must also satisfy ``min_codepoint`` and ``max_codepoint``.
-    - If ``blacklist_categories`` is specified, then any character from those
-      categories will not be produced.  Any overlap between
-      ``whitelist_categories`` and ``blacklist_categories`` will raise an
-      exception, as each character can only belong to a single class.
-    - If ``whitelist_characters`` is specified, then any additional characters
-      in that list will also be produced.
-    - If ``blacklist_characters`` is specified, then any characters in
-      that list will be not be produced. Any overlap between
-      ``whitelist_characters`` and ``blacklist_characters`` will raise an
-      exception.
-
-    The ``_codepoint`` arguments must be integers between zero and
-    :obj:`python:sys.maxunicode`.  The ``_characters`` arguments must be
-    collections of length-one unicode strings, such as a unicode string.
-
-    The ``_categories`` arguments must be used to specify either the
-    one-letter Unicode major category or the two-letter Unicode
-    `general category`_.  For example, ``('Nd', 'Lu')`` signifies "Number,
-    decimal digit" and "Letter, uppercase".  A single letter ('major category')
-    can be given to match all corresponding categories, for example ``'P'``
-    for characters in any punctuation category.
-
-    .. _general category: https://wikipedia.org/wiki/Unicode_character_property
-
-    Examples from this strategy shrink towards the codepoint for ``'0'``,
-    or the first allowable codepoint after it if ``'0'`` is excluded.
-    """
-    check_valid_size(min_codepoint, "min_codepoint")
-    check_valid_size(max_codepoint, "max_codepoint")
-    check_valid_interval(min_codepoint, max_codepoint, "min_codepoint", "max_codepoint")
-    if (
-        min_codepoint is None
-        and max_codepoint is None
-        and whitelist_categories is None
-        and blacklist_categories is None
-        and whitelist_characters is not None
-    ):
-        raise InvalidArgument(
-            "Nothing is excluded by other arguments, so passing only "
-            f"whitelist_characters={whitelist_characters!r} would have no effect.  "
-            "Also pass whitelist_categories=(), or use "
-            f"sampled_from({whitelist_characters!r}) instead."
-        )
-    blacklist_characters = blacklist_characters or ""
-    whitelist_characters = whitelist_characters or ""
-    overlap = set(blacklist_characters).intersection(whitelist_characters)
-    if overlap:
-        raise InvalidArgument(
-            f"Characters {sorted(overlap)!r} are present in both "
-            f"whitelist_characters={whitelist_characters!r}, and "
-            f"blacklist_characters={blacklist_characters!r}"
-        )
-    blacklist_categories = as_general_categories(
-        blacklist_categories, "blacklist_categories"
-    )
-    if (
-        whitelist_categories is not None
-        and not whitelist_categories
-        and not whitelist_characters
-    ):
-        raise InvalidArgument(
-            "When whitelist_categories is an empty collection and there are "
-            "no characters specified in whitelist_characters, nothing can "
-            "be generated by the characters() strategy."
-        )
-    whitelist_categories = as_general_categories(
-        whitelist_categories, "whitelist_categories"
-    )
-    both_cats = set(blacklist_categories or ()).intersection(whitelist_categories or ())
-    if both_cats:
-        raise InvalidArgument(
-            f"Categories {sorted(both_cats)!r} are present in both "
-            f"whitelist_categories={whitelist_categories!r}, and "
-            f"blacklist_categories={blacklist_categories!r}"
-        )
-
-    return OneCharStringStrategy(
-        whitelist_categories=whitelist_categories,
-        blacklist_categories=blacklist_categories,
-        blacklist_characters=blacklist_characters,
-        min_codepoint=min_codepoint,
-        max_codepoint=max_codepoint,
-        whitelist_characters=whitelist_characters,
-    )
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def text(
-    alphabet: UnionSequencestr, SearchStrategystr = characters(
-        blacklist_categories=("Cs",)
-    ),
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> SearchStrategystr:
-    """Generates strings with characters drawn from ``alphabet``, which should
-    be a collection of length one strings or a strategy generating such strings.
-
-    The default alphabet strategy can generate the full unicode range but
-    excludes surrogate characters because they are invalid in the UTF-8
-    encoding.  You can use :func:`~hypothesis.strategies.characters` without
-    arguments to find surrogate-related bugs such as :bpo:`34454`.
-
-    ``min_size`` and ``max_size`` have the usual interpretations.
-    Note that Python measures string length by counting codepoints: U+00C5
-    ``Å`` is a single character, while U+0041 U+030A ``Å`` is two - the ``A``,
-    and a combining ring above.
-
-    Examples from this strategy shrink towards shorter strings, and with the
-    characters in the text shrinking as per the alphabet strategy.
-    This strategy does not :func:`~python:unicodedata.normalize` examples,
-    so generated strings may be in any or none of the 'normal forms'.
-    """
-    check_valid_sizes(min_size, max_size)
-    if isinstance(alphabet, SearchStrategy):
-        char_strategy = alphabet
-    else:
-        non_string = c for c in alphabet if not isinstance(c, str)
-        if non_string:
-            raise InvalidArgument(
-                "The following elements in alphabet are not unicode "
-                f"strings:  {non_string!r}"
-            )
-        not_one_char = c for c in alphabet if len(c) != 1
-        if not_one_char:
-            raise InvalidArgument(
-                "The following elements in alphabet are not of length one, "
-                f"which leads to violation of size constraints:  {not_one_char!r}"
-            )
-        char_strategy = (
-            characters(whitelist_categories=(), whitelist_characters=alphabet)
-            if alphabet
-            else nothing()
-        )
-    if (max_size == 0 or char_strategy.is_empty) and not min_size:
-        return just("")
-    return TextStrategy(char_strategy, min_size=min_size, max_size=max_size)
-
-
-@cacheable
-@defines_strategy()
-def from_regex(
-    regex: UnionAnyStr, PatternAnyStr, *, fullmatch: bool = False
-) -> SearchStrategyAnyStr:
-    r"""Generates strings that contain a match for the given regex (i.e. ones
-    for which :func:`python:re.search` will return a non-None result).
-
-    ``regex`` may be a pattern or :func:`compiled regex <python:re.compile>`.
-    Both byte-strings and unicode strings are supported, and will generate
-    examples of the same type.
-
-    You can use regex flags such as :obj:`python:re.IGNORECASE` or
-    :obj:`python:re.DOTALL` to control generation. Flags can be passed either
-    in compiled regex or inside the pattern with a ``(?iLmsux)`` group.
-
-    Some regular expressions are only partly supported - the underlying
-    strategy checks local matching and relies on filtering to resolve
-    context-dependent expressions.  Using too many of these constructs may
-    cause health-check errors as too many examples are filtered out. This
-    mainly includes (positive or negative) lookahead and lookbehind groups.
-
-    If you want the generated string to match the whole regex you should use
-    boundary markers. So e.g. ``r"\A.\Z"`` will return a single character
-    string, while ``"."`` will return any string, and ``r"\A.$"`` will return
-    a single character optionally followed by a ``"\n"``.
-    Alternatively, passing ``fullmatch=True`` will ensure that the whole
-    string is a match, as if you had used the ``\A`` and ``\Z`` markers.
-
-    Examples from this strategy shrink towards shorter strings and lower
-    character values, with exact behaviour that may depend on the pattern.
-    """
-    check_type(bool, fullmatch, "fullmatch")
-    # TODO: We would like to move this to the top level, but pending some major
-    # refactoring it's hard to do without creating circular imports.
-    from hypothesis.strategies._internal.regex import regex_strategy
-
-    return regex_strategy(regex, fullmatch)
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def binary(
-    *,
-    min_size: int = 0,
-    max_size: Optionalint = None,
-) -> SearchStrategybytes:
-    """Generates :class:`python:bytes`.
-
-    The generated :class:`python:bytes` will have a length of at least ``min_size``
-    and at most ``max_size``.  If ``max_size`` is None there is no upper limit.
-
-    Examples from this strategy shrink towards smaller strings and lower byte
-    values.
-    """
-    check_valid_sizes(min_size, max_size)
-    if min_size == max_size:
-        return FixedSizeBytes(min_size)
-    return lists(
-        integers(min_value=0, max_value=255), min_size=min_size, max_size=max_size
-    ).map(bytes)
-
-
-@cacheable
-@defines_strategy()
-def randoms(
-    *,
-    note_method_calls: bool = False,
-    use_true_random: bool = False,
-) -> SearchStrategyrandom.Random:
-    """Generates instances of ``random.Random``. The generated Random instances
-    are of a special HypothesisRandom subclass.
-
-    - If ``note_method_calls`` is set to ``True``, Hypothesis will print the
-      randomly drawn values in any falsifying test case. This can be helpful
-      for debugging the behaviour of randomized algorithms.
-    - If ``use_true_random`` is set to ``True`` then values will be drawn from
-      their usual distribution, otherwise they will actually be Hypothesis
-      generated values (and will be shrunk accordingly for any failing test
-      case). Setting ``use_true_random=False`` will tend to expose bugs that
-      would occur with very low probability when it is set to True, and this
-      flag should only be set to True when your code relies on the distribution
-      of values for correctness.
-    """
-    check_type(bool, note_method_calls, "note_method_calls")
-    check_type(bool, use_true_random, "use_true_random")
-
-    from hypothesis.strategies._internal.random import RandomStrategy
-
-    return RandomStrategy(
-        use_true_random=use_true_random, note_method_calls=note_method_calls
-    )
-
-
-class RandomSeeder:
-    def __init__(self, seed):
-        self.seed = seed
-
-    def __repr__(self):
-        return f"RandomSeeder({self.seed!r})"
-
-
-class RandomModule(SearchStrategy):
-    def do_draw(self, data):
-        # It would be unsafe to do run this method more than once per test case,
-        # because cleanup() runs tasks in FIFO order (at time of writing!).
-        # Fortunately, the random_module() strategy wraps us in shared(), so
-        # it's cached for all but the first of any number of calls.
-        seed = data.draw(integers(0, 2**32 - 1))
-        seed_all, restore_all = get_seeder_and_restorer(seed)
-        seed_all()
-        cleanup(restore_all)
-        return RandomSeeder(seed)
-
-
-@cacheable
-@defines_strategy()
-def random_module() -> SearchStrategyRandomSeeder:
-    """The Hypothesis engine handles PRNG state for the stdlib and Numpy random
-    modules internally, always seeding them to zero and restoring the previous
-    state after the test.
-
-    If having a fixed seed would unacceptably weaken your tests, and you
-    cannot use a ``random.Random`` instance provided by
-    :func:`~hypothesis.strategies.randoms`, this strategy calls
-    :func:`python:random.seed` with an arbitrary integer and passes you
-    an opaque object whose repr displays the seed value for debugging.
-    If ``numpy.random`` is available, that state is also managed.
-
-    Examples from these strategy shrink to seeds closer to zero.
-    """
-    return shared(RandomModule(), key="hypothesis.strategies.random_module()")
-
-
-class BuildsStrategy(SearchStrategy):
-    def __init__(self, target, args, kwargs):
-        self.target = target
-        self.args = args
-        self.kwargs = kwargs
-
-    def do_draw(self, data):
-        try:
-            return self.target(
-                *(data.draw(a) for a in self.args),
-                **{k: data.draw(v) for k, v in self.kwargs.items()},
-            )
-        except TypeError as err:
-            if (
-                isinstance(self.target, type)
-                and issubclass(self.target, enum.Enum)
-                and not (self.args or self.kwargs)
-            ):
-                name = self.target.__module__ + "." + self.target.__qualname__
-                raise InvalidArgument(
-                    f"Calling {name} with no arguments raised an error - "
-                    f"try using sampled_from({name}) instead of builds({name})"
-                ) from err
-            if not (self.args or self.kwargs):
-                from .types import is_a_new_type, is_generic_type
-
-                if is_a_new_type(self.target) or is_generic_type(self.target):
-                    raise InvalidArgument(
-                        f"Calling {self.target!r} with no arguments raised an "
-                        f"error - try using from_type({self.target!r}) instead "
-                        f"of builds({self.target!r})"
-                    ) from err
-            if getattr(self.target, "__no_type_check__", None) is True:
-                # Note: could use PEP-678 __notes__ here.  Migrate over once we're
-                # using an `exceptiongroup` backport with support for that.
-                raise TypeError(
-                    "This might be because the @no_type_check decorator prevented "
-                    "Hypothesis from inferring a strategy for some required arguments."
-                ) from err
-            raise
-
-    def validate(self):
-        tuples(*self.args).validate()
-        fixed_dictionaries(self.kwargs).validate()
-
-    def __repr__(self):
-        bits = get_pretty_function_description(self.target)
-        bits.extend(map(repr, self.args))
-        bits.extend(f"{k}={v!r}" for k, v in self.kwargs.items())
-        return f"builds({', '.join(bits)})"
-
-
-# The ideal signature builds(target, /, *args, **kwargs) is unfortunately a
-# SyntaxError before Python 3.8 so we emulate it with manual argument unpacking.
-# Note that for the benefit of documentation and introspection tools, we set the
-# __signature__ attribute to show the semantic rather than actual signature.
-@cacheable
-@defines_strategy()
-def builds(
-    *callable_and_args: UnionCallable..., Ex, SearchStrategyAny,
-    **kwargs: UnionSearchStrategyAny, InferType,
-) -> SearchStrategyEx:
-    """Generates values by drawing from ``args`` and ``kwargs`` and passing
-    them to the callable (provided as the first positional argument) in the
-    appropriate argument position.
-
-    e.g. ``builds(target, integers(), flag=booleans())`` would draw an
-    integer ``i`` and a boolean ``b`` and call ``target(i, flag=b)``.
-
-    If the callable has type annotations, they will be used to infer a strategy
-    for required arguments that were not passed to builds.  You can also tell
-    builds to infer a strategy for an optional argument by passing ``...``
-    (:obj:`python:Ellipsis`) as a keyword argument to builds, instead of a strategy for
-    that argument to the callable.
-
-    If the callable is a class defined with :pypi:`attrs`, missing required
-    arguments will be inferred from the attribute on a best-effort basis,
-    e.g. by checking :ref:`attrs standard validators <attrs:api_validators>`.
-    Dataclasses are handled natively by the inference from type hints.
-
-    Examples from this strategy shrink by shrinking the argument values to
-    the callable.
-    """
-    if not callable_and_args:
-        raise InvalidArgument(  # pragma: no cover
-            "builds() must be passed a callable as the first positional "
-            "argument, but no positional arguments were given."
-        )
-    target, args = callable_and_args0, callable_and_args1:
-    if not callable(target):
-        raise InvalidArgument(
-            "The first positional argument to builds() must be a callable "
-            "target to construct."
-        )
-
-    if infer in args:
-        # Avoid an implementation nightmare juggling tuples and worse things
-        raise InvalidArgument(
-            "... was passed as a positional argument to "
-            "builds(), but is only allowed as a keyword arg"
-        )
-    required = required_args(target, args, kwargs)
-    to_infer = {k for k, v in kwargs.items() if v is infer}
-    if required or to_infer:
-        if isinstance(target, type) and attr.has(target):
-            # Use our custom introspection for attrs classes
-            from hypothesis.strategies._internal.attrs import from_attrs
-
-            return from_attrs(target, args, kwargs, required | to_infer)
-        # Otherwise, try using type hints
-        hints = get_type_hints(target)
-        if to_infer - set(hints):
-            badargs = ", ".join(sorted(to_infer - set(hints)))
-            raise InvalidArgument(
-                f"passed ... for {badargs}, but we cannot infer a strategy "
-                "because these arguments have no type annotation"
-            )
-        infer_for = {k: v for k, v in hints.items() if k in (required | to_infer)}
-        if infer_for:
-            from hypothesis.strategies._internal.types import _global_type_lookup
-
-            for kw, t in infer_for.items():
-                if (
-                    getattr(t, "__module__", None) in ("builtins", "typing")
-                    or t in _global_type_lookup
-                ):
-                    kwargskw = from_type(t)
-                else:
-                    # We defer resolution of these type annotations so that the obvious
-                    # approach to registering recursive types just works.  See
-                    # https://github.com/HypothesisWorks/hypothesis/issues/3026
-                    kwargskw = deferred(lambda t=t: from_type(t))  # type: ignore
-    return BuildsStrategy(target, args, kwargs)
-
-
-if sys.version_info:2 >= (3, 8):  # pragma: no branch
-    # See notes above definition - this signature is compatible and better
-    # matches the semantics of the function.  Great for documentation!
-    sig = signature(builds)
-    args, kwargs = sig.parameters.values()
-    builds = define_function_signature_from_signature(
-        name=builds.__name__,
-        docstring=builds.__doc__,
-        signature=sig.replace(
-            parameters=
-                Parameter(
-                    name="target",
-                    kind=Parameter.POSITIONAL_ONLY,
-                    annotation=Callable..., Ex,
-                ),
-                args.replace(name="args", annotation=SearchStrategyAny),
-                kwargs,
-            
-        ),
-    )(builds)
-
-
-@cacheable
-@defines_strategy(never_lazy=True)
-def from_type(thing: TypeEx) -> SearchStrategyEx:
-    """Looks up the appropriate search strategy for the given type.
-
-    ``from_type`` is used internally to fill in missing arguments to
-    :func:`~hypothesis.strategies.builds` and can be used interactively
-    to explore what strategies are available or to debug type resolution.
-
-    You can use :func:`~hypothesis.strategies.register_type_strategy` to
-    handle your custom types, or to globally redefine certain strategies -
-    for example excluding NaN from floats, or use timezone-aware instead of
-    naive time and datetime strategies.
-
-    The resolution logic may be changed in a future version, but currently
-    tries these five options:
-
-    1. If ``thing`` is in the default lookup mapping or user-registered lookup,
-       return the corresponding strategy.  The default lookup covers all types
-       with Hypothesis strategies, including extras where possible.
-    2. If ``thing`` is from the :mod:`python:typing` module, return the
-       corresponding strategy (special logic).
-    3. If ``thing`` has one or more subtypes in the merged lookup, return
-       the union of the strategies for those types that are not subtypes of
-       other elements in the lookup.
-    4. Finally, if ``thing`` has type annotations for all required arguments,
-       and is not an abstract class, it is resolved via
-       :func:`~hypothesis.strategies.builds`.
-    5. Because :mod:`abstract types <python:abc>` cannot be instantiated,
-       we treat abstract types as the union of their concrete subclasses.
-       Note that this lookup works via inheritance but not via
-       :obj:`~python:abc.ABCMeta.register`, so you may still need to use
-       :func:`~hypothesis.strategies.register_type_strategy`.
-
-    There is a valuable recipe for leveraging ``from_type()`` to generate
-    "everything except" values from a specified type. I.e.
-
-    .. code-block:: python
-
-        def everything_except(excluded_types):
-            return (
-                from_type(type)
-                .flatmap(from_type)
-                .filter(lambda x: not isinstance(x, excluded_types))
-            )
-
-    For example, ``everything_except(int)`` returns a strategy that can
-    generate anything that ``from_type()`` can ever generate, except for
-    instances of :class:`python:int`, and excluding instances of types
-    added via :func:`~hypothesis.strategies.register_type_strategy`.
-
-    This is useful when writing tests which check that invalid input is
-    rejected in a certain way.
-    """
-    # This tricky little dance is because we want to show the repr of the actual
-    # underlying strategy wherever possible, as a form of user education, but
-    # would prefer to fall back to the default "from_type(...)" repr instead of
-    # "deferred(...)" for recursive types or invalid arguments.
-    try:
-        return _from_type(thing)
-    except Exception:
-        return LazyStrategy(
-            lambda thing: deferred(lambda: _from_type(thing)),
-            (thing,),
-            {},
-            force_repr=f"from_type({thing!r})",
-        )
-
-
-def _from_type(thing: TypeEx) -> SearchStrategyEx:
-    # TODO: We would like to move this to the top level, but pending some major
-    # refactoring it's hard to do without creating circular imports.
-    from hypothesis.strategies._internal import types
-
-    def as_strategy(strat_or_callable, thing, final=True):
-        # User-provided strategies need some validation, and callables even more
-        # of it.  We do this in three places, hence the helper function
-        if not isinstance(strat_or_callable, SearchStrategy):
-            assert callable(strat_or_callable)  # Validated in register_type_strategy
-            strategy = strat_or_callable(thing)
-        else:
-            strategy = strat_or_callable
-        if not isinstance(strategy, SearchStrategy):
-            raise ResolutionFailed(
-                f"Error: {thing} was registered for {nicerepr(strat_or_callable)}, "
-                f"but returned non-strategy {strategy!r}"
-            )
-        if strategy.is_empty:
-            raise ResolutionFailed(f"Error: {thing!r} resolved to an empty strategy")
-        return strategy
-
-    if not isinstance(thing, type):
-        if types.is_a_new_type(thing):
-            # Check if we have an explicitly registered strategy for this thing,
-            # resolve it so, and otherwise resolve as for the base type.
-            if thing in types._global_type_lookup:
-                return as_strategy(types._global_type_lookupthing, thing)
-            return from_type(thing.__supertype__)
-        # Unions are not instances of `type` - but we still want to resolve them!
-        if types.is_a_union(thing):
-            args = sorted(thing.__args__, key=types.type_sorting_key)
-            return one_of(from_type(t) for t in args)
-    if not types.is_a_type(thing):
-        if isinstance(thing, str):
-            # See https://github.com/HypothesisWorks/hypothesis/issues/3016
-            raise InvalidArgument(
-                f"Got {thing!r} as a type annotation, but the forward-reference "
-                "could not be resolved from a string to a type.  Consider using "
-                "`from __future__ import annotations` instead of forward-reference "
-                "strings."
-            )
-        raise InvalidArgument(f"thing={thing!r} must be a type")  # pragma: no cover
-    if thing in types.NON_RUNTIME_TYPES:
-        # Some code like `st.from_type(TypeAlias)` does not make sense.
-        # Because there are types in python that do not exist in runtime.
-        raise InvalidArgument(
-            f"Could not resolve {thing!r} to a strategy, "
-            f"because there is no such thing as a runtime instance of {thing!r}"
-        )
-    # Now that we know `thing` is a type, the first step is to check for an
-    # explicitly registered strategy. This is the best (and hopefully most
-    # common) way to resolve a type to a strategy.  Note that the value in the
-    # lookup may be a strategy or a function from type -> strategy; and we
-    # convert empty results into an explicit error.
-    try:
-        if thing in types._global_type_lookup:
-            return as_strategy(types._global_type_lookupthing, thing)
-    except TypeError:  # pragma: no cover
-        # This is due to a bizarre divergence in behaviour under Python 3.9.0:
-        # typing.Callable, foo has __args__ = (foo,) but collections.abc.Callable
-        # has __args__ = (, foo); and as a result is non-hashable.
-        pass
-    if (
-        hasattr(typing, "_TypedDictMeta")
-        and type(thing) is typing._TypedDictMeta  # type: ignore
-        or hasattr(types.typing_extensions, "_TypedDictMeta")  # type: ignore
-        and type(thing) is types.typing_extensions._TypedDictMeta  # type: ignore
-    ):  # pragma: no cover
-        # The __optional_keys__ attribute may or may not be present, but if there's no
-        # way to tell and we just have to assume that everything is required.
-        # See https://github.com/python/cpython/pull/17214 for details.
-        optional = set(getattr(thing, "__optional_keys__", ()))
-        anns = {}
-        for k, v in get_type_hints(thing).items():
-            origin = getattr(v, "__origin__", None)
-            if origin in types.RequiredTypes + types.NotRequiredTypes:
-                if origin in types.NotRequiredTypes:
-                    optional.add(k)
-                else:
-                    optional.discard(k)
-                try:
-                    v = v.__args__0
-                except IndexError:
-                    raise InvalidArgument(
-                        f"`{k}: {v.__name__}` is not a valid type annotation"
-                    ) from None
-            annsk = from_type(v)
-        if (
-            (not anns)
-            and thing.__annotations__
-            and ".<locals>." in getattr(thing, "__qualname__", "")
-        ):
-            raise InvalidArgument("Failed to retrieve type annotations for local type")
-        return fixed_dictionaries(  # type: ignore
-            mapping={k: v for k, v in anns.items() if k not in optional},
-            optional={k: v for k, v in anns.items() if k in optional},
-        )
-    # We also have a special case for TypeVars.
-    # They are represented as instances like `~T` when they come here.
-    # We need to work with their type instead.
-    if isinstance(thing, TypeVar) and type(thing) in types._global_type_lookup:
-        return as_strategy(types._global_type_lookuptype(thing), thing)
-    # If there's no explicitly registered strategy, maybe a subtype of thing
-    # is registered - if so, we can resolve it to the subclass strategy.
-    # We'll start by checking if thing is from from the typing module,
-    # because there are several special cases that don't play well with
-    # subclass and instance checks.
-    if isinstance(thing, types.typing_root_type) or (
-        sys.version_info:2 >= (3, 9)
-        and isinstance(getattr(thing, "__origin__", None), type)
-        and getattr(thing, "__args__", None)
-    ):
-        return types.from_typing_type(thing)
-    # If it's not from the typing module, we get all registered types that are
-    # a subclass of `thing` and are not themselves a subtype of any other such
-    # type.  For example, `Number -> integers() | floats()`, but bools() is
-    # not included because bool is a subclass of int as well as Number.
-    strategies = 
-        as_strategy(v, thing, final=False)
-        for k, v in sorted(types._global_type_lookup.items(), key=repr)
-        if isinstance(k, type)
-        and issubclass(k, thing)
-        and sum(types.try_issubclass(k, typ) for typ in types._global_type_lookup) == 1
-    
-    if any(not s.is_empty for s in strategies):
-        return one_of(strategies)
-    # If we don't have a strategy registered for this type or any subtype, we
-    # may be able to fall back on type annotations.
-    if issubclass(thing, enum.Enum):
-        return sampled_from(thing)
-
-    # Finally, try to build an instance by calling the type object.  Unlike builds(),
-    # this block *does* try to infer strategies for arguments with default values.
-    # That's because of the semantic different; builds() -> "call this with ..."
-    # so we only infer when *not* doing so would be an error; from_type() -> "give
-    # me arbitrary instances" so the greater variety is acceptable.
-    # And if it's *too* varied, express your opinions with register_type_strategy()
-    if not isabstract(thing):
-        # If we know that builds(thing) will fail, give a better error message
-        required = required_args(thing)
-        if required and not (
-            required.issubset(get_type_hints(thing))
-            or attr.has(thing)
-            or is_typed_named_tuple(thing)  # weird enough that we have a specific check
-        ):
-            raise ResolutionFailed(
-                f"Could not resolve {thing!r} to a strategy; consider "
-                "using register_type_strategy"
-            )
-        try:
-            hints = get_type_hints(thing)
-            params = get_signature(thing).parameters
-        except Exception:
-            return builds(thing)
-        kwargs = {}
-        for k, p in params.items():
-            if (
-                k in hints
-                and k != "return"
-                and p.default is not Parameter.empty
-                and p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY)
-            ):
-                kwargsk = just(p.default) | _from_type(hintsk)
-        return builds(thing, **kwargs)
-    # And if it's an abstract type, we'll resolve to a union of subclasses instead.
-    subclasses = thing.__subclasses__()
-    if not subclasses:
-        raise ResolutionFailed(
-            f"Could not resolve {thing!r} to a strategy, because it is an abstract "
-            "type without any subclasses. Consider using register_type_strategy"
-        )
-    subclass_strategies = nothing()
-    for sc in subclasses:
-        try:
-            subclass_strategies |= _from_type(sc)
-        except Exception:
-            pass
-    if subclass_strategies.is_empty:
-        # We're unable to resolve subclasses now, but we might be able to later -
-        # so we'll just go back to the mixed distribution.
-        return sampled_from(subclasses).flatmap(from_type)
-    return subclass_strategies
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def fractions(
-    min_value: OptionalUnionReal, str = None,
-    max_value: OptionalUnionReal, str = None,
-    *,
-    max_denominator: Optionalint = None,
-) -> SearchStrategyFraction:
-    """Returns a strategy which generates Fractions.
-
-    If ``min_value`` is not None then all generated values are no less than
-    ``min_value``.  If ``max_value`` is not None then all generated values are no
-    greater than ``max_value``.  ``min_value`` and ``max_value`` may be anything accepted
-    by the :class:`~fractions.Fraction` constructor.
-
-    If ``max_denominator`` is not None then the denominator of any generated
-    values is no greater than ``max_denominator``. Note that ``max_denominator`` must
-    be None or a positive integer.
-
-    Examples from this strategy shrink towards smaller denominators, then
-    closer to zero.
-    """
-    min_value = try_convert(Fraction, min_value, "min_value")
-    max_value = try_convert(Fraction, max_value, "max_value")
-    # These assertions tell Mypy what happened in try_convert
-    assert min_value is None or isinstance(min_value, Fraction)
-    assert max_value is None or isinstance(max_value, Fraction)
-
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-    check_valid_integer(max_denominator, "max_denominator")
-
-    if max_denominator is not None:
-        if max_denominator < 1:
-            raise InvalidArgument(f"max_denominator={max_denominator!r} must be >= 1")
-        if min_value is not None and min_value.denominator > max_denominator:
-            raise InvalidArgument(
-                f"The min_value={min_value!r} has a denominator greater than the "
-                f"max_denominator={max_denominator!r}"
-            )
-        if max_value is not None and max_value.denominator > max_denominator:
-            raise InvalidArgument(
-                f"The max_value={max_value!r} has a denominator greater than the "
-                f"max_denominator={max_denominator!r}"
-            )
-
-    if min_value is not None and min_value == max_value:
-        return just(min_value)
-
-    def dm_func(denom):
-        """Take denom, construct numerator strategy, and build fraction."""
-        # Four cases of algebra to get integer bounds and scale factor.
-        min_num, max_num = None, None
-        if max_value is None and min_value is None:
-            pass
-        elif min_value is None:
-            max_num = denom * max_value.numerator
-            denom *= max_value.denominator
-        elif max_value is None:
-            min_num = denom * min_value.numerator
-            denom *= min_value.denominator
-        else:
-            low = min_value.numerator * max_value.denominator
-            high = max_value.numerator * min_value.denominator
-            scale = min_value.denominator * max_value.denominator
-            # After calculating our integer bounds and scale factor, we remove
-            # the gcd to avoid drawing more bytes for the example than needed.
-            # Note that `div` can be at most equal to `scale`.
-            div = math.gcd(scale, math.gcd(low, high))
-            min_num = denom * low // div
-            max_num = denom * high // div
-            denom *= scale // div
-
-        return builds(
-            Fraction, integers(min_value=min_num, max_value=max_num), just(denom)
-        )
-
-    if max_denominator is None:
-        return integers(min_value=1).flatmap(dm_func)
-
-    return (
-        integers(1, max_denominator)
-        .flatmap(dm_func)
-        .map(lambda f: f.limit_denominator(max_denominator))
-    )
-
-
-def _as_finite_decimal(
-    value: UnionReal, str, None, name: str, allow_infinity: Optionalbool
-) -> OptionalDecimal:
-    """Convert decimal bounds to decimals, carefully."""
-    assert name in ("min_value", "max_value")
-    if value is None:
-        return None
-    if not isinstance(value, Decimal):
-        with localcontext(Context()):  # ensure that default traps are enabled
-            value = try_convert(Decimal, value, name)
-    assert isinstance(value, Decimal)
-    if value.is_finite():
-        return value
-    if value.is_infinite() and (value < 0 if "min" in name else value > 0):
-        if allow_infinity or allow_infinity is None:
-            return None
-        raise InvalidArgument(
-            f"allow_infinity={allow_infinity!r}, but {name}={value!r}"
-        )
-    # This could be infinity, quiet NaN, or signalling NaN
-    raise InvalidArgument(f"Invalid {name}={value!r}")
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def decimals(
-    min_value: OptionalUnionReal, str = None,
-    max_value: OptionalUnionReal, str = None,
-    *,
-    allow_nan: Optionalbool = None,
-    allow_infinity: Optionalbool = None,
-    places: Optionalint = None,
-) -> SearchStrategyDecimal:
-    """Generates instances of :class:`python:decimal.Decimal`, which may be:
-
-    - A finite rational number, between ``min_value`` and ``max_value``.
-    - Not a Number, if ``allow_nan`` is True.  None means "allow NaN, unless
-      ``min_value`` and ``max_value`` are not None".
-    - Positive or negative infinity, if ``max_value`` and ``min_value``
-      respectively are None, and ``allow_infinity`` is not False.  None means
-      "allow infinity, unless excluded by the min and max values".
-
-    Note that where floats have one ``NaN`` value, Decimals have four: signed,
-    and either *quiet* or *signalling*.  See `the decimal module docs
-    <https://docs.python.org/3/library/decimal.html#special-values>`_ for
-    more information on special values.
-
-    If ``places`` is not None, all finite values drawn from the strategy will
-    have that number of digits after the decimal place.
-
-    Examples from this strategy do not have a well defined shrink order but
-    try to maximize human readability when shrinking.
-    """
-    # Convert min_value and max_value to Decimal values, and validate args
-    check_valid_integer(places, "places")
-    if places is not None and places < 0:
-        raise InvalidArgument(f"places={places!r} may not be negative")
-    min_value = _as_finite_decimal(min_value, "min_value", allow_infinity)
-    max_value = _as_finite_decimal(max_value, "max_value", allow_infinity)
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-    if allow_infinity and (None not in (min_value, max_value)):
-        raise InvalidArgument("Cannot allow infinity between finite bounds")
-    # Set up a strategy for finite decimals.  Note that both floating and
-    # fixed-point decimals require careful handling to remain isolated from
-    # any external precision context - in short, we always work out the
-    # required precision for lossless operation and use context methods.
-    if places is not None:
-        # Fixed-point decimals are basically integers with a scale factor
-        def ctx(val):
-            """Return a context in which this value is lossless."""
-            precision = ceil(math.log10(abs(val) or 1)) + places + 1
-            return Context(prec=max(precision, 1))
-
-        def int_to_decimal(val):
-            context = ctx(val)
-            return context.quantize(context.multiply(val, factor), factor)
-
-        factor = Decimal(10) ** -places
-        min_num, max_num = None, None
-        if min_value is not None:
-            min_num = ceil(ctx(min_value).divide(min_value, factor))
-        if max_value is not None:
-            max_num = floor(ctx(max_value).divide(max_value, factor))
-        if min_num is not None and max_num is not None and min_num > max_num:
-            raise InvalidArgument(
-                f"There are no decimals with {places} places between "
-                f"min_value={min_value!r} and max_value={max_value!r}"
-            )
-        strat = integers(min_num, max_num).map(int_to_decimal)
-    else:
-        # Otherwise, they're like fractions featuring a power of ten
-        def fraction_to_decimal(val):
-            precision = (
-                ceil(math.log10(abs(val.numerator) or 1) + math.log10(val.denominator))
-                + 1
-            )
-            return Context(prec=precision or 1).divide(
-                Decimal(val.numerator), val.denominator
-            )
-
-        strat = fractions(min_value, max_value).map(fraction_to_decimal)
-    # Compose with sampled_from for infinities and NaNs as appropriate
-    special: ListDecimal = 
-    if allow_nan or (allow_nan is None and (None in (min_value, max_value))):
-        special.extend(map(Decimal, ("NaN", "-NaN", "sNaN", "-sNaN")))
-    if allow_infinity or (allow_infinity is max_value is None):
-        special.append(Decimal("Infinity"))
-    if allow_infinity or (allow_infinity is min_value is None):
-        special.append(Decimal("-Infinity"))
-    return strat | (sampled_from(special) if special else nothing())
-
-
-@defines_strategy(never_lazy=True)
-def recursive(
-    base: SearchStrategyEx,
-    extend: CallableSearchStrategyAny, SearchStrategyT,
-    *,
-    max_leaves: int = 100,
-) -> SearchStrategyUnionT, Ex:
-    """base: A strategy to start from.
-
-    extend: A function which takes a strategy and returns a new strategy.
-
-    max_leaves: The maximum number of elements to be drawn from base on a given
-    run.
-
-    This returns a strategy ``S`` such that ``S = extend(base | S)``. That is,
-    values may be drawn from base, or from any strategy reachable by mixing
-    applications of | and extend.
-
-    An example may clarify: ``recursive(booleans(), lists)`` would return a
-    strategy that may return arbitrarily nested and mixed lists of booleans.
-    So e.g. ``False``, ``True``, ``False, ``, and ``True`` are
-    all valid values to be drawn from that strategy.
-
-    Examples from this strategy shrink by trying to reduce the amount of
-    recursion and by shrinking according to the shrinking behaviour of base
-    and the result of extend.
-
-    """
-
-    return RecursiveStrategy(base, extend, max_leaves)
-
-
-class PermutationStrategy(SearchStrategy):
-    def __init__(self, values):
-        self.values = values
-
-    def do_draw(self, data):
-        # Reversed Fisher-Yates shuffle: swap each element with itself or with
-        # a later element.  This shrinks i==j for each element, i.e. to no
-        # change.  We don't consider the last element as it's always a no-op.
-        result = list(self.values)
-        for i in range(len(result) - 1):
-            j = integer_range(data, i, len(result) - 1)
-            resulti, resultj = resultj, resulti
-        return result
-
-
-@defines_strategy()
-def permutations(values: SequenceT) -> SearchStrategyListT:
-    """Return a strategy which returns permutations of the ordered collection
-    ``values``.
-
-    Examples from this strategy shrink by trying to become closer to the
-    original order of values.
-    """
-    values = check_sample(values, "permutations")
-    if not values:
-        return builds(list)
-
-    return PermutationStrategy(values)
-
-
-class CompositeStrategy(SearchStrategy):
-    def __init__(self, definition, args, kwargs):
-        self.definition = definition
-        self.args = args
-        self.kwargs = kwargs
-
-    def do_draw(self, data):
-        return self.definition(data.draw, *self.args, **self.kwargs)
-
-    def calc_label(self):
-        return calc_label_from_cls(self.definition)
-
-
-class DrawFn(Protocol):
-    """This type only exists so that you can write type hints for functions
-    decorated with :func:`@composite <hypothesis.strategies.composite>`.
-
-    .. code-block:: python
-
-        @composite
-        def list_and_index(draw: DrawFn) -> Tupleint, str:
-            i = draw(integers())  # type inferred as 'int'
-            s = draw(text())  # type inferred as 'str'
-
-    """
-
-    def __init__(self):
-        raise TypeError("Protocols cannot be instantiated")  # pragma: no cover
-
-    # On Python 3.8+, Protocol overrides our signature for __init__,
-    # so we override it right back to make the docs look nice.
-    __signature__: Signature = Signature(parameters=)
-
-    # We define this as a callback protocol because a simple typing.Callable is
-    # insufficient to fully represent the interface, due to the optional `label`
-    # parameter.
-    def __call__(self, strategy: SearchStrategyEx, label: object = None) -> Ex:
-        raise NotImplementedError
-
-
-@cacheable
-def composite(f: Callable..., Ex) -> Callable..., SearchStrategyEx:
-    """Defines a strategy that is built out of potentially arbitrarily many
-    other strategies.
-
-    This is intended to be used as a decorator. See
-    :ref:`the full documentation for more details <composite-strategies>`
-    about how to use this function.
-
-    Examples from this strategy shrink by shrinking the output of each draw
-    call.
-    """
-    if isinstance(f, (classmethod, staticmethod)):
-        special_method = type(f)
-        f = f.__func__
-    else:
-        special_method = None
-
-    sig = get_signature(f)
-    params = tuple(sig.parameters.values())
-
-    if not (params and "POSITIONAL" in params0.kind.name):
-        raise InvalidArgument(
-            "Functions wrapped with composite must take at least one "
-            "positional argument."
-        )
-    if params0.default is not sig.empty:
-        raise InvalidArgument("A default value for initial argument will never be used")
-    if params0.kind.name != "VAR_POSITIONAL":
-        params = params1:
-    newsig = sig.replace(
-        parameters=params,
-        return_annotation=SearchStrategy
-        if sig.return_annotation is sig.empty
-        else SearchStrategysig.return_annotation,  # type: ignore
-    )
-
-    @defines_strategy()
-    @define_function_signature_from_signature(f.__name__, f.__doc__, newsig)
-    def accept(*args, **kwargs):
-        return CompositeStrategy(f, args, kwargs)
-
-    accept.__module__ = f.__module__
-    accept.__signature__ = newsig
-    if special_method is not None:
-        return special_method(accept)
-    return accept
-
-
-@defines_strategy(force_reusable_values=True)
-@cacheable
-def complex_numbers(
-    *,
-    min_magnitude: Real = 0,
-    max_magnitude: OptionalReal = None,
-    allow_infinity: Optionalbool = None,
-    allow_nan: Optionalbool = None,
-) -> SearchStrategycomplex:
-    """Returns a strategy that generates complex numbers.
-
-    This strategy draws complex numbers with constrained magnitudes.
-    The ``min_magnitude`` and ``max_magnitude`` parameters should be
-    non-negative :class:`~python:numbers.Real` numbers; a value
-    of ``None`` corresponds an infinite upper bound.
-
-    If ``min_magnitude`` is nonzero or ``max_magnitude`` is finite, it
-    is an error to enable ``allow_nan``.  If ``max_magnitude`` is finite,
-    it is an error to enable ``allow_infinity``.
-
-    The magnitude constraints are respected up to a relative error
-    of (around) floating-point epsilon, due to implementation via
-    the system ``sqrt`` function.
-
-    Examples from this strategy shrink by shrinking their real and
-    imaginary parts, as :func:`~hypothesis.strategies.floats`.
-
-    If you need to generate complex numbers with particular real and
-    imaginary parts or relationships between parts, consider using
-    :func:`builds(complex, ...) <hypothesis.strategies.builds>` or
-    :func:`@composite <hypothesis.strategies.composite>` respectively.
-    """
-    check_valid_magnitude(min_magnitude, "min_magnitude")
-    check_valid_magnitude(max_magnitude, "max_magnitude")
-    check_valid_interval(min_magnitude, max_magnitude, "min_magnitude", "max_magnitude")
-    if max_magnitude == math.inf:
-        max_magnitude = None
-
-    if allow_infinity is None:
-        allow_infinity = bool(max_magnitude is None)
-    elif allow_infinity and max_magnitude is not None:
-        raise InvalidArgument(
-            f"Cannot have allow_infinity={allow_infinity!r} with "
-            f"max_magnitude={max_magnitude!r}"
-        )
-    if allow_nan is None:
-        allow_nan = bool(min_magnitude == 0 and max_magnitude is None)
-    elif allow_nan and not (min_magnitude == 0 and max_magnitude is None):
-        raise InvalidArgument(
-            f"Cannot have allow_nan={allow_nan!r}, min_magnitude={min_magnitude!r} "
-            f"max_magnitude={max_magnitude!r}"
-        )
-    allow_kw = {"allow_nan": allow_nan, "allow_infinity": allow_infinity}
-
-    if min_magnitude == 0 and max_magnitude is None:
-        # In this simple but common case, there are no constraints on the
-        # magnitude and therefore no relationship between the real and
-        # imaginary parts.
-        return builds(complex, floats(**allow_kw), floats(**allow_kw))
-
-    @composite
-    def constrained_complex(draw):
-        # Draw the imaginary part, and determine the maximum real part given
-        # this and the max_magnitude
-        if max_magnitude is None:
-            zi = draw(floats(**allow_kw))
-            rmax = None
-        else:
-            zi = draw(floats(-max_magnitude, max_magnitude, **allow_kw))
-            rmax = cathetus(max_magnitude, zi)
-        # Draw the real part from the allowed range given the imaginary part
-        if min_magnitude == 0 or math.fabs(zi) >= min_magnitude:
-            zr = draw(floats(None if rmax is None else -rmax, rmax, **allow_kw))
-        else:
-            zr = draw(floats(cathetus(min_magnitude, zi), rmax, **allow_kw))
-        # Order of conditions carefully tuned so that for a given pair of
-        # magnitude arguments, we always either draw or do not draw the bool
-        # (crucial for good shrinking behaviour) but only invert when needed.
-        if min_magnitude > 0 and draw(booleans()) and math.fabs(zi) <= min_magnitude:
-            zr = -zr
-        return complex(zr, zi)
-
-    return constrained_complex()
-
-
-@defines_strategy(never_lazy=True)
-def shared(
-    base: SearchStrategyEx,
-    *,
-    key: OptionalHashable = None,
-) -> SearchStrategyEx:
-    """Returns a strategy that draws a single shared value per run, drawn from
-    base. Any two shared instances with the same key will share the same value,
-    otherwise the identity of this strategy will be used. That is:
-
-    >>> s = integers()  # or any other strategy
-    >>> x = shared(s)
-    >>> y = shared(s)
-
-    In the above x and y may draw different (or potentially the same) values.
-    In the following they will always draw the same:
-
-    >>> x = shared(s, key="hi")
-    >>> y = shared(s, key="hi")
-
-    Examples from this strategy shrink as per their base strategy.
-    """
-    return SharedStrategy(base, key)
-
-
-@composite
-def _maybe_nil_uuids(draw, uuid):
-    # Equivalent to `random_uuids | just(...)`, with a stronger bias to the former.
-    if draw(data()).conjecture_data.draw_bits(6) == 63:
-        return UUID("00000000-0000-0000-0000-000000000000")
-    return uuid
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def uuids(
-    *, version: Optionalint = None, allow_nil: bool = False
-) -> SearchStrategyUUID:
-    """Returns a strategy that generates :class:`UUIDs <uuid.UUID>`.
-
-    If the optional version argument is given, value is passed through
-    to :class:`~python:uuid.UUID` and only UUIDs of that version will
-    be generated.
-
-    If ``allow_nil`` is True, generate the nil UUID much more often.
-    Otherwise, all returned values from this will be unique, so e.g. if you do
-    ``lists(uuids())`` the resulting list will never contain duplicates.
-
-    Examples from this strategy don't have any meaningful shrink order.
-    """
-    check_type(bool, allow_nil, "allow_nil")
-    if version not in (None, 1, 2, 3, 4, 5):
-        raise InvalidArgument(
-            f"version={version!r}, but version must be in "
-            "(None, 1, 2, 3, 4, 5) to pass to the uuid.UUID constructor."
-        )
-    random_uuids = shared(
-        randoms(use_true_random=True), key="hypothesis.strategies.uuids.generator"
-    ).map(lambda r: UUID(version=version, int=r.getrandbits(128)))
-
-    if allow_nil:
-        if version is not None:
-            raise InvalidArgument("The nil UUID is not of any version")
-        return random_uuids.flatmap(_maybe_nil_uuids)
-    return random_uuids
-
-
-class RunnerStrategy(SearchStrategy):
-    def __init__(self, default):
-        self.default = default
-
-    def do_draw(self, data):
-        runner = getattr(data, "hypothesis_runner", not_set)
-        if runner is not_set:
-            if self.default is not_set:
-                raise InvalidArgument(
-                    "Cannot use runner() strategy with no "
-                    "associated runner or explicit default."
-                )
-            else:
-                return self.default
-        else:
-            return runner
-
-
-@defines_strategy(force_reusable_values=True)
-def runner(*, default: Any = not_set) -> SearchStrategyAny:
-    """A strategy for getting "the current test runner", whatever that may be.
-    The exact meaning depends on the entry point, but it will usually be the
-    associated 'self' value for it.
-
-    If there is no current test runner and a default is provided, return
-    that default. If no default is provided, raises InvalidArgument.
-
-    Examples from this strategy do not shrink (because there is only one).
-    """
-    return RunnerStrategy(default)
-
-
-class DataObject:
-    """This type only exists so that you can write type hints for tests using
-    the :func:`~hypothesis.strategies.data` strategy.  Do not use it directly!
-    """
-
-    # Note that "only exists" here really means "is only exported to users",
-    # but we want to treat it as "semi-stable", not document it as "public API".
-
-    def __init__(self, data):
-        self.count = 0
-        self.conjecture_data = data
-
-    def __repr__(self):
-        return "data(...)"
-
-    def draw(self, strategy: SearchStrategyEx, label: Any = None) -> Ex:
-        check_strategy(strategy, "strategy")
-        result = self.conjecture_data.draw(strategy)
-        self.count += 1
-        if label is not None:
-            note(f"Draw {self.count} ({label}): {result!r}")
-        else:
-            note(f"Draw {self.count}: {result!r}")
-        return result
-
-
-class DataStrategy(SearchStrategy):
-    supports_find = False
-
-    def do_draw(self, data):
-        if not hasattr(data, "hypothesis_shared_data_strategy"):
-            data.hypothesis_shared_data_strategy = DataObject(data)
-        return data.hypothesis_shared_data_strategy
-
-    def __repr__(self):
-        return "data()"
-
-    def map(self, f):
-        self.__not_a_first_class_strategy("map")
-
-    def filter(self, f):
-        self.__not_a_first_class_strategy("filter")
-
-    def flatmap(self, f):
-        self.__not_a_first_class_strategy("flatmap")
-
-    def example(self):
-        self.__not_a_first_class_strategy("example")
-
-    def __not_a_first_class_strategy(self, name):
-        raise InvalidArgument(
-            f"Cannot call {name} on a DataStrategy. You should probably "
-            "be using @composite for whatever it is you're trying to do."
-        )
-
-
-@cacheable
-@defines_strategy(never_lazy=True)
-def data() -> SearchStrategyDataObject:
-    """This isn't really a normal strategy, but instead gives you an object
-    which can be used to draw data interactively from other strategies.
-
-    See :ref:`the rest of the documentation <interactive-draw>` for more
-    complete information.
-
-    Examples from this strategy do not shrink (because there is only one),
-    but the result of calls to each draw() call shrink as they normally would.
-    """
-    return DataStrategy()
-
-
-def register_type_strategy(
-    custom_type: TypeEx,
-    strategy: UnionSearchStrategyEx, CallableTypeEx, SearchStrategyEx,
-) -> None:
-    """Add an entry to the global type-to-strategy lookup.
-
-    This lookup is used in :func:`~hypothesis.strategies.builds` and
-    :func:`@given <hypothesis.given>`.
-
-    :func:`~hypothesis.strategies.builds` will be used automatically for
-    classes with type annotations on ``__init__`` , so you only need to
-    register a strategy if one or more arguments need to be more tightly
-    defined than their type-based default, or if you want to supply a strategy
-    for an argument with a default value.
-
-    ``strategy`` may be a search strategy, or a function that takes a type and
-    returns a strategy (useful for generic types).
-
-    Note that you may not register a parametrised generic type (such as
-    ``MyCollectionint``) directly, because the resolution logic does not
-    handle this case correctly.  Instead, you may register a *function* for
-    ``MyCollection`` and `inspect the type parameters within that function
-    <https://stackoverflow.com/q/48572831>`__.
-    """
-    # TODO: We would like to move this to the top level, but pending some major
-    # refactoring it's hard to do without creating circular imports.
-    from hypothesis.strategies._internal import types
-
-    if not types.is_a_type(custom_type):
-        raise InvalidArgument(f"custom_type={custom_type!r} must be a type")
-    if custom_type in types.NON_RUNTIME_TYPES:
-        raise InvalidArgument(
-            f"custom_type={custom_type!r} is not allowed to be registered, "
-            f"because there is no such thing as a runtime instance of {custom_type!r}"
-        )
-    elif not (isinstance(strategy, SearchStrategy) or callable(strategy)):
-        raise InvalidArgument(
-            "strategy=%r must be a SearchStrategy, or a function that takes "
-            "a generic type and returns a specific SearchStrategy"
-        )
-    elif isinstance(strategy, SearchStrategy) and strategy.is_empty:
-        raise InvalidArgument("strategy=%r must not be empty")
-    elif types.has_type_arguments(custom_type):
-        origin = getattr(custom_type, "__origin__", None)
-        raise InvalidArgument(
-            f"Cannot register generic type {custom_type!r}, because it has type "
-            "arguments which would not be handled.  Instead, register a function "
-            f"for {origin!r} which can inspect specific type objects and return a "
-            "strategy."
-        )
-    if (
-        "pydantic.generics" in sys.modules
-        and issubclass(custom_type, sys.modules"pydantic.generics".GenericModel)
-        and not re.search(r"A-Za-z_+\.+\", repr(custom_type))
-        and callable(strategy)
-    ):  # pragma: no cover
-        # See https://github.com/HypothesisWorks/hypothesis/issues/2940
-        raise InvalidArgument(
-            f"Cannot register a function for {custom_type!r}, because parametrized "
-            "`pydantic.generics.GenericModel` subclasses aren't actually generic "
-            "types at runtime.  In this case, you should register a strategy "
-            "directly for each parametrized form that you anticipate using."
-        )
-
-    types._global_type_lookupcustom_type = strategy
-    from_type.__clear_cache()  # type: ignore
-
-
-@cacheable
-@defines_strategy(never_lazy=True)
-def deferred(definition: Callable, SearchStrategyEx) -> SearchStrategyEx:
-    """A deferred strategy allows you to write a strategy that references other
-    strategies that have not yet been defined. This allows for the easy
-    definition of recursive and mutually recursive strategies.
-
-    The definition argument should be a zero-argument function that returns a
-    strategy. It will be evaluated the first time the strategy is used to
-    produce an example.
-
-    Example usage:
-
-    >>> import hypothesis.strategies as st
-    >>> x = st.deferred(lambda: st.booleans() | st.tuples(x, x))
-    >>> x.example()
-    (((False, (True, True)), (False, True)), (True, True))
-    >>> x.example()
-    True
-
-    Mutual recursion also works fine:
-
-    >>> a = st.deferred(lambda: st.booleans() | b)
-    >>> b = st.deferred(lambda: st.tuples(a, a))
-    >>> a.example()
-    True
-    >>> b.example()
-    (False, (False, ((False, True), False)))
-
-    Examples from this strategy shrink as they normally would from the strategy
-    returned by the definition.
-    """
-    return DeferredStrategy(definition)
-
-
-@defines_strategy(force_reusable_values=True)
-def emails() -> SearchStrategystr:
-    """A strategy for generating email addresses as unicode strings. The
-    address format is specified in :rfc:`5322#section-3.4.1`. Values shrink
-    towards shorter local-parts and host domains.
-
-    This strategy is useful for generating "user data" for tests, as
-    mishandling of email addresses is a common source of bugs.
-    """
-    from hypothesis.provisional import domains
-
-    local_chars = string.ascii_letters + string.digits + "!#$%&'*+-/=^_`{|}~"
-    local_part = text(local_chars, min_size=1, max_size=64)
-    # TODO: include dot-atoms, quoted strings, escaped chars, etc in local part
-    return builds("{}@{}".format, local_part, domains()).filter(
-        lambda addr: len(addr) <= 254
-    )
-
-
-@defines_strategy()
-def functions(
-    *,
-    like: Callable..., Any = lambda: None,
-    returns: UnionSearchStrategyAny, InferType = infer,
-    pure: bool = False,
-) -> SearchStrategyCallable..., Any:
-    # The proper type signature of `functions()` would have T instead of Any, but mypy
-    # disallows default args for generics: https://github.com/python/mypy/issues/3737
-    """functions(*, like=lambda: None, returns=..., pure=False)
-
-    A strategy for functions, which can be used in callbacks.
-
-    The generated functions will mimic the interface of ``like``, which must
-    be a callable (including a class, method, or function).  The return value
-    for the function is drawn from the ``returns`` argument, which must be a
-    strategy.  If ``returns`` is not passed, we attempt to infer a strategy
-    from the return-type annotation if present, falling back to :func:`~none`.
-
-    If ``pure=True``, all arguments passed to the generated function must be
-    hashable, and if passed identical arguments the original return value will
-    be returned again - *not* regenerated, so beware mutable values.
-
-    If ``pure=False``, generated functions do not validate their arguments, and
-    may return a different value if called again with the same arguments.
-
-    Generated functions can only be called within the scope of the ``@given``
-    which created them.  This strategy does not support ``.example()``.
-    """
-    check_type(bool, pure, "pure")
-    if not callable(like):
-        raise InvalidArgument(
-            "The first argument to functions() must be a callable to imitate, "
-            f"but got non-callable like={nicerepr(like)!r}"
-        )
-
-    if returns is None or returns is infer:
-        # Passing `None` has never been *documented* as working, but it still
-        # did from May 2020 to Jan 2022 so we'll avoid breaking it without cause.
-        hints = get_type_hints(like)
-        returns = from_type(hints.get("return", type(None)))
-
-    check_strategy(returns, "returns")
-    return FunctionStrategy(like, returns, pure)
-
-
-@composite
-def slices(draw: Any, size: int) -> slice:
-    """Generates slices that will select indices up to the supplied size
-
-    Generated slices will have start and stop indices that range from -size to size - 1
-    and will step in the appropriate direction. Slices should only produce an empty selection
-    if the start and end are the same.
-
-    Examples from this strategy shrink toward 0 and smaller values
-    """
-    check_valid_size(size, "size")
-    if size == 0:
-        step = draw(none() | integers().filter(bool))
-        return slice(None, None, step)
-    # For slices start is inclusive and stop is exclusive
-    start = draw(integers(0, size - 1) | none())
-    stop = draw(integers(0, size) | none())
-
-    # Limit step size to be reasonable
-    if start is None and stop is None:
-        max_step = size
-    elif start is None:
-        max_step = stop
-    elif stop is None:
-        max_step = start
-    else:
-        max_step = abs(start - stop)
-
-    step = draw(integers(1, max_step or 1))
-
-    if (draw(booleans()) and start == stop) or (stop or 0) < (start or 0):
-        step *= -1
-
-    if draw(booleans()) and start is not None:
-        start -= size
-    if draw(booleans()) and stop is not None:
-        stop -= size
-    if (not draw(booleans())) and step == 1:
-        step = None
-
-    return slice(start, stop, step)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/datetime.py Deleted

@@ -1,468 +0,0 @@
-# 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 datetime as dt
-import os.path
-from calendar import monthrange
-from functools import lru_cache
-from importlib import resources
-from typing import Optional
-
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture import utils
-from hypothesis.internal.validation import check_type, check_valid_interval
-from hypothesis.strategies._internal.core import sampled_from
-from hypothesis.strategies._internal.misc import just, none
-from hypothesis.strategies._internal.strategies import SearchStrategy
-from hypothesis.strategies._internal.utils import defines_strategy
-
-# The zoneinfo module, required for the timezones() and timezone_keys()
-# strategies, is new in Python 3.9 and the backport might be missing.
-try:
-    import zoneinfo
-except ImportError:
-    try:
-        from backports import zoneinfo  # type: ignore
-    except ImportError:
-        # We raise an error recommending `pip install hypothesiszoneinfo`
-        # when timezones() or timezone_keys() strategies are actually used.
-        zoneinfo = None  # type: ignore
-
-DATENAMES = ("year", "month", "day")
-TIMENAMES = ("hour", "minute", "second", "microsecond")
-
-
-def is_pytz_timezone(tz):
-    if not isinstance(tz, dt.tzinfo):
-        return False
-    module = type(tz).__module__
-    return module == "pytz" or module.startswith("pytz.")
-
-
-def replace_tzinfo(value, timezone):
-    if is_pytz_timezone(timezone):
-        # Pytz timezones are a little complicated, and using the .replace method
-        # can cause some weird issues, so we use their special "localize" instead.
-        #
-        # We use the fold attribute as a convenient boolean for is_dst, even though
-        # they're semantically distinct.  For ambiguous or imaginary hours, fold says
-        # whether you should use the offset that applies before the gap (fold=0) or
-        # the offset that applies after the gap (fold=1). is_dst says whether you
-        # should choose the side that is "DST" or "STD" (STD->STD or DST->DST
-        # transitions are unclear as you might expect).
-        #
-        # WARNING: this is INCORRECT for timezones with negative DST offsets such as
-        #       "Europe/Dublin", but it's unclear what we could do instead beyond
-        #       documenting the problem and recommending use of `dateutil` instead.
-        return timezone.localize(value, is_dst=not value.fold)
-    return value.replace(tzinfo=timezone)
-
-
-def datetime_does_not_exist(value):
-    """This function tests whether the given datetime can be round-tripped to and
-    from UTC.  It is an exact inverse of (and very similar to) the dateutil method
-    https://dateutil.readthedocs.io/en/stable/tz.html#dateutil.tz.datetime_exists
-    """
-    # Naive datetimes cannot be imaginary, but we need this special case because
-    # chaining .astimezone() ends with *the system local timezone*, not None.
-    # See bug report in https://github.com/HypothesisWorks/hypothesis/issues/2662
-    if value.tzinfo is None:
-        return False
-    try:
-        # Does the naive portion of the datetime change when round-tripped to
-        # UTC?  If so, or if this overflows, we say that it does not exist.
-        roundtrip = value.astimezone(dt.timezone.utc).astimezone(value.tzinfo)
-    except OverflowError:
-        # Overflows at datetime.min or datetime.max boundary condition.
-        # Rejecting these is acceptable, because timezones are close to
-        # meaningless before ~1900 and subject to a lot of change by
-        # 9999, so it should be a very small fraction of possible values.
-        return True
-
-    if (
-        value.tzinfo is not roundtrip.tzinfo
-        and value.utcoffset() != roundtrip.utcoffset()
-    ):
-        # This only ever occurs during imaginary (i.e. nonexistent) datetimes,
-        # and only for pytz timezones which do not follow PEP-495 semantics.
-        # (may exclude a few other edge cases, but you should use zoneinfo anyway)
-        return True
-
-    assert value.tzinfo is roundtrip.tzinfo, "so only the naive portions are compared"
-    return value != roundtrip
-
-
-def draw_capped_multipart(
-    data, min_value, max_value, duration_names=DATENAMES + TIMENAMES
-):
-    assert isinstance(min_value, (dt.date, dt.time, dt.datetime))
-    assert type(min_value) == type(max_value)
-    assert min_value <= max_value
-    result = {}
-    cap_low, cap_high = True, True
-    for name in duration_names:
-        low = getattr(min_value if cap_low else dt.datetime.min, name)
-        high = getattr(max_value if cap_high else dt.datetime.max, name)
-        if name == "day" and not cap_high:
-            _, high = monthrange(**result)
-        if name == "year":
-            val = utils.integer_range(data, low, high, 2000)
-        else:
-            val = utils.integer_range(data, low, high)
-        resultname = val
-        cap_low = cap_low and val == low
-        cap_high = cap_high and val == high
-    if hasattr(min_value, "fold"):
-        # The `fold` attribute is ignored in comparison of naive datetimes.
-        # In tz-aware datetimes it would require *very* invasive changes to
-        # the logic above, and be very sensitive to the specific timezone
-        # (at the cost of efficient shrinking and mutation), so at least for
-        # now we stick with the status quo and generate it independently.
-        result"fold" = utils.integer_range(data, 0, 1)
-    return result
-
-
-class DatetimeStrategy(SearchStrategy):
-    def __init__(self, min_value, max_value, timezones_strat, allow_imaginary):
-        assert isinstance(min_value, dt.datetime)
-        assert isinstance(max_value, dt.datetime)
-        assert min_value.tzinfo is None
-        assert max_value.tzinfo is None
-        assert min_value <= max_value
-        assert isinstance(timezones_strat, SearchStrategy)
-        assert isinstance(allow_imaginary, bool)
-        self.min_value = min_value
-        self.max_value = max_value
-        self.tz_strat = timezones_strat
-        self.allow_imaginary = allow_imaginary
-
-    def do_draw(self, data):
-        # We start by drawing a timezone, and an initial datetime.
-        tz = data.draw(self.tz_strat)
-        result = self.draw_naive_datetime_and_combine(data, tz)
-
-        # TODO: with some probability, systematically search for one of
-        #   - an imaginary time (if allowed),
-        #   - a time within 24hrs of a leap second (if there any are within bounds),
-        #   - other subtle, little-known, or nasty issues as described in
-        #     https://github.com/HypothesisWorks/hypothesis/issues/69
-
-        # If we happened to end up with a disallowed imaginary time, reject it.
-        if (not self.allow_imaginary) and datetime_does_not_exist(result):
-            data.mark_invalid()
-        return result
-
-    def draw_naive_datetime_and_combine(self, data, tz):
-        result = draw_capped_multipart(data, self.min_value, self.max_value)
-        try:
-            return replace_tzinfo(dt.datetime(**result), timezone=tz)
-        except (ValueError, OverflowError):
-            msg = "Failed to draw a datetime between %r and %r with timezone from %r."
-            data.note_event(msg % (self.min_value, self.max_value, self.tz_strat))
-            data.mark_invalid()
-
-
-@defines_strategy(force_reusable_values=True)
-def datetimes(
-    min_value: dt.datetime = dt.datetime.min,
-    max_value: dt.datetime = dt.datetime.max,
-    *,
-    timezones: SearchStrategyOptionaldt.tzinfo = none(),
-    allow_imaginary: bool = True,
-) -> SearchStrategydt.datetime:
-    """datetimes(min_value=datetime.datetime.min, max_value=datetime.datetime.max, *, timezones=none(), allow_imaginary=True)
-
-    A strategy for generating datetimes, which may be timezone-aware.
-
-    This strategy works by drawing a naive datetime between ``min_value``
-    and ``max_value``, which must both be naive (have no timezone).
-
-    ``timezones`` must be a strategy that generates either ``None``, for naive
-    datetimes, or :class:`~python:datetime.tzinfo` objects for 'aware' datetimes.
-    You can construct your own, though we recommend using one of these built-in
-    strategies:
-
-    * with Python 3.9 or newer or :pypi:`backports.zoneinfo`:
-      :func:`hypothesis.strategies.timezones`;
-    * with :pypi:`dateutil <python-dateutil>`:
-      :func:`hypothesis.extra.dateutil.timezones`; or
-    * with :pypi:`pytz`: :func:`hypothesis.extra.pytz.timezones`.
-
-    You may pass ``allow_imaginary=False`` to filter out "imaginary" datetimes
-    which did not (or will not) occur due to daylight savings, leap seconds,
-    timezone and calendar adjustments, etc.  Imaginary datetimes are allowed
-    by default, because malformed timestamps are a common source of bugs.
-
-    Examples from this strategy shrink towards midnight on January 1st 2000,
-    local time.
-    """
-    # Why must bounds be naive?  In principle, we could also write a strategy
-    # that took aware bounds, but the API and validation is much harder.
-    # If you want to generate datetimes between two particular moments in
-    # time I suggest (a) just filtering out-of-bounds values; (b) if bounds
-    # are very close, draw a value and subtract its UTC offset, handling
-    # overflows and nonexistent times; or (c) do something customised to
-    # handle datetimes in e.g. a four-microsecond span which is not
-    # representable in UTC.  Handling (d), all of the above, leads to a much
-    # more complex API for all users and a useful feature for very few.
-    check_type(bool, allow_imaginary, "allow_imaginary")
-    check_type(dt.datetime, min_value, "min_value")
-    check_type(dt.datetime, max_value, "max_value")
-    if min_value.tzinfo is not None:
-        raise InvalidArgument(f"min_value={min_value!r} must not have tzinfo")
-    if max_value.tzinfo is not None:
-        raise InvalidArgument(f"max_value={max_value!r} must not have tzinfo")
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-    if not isinstance(timezones, SearchStrategy):
-        raise InvalidArgument(
-            f"timezones={timezones!r} must be a SearchStrategy that can "
-            "provide tzinfo for datetimes (either None or dt.tzinfo objects)"
-        )
-    return DatetimeStrategy(min_value, max_value, timezones, allow_imaginary)
-
-
-class TimeStrategy(SearchStrategy):
-    def __init__(self, min_value, max_value, timezones_strat):
-        self.min_value = min_value
-        self.max_value = max_value
-        self.tz_strat = timezones_strat
-
-    def do_draw(self, data):
-        result = draw_capped_multipart(data, self.min_value, self.max_value, TIMENAMES)
-        tz = data.draw(self.tz_strat)
-        return dt.time(**result, tzinfo=tz)
-
-
-@defines_strategy(force_reusable_values=True)
-def times(
-    min_value: dt.time = dt.time.min,
-    max_value: dt.time = dt.time.max,
-    *,
-    timezones: SearchStrategyOptionaldt.tzinfo = none(),
-) -> SearchStrategydt.time:
-    """times(min_value=datetime.time.min, max_value=datetime.time.max, *, timezones=none())
-
-    A strategy for times between ``min_value`` and ``max_value``.
-
-    The ``timezones`` argument is handled as for :py:func:`datetimes`.
-
-    Examples from this strategy shrink towards midnight, with the timezone
-    component shrinking as for the strategy that provided it.
-    """
-    check_type(dt.time, min_value, "min_value")
-    check_type(dt.time, max_value, "max_value")
-    if min_value.tzinfo is not None:
-        raise InvalidArgument(f"min_value={min_value!r} must not have tzinfo")
-    if max_value.tzinfo is not None:
-        raise InvalidArgument(f"max_value={max_value!r} must not have tzinfo")
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-    return TimeStrategy(min_value, max_value, timezones)
-
-
-class DateStrategy(SearchStrategy):
-    def __init__(self, min_value, max_value):
-        assert isinstance(min_value, dt.date)
-        assert isinstance(max_value, dt.date)
-        assert min_value < max_value
-        self.min_value = min_value
-        self.max_value = max_value
-
-    def do_draw(self, data):
-        return dt.date(
-            **draw_capped_multipart(data, self.min_value, self.max_value, DATENAMES)
-        )
-
-
-@defines_strategy(force_reusable_values=True)
-def dates(
-    min_value: dt.date = dt.date.min, max_value: dt.date = dt.date.max
-) -> SearchStrategydt.date:
-    """dates(min_value=datetime.date.min, max_value=datetime.date.max)
-
-    A strategy for dates between ``min_value`` and ``max_value``.
-
-    Examples from this strategy shrink towards January 1st 2000.
-    """
-    check_type(dt.date, min_value, "min_value")
-    check_type(dt.date, max_value, "max_value")
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-    if min_value == max_value:
-        return just(min_value)
-    return DateStrategy(min_value, max_value)
-
-
-class TimedeltaStrategy(SearchStrategy):
-    def __init__(self, min_value, max_value):
-        assert isinstance(min_value, dt.timedelta)
-        assert isinstance(max_value, dt.timedelta)
-        assert min_value < max_value
-        self.min_value = min_value
-        self.max_value = max_value
-
-    def do_draw(self, data):
-        result = {}
-        low_bound = True
-        high_bound = True
-        for name in ("days", "seconds", "microseconds"):
-            low = getattr(self.min_value if low_bound else dt.timedelta.min, name)
-            high = getattr(self.max_value if high_bound else dt.timedelta.max, name)
-            val = utils.integer_range(data, low, high, 0)
-            resultname = val
-            low_bound = low_bound and val == low
-            high_bound = high_bound and val == high
-        return dt.timedelta(**result)
-
-
-@defines_strategy(force_reusable_values=True)
-def timedeltas(
-    min_value: dt.timedelta = dt.timedelta.min,
-    max_value: dt.timedelta = dt.timedelta.max,
-) -> SearchStrategydt.timedelta:
-    """timedeltas(min_value=datetime.timedelta.min, max_value=datetime.timedelta.max)
-
-    A strategy for timedeltas between ``min_value`` and ``max_value``.
-
-    Examples from this strategy shrink towards zero.
-    """
-    check_type(dt.timedelta, min_value, "min_value")
-    check_type(dt.timedelta, max_value, "max_value")
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-    if min_value == max_value:
-        return just(min_value)
-    return TimedeltaStrategy(min_value=min_value, max_value=max_value)
-
-
-@lru_cache(maxsize=None)
-def _valid_key_cacheable(tzpath, key):
-    assert isinstance(tzpath, tuple)  # zoneinfo changed, better update this function!
-    for root in tzpath:
-        if os.path.exists(os.path.join(root, key)):  # pragma: no branch
-            # No branch because most systems only have one TZPATH component.
-            return True
-    else:  # pragma: no cover
-        # This branch is only taken for names which are known to zoneinfo
-        # but not present on the filesystem, i.e. on Windows with tzdata,
-        # and so is never executed by our coverage tests.
-        *package_loc, resource_name = key.split("/")
-        package = "tzdata.zoneinfo." + ".".join(package_loc)
-        try:
-            try:
-                traversable = resources.files(package) / resource_name
-                return traversable.exists()
-            except (AttributeError, ValueError):
-                # .files() was added in Python 3.9
-                return resources.is_resource(package, resource_name)
-        except ModuleNotFoundError:
-            return False
-
-
-@defines_strategy(force_reusable_values=True)
-def timezone_keys(
-    *,
-    # allow_alias: bool = True,
-    # allow_deprecated: bool = True,
-    allow_prefix: bool = True,
-) -> SearchStrategystr:
-    """A strategy for :wikipedia:`IANA timezone names <List_of_tz_database_time_zones>`.
-
-    As well as timezone names like ``"UTC"``, ``"Australia/Sydney"``, or
-    ``"America/New_York"``, this strategy can generate:
-
-    - Aliases such as ``"Antarctica/McMurdo"``, which links to ``"Pacific/Auckland"``.
-    - Deprecated names such as ``"Antarctica/South_Pole"``, which *also* links to
-      ``"Pacific/Auckland"``.  Note that most but
-      not all deprecated timezone names are also aliases.
-    - Timezone names with the ``"posix/"`` or ``"right/"`` prefixes, unless
-      ``allow_prefix=False``.
-
-    These strings are provided separately from Tzinfo objects - such as ZoneInfo
-    instances from the timezones() strategy - to facilitate testing of timezone
-    logic without needing workarounds to access non-canonical names.
-
-    .. note::
-
-        The :mod:`python:zoneinfo` module is new in Python 3.9, so you will need
-        to install the :pypi:`backports.zoneinfo` module on earlier versions.
-
-        `On Windows, you will also need to install the tzdata package
-        <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__.
-
-        ``pip install hypothesiszoneinfo`` will install these conditional
-        dependencies if and only if they are needed.
-
-    On Windows, you may need to access IANA timezone data via the :pypi:`tzdata`
-    package.  For non-IANA timezones, such as Windows-native names or GNU TZ
-    strings, we recommend using :func:`~hypothesis.strategies.sampled_from` with
-    the :pypi:`dateutil <python-dateutil>` package, e.g.
-    :meth:`dateutil:dateutil.tz.tzwin.list`.
-    """
-    # check_type(bool, allow_alias, "allow_alias")
-    # check_type(bool, allow_deprecated, "allow_deprecated")
-    check_type(bool, allow_prefix, "allow_prefix")
-    if zoneinfo is None:  # pragma: no cover
-        raise ModuleNotFoundError(
-            "The zoneinfo module is required, but could not be imported.  "
-            "Run `pip install hypothesiszoneinfo` and try again."
-        )
-
-    available_timezones = ("UTC",) + tuple(sorted(zoneinfo.available_timezones()))
-
-    # TODO: filter out alias and deprecated names if disallowed
-
-    # When prefixes are allowed, we first choose a key and then flatmap to get our
-    # choice with one of the available prefixes.  That in turn means that we need
-    # some logic to determine which prefixes are available for a given key:
-
-    def valid_key(key):
-        return key == "UTC" or _valid_key_cacheable(zoneinfo.TZPATH, key)
-
-    # TODO: work out how to place a higher priority on "weird" timezones
-    # For details see https://github.com/HypothesisWorks/hypothesis/issues/2414
-    strategy = sampled_from(key for key in available_timezones if valid_key(key))
-
-    if not allow_prefix:
-        return strategy
-
-    def sample_with_prefixes(zone):
-        keys_with_prefixes = (zone, f"posix/{zone}", f"right/{zone}")
-        return sampled_from(key for key in keys_with_prefixes if valid_key(key))
-
-    return strategy.flatmap(sample_with_prefixes)
-
-
-@defines_strategy(force_reusable_values=True)
-def timezones(*, no_cache: bool = False) -> SearchStrategy"zoneinfo.ZoneInfo":
-    """A strategy for :class:`python:zoneinfo.ZoneInfo` objects.
-
-    If ``no_cache=True``, the generated instances are constructed using
-    :meth:`ZoneInfo.no_cache <python:zoneinfo.ZoneInfo.no_cache>` instead
-    of the usual constructor.  This may change the semantics of your datetimes
-    in surprising ways, so only use it if you know that you need to!
-
-    .. note::
-
-        The :mod:`python:zoneinfo` module is new in Python 3.9, so you will need
-        to install the :pypi:`backports.zoneinfo` module on earlier versions.
-
-        `On Windows, you will also need to install the tzdata package
-        <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__.
-
-        ``pip install hypothesiszoneinfo`` will install these conditional
-        dependencies if and only if they are needed.
-    """
-    check_type(bool, no_cache, "no_cache")
-    if zoneinfo is None:  # pragma: no cover
-        raise ModuleNotFoundError(
-            "The zoneinfo module is required, but could not be imported.  "
-            "Run `pip install hypothesiszoneinfo` and try again."
-        )
-    return timezone_keys().map(
-        zoneinfo.ZoneInfo.no_cache if no_cache else zoneinfo.ZoneInfo
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/numbers.py Deleted

@@ -1,534 +0,0 @@
-# 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 math
-from decimal import Decimal
-from fractions import Fraction
-from sys import float_info
-from typing import Optional, Union
-
-from hypothesis.control import reject
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture import floats as flt, utils as d
-from hypothesis.internal.conjecture.utils import calc_label_from_name
-from hypothesis.internal.filtering import get_integer_predicate_bounds
-from hypothesis.internal.floats import (
-    float_of,
-    int_to_float,
-    is_negative,
-    make_float_clamper,
-    next_down,
-    next_down_normal,
-    next_up,
-    next_up_normal,
-    width_smallest_normals,
-)
-from hypothesis.internal.validation import (
-    check_type,
-    check_valid_bound,
-    check_valid_interval,
-)
-from hypothesis.strategies._internal.misc import nothing
-from hypothesis.strategies._internal.strategies import SearchStrategy
-from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-
-# See https://github.com/python/mypy/issues/3186 - numbers.Real is wrong!
-Real = Unionint, float, Fraction, Decimal
-ONE_BOUND_INTEGERS_LABEL = d.calc_label_from_name("trying a one-bound int allowing 0")
-
-
-class IntegersStrategy(SearchStrategy):
-    def __init__(self, start, end):
-        assert isinstance(start, int) or start is None
-        assert isinstance(end, int) or end is None
-        assert start is None or end is None or start <= end
-        self.start = start
-        self.end = end
-
-    def __repr__(self):
-        if self.start is None and self.end is None:
-            return "integers()"
-        if self.end is None:
-            return f"integers(min_value={self.start})"
-        if self.start is None:
-            return f"integers(max_value={self.end})"
-        return f"integers({self.start}, {self.end})"
-
-    def do_draw(self, data):
-        if self.start is None and self.end is None:
-            return d.unbounded_integers(data)
-
-        if self.start is None:
-            if self.end <= 0:
-                return self.end - abs(d.unbounded_integers(data))
-            else:
-                probe = self.end + 1
-                while self.end < probe:
-                    data.start_example(ONE_BOUND_INTEGERS_LABEL)
-                    probe = d.unbounded_integers(data)
-                    data.stop_example(discard=self.end < probe)
-                return probe
-
-        if self.end is None:
-            if self.start >= 0:
-                return self.start + abs(d.unbounded_integers(data))
-            else:
-                probe = self.start - 1
-                while probe < self.start:
-                    data.start_example(ONE_BOUND_INTEGERS_LABEL)
-                    probe = d.unbounded_integers(data)
-                    data.stop_example(discard=probe < self.start)
-                return probe
-
-        return d.integer_range(data, self.start, self.end, center=0)
-
-    def filter(self, condition):
-        kwargs, pred = get_integer_predicate_bounds(condition)
-
-        start, end = self.start, self.end
-        if "min_value" in kwargs:
-            start = max(kwargs"min_value", -math.inf if start is None else start)
-        if "max_value" in kwargs:
-            end = min(kwargs"max_value", math.inf if end is None else end)
-
-        if start != self.start or end != self.end:
-            if start is not None and end is not None and start > end:
-                return nothing()
-            self = type(self)(start, end)
-        if pred is None:
-            return self
-        return super().filter(pred)
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def integers(
-    min_value: Optionalint = None,
-    max_value: Optionalint = None,
-) -> SearchStrategyint:
-    """Returns a strategy which generates integers.
-
-    If min_value is not None then all values will be >= min_value. If
-    max_value is not None then all values will be <= max_value
-
-    Examples from this strategy will shrink towards zero, and negative values
-    will also shrink towards positive (i.e. -n may be replaced by +n).
-    """
-    check_valid_bound(min_value, "min_value")
-    check_valid_bound(max_value, "max_value")
-    check_valid_interval(min_value, max_value, "min_value", "max_value")
-
-    if min_value is not None:
-        if min_value != int(min_value):
-            raise InvalidArgument(
-                "min_value=%r of type %r cannot be exactly represented as an integer."
-                % (min_value, type(min_value))
-            )
-        min_value = int(min_value)
-    if max_value is not None:
-        if max_value != int(max_value):
-            raise InvalidArgument(
-                "max_value=%r of type %r cannot be exactly represented as an integer."
-                % (max_value, type(max_value))
-            )
-        max_value = int(max_value)
-
-    return IntegersStrategy(min_value, max_value)
-
-
-SMALLEST_SUBNORMAL = next_up(0.0)
-SIGNALING_NAN = int_to_float(0x7FF8_0000_0000_0001)  # nonzero mantissa
-assert math.isnan(SIGNALING_NAN) and math.copysign(1, SIGNALING_NAN) == 1
-
-NASTY_FLOATS = sorted(
-    
-        0.0,
-        0.5,
-        1.1,
-        1.5,
-        1.9,
-        1.0 / 3,
-        10e6,
-        10e-6,
-        1.175494351e-38,
-        next_up(0.0),
-        float_info.min,
-        float_info.max,
-        3.402823466e38,
-        9007199254740992,
-        1 - 10e-6,
-        2 + 10e-6,
-        1.192092896e-07,
-        2.2204460492503131e-016,
-    
-    + 2.0**-n for n in (24, 14, 149, 126)  # minimum (sub)normals for float16,32
-    + float_info.min / n for n in (2, 10, 1000, 100_000)  # subnormal in float64
-    + math.inf, math.nan * 5
-    + SIGNALING_NAN,
-    key=flt.float_to_lex,
-)
-NASTY_FLOATS = list(map(float, NASTY_FLOATS))
-NASTY_FLOATS.extend(-x for x in NASTY_FLOATS)
-
-FLOAT_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
-    "getting another float in FloatStrategy"
-)
-
-
-def _sign_aware_lte(x: float, y: float) -> bool:
-    """Less-than-or-equals, but strictly orders -0.0 and 0.0"""
-    if x == 0.0 == y:
-        return math.copysign(1.0, x) <= math.copysign(1.0, y)
-    else:
-        return x <= y
-
-
-class FloatStrategy(SearchStrategy):
-    """A strategy for floating point numbers."""
-
-    def __init__(
-        self,
-        min_value: float = -math.inf,
-        max_value: float = math.inf,
-        allow_nan: bool = True,
-        # The smallest nonzero number we can represent is usually a subnormal, but may
-        # be the smallest normal if we're running in unsafe denormals-are-zero mode.
-        # While that's usually an explicit error, we do need to handle the case where
-        # the user passes allow_subnormal=False.
-        smallest_nonzero_magnitude: float = SMALLEST_SUBNORMAL,
-    ):
-        super().__init__()
-        assert isinstance(allow_nan, bool)
-        assert smallest_nonzero_magnitude >= 0.0, "programmer error if this is negative"
-        if smallest_nonzero_magnitude == 0.0:  # pragma: no cover
-            raise FloatingPointError(
-                "Got allow_subnormal=True, but we can't represent subnormal floats "
-                "right now, in violation of the IEEE-754 floating-point "
-                "specification.  This is usually because something was compiled with "
-                "-ffast-math or a similar option, which sets global processor state.  "
-                "See https://simonbyrne.github.io/notes/fastmath/ for a more detailed "
-                "writeup - and good luck!"
-            )
-        self.min_value = min_value
-        self.max_value = max_value
-        self.allow_nan = allow_nan
-        self.smallest_nonzero_magnitude = smallest_nonzero_magnitude
-
-        boundary_values = 
-            min_value,
-            next_up(min_value),
-            min_value + 1,
-            max_value - 1,
-            next_down(max_value),
-            max_value,
-        
-        self.nasty_floats = 
-            f for f in NASTY_FLOATS + boundary_values if self.permitted(f)
-        
-        weights = 0.2 * len(self.nasty_floats) + 0.8 * len(self.nasty_floats)
-        self.sampler = d.Sampler(weights) if self.nasty_floats else None
-
-        self.pos_clamper = self.neg_clamper = None
-        if _sign_aware_lte(0.0, max_value):
-            pos_min = max(min_value, smallest_nonzero_magnitude)
-            allow_zero = _sign_aware_lte(min_value, 0.0)
-            self.pos_clamper = make_float_clamper(pos_min, max_value, allow_zero)
-        if _sign_aware_lte(min_value, -0.0):
-            neg_max = min(max_value, -smallest_nonzero_magnitude)
-            allow_zero = _sign_aware_lte(-0.0, max_value)
-            self.neg_clamper = make_float_clamper(-neg_max, -min_value, allow_zero)
-
-        self.forced_sign_bit: Optionalint = None
-        if (self.pos_clamper is None) != (self.neg_clamper is None):
-            self.forced_sign_bit = 1 if self.neg_clamper else 0
-
-    def __repr__(self):
-        return "{}(min_value={}, max_value={}, allow_nan={}, smallest_nonzero_magnitude={})".format(
-            self.__class__.__name__,
-            self.min_value,
-            self.max_value,
-            self.allow_nan,
-            self.smallest_nonzero_magnitude,
-        )
-
-    def permitted(self, f):
-        assert isinstance(f, float)
-        if math.isnan(f):
-            return self.allow_nan
-        if 0 < abs(f) < self.smallest_nonzero_magnitude:
-            return False
-        return _sign_aware_lte(self.min_value, f) and _sign_aware_lte(f, self.max_value)
-
-    def do_draw(self, data):
-        while True:
-            data.start_example(FLOAT_STRATEGY_DO_DRAW_LABEL)
-            i = self.sampler.sample(data) if self.sampler else 0
-            data.start_example(flt.DRAW_FLOAT_LABEL)
-            if i == 0:
-                result = flt.draw_float(data, forced_sign_bit=self.forced_sign_bit)
-                is_negative = flt.float_to_int(result) >> 63
-                if is_negative:
-                    clamped = -self.neg_clamper(-result)
-                else:
-                    clamped = self.pos_clamper(result)
-                if clamped != result:
-                    data.stop_example(discard=True)
-                    data.start_example(flt.DRAW_FLOAT_LABEL)
-                    flt.write_float(data, clamped)
-                    result = clamped
-            else:
-                result = self.nasty_floatsi - 1
-
-                flt.write_float(data, result)
-
-            data.stop_example()  # (DRAW_FLOAT_LABEL)
-            data.stop_example()  # (FLOAT_STRATEGY_DO_DRAW_LABEL)
-            return result
-
-
-@cacheable
-@defines_strategy(force_reusable_values=True)
-def floats(
-    min_value: OptionalReal = None,
-    max_value: OptionalReal = None,
-    *,
-    allow_nan: Optionalbool = None,
-    allow_infinity: Optionalbool = None,
-    allow_subnormal: Optionalbool = None,
-    width: int = 64,
-    exclude_min: bool = False,
-    exclude_max: bool = False,
-) -> SearchStrategyfloat:
-    """Returns a strategy which generates floats.
-
-    - If min_value is not None, all values will be ``>= min_value``
-      (or ``> min_value`` if ``exclude_min``).
-    - If max_value is not None, all values will be ``<= max_value``
-      (or ``< max_value`` if ``exclude_max``).
-    - If min_value or max_value is not None, it is an error to enable
-      allow_nan.
-    - If both min_value and max_value are not None, it is an error to enable
-      allow_infinity.
-    - If inferred values range does not include subnormal values, it is an error
-      to enable allow_subnormal.
-
-    Where not explicitly ruled out by the bounds,
-    :wikipedia:`subnormals <Subnormal_number>`, infinities, and NaNs are possible
-    values generated by this strategy.
-
-    The width argument specifies the maximum number of bits of precision
-    required to represent the generated float. Valid values are 16, 32, or 64.
-    Passing ``width=32`` will still use the builtin 64-bit ``float`` class,
-    but always for values which can be exactly represented as a 32-bit float.
-
-    The exclude_min and exclude_max argument can be used to generate numbers
-    from open or half-open intervals, by excluding the respective endpoints.
-    Excluding either signed zero will also exclude the other.
-    Attempting to exclude an endpoint which is None will raise an error;
-    use ``allow_infinity=False`` to generate finite floats.  You can however
-    use e.g. ``min_value=-math.inf, exclude_min=True`` to exclude only
-    one infinite endpoint.
-
-    Examples from this strategy have a complicated and hard to explain
-    shrinking behaviour, but it tries to improve "human readability". Finite
-    numbers will be preferred to infinity and infinity will be preferred to
-    NaN.
-    """
-    check_type(bool, exclude_min, "exclude_min")
-    check_type(bool, exclude_max, "exclude_max")
-
-    if allow_nan is None:
-        allow_nan = bool(min_value is None and max_value is None)
-    elif allow_nan and (min_value is not None or max_value is not None):
-        raise InvalidArgument(
-            f"Cannot have allow_nan={allow_nan!r}, with min_value or max_value"
-        )
-
-    if width not in (16, 32, 64):
-        raise InvalidArgument(
-            f"Got width={width!r}, but the only valid values "
-            "are the integers 16, 32, and 64."
-        )
-
-    check_valid_bound(min_value, "min_value")
-    check_valid_bound(max_value, "max_value")
-
-    if math.copysign(1.0, -0.0) == 1.0:  # pragma: no cover
-        raise FloatingPointError(
-            "You Python install can't represent -0.0, which is required by the "
-            "IEEE-754 floating-point specification.  This is probably because it was "
-            "compiled with an unsafe option like -ffast-math; for a more detailed "
-            "explanation see https://simonbyrne.github.io/notes/fastmath/"
-        )
-    if allow_subnormal and next_up(0.0, width=width) == 0:  # pragma: no cover
-        # Not worth having separate CI envs and dependencies just to cover this branch;
-        # discussion in https://github.com/HypothesisWorks/hypothesis/issues/3092
-        #
-        # Erroring out here ensures that the database contents are interpreted
-        # consistently - which matters for such a foundational strategy, even if it's
-        # not always true for all user-composed strategies further up the stack.
-        raise FloatingPointError(
-            f"Got allow_subnormal={allow_subnormal!r}, but we can't represent "
-            f"subnormal floats right now, in violation of the IEEE-754 floating-point "
-            f"specification.  This is usually because something was compiled with "
-            f"-ffast-math or a similar option, which sets global processor state.  "
-            f"See https://simonbyrne.github.io/notes/fastmath/ for a more detailed "
-            f"writeup - and good luck!"
-        )
-
-    min_arg, max_arg = min_value, max_value
-    if min_value is not None:
-        min_value = float_of(min_value, width)
-        assert isinstance(min_value, float)
-    if max_value is not None:
-        max_value = float_of(max_value, width)
-        assert isinstance(max_value, float)
-
-    if min_value != min_arg:
-        raise InvalidArgument(
-            f"min_value={min_arg!r} cannot be exactly represented as a float "
-            f"of width {width} - use min_value={min_value!r} instead."
-        )
-    if max_value != max_arg:
-        raise InvalidArgument(
-            f"max_value={max_arg!r} cannot be exactly represented as a float "
-            f"of width {width} - use max_value={max_value!r} instead."
-        )
-
-    if exclude_min and (min_value is None or min_value == math.inf):
-        raise InvalidArgument(f"Cannot exclude min_value={min_value!r}")
-    if exclude_max and (max_value is None or max_value == -math.inf):
-        raise InvalidArgument(f"Cannot exclude max_value={max_value!r}")
-
-    assumed_allow_subnormal = allow_subnormal is None or allow_subnormal
-    if min_value is not None and (
-        exclude_min or (min_arg is not None and min_value < min_arg)
-    ):
-        min_value = next_up_normal(min_value, width, assumed_allow_subnormal)
-        if min_value == min_arg:
-            assert min_value == min_arg == 0
-            assert is_negative(min_arg) and not is_negative(min_value)
-            min_value = next_up_normal(min_value, width, assumed_allow_subnormal)
-        assert min_value > min_arg  # type: ignore
-    if max_value is not None and (
-        exclude_max or (max_arg is not None and max_value > max_arg)
-    ):
-        max_value = next_down_normal(max_value, width, assumed_allow_subnormal)
-        if max_value == max_arg:
-            assert max_value == max_arg == 0
-            assert is_negative(max_value) and not is_negative(max_arg)
-            max_value = next_down_normal(max_value, width, assumed_allow_subnormal)
-        assert max_value < max_arg  # type: ignore
-
-    if min_value == -math.inf:
-        min_value = None
-    if max_value == math.inf:
-        max_value = None
-
-    bad_zero_bounds = (
-        min_value == max_value == 0
-        and is_negative(max_value)
-        and not is_negative(min_value)
-    )
-    if (
-        min_value is not None
-        and max_value is not None
-        and (min_value > max_value or bad_zero_bounds)
-    ):
-        # This is a custom alternative to check_valid_interval, because we want
-        # to include the bit-width and exclusion information in the message.
-        msg = (
-            "There are no %s-bit floating-point values between min_value=%r "
-            "and max_value=%r" % (width, min_arg, max_arg)
-        )
-        if exclude_min or exclude_max:
-            msg += f", exclude_min={exclude_min!r} and exclude_max={exclude_max!r}"
-        raise InvalidArgument(msg)
-
-    if allow_infinity is None:
-        allow_infinity = bool(min_value is None or max_value is None)
-    elif allow_infinity:
-        if min_value is not None and max_value is not None:
-            raise InvalidArgument(
-                f"Cannot have allow_infinity={allow_infinity!r}, "
-                "with both min_value and max_value"
-            )
-    elif min_value == math.inf:
-        if min_arg == math.inf:
-            raise InvalidArgument("allow_infinity=False excludes min_value=inf")
-        raise InvalidArgument(
-            f"exclude_min=True turns min_value={min_arg!r} into inf, "
-            "but allow_infinity=False"
-        )
-    elif max_value == -math.inf:
-        if max_arg == -math.inf:
-            raise InvalidArgument("allow_infinity=False excludes max_value=-inf")
-        raise InvalidArgument(
-            f"exclude_max=True turns max_value={max_arg!r} into -inf, "
-            "but allow_infinity=False"
-        )
-
-    smallest_normal = width_smallest_normalswidth
-    if allow_subnormal is None:
-        if min_value is not None and max_value is not None:
-            if min_value == max_value:
-                allow_subnormal = -smallest_normal < min_value < smallest_normal
-            else:
-                allow_subnormal = (
-                    min_value < smallest_normal and max_value > -smallest_normal
-                )
-        elif min_value is not None:
-            allow_subnormal = min_value < smallest_normal
-        elif max_value is not None:
-            allow_subnormal = max_value > -smallest_normal
-        else:
-            allow_subnormal = True
-    if allow_subnormal:
-        if min_value is not None and min_value >= smallest_normal:
-            raise InvalidArgument(
-                f"allow_subnormal=True, but minimum value {min_value} "
-                f"excludes values below float{width}'s "
-                f"smallest positive normal {smallest_normal}"
-            )
-        if max_value is not None and max_value <= -smallest_normal:
-            raise InvalidArgument(
-                f"allow_subnormal=True, but maximum value {max_value} "
-                f"excludes values above float{width}'s "
-                f"smallest negative normal {-smallest_normal}"
-            )
-
-    if min_value is None:
-        min_value = float("-inf")
-    if max_value is None:
-        max_value = float("inf")
-    assert isinstance(min_value, float)
-    assert isinstance(max_value, float)
-    smallest_nonzero_magnitude = (
-        SMALLEST_SUBNORMAL if allow_subnormal else smallest_normal
-    )
-    result: SearchStrategy = FloatStrategy(
-        min_value,
-        max_value,
-        allow_nan=allow_nan,
-        smallest_nonzero_magnitude=smallest_nonzero_magnitude,
-    )
-
-    if width < 64:
-
-        def downcast(x):
-            try:
-                return float_of(x, width)
-            except OverflowError:  # pragma: no cover
-                reject()
-
-        result = result.map(downcast)
-    if not allow_infinity:
-        result = result.filter(lambda x: not math.isinf(x))
-    return result

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/random.py Deleted

@@ -1,438 +0,0 @@
-# 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 inspect
-import math
-from random import Random
-from typing import Dict
-
-import attr
-
-from hypothesis.control import should_note
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.reflection import define_function_signature_from_signature
-from hypothesis.reporting import report
-from hypothesis.strategies._internal.core import (
-    binary,
-    lists,
-    permutations,
-    sampled_from,
-)
-from hypothesis.strategies._internal.numbers import floats, integers
-from hypothesis.strategies._internal.strategies import SearchStrategy
-
-
-class HypothesisRandom(Random):
-    """A subclass of Random designed to expose the seed it was initially
-    provided with."""
-
-    def __init__(self, note_method_calls):
-        self.__note_method_calls = note_method_calls
-
-    def __deepcopy__(self, table):
-        return self.__copy__()
-
-    def __repr__(self):
-        raise NotImplementedError()
-
-    def seed(self, seed):
-        raise NotImplementedError()
-
-    def getstate(self):
-        raise NotImplementedError()
-
-    def setstate(self, state):
-        raise NotImplementedError()
-
-    def _hypothesis_log_random(self, method, kwargs, result):
-        if not (self.__note_method_calls and should_note()):
-            return
-
-        args, kwargs = convert_kwargs(method, kwargs)
-        argstr = ", ".join(
-            list(map(repr, args)) + f"{k}={v!r}" for k, v in kwargs.items()
-        )
-        report(f"{self!r}.{method}({argstr}) -> {result!r}")
-
-    def _hypothesis_do_random(self, method, kwargs):
-        raise NotImplementedError()
-
-
-RANDOM_METHODS = 
-    name
-    for name in 
-        "_randbelow",
-        "betavariate",
-        "choice",
-        "choices",
-        "expovariate",
-        "gammavariate",
-        "gauss",
-        "getrandbits",
-        "lognormvariate",
-        "normalvariate",
-        "paretovariate",
-        "randint",
-        "random",
-        "randrange",
-        "sample",
-        "shuffle",
-        "triangular",
-        "uniform",
-        "vonmisesvariate",
-        "weibullvariate",
-        "randbytes",
-    
-    if hasattr(Random, name)
-
-
-
-# Fake shims to get a good signature
-def getrandbits(self, n: int) -> int:  # type: ignore
-    raise NotImplementedError()
-
-
-def random(self) -> float:  # type: ignore
-    raise NotImplementedError()
-
-
-def _randbelow(self, n: int) -> int:  # type: ignore
-    raise NotImplementedError()
-
-
-STUBS = {f.__name__: f for f in getrandbits, random, _randbelow}
-
-
-SIGNATURES: Dictstr, inspect.Signature = {}
-
-
-def sig_of(name):
-    try:
-        return SIGNATURESname
-    except KeyError:
-        pass
-
-    target = getattr(Random, name)
-    result = inspect.signature(STUBS.get(name, target))
-    SIGNATURESname = result
-    return result
-
-
-def define_copy_method(name):
-    target = getattr(Random, name)
-
-    def implementation(self, **kwargs):
-        result = self._hypothesis_do_random(name, kwargs)
-        self._hypothesis_log_random(name, kwargs, result)
-        return result
-
-    spec = inspect.signature(STUBS.get(name, target))
-
-    result = define_function_signature_from_signature(
-        target.__name__, target.__doc__, spec
-    )(implementation)
-
-    result.__module__ = __name__
-    result.__qualname__ = "HypothesisRandom." + result.__name__
-
-    setattr(HypothesisRandom, name, result)
-
-
-for r in RANDOM_METHODS:
-    define_copy_method(r)
-
-
-@attr.s(slots=True)
-class RandomState:
-    next_states = attr.ib(default=attr.Factory(dict))
-    state_id = attr.ib(default=None)
-
-
-def state_for_seed(data, seed):
-    try:
-        seeds_to_states = data.seeds_to_states
-    except AttributeError:
-        seeds_to_states = {}
-        data.seeds_to_states = seeds_to_states
-
-    try:
-        state = seeds_to_statesseed
-    except KeyError:
-        state = RandomState()
-        seeds_to_statesseed = state
-
-    return state
-
-
-UNIFORM = floats(0, 1)
-
-
-def normalize_zero(f: float) -> float:
-    if f == 0.0:
-        return 0.0
-    else:
-        return f
-
-
-class ArtificialRandom(HypothesisRandom):
-    VERSION = 10**6
-
-    def __init__(self, note_method_calls, data):
-        super().__init__(note_method_calls=note_method_calls)
-        self.__data = data
-        self.__state = RandomState()
-
-    def __repr__(self):
-        return "HypothesisRandom(generated data)"
-
-    def __copy__(self):
-        result = ArtificialRandom(
-            note_method_calls=self._HypothesisRandom__note_method_calls,
-            data=self.__data,
-        )
-        result.setstate(self.getstate())
-        return result
-
-    def __convert_result(self, method, kwargs, result):
-        if method == "choice":
-            return kwargs.get("seq")result
-        if method in ("choices", "sample"):
-            seq = kwargs"population"
-            return seqi for i in result
-        if method == "shuffle":
-            seq = kwargs"x"
-            original = list(seq)
-            for i, i2 in enumerate(result):
-                seqi = originali2
-            return
-        return result
-
-    def _hypothesis_do_random(self, method, kwargs):
-        if method == "choices":
-            key = (method, len(kwargs"population"), kwargs.get("k"))
-        elif method == "choice":
-            key = (method, len(kwargs"seq"))
-        elif method == "shuffle":
-            key = (method, len(kwargs"x"))
-        else:
-            key = (method,) + tuple(sorted(kwargs))
-
-        try:
-            result, self.__state = self.__state.next_stateskey
-        except KeyError:
-            pass
-        else:
-            return self.__convert_result(method, kwargs, result)
-
-        if method == "_randbelow":
-            result = cu.integer_range(self.__data, 0, kwargs"n" - 1)
-        elif method in ("betavariate", "random"):
-            result = self.__data.draw(UNIFORM)
-        elif method == "uniform":
-            a = normalize_zero(kwargs"a")
-            b = normalize_zero(kwargs"b")
-            result = self.__data.draw(floats(a, b))
-        elif method in ("weibullvariate", "gammavariate"):
-            result = self.__data.draw(floats(min_value=0.0, allow_infinity=False))
-        elif method in ("gauss", "normalvariate"):
-            mu = kwargs"mu"
-            result = mu + self.__data.draw(
-                floats(allow_nan=False, allow_infinity=False)
-            )
-        elif method == "vonmisesvariate":
-            result = self.__data.draw(floats(0, 2 * math.pi))
-        elif method == "randrange":
-            if kwargs"stop" is None:
-                stop = kwargs"start"
-                start = 0
-            else:
-                start = kwargs"start"
-                stop = kwargs"stop"
-
-            step = kwargs"step"
-            if start == stop:
-                raise ValueError(f"empty range for randrange({start}, {stop}, {step})")
-
-            if step != 1:
-                endpoint = (stop - start) // step
-                if (start - stop) % step == 0:
-                    endpoint -= 1
-
-                i = cu.integer_range(self.__data, 0, endpoint)
-                result = start + i * step
-            else:
-                result = cu.integer_range(self.__data, start, stop - 1)
-        elif method == "randint":
-            result = cu.integer_range(self.__data, kwargs"a", kwargs"b")
-        elif method == "choice":
-            seq = kwargs"seq"
-            result = cu.integer_range(self.__data, 0, len(seq) - 1)
-        elif method == "choices":
-            k = kwargs"k"
-            result = self.__data.draw(
-                lists(
-                    integers(0, len(kwargs"population") - 1),
-                    min_size=k,
-                    max_size=k,
-                )
-            )
-        elif method == "sample":
-            k = kwargs"k"
-            seq = kwargs"population"
-
-            if k > len(seq) or k < 0:
-                raise ValueError(
-                    f"Sample size {k} not in expected range 0 <= k <= {len(seq)}"
-                )
-
-            result = self.__data.draw(
-                lists(
-                    sampled_from(range(len(seq))),
-                    min_size=k,
-                    max_size=k,
-                    unique=True,
-                )
-            )
-
-        elif method == "getrandbits":
-            result = self.__data.draw_bits(kwargs"n")
-        elif method == "triangular":
-            low = normalize_zero(kwargs"low")
-            high = normalize_zero(kwargs"high")
-            mode = normalize_zero(kwargs"mode")
-            if mode is None:
-                result = self.__data.draw(floats(low, high))
-            elif self.__data.draw_bits(1):
-                result = self.__data.draw(floats(mode, high))
-            else:
-                result = self.__data.draw(floats(low, mode))
-        elif method in ("paretovariate", "expovariate", "lognormvariate"):
-            result = self.__data.draw(floats(min_value=0.0))
-        elif method == "shuffle":
-            result = self.__data.draw(permutations(range(len(kwargs"x"))))
-        # This is tested for but only appears in 3.9 so doesn't appear in coverage.
-        elif method == "randbytes":  # pragma: no cover
-            n = kwargs"n"
-            result = self.__data.draw(binary(min_size=n, max_size=n))
-        else:
-            raise NotImplementedError(method)
-
-        new_state = RandomState()
-        self.__state.next_stateskey = (result, new_state)
-        self.__state = new_state
-
-        return self.__convert_result(method, kwargs, result)
-
-    def seed(self, seed):
-        self.__state = state_for_seed(self.__data, seed)
-
-    def getstate(self):
-        if self.__state.state_id is not None:
-            return self.__state.state_id
-
-        try:
-            states_for_ids = self.__data.states_for_ids
-        except AttributeError:
-            states_for_ids = {}
-            self.__data.states_for_ids = states_for_ids
-
-        self.__state.state_id = len(states_for_ids)
-        states_for_idsself.__state.state_id = self.__state
-
-        return self.__state.state_id
-
-    def setstate(self, state):
-        self.__state = self.__data.states_for_idsstate
-
-
-DUMMY_RANDOM = Random(0)
-
-
-def convert_kwargs(name, kwargs):
-    kwargs = dict(kwargs)
-
-    signature = sig_of(name)
-
-    bound = signature.bind(DUMMY_RANDOM, **kwargs)
-    bound.apply_defaults()
-
-    for k in list(kwargs):
-        if (
-            kwargsk is signature.parametersk.default
-            or signature.parametersk.kind != inspect.Parameter.KEYWORD_ONLY
-        ):
-            kwargs.pop(k)
-
-    arg_names = list(signature.parameters)1:
-
-    args = 
-
-    for a in arg_names:
-        if signature.parametersa.kind == inspect.Parameter.KEYWORD_ONLY:
-            break
-        args.append(bound.argumentsa)
-        kwargs.pop(a, None)
-
-    while args:
-        name = arg_nameslen(args) - 1
-        if args-1 is signature.parametersname.default:
-            args.pop()
-        else:
-            break  # pragma: no cover  # Only on Python < 3.8
-
-    return (args, kwargs)
-
-
-class TrueRandom(HypothesisRandom):
-    def __init__(self, seed, note_method_calls):
-        super().__init__(note_method_calls)
-        self.__seed = seed
-        self.__random = Random(seed)
-
-    def _hypothesis_do_random(self, method, kwargs):
-        args, kwargs = convert_kwargs(method, kwargs)
-
-        return getattr(self.__random, method)(*args, **kwargs)
-
-    def __copy__(self):
-        result = TrueRandom(
-            seed=self.__seed,
-            note_method_calls=self._HypothesisRandom__note_method_calls,
-        )
-        result.setstate(self.getstate())
-        return result
-
-    def __repr__(self):
-        return f"Random({self.__seed!r})"
-
-    def seed(self, seed):
-        self.__random.seed(seed)
-        self.__seed = seed
-
-    def getstate(self):
-        return self.__random.getstate()
-
-    def setstate(self, state):
-        self.__random.setstate(state)
-
-
-class RandomStrategy(SearchStrategy):
-    def __init__(self, note_method_calls, use_true_random):
-        self.__note_method_calls = note_method_calls
-        self.__use_true_random = use_true_random
-
-    def do_draw(self, data):
-        if self.__use_true_random:
-            seed = data.draw_bits(64)
-            return TrueRandom(seed=seed, note_method_calls=self.__note_method_calls)
-        else:
-            return ArtificialRandom(
-                note_method_calls=self.__note_method_calls, data=data
-            )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/recursive.py Deleted

@@ -1,117 +0,0 @@
-# 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 threading
-from contextlib import contextmanager
-
-from hypothesis.internal.lazyformat import lazyformat
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.strategies._internal.strategies import (
-    OneOfStrategy,
-    SearchStrategy,
-    check_strategy,
-)
-
-
-class LimitReached(BaseException):
-    pass
-
-
-class LimitedStrategy(SearchStrategy):
-    def __init__(self, strategy):
-        super().__init__()
-        self.base_strategy = strategy
-        self._threadlocal = threading.local()
-
-    @property
-    def marker(self):
-        return getattr(self._threadlocal, "marker", 0)
-
-    @marker.setter
-    def marker(self, value):
-        self._threadlocal.marker = value
-
-    @property
-    def currently_capped(self):
-        return getattr(self._threadlocal, "currently_capped", False)
-
-    @currently_capped.setter
-    def currently_capped(self, value):
-        self._threadlocal.currently_capped = value
-
-    def __repr__(self):
-        return f"LimitedStrategy({self.base_strategy!r})"
-
-    def do_validate(self):
-        self.base_strategy.validate()
-
-    def do_draw(self, data):
-        assert self.currently_capped
-        if self.marker <= 0:
-            raise LimitReached()
-        self.marker -= 1
-        return data.draw(self.base_strategy)
-
-    @contextmanager
-    def capped(self, max_templates):
-        try:
-            was_capped = self.currently_capped
-            self.currently_capped = True
-            self.marker = max_templates
-            yield
-        finally:
-            self.currently_capped = was_capped
-
-
-class RecursiveStrategy(SearchStrategy):
-    def __init__(self, base, extend, max_leaves):
-        self.max_leaves = max_leaves
-        self.base = base
-        self.limited_base = LimitedStrategy(base)
-        self.extend = extend
-
-        strategies = self.limited_base, self.extend(self.limited_base)
-        while 2 ** (len(strategies) - 1) <= max_leaves:
-            strategies.append(extend(OneOfStrategy(tuple(strategies))))
-        self.strategy = OneOfStrategy(strategies)
-
-    def __repr__(self):
-        if not hasattr(self, "_cached_repr"):
-            self._cached_repr = "recursive(%r, %s, max_leaves=%d)" % (
-                self.base,
-                get_pretty_function_description(self.extend),
-                self.max_leaves,
-            )
-        return self._cached_repr
-
-    def do_validate(self):
-        check_strategy(self.base, "base")
-        extended = self.extend(self.limited_base)
-        check_strategy(extended, f"extend({self.limited_base!r})")
-        self.limited_base.validate()
-        extended.validate()
-
-    def do_draw(self, data):
-        count = 0
-        while True:
-            try:
-                with self.limited_base.capped(self.max_leaves):
-                    return data.draw(self.strategy)
-            except LimitReached:
-                # Workaround for possible coverage bug - this branch is definitely
-                # covered but for some reason is showing up as not covered.
-                if count == 0:  # pragma: no branch
-                    data.note_event(
-                        lazyformat(
-                            "Draw for %r exceeded max_leaves and had to be retried",
-                            self,
-                        )
-                    )
-                count += 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/regex.py Deleted

@@ -1,501 +0,0 @@
-# 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 operator
-import re
-
-try:  # pragma: no cover
-    import re._constants as sre
-    import re._parser as sre_parse
-except ImportError:  # Python < 3.11
-    import sre_constants as sre  # type: ignore
-    import sre_parse  # type: ignore
-
-from hypothesis import reject, strategies as st
-from hypothesis.internal.charmap import as_general_categories, categories
-from hypothesis.internal.compat import int_to_byte
-
-UNICODE_CATEGORIES = set(categories())
-
-
-SPACE_CHARS = set(" \t\n\r\f\v")
-UNICODE_SPACE_CHARS = SPACE_CHARS | set("\x1c\x1d\x1e\x1f\x85")
-UNICODE_DIGIT_CATEGORIES = {"Nd"}
-UNICODE_SPACE_CATEGORIES = set(as_general_categories("Z"))
-UNICODE_LETTER_CATEGORIES = set(as_general_categories("L"))
-UNICODE_WORD_CATEGORIES = set(as_general_categories("L", "N"))
-
-# This is verbose, but correct on all versions of Python
-BYTES_ALL = {int_to_byte(i) for i in range(256)}
-BYTES_DIGIT = {b for b in BYTES_ALL if re.match(b"\\d", b)}
-BYTES_SPACE = {b for b in BYTES_ALL if re.match(b"\\s", b)}
-BYTES_WORD = {b for b in BYTES_ALL if re.match(b"\\w", b)}
-BYTES_LOOKUP = {
-    sre.CATEGORY_DIGIT: BYTES_DIGIT,
-    sre.CATEGORY_SPACE: BYTES_SPACE,
-    sre.CATEGORY_WORD: BYTES_WORD,
-    sre.CATEGORY_NOT_DIGIT: BYTES_ALL - BYTES_DIGIT,
-    sre.CATEGORY_NOT_SPACE: BYTES_ALL - BYTES_SPACE,
-    sre.CATEGORY_NOT_WORD: BYTES_ALL - BYTES_WORD,
-}
-
-
-GROUP_CACHE_STRATEGY = st.shared(st.builds(dict), key="hypothesis.regex.group_cache")
-
-
-@st.composite
-def update_group(draw, group_name, strategy):
-    cache = draw(GROUP_CACHE_STRATEGY)
-    result = draw(strategy)
-    cachegroup_name = result
-    return result
-
-
-@st.composite
-def reuse_group(draw, group_name):
-    cache = draw(GROUP_CACHE_STRATEGY)
-    try:
-        return cachegroup_name
-    except KeyError:
-        reject()
-
-
-@st.composite
-def group_conditional(draw, group_name, if_yes, if_no):
-    cache = draw(GROUP_CACHE_STRATEGY)
-    if group_name in cache:
-        return draw(if_yes)
-    else:
-        return draw(if_no)
-
-
-@st.composite
-def clear_cache_after_draw(draw, base_strategy):
-    cache = draw(GROUP_CACHE_STRATEGY)
-    result = draw(base_strategy)
-    cache.clear()
-    return result
-
-
-class Context:
-    __slots__ = "flags"
-
-    def __init__(self, flags):
-        self.flags = flags
-
-
-class CharactersBuilder:
-    """Helper object that allows to configure `characters` strategy with
-    various unicode categories and characters. Also allows negation of
-    configured set.
-
-    :param negate: If True, configure :func:`hypothesis.strategies.characters`
-        to match anything other than configured character set
-    :param flags: Regex flags. They affect how and which characters are matched
-    """
-
-    def __init__(self, negate=False, flags=0):
-        self._categories = set()
-        self._whitelist_chars = set()
-        self._blacklist_chars = set()
-        self._negate = negate
-        self._ignorecase = flags & re.IGNORECASE
-        self._unicode = not bool(flags & re.ASCII)
-        self.code_to_char = chr
-
-    @property
-    def strategy(self):
-        """Returns resulting strategy that generates configured char set."""
-        max_codepoint = None if self._unicode else 127
-        # Due to the .swapcase() issue described below (and in issue #2657),
-        # self._whitelist_chars may contain strings of len > 1.  We therefore
-        # have some extra logic to filter them out of st.characters() args,
-        # but still generate them if allowed to.
-        if self._negate:
-            black_chars = self._blacklist_chars - self._whitelist_chars
-            return st.characters(
-                blacklist_categories=self._categories | {"Cc", "Cs"},
-                blacklist_characters={c for c in self._whitelist_chars if len(c) == 1},
-                whitelist_characters=black_chars,
-                max_codepoint=max_codepoint,
-            )
-        white_chars = self._whitelist_chars - self._blacklist_chars
-        multi_chars = {c for c in white_chars if len(c) > 1}
-        char_strategy = st.characters(
-            whitelist_categories=self._categories,
-            blacklist_characters=self._blacklist_chars,
-            whitelist_characters=white_chars - multi_chars,
-            max_codepoint=max_codepoint,
-        )
-        if multi_chars:
-            char_strategy |= st.sampled_from(sorted(multi_chars))
-        return char_strategy
-
-    def add_category(self, category):
-        """Update unicode state to match sre_parse object ``category``."""
-        if category == sre.CATEGORY_DIGIT:
-            self._categories |= UNICODE_DIGIT_CATEGORIES
-        elif category == sre.CATEGORY_NOT_DIGIT:
-            self._categories |= UNICODE_CATEGORIES - UNICODE_DIGIT_CATEGORIES
-        elif category == sre.CATEGORY_SPACE:
-            self._categories |= UNICODE_SPACE_CATEGORIES
-            self._whitelist_chars |= (
-                UNICODE_SPACE_CHARS if self._unicode else SPACE_CHARS
-            )
-        elif category == sre.CATEGORY_NOT_SPACE:
-            self._categories |= UNICODE_CATEGORIES - UNICODE_SPACE_CATEGORIES
-            self._blacklist_chars |= (
-                UNICODE_SPACE_CHARS if self._unicode else SPACE_CHARS
-            )
-        elif category == sre.CATEGORY_WORD:
-            self._categories |= UNICODE_WORD_CATEGORIES
-            self._whitelist_chars.add("_")
-        elif category == sre.CATEGORY_NOT_WORD:
-            self._categories |= UNICODE_CATEGORIES - UNICODE_WORD_CATEGORIES
-            self._blacklist_chars.add("_")
-        else:
-            raise NotImplementedError(f"Unknown character category: {category}")
-
-    def add_char(self, char):
-        """Add given char to the whitelist."""
-        c = self.code_to_char(char)
-        self._whitelist_chars.add(c)
-        if (
-            self._ignorecase
-            and re.match(re.escape(c), c.swapcase(), flags=re.IGNORECASE) is not None
-        ):
-            # Note that it is possible that `len(c.swapcase()) > 1`
-            self._whitelist_chars.add(c.swapcase())
-
-
-class BytesBuilder(CharactersBuilder):
-    def __init__(self, negate=False, flags=0):
-        self._whitelist_chars = set()
-        self._blacklist_chars = set()
-        self._negate = negate
-        self._ignorecase = flags & re.IGNORECASE
-        self.code_to_char = int_to_byte
-
-    @property
-    def strategy(self):
-        """Returns resulting strategy that generates configured char set."""
-        allowed = self._whitelist_chars
-        if self._negate:
-            allowed = BYTES_ALL - allowed
-        return st.sampled_from(sorted(allowed))
-
-    def add_category(self, category):
-        """Update characters state to match sre_parse object ``category``."""
-        self._whitelist_chars |= BYTES_LOOKUPcategory
-
-
-@st.composite
-def maybe_pad(draw, regex, strategy, left_pad_strategy, right_pad_strategy):
-    """Attempt to insert padding around the result of a regex draw while
-    preserving the match."""
-    result = draw(strategy)
-    left_pad = draw(left_pad_strategy)
-    if left_pad and regex.search(left_pad + result):
-        result = left_pad + result
-    right_pad = draw(right_pad_strategy)
-    if right_pad and regex.search(result + right_pad):
-        result += right_pad
-    return result
-
-
-def base_regex_strategy(regex, parsed=None):
-    if parsed is None:
-        parsed = sre_parse.parse(regex.pattern, flags=regex.flags)
-    return clear_cache_after_draw(
-        _strategy(parsed, Context(flags=regex.flags), isinstance(regex.pattern, str))
-    )
-
-
-def regex_strategy(regex, fullmatch, *, _temp_jsonschema_hack_no_end_newline=False):
-    if not hasattr(regex, "pattern"):
-        regex = re.compile(regex)
-
-    is_unicode = isinstance(regex.pattern, str)
-
-    parsed = sre_parse.parse(regex.pattern, flags=regex.flags)
-
-    if fullmatch:
-        if not parsed:
-            return st.just("" if is_unicode else b"")
-        return base_regex_strategy(regex, parsed).filter(regex.fullmatch)
-
-    if not parsed:
-        if is_unicode:
-            return st.text()
-        else:
-            return st.binary()
-
-    if is_unicode:
-        base_padding_strategy = st.text()
-        empty = st.just("")
-        newline = st.just("\n")
-    else:
-        base_padding_strategy = st.binary()
-        empty = st.just(b"")
-        newline = st.just(b"\n")
-
-    right_pad = base_padding_strategy
-    left_pad = base_padding_strategy
-
-    if parsed-10 == sre.AT:
-        if parsed-11 == sre.AT_END_STRING:
-            right_pad = empty
-        elif parsed-11 == sre.AT_END:
-            if regex.flags & re.MULTILINE:
-                right_pad = st.one_of(
-                    empty, st.builds(operator.add, newline, right_pad)
-                )
-            else:
-                right_pad = st.one_of(empty, newline)
-
-            # This will be removed when a regex-syntax-translation library exists.
-            # It's a pretty nasty hack, but means that we can match the semantics
-            # of JSONschema's compatible subset of ECMA regex, which is important
-            # for hypothesis-jsonschema and Schemathesis. See e.g.
-            # https://github.com/schemathesis/schemathesis/issues/1241
-            if _temp_jsonschema_hack_no_end_newline:
-                right_pad = empty
-
-    if parsed00 == sre.AT:
-        if parsed01 == sre.AT_BEGINNING_STRING:
-            left_pad = empty
-        elif parsed01 == sre.AT_BEGINNING:
-            if regex.flags & re.MULTILINE:
-                left_pad = st.one_of(empty, st.builds(operator.add, left_pad, newline))
-            else:
-                left_pad = empty
-
-    base = base_regex_strategy(regex, parsed).filter(regex.search)
-
-    return maybe_pad(regex, base, left_pad, right_pad)
-
-
-def _strategy(codes, context, is_unicode):
-    """Convert SRE regex parse tree to strategy that generates strings matching
-    that regex represented by that parse tree.
-
-    `codes` is either a list of SRE regex elements representations or a
-    particular element representation. Each element is a tuple of element code
-    (as string) and parameters. E.g. regex 'ab0-9+' compiles to following
-    elements:
-
-        
-            (LITERAL, 97),
-            (LITERAL, 98),
-            (MAX_REPEAT, (1, 4294967295, 
-                (IN, 
-                    (RANGE, (48, 57))
-                )
-            ))
-        
-
-    The function recursively traverses regex element tree and converts each
-    element to strategy that generates strings that match that element.
-
-    Context stores
-    1. List of groups (for backreferences)
-    2. Active regex flags (e.g. IGNORECASE, DOTALL, UNICODE, they affect
-       behavior of various inner strategies)
-    """
-
-    def recurse(codes):
-        return _strategy(codes, context, is_unicode)
-
-    if is_unicode:
-        empty = ""
-        to_char = chr
-    else:
-        empty = b""
-        to_char = int_to_byte
-        binary_char = st.binary(min_size=1, max_size=1)
-
-    if not isinstance(codes, tuple):
-        # List of codes
-        strategies = 
-
-        i = 0
-        while i < len(codes):
-            if codesi0 == sre.LITERAL and not context.flags & re.IGNORECASE:
-                # Merge subsequent "literals" into one `just()` strategy
-                # that generates corresponding text if no IGNORECASE
-                j = i + 1
-                while j < len(codes) and codesj0 == sre.LITERAL:
-                    j += 1
-
-                if i + 1 < j:
-                    chars = (to_char(charcode) for _, charcode in codesi:j)
-                    strategies.append(st.just(empty.join(chars)))
-                    i = j
-                    continue
-
-            strategies.append(recurse(codesi))
-            i += 1
-
-        # We handle this separately at the top level, but some regex can
-        # contain empty lists internally, so we need to handle this here too.
-        if not strategies:
-            return st.just(empty)
-
-        if len(strategies) == 1:
-            return strategies0
-        return st.tuples(*strategies).map(empty.join)
-    else:
-        # Single code
-        code, value = codes
-        if code == sre.LITERAL:
-            # Regex 'a' (single char)
-            c = to_char(value)
-            if (
-                context.flags & re.IGNORECASE
-                and c != c.swapcase()
-                and re.match(re.escape(c), c.swapcase(), re.IGNORECASE) is not None
-            ):
-                # We do the explicit check for swapped-case matching because
-                # eg 'ß'.upper() == 'SS' and ignorecase doesn't match it.
-                return st.sampled_from(c, c.swapcase())
-            return st.just(c)
-
-        elif code == sre.NOT_LITERAL:
-            # Regex '^a' (negation of a single char)
-            c = to_char(value)
-            blacklist = {c}
-            if (
-                context.flags & re.IGNORECASE
-                and re.match(re.escape(c), c.swapcase(), re.IGNORECASE) is not None
-            ):
-                # There are a few cases where .swapcase() returns two characters,
-                # but is still a case-insensitive match.  In such cases we add *both*
-                # characters to our blacklist, to avoid doing the wrong thing for
-                # patterns such as r"^\u0130+" where "i\u0307" matches.
-                #
-                # (that's respectively 'Latin letter capital I with dot above' and
-                # 'latin latter i' + 'combining dot above'; see issue #2657)
-                #
-                # As a final additional wrinkle, "latin letter capital I" *also*
-                # case-insensitive-matches, with or without combining dot character.
-                # We therefore have to chain .swapcase() calls until a fixpoint.
-                stack = c.swapcase()
-                while stack:
-                    for char in stack.pop():
-                        blacklist.add(char)
-                        stack.extend(set(char.swapcase()) - blacklist)
-
-            if is_unicode:
-                return st.characters(blacklist_characters=blacklist)
-            else:
-                return binary_char.filter(lambda c: c not in blacklist)
-
-        elif code == sre.IN:
-            # Regex 'abc0-9' (set of characters)
-            negate = value00 == sre.NEGATE
-            if is_unicode:
-                builder = CharactersBuilder(negate, context.flags)
-            else:
-                builder = BytesBuilder(negate, context.flags)
-
-            for charset_code, charset_value in value:
-                if charset_code == sre.NEGATE:
-                    # Regex '^...' (negation)
-                    # handled by builder = CharactersBuilder(...) above
-                    pass
-                elif charset_code == sre.LITERAL:
-                    # Regex 'a' (single char)
-                    builder.add_char(charset_value)
-                elif charset_code == sre.RANGE:
-                    # Regex 'a-z' (char range)
-                    low, high = charset_value
-                    for char_code in range(low, high + 1):
-                        builder.add_char(char_code)
-                elif charset_code == sre.CATEGORY:
-                    # Regex '\w' (char category)
-                    builder.add_category(charset_value)
-                else:
-                    # Currently there are no known code points other than
-                    # handled here. This code is just future proofing
-                    raise NotImplementedError(f"Unknown charset code: {charset_code}")
-            return builder.strategy
-
-        elif code == sre.ANY:
-            # Regex '.' (any char)
-            if is_unicode:
-                if context.flags & re.DOTALL:
-                    return st.characters()
-                return st.characters(blacklist_characters="\n")
-            else:
-                if context.flags & re.DOTALL:
-                    return binary_char
-                return binary_char.filter(lambda c: c != b"\n")
-
-        elif code == sre.AT:
-            # Regexes like '^...', '...$', '\bfoo', '\Bfoo'
-            # An empty string (or newline) will match the token itself, but
-            # we don't and can't check the position (eg '%' at the end)
-            return st.just(empty)
-
-        elif code == sre.SUBPATTERN:
-            # Various groups: '(...)', '(:...)' or '(?P<name>...)'
-            old_flags = context.flags
-            context.flags = (context.flags | value1) & ~value2
-
-            strat = _strategy(value-1, context, is_unicode)
-
-            context.flags = old_flags
-
-            if value0:
-                strat = update_group(value0, strat)
-
-            return strat
-
-        elif code == sre.GROUPREF:
-            # Regex '\\1' or '(?P=name)' (group reference)
-            return reuse_group(value)
-
-        elif code == sre.ASSERT:
-            # Regex '(?=...)' or '(?<=...)' (positive lookahead/lookbehind)
-            return recurse(value1)
-
-        elif code == sre.ASSERT_NOT:
-            # Regex '(?!...)' or '(?<!...)' (negative lookahead/lookbehind)
-            return st.just(empty)
-
-        elif code == sre.BRANCH:
-            # Regex 'a|b|c' (branch)
-            return st.one_of(recurse(branch) for branch in value1)
-
-        elif code in sre.MIN_REPEAT, sre.MAX_REPEAT:
-            # Regexes 'a?', 'a*', 'a+' and their non-greedy variants
-            # (repeaters)
-            at_least, at_most, subregex = value
-            if at_most == sre.MAXREPEAT:
-                at_most = None
-            if at_least == 0 and at_most == 1:
-                return st.just(empty) | recurse(subregex)
-            return st.lists(recurse(subregex), min_size=at_least, max_size=at_most).map(
-                empty.join
-            )
-
-        elif code == sre.GROUPREF_EXISTS:
-            # Regex '(?(id/name)yes-pattern|no-pattern)'
-            # (if group exists choice)
-            return group_conditional(
-                value0,
-                recurse(value1),
-                recurse(value2) if value2 else st.just(empty),
-            )
-
-        else:
-            # Currently there are no known code points other than handled here.
-            # This code is just future proofing
-            raise NotImplementedError(f"Unknown code point: {code!r}")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/strategies.py Deleted

@@ -1,983 +0,0 @@
-# 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 sys
-import warnings
-from collections import abc, defaultdict
-from random import shuffle
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generic,
-    List,
-    Sequence,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
-
-from hypothesis._settings import HealthCheck, Phase, Verbosity, settings
-from hypothesis.control import _current_build_context, assume
-from hypothesis.errors import (
-    HypothesisException,
-    InvalidArgument,
-    NonInteractiveExampleWarning,
-    UnsatisfiedAssumption,
-)
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.internal.conjecture.utils import (
-    calc_label_from_cls,
-    calc_label_from_name,
-    combine_labels,
-)
-from hypothesis.internal.coverage import check_function
-from hypothesis.internal.lazyformat import lazyformat
-from hypothesis.internal.reflection import (
-    get_pretty_function_description,
-    is_identity_function,
-)
-from hypothesis.strategies._internal.utils import defines_strategy
-from hypothesis.utils.conventions import UniqueIdentifier
-
-Ex = TypeVar("Ex", covariant=True)
-Ex_Inv = TypeVar("Ex_Inv")
-T = TypeVar("T")
-T3 = TypeVar("T3")
-T4 = TypeVar("T4")
-T5 = TypeVar("T5")
-
-calculating = UniqueIdentifier("calculating")
-
-MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
-    "another attempted draw in MappedSearchStrategy"
-)
-
-FILTERED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
-    "single loop iteration in FilteredStrategy"
-)
-
-
-def recursive_property(name, default):
-    """Handle properties which may be mutually recursive among a set of
-    strategies.
-
-    These are essentially lazily cached properties, with the ability to set
-    an override: If the property has not been explicitly set, we calculate
-    it on first access and memoize the result for later.
-
-    The problem is that for properties that depend on each other, a naive
-    calculation strategy may hit infinite recursion. Consider for example
-    the property is_empty. A strategy defined as x = st.deferred(lambda: x)
-    is certainly empty (in order to draw a value from x we would have to
-    draw a value from x, for which we would have to draw a value from x,
-    ...), but in order to calculate it the naive approach would end up
-    calling x.is_empty in order to calculate x.is_empty in order to etc.
-
-    The solution is one of fixed point calculation. We start with a default
-    value that is the value of the property in the absence of evidence to
-    the contrary, and then update the values of the property for all
-    dependent strategies until we reach a fixed point.
-
-    The approach taken roughly follows that in section 4.2 of Adams,
-    Michael D., Celeste Hollenbeck, and Matthew Might. "On the complexity
-    and performance of parsing with derivatives." ACM SIGPLAN Notices 51.6
-    (2016): 224-236.
-    """
-    cache_key = "cached_" + name
-    calculation = "calc_" + name
-    force_key = "force_" + name
-
-    def forced_value(target):
-        try:
-            return getattr(target, force_key)
-        except AttributeError:
-            return getattr(target, cache_key)
-
-    def accept(self):
-        try:
-            return forced_value(self)
-        except AttributeError:
-            pass
-
-        mapping = {}
-        sentinel = object()
-        hit_recursion = False
-
-        # For a first pass we do a direct recursive calculation of the
-        # property, but we block recursively visiting a value in the
-        # computation of its property: When that happens, we simply
-        # note that it happened and return the default value.
-        def recur(strat):
-            try:
-                return forced_value(strat)
-            except AttributeError:
-                pass
-            result = mapping.get(strat, sentinel)
-            if result is calculating:
-                hit_recursion0 = True
-                return default
-            elif result is sentinel:
-                mappingstrat = calculating
-                mappingstrat = getattr(strat, calculation)(recur)
-                return mappingstrat
-            return result
-
-        recur(self)
-
-        # If we hit self-recursion in the computation of any strategy
-        # value, our mapping at the end is imprecise - it may or may
-        # not have the right values in it. We now need to proceed with
-        # a more careful fixed point calculation to get the exact
-        # values. Hopefully our mapping is still pretty good and it
-        # won't take a large number of updates to reach a fixed point.
-        if hit_recursion0:
-            needs_update = set(mapping)
-
-            # We track which strategies use which in the course of
-            # calculating their property value. If A ever uses B in
-            # the course of calculating its value, then whenever the
-            # value of B changes we might need to update the value of
-            # A.
-            listeners = defaultdict(set)
-        else:
-            needs_update = None
-
-        def recur2(strat):
-            def recur_inner(other):
-                try:
-                    return forced_value(other)
-                except AttributeError:
-                    pass
-                listenersother.add(strat)
-                result = mapping.get(other, sentinel)
-                if result is sentinel:
-                    needs_update.add(other)
-                    mappingother = default
-                    return default
-                return result
-
-            return recur_inner
-
-        count = 0
-        seen = set()
-        while needs_update:
-            count += 1
-            # If we seem to be taking a really long time to stabilize we
-            # start tracking seen values to attempt to detect an infinite
-            # loop. This should be impossible, and most code will never
-            # hit the count, but having an assertion for it means that
-            # testing is easier to debug and we don't just have a hung
-            # test.
-            # Note: This is actually covered, by test_very_deep_deferral
-            # in tests/cover/test_deferred_strategies.py. Unfortunately it
-            # runs into a coverage bug. See
-            # https://github.com/nedbat/coveragepy/issues/605
-            # for details.
-            if count > 50:  # pragma: no cover
-                key = frozenset(mapping.items())
-                assert key not in seen, (key, name)
-                seen.add(key)
-            to_update = needs_update
-            needs_update = set()
-            for strat in to_update:
-                new_value = getattr(strat, calculation)(recur2(strat))
-                if new_value != mappingstrat:
-                    needs_update.update(listenersstrat)
-                    mappingstrat = new_value
-
-        # We now have a complete and accurate calculation of the
-        # property values for everything we have seen in the course of
-        # running this calculation. We simultaneously update all of
-        # them (not just the strategy we started out with).
-        for k, v in mapping.items():
-            setattr(k, cache_key, v)
-        return getattr(self, cache_key)
-
-    accept.__name__ = name
-    return property(accept)
-
-
-class SearchStrategy(GenericEx):
-    """A SearchStrategy is an object that knows how to explore data of a given
-    type.
-
-    Except where noted otherwise, methods on this class are not part of
-    the public API and their behaviour may change significantly between
-    minor version releases. They will generally be stable between patch
-    releases.
-    """
-
-    supports_find = True
-    validate_called = False
-    __label = None
-    __module__ = "hypothesis.strategies"
-
-    def available(self, data):
-        """Returns whether this strategy can *currently* draw any
-        values. This typically useful for stateful testing where ``Bundle``
-        grows over time a list of value to choose from.
-
-        Unlike ``empty`` property, this method's return value may change
-        over time.
-        Note: ``data`` parameter will only be used for introspection and no
-        value drawn from it.
-        """
-        return not self.is_empty
-
-    # Returns True if this strategy can never draw a value and will always
-    # result in the data being marked invalid.
-    # The fact that this returns False does not guarantee that a valid value
-    # can be drawn - this is not intended to be perfect, and is primarily
-    # intended to be an optimisation for some cases.
-    is_empty = recursive_property("is_empty", True)
-
-    # Returns True if values from this strategy can safely be reused without
-    # this causing unexpected behaviour.
-
-    # True if values from this strategy can be implicitly reused (e.g. as
-    # background values in a numpy array) without causing surprising
-    # user-visible behaviour. Should be false for built-in strategies that
-    # produce mutable values, and for strategies that have been mapped/filtered
-    # by arbitrary user-provided functions.
-    has_reusable_values = recursive_property("has_reusable_values", True)
-
-    # Whether this strategy is suitable for holding onto in a cache.
-    is_cacheable = recursive_property("is_cacheable", True)
-
-    def calc_is_cacheable(self, recur):
-        return True
-
-    def calc_is_empty(self, recur):
-        # Note: It is correct and significant that the default return value
-        # from calc_is_empty is False despite the default value for is_empty
-        # being true. The reason for this is that strategies should be treated
-        # as empty absent evidence to the contrary, but most basic strategies
-        # are trivially non-empty and it would be annoying to have to override
-        # this method to show that.
-        return False
-
-    def calc_has_reusable_values(self, recur):
-        return False
-
-    def example(self) -> Ex:
-        """Provide an example of the sort of value that this strategy
-        generates. This is biased to be slightly simpler than is typical for
-        values from this strategy, for clarity purposes.
-
-        This method shouldn't be taken too seriously. It's here for interactive
-        exploration of the API, not for any sort of real testing.
-
-        This method is part of the public API.
-        """
-        if getattr(sys, "ps1", None) is None:  # pragma: no branch
-            # The other branch *is* covered in cover/test_examples.py; but as that
-            # uses `pexpect` for an interactive session `coverage` doesn't see it.
-            warnings.warn(
-                "The `.example()` method is good for exploring strategies, but should "
-                "only be used interactively.  We recommend using `@given` for tests - "
-                "it performs better, saves and replays failures to avoid flakiness, "
-                "and reports minimal examples. (strategy: %r)" % (self,),
-                NonInteractiveExampleWarning,
-            )
-
-        context = _current_build_context.value
-        if context is not None:
-            if context.data is not None and context.data.depth > 0:
-                raise HypothesisException(
-                    "Using example() inside a strategy definition is a bad "
-                    "idea. Instead consider using hypothesis.strategies.builds() "
-                    "or @hypothesis.strategies.composite to define your strategy."
-                    " See https://hypothesis.readthedocs.io/en/latest/data.html"
-                    "#hypothesis.strategies.builds or "
-                    "https://hypothesis.readthedocs.io/en/latest/data.html"
-                    "#composite-strategies for more details."
-                )
-            else:
-                raise HypothesisException(
-                    "Using example() inside a test function is a bad "
-                    "idea. Instead consider using hypothesis.strategies.data() "
-                    "to draw more examples during testing. See "
-                    "https://hypothesis.readthedocs.io/en/latest/data.html"
-                    "#drawing-interactively-in-tests for more details."
-                )
-
-        try:
-            return self.__examples.pop()
-        except (AttributeError, IndexError):
-            self.__examples: ListEx = 
-
-        from hypothesis.core import given
-
-        # Note: this function has a weird name because it might appear in
-        # tracebacks, and we want users to know that they can ignore it.
-        @given(self)
-        @settings(
-            database=None,
-            max_examples=100,
-            deadline=None,
-            verbosity=Verbosity.quiet,
-            phases=(Phase.generate,),
-            suppress_health_check=HealthCheck.all(),
-        )
-        def example_generating_inner_function(ex):
-            self.__examples.append(ex)
-
-        example_generating_inner_function()
-        shuffle(self.__examples)
-        return self.__examples.pop()
-
-    def map(self, pack: CallableEx, T) -> "SearchStrategyT":
-        """Returns a new strategy that generates values by generating a value
-        from this strategy and then calling pack() on the result, giving that.
-
-        This method is part of the public API.
-        """
-        if is_identity_function(pack):
-            return self  # type: ignore  # Mypy has no way to know that `Ex == T`
-        return MappedSearchStrategy(pack=pack, strategy=self)
-
-    def flatmap(
-        self, expand: CallableEx, "SearchStrategyT"
-    ) -> "SearchStrategyT":
-        """Returns a new strategy that generates values by generating a value
-        from this strategy, say x, then generating a value from
-        strategy(expand(x))
-
-        This method is part of the public API.
-        """
-        from hypothesis.strategies._internal.flatmapped import FlatMapStrategy
-
-        return FlatMapStrategy(expand=expand, strategy=self)
-
-    def filter(self, condition: CallableEx, Any) -> "SearchStrategyEx":
-        """Returns a new strategy that generates values from this strategy
-        which satisfy the provided condition. Note that if the condition is too
-        hard to satisfy this might result in your tests failing with
-        Unsatisfiable.
-
-        This method is part of the public API.
-        """
-        return FilteredStrategy(conditions=(condition,), strategy=self)
-
-    def _filter_for_filtered_draw(self, condition):
-        # Hook for parent strategies that want to perform fallible filtering
-        # on one of their internal strategies (e.g. UniqueListStrategy).
-        # The returned object must have a `.do_filtered_draw(data)` method
-        # that behaves like `do_draw`, but returns the sentinel object
-        # `filter_not_satisfied` if the condition could not be satisfied.
-
-        # This is separate from the main `filter` method so that strategies
-        # can override `filter` without having to also guarantee a
-        # `do_filtered_draw` method.
-        return FilteredStrategy(conditions=(condition,), strategy=self)
-
-    @property
-    def branches(self) -> List"SearchStrategyEx":
-        return self
-
-    def __or__(self, other: "SearchStrategyT") -> "SearchStrategyUnionEx, T":
-        """Return a strategy which produces values by randomly drawing from one
-        of this strategy or the other strategy.
-
-        This method is part of the public API.
-        """
-        if not isinstance(other, SearchStrategy):
-            raise ValueError(f"Cannot | a SearchStrategy with {other!r}")
-        return OneOfStrategy((self, other))
-
-    def validate(self) -> None:
-        """Throw an exception if the strategy is not valid.
-
-        This can happen due to lazy construction
-        """
-        if self.validate_called:
-            return
-        try:
-            self.validate_called = True
-            self.do_validate()
-            self.is_empty
-            self.has_reusable_values
-        except Exception:
-            self.validate_called = False
-            raise
-
-    LABELS: Dicttype, int = {}
-
-    @property
-    def class_label(self):
-        cls = self.__class__
-        try:
-            return cls.LABELScls
-        except KeyError:
-            pass
-        result = calc_label_from_cls(cls)
-        cls.LABELScls = result
-        return result
-
-    @property
-    def label(self) -> int:
-        if self.__label is calculating:
-            return 0
-        if self.__label is None:
-            self.__label = calculating
-            self.__label = self.calc_label()
-        return cast(int, self.__label)
-
-    def calc_label(self):
-        return self.class_label
-
-    def do_validate(self):
-        pass
-
-    def do_draw(self, data: ConjectureData) -> Ex:
-        raise NotImplementedError(f"{type(self).__name__}.do_draw")
-
-    def __init__(self):
-        pass
-
-
-def is_simple_data(value):
-    try:
-        hash(value)
-        return True
-    except TypeError:
-        return False
-
-
-class SampledFromStrategy(SearchStrategy):
-    """A strategy which samples from a set of elements. This is essentially
-    equivalent to using a OneOfStrategy over Just strategies but may be more
-    efficient and convenient.
-
-    The conditional distribution chooses uniformly at random from some
-    non-empty subset of the elements.
-    """
-
-    def __init__(self, elements, repr_=None, transformations=()):
-        super().__init__()
-        self.elements = cu.check_sample(elements, "sampled_from")
-        assert self.elements
-        self.repr_ = repr_
-        self._transformations = transformations
-
-    def map(self, pack):
-        return type(self)(
-            self.elements,
-            repr_=self.repr_,
-            transformations=self._transformations + (("map", pack),),
-        )
-
-    def filter(self, condition):
-        return type(self)(
-            self.elements,
-            repr_=self.repr_,
-            transformations=self._transformations + (("filter", condition),),
-        )
-
-    def __repr__(self):
-        return (
-            self.repr_
-            or "sampled_from("
-            + ", ".join(map(get_pretty_function_description, self.elements))
-            + ")"
-        ) + "".join(
-            f".{name}({get_pretty_function_description(f)})"
-            for name, f in self._transformations
-        )
-
-    def calc_has_reusable_values(self, recur):
-        # Because our custom .map/.filter implementations skip the normal
-        # wrapper strategies (which would automatically return False for us),
-        # we need to manually return False here if any transformations have
-        # been applied.
-        return not self._transformations
-
-    def calc_is_cacheable(self, recur):
-        return is_simple_data(self.elements)
-
-    def _transform(self, element):
-        # Used in UniqueSampledListStrategy
-        for name, f in self._transformations:
-            if name == "map":
-                element = f(element)
-            else:
-                assert name == "filter"
-                if not f(element):
-                    return filter_not_satisfied
-        return element
-
-    def do_draw(self, data):
-        result = self.do_filtered_draw(data)
-        if result is filter_not_satisfied:
-            data.note_event(f"Aborted test because unable to satisfy {self!r}")
-            data.mark_invalid()
-        return result
-
-    def get_element(self, i):
-        return self._transform(self.elementsi)
-
-    def do_filtered_draw(self, data):
-        # Set of indices that have been tried so far, so that we never test
-        # the same element twice during a draw.
-        known_bad_indices = set()
-
-        # Start with ordinary rejection sampling. It's fast if it works, and
-        # if it doesn't work then it was only a small amount of overhead.
-        for _ in range(3):
-            i = cu.integer_range(data, 0, len(self.elements) - 1)
-            if i not in known_bad_indices:
-                element = self.get_element(i)
-                if element is not filter_not_satisfied:
-                    return element
-                if not known_bad_indices:
-                    FilteredStrategy.note_retried(self, data)
-                known_bad_indices.add(i)
-
-        # If we've tried all the possible elements, give up now.
-        max_good_indices = len(self.elements) - len(known_bad_indices)
-        if not max_good_indices:
-            return filter_not_satisfied
-
-        # Figure out the bit-length of the index that we will write back after
-        # choosing an allowed element.
-        write_length = len(self.elements).bit_length()
-
-        # Impose an arbitrary cutoff to prevent us from wasting too much time
-        # on very large element lists.
-        cutoff = 10000
-        max_good_indices = min(max_good_indices, cutoff)
-
-        # Before building the list of allowed indices, speculatively choose
-        # one of them. We don't yet know how many allowed indices there will be,
-        # so this choice might be out-of-bounds, but that's OK.
-        speculative_index = cu.integer_range(data, 0, max_good_indices - 1)
-
-        # Calculate the indices of allowed values, so that we can choose one
-        # of them at random. But if we encounter the speculatively-chosen one,
-        # just use that and return immediately.  Note that we also track the
-        # allowed elements, in case of .map(some_stateful_function)
-        allowed = 
-        for i in range(min(len(self.elements), cutoff)):
-            if i not in known_bad_indices:
-                element = self.get_element(i)
-                if element is not filter_not_satisfied:
-                    allowed.append((i, element))
-                    if len(allowed) > speculative_index:
-                        # Early-exit case: We reached the speculative index, so
-                        # we just return the corresponding element.
-                        data.draw_bits(write_length, forced=i)
-                        return element
-
-        # The speculative index didn't work out, but at this point we've built
-        # and can choose from the complete list of allowed indices and elements.
-        if allowed:
-            i, element = cu.choice(data, allowed)
-            data.draw_bits(write_length, forced=i)
-            return element
-        # If there are no allowed indices, the filter couldn't be satisfied.
-        return filter_not_satisfied
-
-
-class OneOfStrategy(SearchStrategy):
-    """Implements a union of strategies. Given a number of strategies this
-    generates values which could have come from any of them.
-
-    The conditional distribution draws uniformly at random from some
-    non-empty subset of these strategies and then draws from the
-    conditional distribution of that strategy.
-    """
-
-    def __init__(self, strategies):
-        super().__init__()
-        strategies = tuple(strategies)
-        self.original_strategies = list(strategies)
-        self.__element_strategies = None
-        self.__in_branches = False
-
-    def calc_is_empty(self, recur):
-        return all(recur(e) for e in self.original_strategies)
-
-    def calc_has_reusable_values(self, recur):
-        return all(recur(e) for e in self.original_strategies)
-
-    def calc_is_cacheable(self, recur):
-        return all(recur(e) for e in self.original_strategies)
-
-    @property
-    def element_strategies(self):
-        if self.__element_strategies is None:
-            # While strategies are hashable, they use object.__hash__ and are
-            # therefore distinguished only by identity.
-            #
-            # In principle we could "just" define a __hash__ method
-            # (and __eq__, but that's easy in terms of type() and hash())
-            # to make this more powerful, but this is harder than it sounds:
-            #
-            # 1. Strategies are often distinguished by non-hashable attributes,
-            #    or by attributes that have the same hash value ("^.+" / b"^.+").
-            # 2. LazyStrategy: can't reify the wrapped strategy without breaking
-            #    laziness, so there's a hash each for the lazy and the nonlazy.
-            #
-            # Having made several attempts, the minor benefits of making strategies
-            # hashable are simply not worth the engineering effort it would take.
-            # See also issues #2291 and #2327.
-            seen = {self}
-            strategies = 
-            for arg in self.original_strategies:
-                check_strategy(arg)
-                if not arg.is_empty:
-                    for s in arg.branches:
-                        if s not in seen and not s.is_empty:
-                            seen.add(s)
-                            strategies.append(s)
-            self.__element_strategies = strategies
-        return self.__element_strategies
-
-    def calc_label(self):
-        return combine_labels(
-            self.class_label, *(p.label for p in self.original_strategies)
-        )
-
-    def do_draw(self, data: ConjectureData) -> Ex:
-        strategy = data.draw(
-            SampledFromStrategy(self.element_strategies).filter(
-                lambda s: s.available(data)
-            )
-        )
-        return data.draw(strategy)
-
-    def __repr__(self):
-        return "one_of(%s)" % ", ".join(map(repr, self.original_strategies))
-
-    def do_validate(self):
-        for e in self.element_strategies:
-            e.validate()
-
-    @property
-    def branches(self):
-        if not self.__in_branches:
-            try:
-                self.__in_branches = True
-                return self.element_strategies
-            finally:
-                self.__in_branches = False
-        else:
-            return self
-
-    def filter(self, condition):
-        return FilteredStrategy(
-            OneOfStrategy(s.filter(condition) for s in self.original_strategies),
-            conditions=(),
-        )
-
-
-@overload
-def one_of(
-    __args: SequenceSearchStrategyAny,
-) -> SearchStrategyAny:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def one_of(__a1: SearchStrategyEx) -> SearchStrategyEx:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def one_of(
-    __a1: SearchStrategyEx, __a2: SearchStrategyT
-) -> SearchStrategyUnionEx, T:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def one_of(
-    __a1: SearchStrategyEx, __a2: SearchStrategyT, __a3: SearchStrategyT3
-) -> SearchStrategyUnionEx, T, T3:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def one_of(
-    __a1: SearchStrategyEx,
-    __a2: SearchStrategyT,
-    __a3: SearchStrategyT3,
-    __a4: SearchStrategyT4,
-) -> SearchStrategyUnionEx, T, T3, T4:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def one_of(
-    __a1: SearchStrategyEx,
-    __a2: SearchStrategyT,
-    __a3: SearchStrategyT3,
-    __a4: SearchStrategyT4,
-    __a5: SearchStrategyT5,
-) -> SearchStrategyUnionEx, T, T3, T4, T5:  # pragma: no cover
-    ...
-
-
-@overload  # noqa: F811
-def one_of(*args: SearchStrategyAny) -> SearchStrategyAny:  # pragma: no cover
-    ...
-
-
-@defines_strategy(never_lazy=True)
-def one_of(
-    *args: UnionSequenceSearchStrategyAny, SearchStrategyAny
-) -> SearchStrategyAny:  # noqa: F811
-    # Mypy workaround alert:  Any is too loose above; the return parameter
-    # should be the union of the input parameters.  Unfortunately, Mypy <=0.600
-    # raises errors due to incompatible inputs instead.  See #1270 for links.
-    # v0.610 doesn't error; it gets inference wrong for 2+ arguments instead.
-    """Return a strategy which generates values from any of the argument
-    strategies.
-
-    This may be called with one iterable argument instead of multiple
-    strategy arguments, in which case ``one_of(x)`` and ``one_of(*x)`` are
-    equivalent.
-
-    Examples from this strategy will generally shrink to ones that come from
-    strategies earlier in the list, then shrink according to behaviour of the
-    strategy that produced them. In order to get good shrinking behaviour,
-    try to put simpler strategies first. e.g. ``one_of(none(), text())`` is
-    better than ``one_of(text(), none())``.
-
-    This is especially important when using recursive strategies. e.g.
-    ``x = st.deferred(lambda: st.none() | st.tuples(x, x))`` will shrink well,
-    but ``x = st.deferred(lambda: st.tuples(x, x) | st.none())`` will shrink
-    very badly indeed.
-    """
-    if len(args) == 1 and not isinstance(args0, SearchStrategy):
-        try:
-            args = tuple(args0)
-        except TypeError:
-            pass
-    if len(args) == 1 and isinstance(args0, SearchStrategy):
-        # This special-case means that we can one_of over lists of any size
-        # without incurring any performance overhead when there is only one
-        # strategy, and keeps our reprs simple.
-        return args0
-    if args and not any(isinstance(a, SearchStrategy) for a in args):
-        # And this special case is to give a more-specific error message if it
-        # seems that the user has confused `one_of()` for  `sampled_from()`;
-        # the remaining validation is left to OneOfStrategy.  See PR #2627.
-        raise InvalidArgument(
-            f"Did you mean st.sampled_from({list(args)!r})?  st.one_of() is used "
-            "to combine strategies, but all of the arguments were of other types."
-        )
-    return OneOfStrategy(args)
-
-
-class MappedSearchStrategy(SearchStrategy):
-    """A strategy which is defined purely by conversion to and from another
-    strategy.
-
-    Its parameter and distribution come from that other strategy.
-    """
-
-    def __init__(self, strategy, pack=None):
-        super().__init__()
-        self.mapped_strategy = strategy
-        if pack is not None:
-            self.pack = pack
-
-    def calc_is_empty(self, recur):
-        return recur(self.mapped_strategy)
-
-    def calc_is_cacheable(self, recur):
-        return recur(self.mapped_strategy)
-
-    def __repr__(self):
-        if not hasattr(self, "_cached_repr"):
-            self._cached_repr = "{!r}.map({})".format(
-                self.mapped_strategy,
-                get_pretty_function_description(self.pack),
-            )
-        return self._cached_repr
-
-    def do_validate(self):
-        self.mapped_strategy.validate()
-
-    def pack(self, x):
-        """Take a value produced by the underlying mapped_strategy and turn it
-        into a value suitable for outputting from this strategy."""
-        raise NotImplementedError(f"{self.__class__.__name__}.pack()")
-
-    def do_draw(self, data: ConjectureData) -> Ex:
-        with warnings.catch_warnings():
-            if isinstance(self.pack, type) and issubclass(
-                self.pack, (abc.Mapping, abc.Set)
-            ):
-                warnings.simplefilter("ignore", BytesWarning)
-            for _ in range(3):
-                i = data.index
-                try:
-                    data.start_example(MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL)
-                    result = self.pack(data.draw(self.mapped_strategy))
-                    data.stop_example()
-                    return result
-                except UnsatisfiedAssumption:
-                    data.stop_example(discard=True)
-                    if data.index == i:
-                        raise
-        raise UnsatisfiedAssumption()
-
-    @property
-    def branches(self) -> ListSearchStrategyEx:
-        return 
-            MappedSearchStrategy(pack=self.pack, strategy=strategy)
-            for strategy in self.mapped_strategy.branches
-        
-
-
-filter_not_satisfied = UniqueIdentifier("filter not satisfied")
-
-
-class FilteredStrategy(SearchStrategy):
-    def __init__(self, strategy, conditions):
-        super().__init__()
-        if isinstance(strategy, FilteredStrategy):
-            # Flatten chained filters into a single filter with multiple conditions.
-            self.flat_conditions = strategy.flat_conditions + conditions
-            self.filtered_strategy = strategy.filtered_strategy
-        else:
-            self.flat_conditions = conditions
-            self.filtered_strategy = strategy
-
-        assert isinstance(self.flat_conditions, tuple)
-        assert not isinstance(self.filtered_strategy, FilteredStrategy)
-
-        self.__condition = None
-
-    def calc_is_empty(self, recur):
-        return recur(self.filtered_strategy)
-
-    def calc_is_cacheable(self, recur):
-        return recur(self.filtered_strategy)
-
-    def __repr__(self):
-        if not hasattr(self, "_cached_repr"):
-            self._cached_repr = "{!r}{}".format(
-                self.filtered_strategy,
-                "".join(
-                    f".filter({get_pretty_function_description(cond)})"
-                    for cond in self.flat_conditions
-                ),
-            )
-        return self._cached_repr
-
-    def do_validate(self):
-        # Start by validating our inner filtered_strategy.  If this was a LazyStrategy,
-        # validation also reifies it so that subsequent calls to e.g. `.filter()` will
-        # be passed through.
-        self.filtered_strategy.validate()
-        # So now we have a reified inner strategy, we'll replay all our saved
-        # predicates in case some or all of them can be rewritten.  Note that this
-        # replaces the `fresh` strategy too!
-        fresh = self.filtered_strategy
-        for cond in self.flat_conditions:
-            fresh = fresh.filter(cond)
-        if isinstance(fresh, FilteredStrategy):
-            # In this case we have at least some non-rewritten filter predicates,
-            # so we just re-initialize the strategy.
-            FilteredStrategy.__init__(
-                self, fresh.filtered_strategy, fresh.flat_conditions
-            )
-        else:
-            # But if *all* the predicates were rewritten... well, do_validate() is
-            # an in-place method so we still just re-initialize the strategy!
-            FilteredStrategy.__init__(self, fresh, ())
-
-    def filter(self, condition):
-        # If we can, it's more efficient to rewrite our strategy to satisfy the
-        # condition.  We therefore exploit the fact that the order of predicates
-        # doesn't matter (`f(x) and g(x) == g(x) and f(x)`) by attempting to apply
-        # condition directly to our filtered strategy as the inner-most filter.
-        out = self.filtered_strategy.filter(condition)
-        # If it couldn't be rewritten, we'll get a new FilteredStrategy - and then
-        # combine the conditions of each in our expected newest=last order.
-        if isinstance(out, FilteredStrategy):
-            return FilteredStrategy(
-                out.filtered_strategy, self.flat_conditions + out.flat_conditions
-            )
-        # But if it *could* be rewritten, we can return the more efficient form!
-        return FilteredStrategy(out, self.flat_conditions)
-
-    @property
-    def condition(self):
-        if self.__condition is None:
-            if len(self.flat_conditions) == 1:
-                # Avoid an extra indirection in the common case of only one condition.
-                self.__condition = self.flat_conditions0
-            elif len(self.flat_conditions) == 0:
-                # Possible, if unlikely, due to filter predicate rewriting
-                self.__condition = lambda _: True
-            else:
-                self.__condition = lambda x: all(
-                    cond(x) for cond in self.flat_conditions
-                )
-        return self.__condition
-
-    def do_draw(self, data: ConjectureData) -> Ex:
-        result = self.do_filtered_draw(data)
-        if result is not filter_not_satisfied:
-            return result
-
-        data.note_event(f"Aborted test because unable to satisfy {self!r}")
-        data.mark_invalid()
-        raise NotImplementedError("Unreachable, for Mypy")
-
-    def note_retried(self, data):
-        data.note_event(lazyformat("Retried draw from %r to satisfy filter", self))
-
-    def do_filtered_draw(self, data):
-        for i in range(3):
-            start_index = data.index
-            data.start_example(FILTERED_SEARCH_STRATEGY_DO_DRAW_LABEL)
-            value = data.draw(self.filtered_strategy)
-            if self.condition(value):
-                data.stop_example()
-                return value
-            else:
-                data.stop_example(discard=True)
-                if i == 0:
-                    self.note_retried(data)
-                # This is to guard against the case where we consume no data.
-                # As long as we consume data, we'll eventually pass or raise.
-                # But if we don't this could be an infinite loop.
-                assume(data.index > start_index)
-
-        return filter_not_satisfied
-
-    @property
-    def branches(self) -> ListSearchStrategyEx:
-        return 
-            FilteredStrategy(strategy=strategy, conditions=self.flat_conditions)
-            for strategy in self.filtered_strategy.branches
-        
-
-
-@check_function
-def check_strategy(arg, name=""):
-    if not isinstance(arg, SearchStrategy):
-        hint = ""
-        if isinstance(arg, (list, tuple)):
-            hint = ", such as st.sampled_from({}),".format(name or "...")
-        if name:
-            name += "="
-        raise InvalidArgument(
-            "Expected a SearchStrategy%s but got %s%r (type=%s)"
-            % (hint, name, arg, type(arg).__name__)
-        )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/strings.py Deleted

@@ -1,176 +0,0 @@
-# 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 copy
-import warnings
-
-from hypothesis.errors import HypothesisWarning, InvalidArgument
-from hypothesis.internal import charmap
-from hypothesis.internal.conjecture.utils import biased_coin, integer_range
-from hypothesis.internal.intervalsets import IntervalSet
-from hypothesis.strategies._internal.collections import ListStrategy
-from hypothesis.strategies._internal.strategies import SearchStrategy
-
-
-class OneCharStringStrategy(SearchStrategy):
-    """A strategy which generates single character strings of text type."""
-
-    def __init__(
-        self,
-        whitelist_categories=None,
-        blacklist_categories=None,
-        blacklist_characters=None,
-        min_codepoint=None,
-        max_codepoint=None,
-        whitelist_characters=None,
-    ):
-        assert set(whitelist_categories or ()).issubset(charmap.categories())
-        assert set(blacklist_categories or ()).issubset(charmap.categories())
-        intervals = charmap.query(
-            include_categories=whitelist_categories,
-            exclude_categories=blacklist_categories,
-            min_codepoint=min_codepoint,
-            max_codepoint=max_codepoint,
-            include_characters=whitelist_characters,
-            exclude_characters=blacklist_characters,
-        )
-        self._arg_repr = ", ".join(
-            f"{k}={v!r}"
-            for k, v in 
-                ("whitelist_categories", whitelist_categories),
-                ("blacklist_categories", blacklist_categories),
-                ("whitelist_characters", whitelist_characters),
-                ("blacklist_characters", blacklist_characters),
-                ("min_codepoint", min_codepoint),
-                ("max_codepoint", max_codepoint),
-            
-            if not (v in (None, "") or (k == "blacklist_categories" and v == ("Cs",)))
-        )
-        if not intervals:
-            raise InvalidArgument(
-                "No characters are allowed to be generated by this "
-                f"combination of arguments: {self._arg_repr}"
-            )
-        self.intervals = IntervalSet(intervals)
-        self.zero_point = self.intervals.index_above(ord("0"))
-        self.Z_point = min(
-            self.intervals.index_above(ord("Z")), len(self.intervals) - 1
-        )
-
-    def __repr__(self):
-        return f"characters({self._arg_repr})"
-
-    def do_draw(self, data):
-        if len(self.intervals) > 256:
-            if biased_coin(data, 0.2):
-                i = integer_range(data, 256, len(self.intervals) - 1)
-            else:
-                i = integer_range(data, 0, 255)
-        else:
-            i = integer_range(data, 0, len(self.intervals) - 1)
-
-        i = self.rewrite_integer(i)
-
-        return chr(self.intervalsi)
-
-    def rewrite_integer(self, i):
-        # We would like it so that, where possible, shrinking replaces
-        # characters with simple ascii characters, so we rejig this
-        # bit so that the smallest values are 0, 1, 2, ..., Z.
-        #
-        # Imagine that numbers are laid out as abc0yyyZ...
-        # this rearranges them so that they are laid out as
-        # 0yyyZcba..., which gives a better shrinking order.
-        if i <= self.Z_point:
-            # We want to rewrite the integers 0, n inclusive
-            # to zero_point, Z_point.
-            n = self.Z_point - self.zero_point
-            if i <= n:
-                i += self.zero_point
-            else:
-                # We want to rewrite the integers n + 1, Z_point to
-                # zero_point, 0 (reversing the order so that codepoints below
-                # zero_point shrink upwards).
-                i = self.zero_point - (i - n)
-                assert i < self.zero_point
-            assert 0 <= i <= self.Z_point
-        return i
-
-
-class TextStrategy(ListStrategy):
-    def do_draw(self, data):
-        return "".join(super().do_draw(data))
-
-    def __repr__(self):
-        args = 
-        if repr(self.element_strategy) != "characters()":
-            args.append(repr(self.element_strategy))
-        if self.min_size:
-            args.append(f"min_size={self.min_size}")
-        if self.max_size < float("inf"):
-            args.append(f"max_size={self.max_size}")
-        return f"text({', '.join(args)})"
-
-    # See https://docs.python.org/3/library/stdtypes.html#string-methods
-    # These methods always return Truthy values for any nonempty string.
-    _nonempty_filters = ListStrategy._nonempty_filters + (
-        str.capitalize,
-        str.casefold,
-        str.expandtabs,
-        str.join,
-        str.lower,
-        str.split,
-        str.splitlines,
-        str.swapcase,
-        str.title,
-        str.upper,
-    )
-    _nonempty_and_content_filters = (
-        str.isidentifier,
-        str.islower,
-        str.isupper,
-        str.isalnum,
-        str.isalpha,
-        str.isascii,
-        str.isdecimal,
-        str.isdigit,
-        str.isnumeric,
-        str.isspace,
-        str.istitle,
-    )
-
-    def filter(self, condition):
-        if condition in (str.lower, str.title, str.upper):
-            warnings.warn(
-                f"You applied str.{condition.__name__} as a filter, but this allows "
-                f"all nonempty strings!  Did you mean str.is{condition.__name__}?",
-                HypothesisWarning,
-            )
-        # We use ListStrategy filter logic for the conditions that *only* imply
-        # the string is nonempty.  Here, we increment the min_size but still apply
-        # the filter for conditions that imply nonempty *and specific contents*.
-        #
-        # TODO: we may eventually rewrite the elements_strategy for some of these,
-        #       avoiding rejection sampling and making them much more efficient.
-        if condition in self._nonempty_and_content_filters:
-            assert self.max_size >= 1, "Always-empty is special cased in st.text()"
-            self = copy.copy(self)
-            self.min_size = max(1, self.min_size)
-            return ListStrategy.filter(self, condition)
-
-        return super().filter(condition)
-
-
-class FixedSizeBytes(SearchStrategy):
-    def __init__(self, size):
-        self.size = size
-
-    def do_draw(self, data):
-        return bytes(data.draw_bytes(self.size))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/strategies/_internal/types.py Deleted

@@ -1,931 +0,0 @@
-# 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 builtins
-import collections
-import datetime
-import decimal
-import fractions
-import functools
-import inspect
-import io
-import ipaddress
-import numbers
-import os
-import re
-import sys
-import typing
-import uuid
-from pathlib import PurePath
-from types import FunctionType
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument, ResolutionFailed
-from hypothesis.internal.compat import PYPY
-from hypothesis.internal.conjecture.utils import many as conjecture_utils_many
-from hypothesis.strategies._internal.datetime import zoneinfo  # type: ignore
-from hypothesis.strategies._internal.ipaddress import (
-    SPECIAL_IPv4_RANGES,
-    SPECIAL_IPv6_RANGES,
-    ip_addresses,
-)
-from hypothesis.strategies._internal.lazy import unwrap_strategies
-from hypothesis.strategies._internal.strategies import OneOfStrategy
-
-UnionType: typing.Any
-try:
-    # The type of PEP-604 unions (`int | str`), added in Python 3.10
-    from types import UnionType
-except ImportError:
-    UnionType = ()
-
-try:
-    import typing_extensions
-except ImportError:
-    typing_extensions = None  # type: ignore
-
-try:
-    from typing import _GenericAlias  # type: ignore  # python >= 3.7
-except ImportError:
-    _GenericAlias = ()
-
-try:
-    from typing import _AnnotatedAlias  # type: ignore
-except ImportError:
-    try:
-        from typing_extensions import _AnnotatedAlias
-    except ImportError:
-        _AnnotatedAlias = ()
-
-TypeAliasTypes: tuple = ()
-try:
-    TypeAliasTypes += (typing.TypeAlias,)
-except AttributeError:
-    pass  # Is missing for `python<3.10`
-try:
-    TypeAliasTypes += (typing_extensions.TypeAlias,)
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `typing_extensions<3.10`
-
-ClassVarTypes: tuple = (typing.ClassVar,)
-try:
-    ClassVarTypes += (typing_extensions.ClassVar,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-FinalTypes: tuple = ()
-try:
-    FinalTypes += (typing.Final,)
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `python<3.8`
-try:
-    FinalTypes += (typing_extensions.Final,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-ConcatenateTypes: tuple = ()
-try:
-    ConcatenateTypes += (typing.Concatenate,)
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `python<3.8`
-try:
-    ConcatenateTypes += (typing_extensions.Concatenate,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-ParamSpecTypes: tuple = ()
-try:
-    ParamSpecTypes += (typing.ParamSpec,)
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `python<3.8`
-try:
-    ParamSpecTypes += (typing_extensions.ParamSpec,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-TypeGuardTypes: tuple = ()
-try:
-    TypeGuardTypes += (typing.TypeGuard,)
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `python<3.8`
-try:
-    TypeGuardTypes += (typing_extensions.TypeGuard,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-
-RequiredTypes: tuple = ()
-try:
-    RequiredTypes += (typing.Required,)  # type: ignore
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `python<3.11`
-try:
-    RequiredTypes += (typing_extensions.Required,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-
-NotRequiredTypes: tuple = ()
-try:
-    NotRequiredTypes += (typing.NotRequired,)  # type: ignore
-except AttributeError:  # pragma: no cover
-    pass  # Is missing for `python<3.11`
-try:
-    NotRequiredTypes += (typing_extensions.NotRequired,)
-except AttributeError:  # pragma: no cover
-    pass  # `typing_extensions` might not be installed
-
-
-# We use this variable to be sure that we are working with a type from `typing`:
-typing_root_type = (typing._Final, typing._GenericAlias)  # type: ignore
-
-# We use this to disallow all non-runtime types from being registered and resolved.
-# By "non-runtime" we mean: types that do not really exist in python's
-# and are just added for more fancy type annotations.
-# `Final` is a great example: it just indicates
-# that this value can't be reassigned.
-NON_RUNTIME_TYPES = (
-    typing.Any,
-    *ClassVarTypes,
-    *TypeAliasTypes,
-    *FinalTypes,
-    *ConcatenateTypes,
-    *ParamSpecTypes,
-    *TypeGuardTypes,
-)
-for name in (
-    "Annotated",
-    "NoReturn",
-    "Self",
-    "Required",
-    "NotRequired",
-    "Never",
-    "TypeVarTuple",
-    "Unpack",
-    "LiteralString",
-):
-    try:
-        NON_RUNTIME_TYPES += (getattr(typing, name),)
-    except AttributeError:
-        pass
-    try:
-        NON_RUNTIME_TYPES += (getattr(typing_extensions, name),)
-    except AttributeError:  # pragma: no cover
-        pass  # typing_extensions might not be installed
-
-
-def type_sorting_key(t):
-    """Minimise to None, then non-container types, then container types."""
-    if not (is_a_type(t) or is_typing_literal(t)):  # This branch is for Python < 3.8
-        raise InvalidArgument(f"thing={t} must be a type")  # pragma: no cover
-    if t is None or t is type(None):  # noqa: E721
-        return (-1, repr(t))
-    t = getattr(t, "__origin__", t)
-    if not isinstance(t, type):  # pragma: no cover
-        # Some generics in the typing module are not actually types in 3.7
-        return (2, repr(t))
-    return (int(issubclass(t, collections.abc.Container)), repr(t))
-
-
-def _compatible_args(args, superclass_args):
-    """Check that the args of two generic types are compatible for try_issubclass."""
-    assert superclass_args is not None
-    if args is None:
-        return True
-    return len(args) == len(superclass_args) and all(
-        # "a==b or either is a typevar" is a hacky approximation, but it's
-        # good enough for all the cases that I've seen so far and has the
-        # substantial virtue of (relative) simplicity.
-        a == b or isinstance(a, typing.TypeVar) or isinstance(b, typing.TypeVar)
-        for a, b in zip(args, superclass_args)
-    )
-
-
-def try_issubclass(thing, superclass):
-    try:
-        # In this case we're looking at two distinct classes - which might be generics.
-        # That brings in some complications:
-        if issubclass(
-            getattr(thing, "__origin__", None) or thing,
-            getattr(superclass, "__origin__", None) or superclass,
-        ):
-            superclass_args = getattr(superclass, "__args__", None)
-            if not superclass_args:
-                # The superclass is not generic, so we're definitely a subclass.
-                return True
-            # Sadly this is just some really fiddly logic to handle all the cases
-            # of user-defined generic types, types inheriting from parametrised
-            # generics, and so on.  If you need to change this code, read PEP-560
-            # and Hypothesis issue #2951 closely first, and good luck.  The tests
-            # will help you, I hope - good luck.
-            if getattr(thing, "__args__", None) is not None:
-                return True
-            for orig_base in getattr(thing, "__orig_bases__", None) or None:
-                args = getattr(orig_base, "__args__", None)
-                if _compatible_args(args, superclass_args):
-                    return True
-        return False
-    except (AttributeError, TypeError):
-        # Some types can't be the subject or object of an instance or subclass check
-        return False
-
-
-def is_a_new_type(thing):
-    if not isinstance(typing.NewType, type):
-        # At runtime, `typing.NewType` returns an identity function rather
-        # than an actual type, but we can check whether that thing matches.
-        return (
-            hasattr(thing, "__supertype__")
-            and getattr(thing, "__module__", None) in ("typing", "typing_extensions")
-            and inspect.isfunction(thing)
-        )
-    # In 3.10 and later, NewType is actually a class - which simplifies things.
-    # See https://bugs.python.org/issue44353 for links to the various patches.
-    return isinstance(thing, typing.NewType)  # pragma: no cover  # on 3.8, anyway
-
-
-def is_a_union(thing):
-    """Return True if thing is a typing.Union or types.UnionType (in py310)."""
-    return (
-        isinstance(thing, UnionType)
-        or getattr(thing, "__origin__", None) is typing.Union
-    )
-
-
-def is_a_type(thing):
-    """Return True if thing is a type or a generic type like thing."""
-    return isinstance(thing, type) or is_generic_type(thing) or is_a_new_type(thing)
-
-
-def is_typing_literal(thing):
-    return (
-        hasattr(typing, "Literal")
-        and getattr(thing, "__origin__", None) == typing.Literal
-        or hasattr(typing_extensions, "Literal")
-        and getattr(thing, "__origin__", None) == typing_extensions.Literal
-    )
-
-
-def is_annotated_type(thing):
-    return (
-        isinstance(thing, _AnnotatedAlias)
-        and getattr(thing, "__args__", None) is not None
-    )
-
-
-def find_annotated_strategy(annotated_type):  # pragma: no cover
-    flattened_meta = 
-
-    all_args = (
-        *getattr(annotated_type, "__args__", ()),
-        *getattr(annotated_type, "__metadata__", ()),
-    )
-    for arg in all_args:
-        if is_annotated_type(arg):
-            flattened_meta.append(find_annotated_strategy(arg))
-        if isinstance(arg, st.SearchStrategy):
-            flattened_meta.append(arg)
-    return flattened_meta-1 if flattened_meta else None
-
-
-def has_type_arguments(type_):
-    """Decides whethere or not this type has applied type arguments."""
-    args = getattr(type_, "__args__", None)
-    if args and isinstance(type_, _GenericAlias):
-        # There are some cases when declared types do already have type arguments
-        # Like `Sequence`, that is `_GenericAlias(abc.SequenceT)T`
-        parameters = getattr(type_, "__parameters__", None)
-        if parameters:  # So, we need to know if type args are just "aliases"
-            return args != parameters
-    return bool(args)
-
-
-def is_generic_type(type_):
-    """Decides whether a given type is generic or not."""
-    # The ugly truth is that `MyClass`, `MyClassT`, and `MyClassint` are very different.
-    # We check for `MyClassT` and `MyClassint` with the first condition,
-    # while the second condition is for `MyClass`.
-    return isinstance(type_, typing_root_type) or (
-        isinstance(type_, type) and typing.Generic in type_.__mro__
-    )
-
-
-def _try_import_forward_ref(thing, bound):  # pragma: no cover
-    """
-    Tries to import a real bound type from ``TypeVar`` bound to a ``ForwardRef``.
-
-    This function is very "magical" to say the least, please don't use it.
-    This function fully covered, but is excluded from coverage
-    because we can only cover each path in a separate python version.
-    """
-    try:
-        return typing._eval_type(bound, vars(sys.modulesthing.__module__), None)
-    except (KeyError, AttributeError, NameError):
-        # We fallback to `ForwardRef` instance, you can register it as a type as well:
-        # >>> from typing import ForwardRef
-        # >>> from hypothesis import strategies as st
-        # >>> st.register_type_strategy(ForwardRef('YourType'), your_strategy)
-        return bound
-
-
-def from_typing_type(thing):
-    # We start with special-case support for Tuple, which isn't actually a generic
-    # type; then Final, Literal, and Annotated since they don't support `isinstance`.
-    #
-    # We then explicitly error on non-Generic types, which don't carry enough
-    # information to sensibly resolve to strategies at runtime.
-    # Finally, we run a variation of the subclass lookup in `st.from_type`
-    # among generic types in the lookup.
-    if getattr(thing, "__origin__", None) == tuple or isinstance(
-        thing, getattr(typing, "TupleMeta", ())
-    ):
-        elem_types = getattr(thing, "__tuple_params__", None) or ()
-        elem_types += getattr(thing, "__args__", None) or ()
-        if (
-            getattr(thing, "__tuple_use_ellipsis__", False)
-            or len(elem_types) == 2
-            and elem_types-1 is Ellipsis
-        ):
-            return st.lists(st.from_type(elem_types0)).map(tuple)
-        elif len(elem_types) == 1 and elem_types0 == ():
-            return st.tuples()  # Empty tuple; see issue #1583
-        return st.tuples(*map(st.from_type, elem_types))
-    if hasattr(typing, "Final") and getattr(thing, "__origin__", None) == typing.Final:
-        return st.one_of(st.from_type(t) for t in thing.__args__)
-    if is_typing_literal(thing):
-        args_dfs_stack = list(thing.__args__)
-        literals = 
-        while args_dfs_stack:
-            arg = args_dfs_stack.pop()
-            if is_typing_literal(arg):
-                args_dfs_stack.extend(reversed(arg.__args__))
-            else:
-                literals.append(arg)
-        return st.sampled_from(literals)
-    if is_annotated_type(thing):  # pragma: no cover
-        # This requires Python 3.9+ or the typing_extensions package
-        annotated_strategy = find_annotated_strategy(thing)
-        if annotated_strategy is not None:
-            return annotated_strategy
-        args = thing.__args__
-        assert args, "it's impossible to make an annotated type with no args"
-        annotated_type = args0
-        return st.from_type(annotated_type)
-    # Now, confirm that we're dealing with a generic type as we expected
-    if sys.version_info:2 < (3, 9) and not isinstance(
-        thing, typing_root_type
-    ):  # pragma: no cover
-        raise ResolutionFailed(f"Cannot resolve {thing} to a strategy")
-
-    # Some "generic" classes are not generic *in* anything - for example both
-    # Hashable and Sized have `__args__ == ()` on Python 3.7 or later.
-    origin = getattr(thing, "__origin__", thing)
-    if (
-        origin in vars(collections.abc).values()
-        and len(getattr(thing, "__args__", None) or ) == 0
-    ):
-        return st.from_type(origin)
-
-    # Parametrised generic types have their __origin__ attribute set to the
-    # un-parametrised version, which we need to use in the subclass checks.
-    # e.g.:     typing.Listint.__origin__ == typing.List
-    mapping = {
-        k: v
-        for k, v in _global_type_lookup.items()
-        if is_generic_type(k) and try_issubclass(k, thing)
-    }
-    if typing.Dict in mapping or typing.Set in mapping:
-        # ItemsView can cause test_lookup.py::test_specialised_collection_types
-        # to fail, due to weird isinstance behaviour around the elements.
-        mapping.pop(typing.ItemsView, None)
-    if typing.Deque in mapping and len(mapping) > 1:
-        # Resolving generic sequences to include a deque is more trouble for e.g.
-        # the ghostwriter than it's worth, via undefined names in the repr.
-        mapping.pop(typing.Deque)
-    if len(mapping) > 1:
-        # issubclass treats bytestring as a kind of sequence, which it is,
-        # but treating it as such breaks everything else when it is presumed
-        # to be a generic sequence or container that could hold any item.
-        # Except for sequences of integers, or unions which include integer!
-        # See https://github.com/HypothesisWorks/hypothesis/issues/2257
-        #
-        # This block drops ByteString from the types that can be generated
-        # if there is more than one allowed type, and the element type is
-        # not either `int` or a Union with `int` as one of its elements.
-        elem_type = (getattr(thing, "__args__", None) or "not int")0
-        if is_a_union(elem_type):
-            union_elems = elem_type.__args__
-        else:
-            union_elems = ()
-        if not any(
-            isinstance(T, type) and issubclass(int, T)
-            for T in list(union_elems) + elem_type
-        ):
-            mapping.pop(typing.ByteString, None)
-    elif (
-        (not mapping)
-        and isinstance(thing, typing.ForwardRef)
-        and thing.__forward_arg__ in vars(builtins)
-    ):
-        return st.from_type(getattr(builtins, thing.__forward_arg__))
-    strategies = 
-        v if isinstance(v, st.SearchStrategy) else v(thing)
-        for k, v in mapping.items()
-        if sum(try_issubclass(k, T) for T in mapping) == 1
-    
-    empty = ", ".join(repr(s) for s in strategies if s.is_empty)
-    if empty or not strategies:
-        raise ResolutionFailed(
-            f"Could not resolve {empty or thing} to a strategy; "
-            "consider using register_type_strategy"
-        )
-    return st.one_of(strategies)
-
-
-def can_cast(type, value):
-    """Determine if value can be cast to type."""
-    try:
-        type(value)
-        return True
-    except Exception:
-        return False
-
-
-def _networks(bits):
-    return st.tuples(st.integers(0, 2**bits - 1), st.integers(-bits, 0).map(abs))
-
-
-utc_offsets = st.builds(
-    datetime.timedelta, minutes=st.integers(0, 59), hours=st.integers(-23, 23)
-)
-
-# These builtin and standard-library types have Hypothesis strategies,
-# seem likely to appear in type annotations, or are otherwise notable.
-#
-# The strategies below must cover all possible values from the type, because
-# many users treat them as comprehensive and one of Hypothesis' design goals
-# is to avoid testing less than expected.
-#
-# As a general rule, we try to limit this to scalars because from_type()
-# would have to decide on arbitrary collection elements, and we'd rather
-# not (with typing module generic types and some builtins as exceptions).
-_global_type_lookup: typing.Dict
-    type, typing.Unionst.SearchStrategy, typing.Callabletype, st.SearchStrategy
- = {
-    type(None): st.none(),
-    bool: st.booleans(),
-    int: st.integers(),
-    float: st.floats(),
-    complex: st.complex_numbers(),
-    fractions.Fraction: st.fractions(),
-    decimal.Decimal: st.decimals(),
-    str: st.text(),
-    bytes: st.binary(),
-    datetime.datetime: st.datetimes(),
-    datetime.date: st.dates(),
-    datetime.time: st.times(),
-    datetime.timedelta: st.timedeltas(),
-    datetime.timezone: st.builds(datetime.timezone, offset=utc_offsets)
-    | st.builds(datetime.timezone, offset=utc_offsets, name=st.text(st.characters())),
-    uuid.UUID: st.uuids(),
-    tuple: st.builds(tuple),
-    list: st.builds(list),
-    set: st.builds(set),
-    collections.abc.MutableSet: st.builds(set),
-    frozenset: st.builds(frozenset),
-    dict: st.builds(dict),
-    FunctionType: st.functions(),
-    type(Ellipsis): st.just(Ellipsis),
-    type(NotImplemented): st.just(NotImplemented),
-    bytearray: st.binary().map(bytearray),
-    memoryview: st.binary().map(memoryview),
-    numbers.Real: st.floats(),
-    numbers.Rational: st.fractions(),
-    numbers.Number: st.complex_numbers(),
-    numbers.Integral: st.integers(),
-    numbers.Complex: st.complex_numbers(),
-    slice: st.builds(
-        slice,
-        st.none() | st.integers(),
-        st.none() | st.integers(),
-        st.none() | st.integers(),
-    ),
-    range: st.one_of(
-        st.builds(range, st.integers(min_value=0)),
-        st.builds(range, st.integers(), st.integers()),
-        st.builds(range, st.integers(), st.integers(), st.integers().filter(bool)),
-    ),
-    ipaddress.IPv4Address: ip_addresses(v=4),
-    ipaddress.IPv6Address: ip_addresses(v=6),
-    ipaddress.IPv4Interface: _networks(32).map(ipaddress.IPv4Interface),
-    ipaddress.IPv6Interface: _networks(128).map(ipaddress.IPv6Interface),
-    ipaddress.IPv4Network: st.one_of(
-        _networks(32).map(lambda x: ipaddress.IPv4Network(x, strict=False)),
-        st.sampled_from(SPECIAL_IPv4_RANGES).map(ipaddress.IPv4Network),
-    ),
-    ipaddress.IPv6Network: st.one_of(
-        _networks(128).map(lambda x: ipaddress.IPv6Network(x, strict=False)),
-        st.sampled_from(SPECIAL_IPv6_RANGES).map(ipaddress.IPv6Network),
-    ),
-    os.PathLike: st.builds(PurePath, st.text()),
-    UnicodeDecodeError: st.builds(
-        UnicodeDecodeError,
-        st.just("unknown encoding"),
-        st.just(b""),
-        st.just(0),
-        st.just(0),
-        st.just("reason"),
-    ),
-    UnicodeEncodeError: st.builds(
-        UnicodeEncodeError,
-        st.just("unknown encoding"),
-        st.text(),
-        st.just(0),
-        st.just(0),
-        st.just("reason"),
-    ),
-    UnicodeTranslateError: st.builds(
-        UnicodeTranslateError, st.text(), st.just(0), st.just(0), st.just("reason")
-    ),
-    enumerate: st.builds(enumerate, st.just(())),
-    filter: st.builds(filter, st.just(lambda _: None), st.just(())),
-    map: st.builds(map, st.just(lambda _: None), st.just(())),
-    reversed: st.builds(reversed, st.just(())),
-    classmethod: st.builds(classmethod, st.just(lambda self: self)),
-    staticmethod: st.builds(staticmethod, st.just(lambda self: self)),
-    super: st.builds(super, st.from_type(type)),
-    re.Match: st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool),
-    re.Pattern: st.builds(re.compile, st.sampled_from("", b"")),
-    # Pull requests with more types welcome!
-}
-if zoneinfo is not None:  # pragma: no branch
-    _global_type_lookupzoneinfo.ZoneInfo = st.timezones()
-if PYPY:
-    _global_type_lookupbuiltins.sequenceiterator = st.builds(iter, st.tuples())  # type: ignore
-try:
-    BaseExceptionGroup  # type: ignore # noqa
-except NameError:
-    pass
-else:  # pragma: no cover
-    _global_type_lookupBaseExceptionGroup = st.builds(  # type: ignore
-        BaseExceptionGroup,  # type: ignore
-        st.text(),
-        st.lists(st.from_type(BaseException), min_size=1),
-    )
-    _global_type_lookupExceptionGroup = st.builds(  # type: ignore
-        ExceptionGroup,  # type: ignore
-        st.text(),
-        st.lists(st.from_type(Exception), min_size=1),
-    )
-
-
-_global_type_lookuptype = st.sampled_from(
-    type(None) + sorted(_global_type_lookup, key=str)
-)
-if sys.version_info:2 >= (3, 9):  # pragma: no cover
-    # subclass of MutableMapping, and in Python 3.9 we resolve to a union
-    # which includes this... but we don't actually ever want to build one.
-    _global_type_lookupos._Environ = st.just(os.environ)
-
-
-try:  # pragma: no cover
-    import numpy as np
-
-    from hypothesis.extra.numpy import array_dtypes, array_shapes, arrays, scalar_dtypes
-
-    _global_type_lookupnp.dtype = array_dtypes()
-    _global_type_lookupnp.ndarray = arrays(scalar_dtypes(), array_shapes(max_dims=2))
-except ImportError:
-    pass
-
-
-_global_type_lookup.update(
-    {
-        # Note: while ByteString notionally also represents the bytearray and
-        # memoryview types, it is a subclass of Hashable and those types are not.
-        # We therefore only generate the bytes type.
-        typing.ByteString: st.binary(),
-        collections.abc.ByteString: st.binary(),
-        # TODO: SupportsAbs and SupportsRound should be covariant, ie have functions.
-        typing.SupportsAbs: st.one_of(
-            st.booleans(),
-            st.integers(),
-            st.floats(),
-            st.complex_numbers(),
-            st.fractions(),
-            st.decimals(),
-            st.timedeltas(),
-        ),
-        typing.SupportsRound: st.one_of(
-            st.booleans(), st.integers(), st.floats(), st.decimals(), st.fractions()
-        ),
-        typing.SupportsComplex: st.one_of(
-            st.booleans(),
-            st.integers(),
-            st.floats(),
-            st.complex_numbers(),
-            st.decimals(),
-            st.fractions(),
-        ),
-        typing.SupportsFloat: st.one_of(
-            st.booleans(),
-            st.integers(),
-            st.floats(),
-            st.decimals(),
-            st.fractions(),
-            # with floats its far more annoying to capture all
-            # the magic in a regex. so we just stringify some floats
-            st.floats().map(str),
-        ),
-        typing.SupportsInt: st.one_of(
-            st.booleans(),
-            st.integers(),
-            st.floats(),
-            st.uuids(),
-            st.decimals(),
-            # this generates strings that should able to be parsed into integers
-            st.from_regex(r"\A-?\d+\Z").filter(functools.partial(can_cast, int)),
-        ),
-        typing.SupportsBytes: st.one_of(
-            st.booleans(),
-            st.binary(),
-            st.integers(0, 255),
-            # As with Reversible, we tuplize this for compatibility with Hashable.
-            st.lists(st.integers(0, 255)).map(tuple),  # type: ignore
-        ),
-        typing.BinaryIO: st.builds(io.BytesIO, st.binary()),
-        typing.TextIO: st.builds(io.StringIO, st.text()),
-    }
-)
-if hasattr(typing, "SupportsIndex"):  # pragma: no branch  # new in Python 3.8
-    _global_type_lookuptyping.SupportsIndex = st.integers() | st.booleans()
-
-
-def register(type_, fallback=None, *, module=typing):
-    if isinstance(type_, str):
-        # Use the name of generic types which are not available on all
-        # versions, and the function just won't be added to the registry
-        type_ = getattr(module, type_, None)
-        if type_ is None:  # pragma: no cover
-            return lambda f: f
-
-    def inner(func):
-        if fallback is None:
-            _global_type_lookuptype_ = func
-            return func
-
-        @functools.wraps(func)
-        def really_inner(thing):
-            # This branch is for Python < 3.8, when __args__ was not always tracked
-            if getattr(thing, "__args__", None) is None:
-                return fallback  # pragma: no cover
-            return func(thing)
-
-        _global_type_lookuptype_ = really_inner
-        return really_inner
-
-    return inner
-
-
-@register(typing.Type)
-@register("Type", module=typing_extensions)
-def resolve_Type(thing):
-    if getattr(thing, "__args__", None) is None:
-        # This branch is for Python < 3.8, when __args__ was not always tracked
-        return st.just(type)  # pragma: no cover
-    args = (thing.__args__0,)
-    if is_a_union(args0):
-        args = args0.__args__
-    # Duplicate check from from_type here - only paying when needed.
-    args = list(args)
-    for i, a in enumerate(args):
-        if type(a) == typing.ForwardRef:
-            try:
-                argsi = getattr(builtins, a.__forward_arg__)
-            except AttributeError:
-                raise ResolutionFailed(
-                    f"Cannot find the type referenced by {thing} - try using "
-                    f"st.register_type_strategy({thing}, st.from_type(...))"
-                ) from None
-    return st.sampled_from(sorted(args, key=type_sorting_key))
-
-
-@register(typing.List, st.builds(list))
-def resolve_List(thing):
-    return st.lists(st.from_type(thing.__args__0))
-
-
-def _can_hash(val):
-    try:
-        hash(val)
-        return True
-    except Exception:
-        return False
-
-
-# Some types are subclasses of typing.Hashable, because they define a __hash__
-# method, but have non-hashable instances such as `Decimal("snan")` or may contain
-# such instances (e.g. `FrozenSetDecimal`).  We therefore keep this whitelist of
-# types which are always hashable, and apply the `_can_hash` filter to all others.
-# Our goal is not completeness, it's to get a small performance boost for the most
-# common cases, and a short whitelist is basically free to maintain.
-ALWAYS_HASHABLE_TYPES = {type(None), bool, int, float, complex, str, bytes}
-
-
-def _from_hashable_type(type_):
-    if type_ in ALWAYS_HASHABLE_TYPES:
-        return st.from_type(type_)
-    else:
-        return st.from_type(type_).filter(_can_hash)
-
-
-@register(typing.Set, st.builds(set))
-def resolve_Set(thing):
-    return st.sets(_from_hashable_type(thing.__args__0))
-
-
-@register(typing.FrozenSet, st.builds(frozenset))
-def resolve_FrozenSet(thing):
-    return st.frozensets(_from_hashable_type(thing.__args__0))
-
-
-@register(typing.Dict, st.builds(dict))
-def resolve_Dict(thing):
-    # If thing is a Collection instance, we need to fill in the values
-    keys_vals = thing.__args__ * 2
-    return st.dictionaries(
-        _from_hashable_type(keys_vals0), st.from_type(keys_vals1)
-    )
-
-
-@register(typing.DefaultDict, st.builds(collections.defaultdict))
-@register("DefaultDict", st.builds(collections.defaultdict), module=typing_extensions)
-def resolve_DefaultDict(thing):
-    return resolve_Dict(thing).map(lambda d: collections.defaultdict(None, d))
-
-
-@register(typing.ItemsView, st.builds(dict).map(dict.items))
-def resolve_ItemsView(thing):
-    return resolve_Dict(thing).map(dict.items)
-
-
-@register(typing.KeysView, st.builds(dict).map(dict.keys))
-def resolve_KeysView(thing):
-    return st.dictionaries(_from_hashable_type(thing.__args__0), st.none()).map(
-        dict.keys
-    )
-
-
-@register(typing.ValuesView, st.builds(dict).map(dict.values))
-def resolve_ValuesView(thing):
-    return st.dictionaries(st.integers(), st.from_type(thing.__args__0)).map(
-        dict.values
-    )
-
-
-@register(typing.Iterator, st.iterables(st.nothing()))
-def resolve_Iterator(thing):
-    return st.iterables(st.from_type(thing.__args__0))
-
-
-@register(typing.Counter, st.builds(collections.Counter))
-def resolve_Counter(thing):
-    return st.dictionaries(
-        keys=st.from_type(thing.__args__0),
-        values=st.integers(),
-    ).map(collections.Counter)
-
-
-@register(typing.Deque, st.builds(collections.deque))
-def resolve_deque(thing):
-    return st.lists(st.from_type(thing.__args__0)).map(collections.deque)
-
-
-@register(typing.ChainMap, st.builds(dict).map(collections.ChainMap))
-def resolve_ChainMap(thing):
-    return resolve_Dict(thing).map(collections.ChainMap)
-
-
-@register("OrderedDict", st.builds(dict).map(collections.OrderedDict))
-def resolve_OrderedDict(thing):
-    # typing.OrderedDict is new in Python 3.7.2
-    return resolve_Dict(thing).map(collections.OrderedDict)
-
-
-@register(typing.Pattern, st.builds(re.compile, st.sampled_from("", b"")))
-def resolve_Pattern(thing):
-    if isinstance(thing.__args__0, typing.TypeVar):
-        return st.builds(re.compile, st.sampled_from("", b""))
-    return st.just(re.compile(thing.__args__0()))
-
-
-@register(  # pragma: no branch  # coverage does not see lambda->exit branch
-    typing.Match,
-    st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool),
-)
-def resolve_Match(thing):
-    if thing.__args__0 == bytes:
-        return (
-            st.binary(min_size=1)
-            .map(lambda c: re.match(b".", c, flags=re.DOTALL))
-            .filter(bool)
-        )
-    return st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool)
-
-
-class GeneratorStrategy(st.SearchStrategy):
-    def __init__(self, yields, returns):
-        assert isinstance(yields, st.SearchStrategy)
-        assert isinstance(returns, st.SearchStrategy)
-        self.yields = yields
-        self.returns = returns
-
-    def __repr__(self):
-        return f"<generators yields={self.yields!r} returns={self.returns!r}>"
-
-    def do_draw(self, data):
-        elements = conjecture_utils_many(data, min_size=0, max_size=100, average_size=5)
-        while elements.more():
-            yield data.draw(self.yields)
-        return data.draw(self.returns)
-
-
-@register(typing.Generator, GeneratorStrategy(st.none(), st.none()))
-def resolve_Generator(thing):
-    yields, _, returns = thing.__args__
-    return GeneratorStrategy(st.from_type(yields), st.from_type(returns))
-
-
-@register(typing.Callable, st.functions())
-def resolve_Callable(thing):
-    # Generated functions either accept no arguments, or arbitrary arguments.
-    # This is looser than ideal, but anything tighter would generally break
-    # use of keyword arguments and we'd rather not force positional-only.
-    if not thing.__args__:  # pragma: no cover  # varies by minor version
-        return st.functions()
-
-    *args_types, return_type = thing.__args__
-
-    # Note that a list can only appear in __args__ under Python 3.9 with the
-    # collections.abc version; see https://bugs.python.org/issue42195
-    if len(args_types) == 1 and isinstance(args_types0, list):
-        args_types = tuple(args_types0)
-
-    pep612 = ConcatenateTypes + ParamSpecTypes
-    for arg in args_types:
-        # awkward dance because you can't use Concatenate in isistance or issubclass
-        if getattr(arg, "__origin__", arg) in pep612 or type(arg) in pep612:
-            raise InvalidArgument(
-                "Hypothesis can't yet construct a strategy for instances of a "
-                f"Callable type parametrized by {arg!r}.  Consider using an "
-                "explicit strategy, or opening an issue."
-            )
-    if getattr(return_type, "__origin__", None) in TypeGuardTypes:
-        raise InvalidArgument(
-            "Hypothesis cannot yet construct a strategy for callables which "
-            f"are PEP-647 TypeGuards (got {return_type!r}).  "
-            "Consider using an explicit strategy, or opening an issue."
-        )
-
-    return st.functions(
-        like=(lambda *a, **k: None) if args_types else (lambda: None),
-        returns=st.from_type(return_type),
-    )
-
-
-@register(typing.TypeVar)
-def resolve_TypeVar(thing):
-    type_var_key = f"typevar={thing!r}"
-
-    if getattr(thing, "__bound__", None) is not None:
-        bound = thing.__bound__
-        if isinstance(bound, typing.ForwardRef):
-            bound = _try_import_forward_ref(thing, bound)
-        strat = unwrap_strategies(st.from_type(bound))
-        if not isinstance(strat, OneOfStrategy):
-            return strat
-        # The bound was a union, or we resolved it as a union of subtypes,
-        # so we need to unpack the strategy to ensure consistency across uses.
-        # This incantation runs a sampled_from over the strategies inferred for
-        # each part of the union, wraps that in shared so that we only generate
-        # from one type per testcase, and flatmaps that back to instances.
-        return st.shared(
-            st.sampled_from(strat.original_strategies), key=type_var_key
-        ).flatmap(lambda s: s)
-
-    builtin_scalar_types = type(None), bool, int, float, str, bytes
-    return st.shared(
-        st.sampled_from(
-            # Constraints may be None or () on various Python versions.
-            getattr(thing, "__constraints__", None)
-            or builtin_scalar_types,
-        ),
-        key=type_var_key,
-    ).flatmap(st.from_type)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/utils Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/utils/terminal.py Deleted

@@ -1,36 +0,0 @@
-# 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 os
-
-
-def guess_background_color():
-    """Returns one of "dark", "light", or "unknown".
-
-    This is basically just guessing, but better than always guessing "dark"!
-    See also https://stackoverflow.com/questions/2507337/ and
-    https://unix.stackexchange.com/questions/245378/
-    """
-    django_colors = os.getenv("DJANGO_COLORS")
-    if django_colors in ("light", "dark"):
-        return django_colors
-    # Guessing based on the $COLORFGBG environment variable
-    try:
-        fg, *_, bg = os.getenv("COLORFGBG").split(";")
-    except Exception:
-        pass
-    else:
-        # 0=black, 7=light-grey, 15=white ; we don't interpret other colors
-        if fg in ("7", "15") and bg == "0":
-            return "dark"
-        elif fg == "0" and bg in ("7", "15"):
-            return "light"
-    # TODO: Guessing based on the xterm control sequence
-    return "unknown"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/vendor Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/vendor/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/vendor/pretty.py Deleted

@@ -1,845 +0,0 @@
-# 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/.
-
-"""
-Python advanced pretty printer.  This pretty printer is intended to
-replace the old `pprint` python module which does not allow developers
-to provide their own pretty print callbacks.
-This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
-Example Usage
--------------
-To get a string of the output use `pretty`::
-    from pretty import pretty
-    string = pretty(complex_object)
-Extending
----------
-The pretty library allows developers to add pretty printing rules for their
-own objects.  This process is straightforward.  All you have to do is to
-add a `_repr_pretty_` method to your object and call the methods on the
-pretty printer passed::
-    class MyObject(object):
-        def _repr_pretty_(self, p, cycle):
-            ...
-Here is an example implementation of a `_repr_pretty_` method for a list
-subclass::
-    class MyList(list):
-        def _repr_pretty_(self, p, cycle):
-            if cycle:
-                p.text('MyList(...)')
-            else:
-                with p.group(8, 'MyList(', ')'):
-                    for idx, item in enumerate(self):
-                        if idx:
-                            p.text(',')
-                            p.breakable()
-                        p.pretty(item)
-The `cycle` parameter is `True` if pretty detected a cycle.  You *have* to
-react to that or the result is an infinite loop.  `p.text()` just adds
-non breaking text to the output, `p.breakable()` either adds a whitespace
-or breaks here.  If you pass it an argument it's used instead of the
-default space.  `p.pretty` prettyprints another object using the pretty print
-method.
-The first parameter to the `group` function specifies the extra indentation
-of the next line.  In this example the next item will either be on the same
-line (if the items are short enough) or aligned with the right edge of the
-opening bracket of `MyList`.
-If you just want to indent something you can use the group function
-without open / close parameters.  You can also use this code::
-    with p.indent(2):
-        ...
-Inheritance diagram:
-.. inheritance-diagram:: IPython.lib.pretty
-   :parts: 3
-:copyright: 2007 by Armin Ronacher.
-            Portions (c) 2009 by Robert Kern.
-:license: BSD License.
-"""
-
-import datetime
-import platform
-import re
-import struct
-import types
-from collections import deque
-from contextlib import contextmanager
-from io import StringIO
-from math import copysign, isnan
-
-__all__ = 
-    "pretty",
-    "PrettyPrinter",
-    "RepresentationPrinter",
-    "for_type_by_name",
-
-
-
-MAX_SEQ_LENGTH = 1000
-_re_pattern_type = type(re.compile(""))
-
-PYPY = platform.python_implementation() == "PyPy"
-
-
-def _safe_getattr(obj, attr, default=None):
-    """Safe version of getattr.
-
-    Same as getattr, but will return ``default`` on any Exception,
-    rather than raising.
-
-    """
-    try:
-        return getattr(obj, attr, default)
-    except Exception:
-        return default
-
-
-def pretty(
-    obj, verbose=False, max_width=79, newline="\n", max_seq_length=MAX_SEQ_LENGTH
-):
-    """Pretty print the object's representation."""
-    stream = StringIO()
-    printer = RepresentationPrinter(
-        stream, verbose, max_width, newline, max_seq_length=max_seq_length
-    )
-    printer.pretty(obj)
-    printer.flush()
-    return stream.getvalue()
-
-
-class _PrettyPrinterBase:
-    @contextmanager
-    def indent(self, indent):
-        """`with`-statement support for indenting/dedenting."""
-        self.indentation += indent
-        try:
-            yield
-        finally:
-            self.indentation -= indent
-
-    @contextmanager
-    def group(self, indent=0, open="", close=""):
-        """Like begin_group / end_group but for the with statement."""
-        self.begin_group(indent, open)
-        try:
-            yield
-        finally:
-            self.end_group(indent, close)
-
-
-class PrettyPrinter(_PrettyPrinterBase):
-    """Baseclass for the `RepresentationPrinter` prettyprinter that is used to
-    generate pretty reprs of objects.
-
-    Contrary to the `RepresentationPrinter` this printer knows nothing
-    about the default pprinters or the `_repr_pretty_` callback method.
-
-    """
-
-    def __init__(
-        self, output, max_width=79, newline="\n", max_seq_length=MAX_SEQ_LENGTH
-    ):
-        self.broken = False
-        self.output = output
-        self.max_width = max_width
-        self.newline = newline
-        self.max_seq_length = max_seq_length
-        self.output_width = 0
-        self.buffer_width = 0
-        self.buffer = deque()
-
-        root_group = Group(0)
-        self.group_stack = root_group
-        self.group_queue = GroupQueue(root_group)
-        self.indentation = 0
-
-        self.snans = 0
-
-    def _break_outer_groups(self):
-        while self.max_width < self.output_width + self.buffer_width:
-            group = self.group_queue.deq()
-            if not group:
-                return
-            while group.breakables:
-                x = self.buffer.popleft()
-                self.output_width = x.output(self.output, self.output_width)
-                self.buffer_width -= x.width
-            while self.buffer and isinstance(self.buffer0, Text):
-                x = self.buffer.popleft()
-                self.output_width = x.output(self.output, self.output_width)
-                self.buffer_width -= x.width
-
-    def text(self, obj):
-        """Add literal text to the output."""
-        width = len(obj)
-        if self.buffer:
-            text = self.buffer-1
-            if not isinstance(text, Text):
-                text = Text()
-                self.buffer.append(text)
-            text.add(obj, width)
-            self.buffer_width += width
-            self._break_outer_groups()
-        else:
-            self.output.write(obj)
-            self.output_width += width
-
-    def breakable(self, sep=" "):
-        """Add a breakable separator to the output.
-
-        This does not mean that it will automatically break here.  If no
-        breaking on this position takes place the `sep` is inserted
-        which default to one space.
-
-        """
-        width = len(sep)
-        group = self.group_stack-1
-        if group.want_break:
-            self.flush()
-            self.output.write(self.newline)
-            self.output.write(" " * self.indentation)
-            self.output_width = self.indentation
-            self.buffer_width = 0
-        else:
-            self.buffer.append(Breakable(sep, width, self))
-            self.buffer_width += width
-            self._break_outer_groups()
-
-    def break_(self):
-        """Explicitly insert a newline into the output, maintaining correct
-        indentation."""
-        self.flush()
-        self.output.write(self.newline)
-        self.output.write(" " * self.indentation)
-        self.output_width = self.indentation
-        self.buffer_width = 0
-
-    def begin_group(self, indent=0, open=""):
-        """
-        Begin a group.  If you want support for python < 2.5 which doesn't has
-        the with statement this is the preferred way:
-            p.begin_group(1, '{')
-            ...
-            p.end_group(1, '}')
-        The python 2.5 expression would be this:
-            with p.group(1, '{', '}'):
-                ...
-        The first parameter specifies the indentation for the next line (
-        usually the width of the opening text), the second the opening text.
-        All parameters are optional.
-        """
-        if open:
-            self.text(open)
-        group = Group(self.group_stack-1.depth + 1)
-        self.group_stack.append(group)
-        self.group_queue.enq(group)
-        self.indentation += indent
-
-    def _enumerate(self, seq):
-        """Like enumerate, but with an upper limit on the number of items."""
-        for idx, x in enumerate(seq):
-            if self.max_seq_length and idx >= self.max_seq_length:
-                self.text(",")
-                self.breakable()
-                self.text("...")
-                return
-            yield idx, x
-
-    def end_group(self, dedent=0, close=""):
-        """End a group.
-
-        See `begin_group` for more details.
-
-        """
-        self.indentation -= dedent
-        group = self.group_stack.pop()
-        if not group.breakables:
-            self.group_queue.remove(group)
-        if close:
-            self.text(close)
-
-    def flush(self):
-        """Flush data that is left in the buffer."""
-        if self.snans:
-            # Reset self.snans *before* calling breakable(), which might flush()
-            snans = self.snans
-            self.snans = 0
-            self.breakable("  ")
-            self.text(f"# Saw {snans} signaling NaN" + "s" * (snans > 1))
-        for data in self.buffer:
-            self.output_width += data.output(self.output, self.output_width)
-        self.buffer.clear()
-        self.buffer_width = 0
-
-
-def _get_mro(obj_class):
-    """Get a reasonable method resolution order of a class and its superclasses
-    for both old-style and new-style classes."""
-    if not hasattr(obj_class, "__mro__"):  # pragma: no cover
-        # Old-style class. Mix in object to make a fake new-style class.
-        try:
-            obj_class = type(obj_class.__name__, (obj_class, object), {})
-        except TypeError:
-            # Old-style extension type that does not descend from object.
-            # FIXME: try to construct a more thorough MRO.
-            mro = obj_class
-        else:
-            mro = obj_class.__mro__1:-1
-    else:
-        mro = obj_class.__mro__
-    return mro
-
-
-class RepresentationPrinter(PrettyPrinter):
-    """Special pretty printer that has a `pretty` method that calls the pretty
-    printer for a python object.
-
-    This class stores processing data on `self` so you must *never* use
-    this class in a threaded environment.  Always lock it or
-    reinstanciate it. Instances also have a verbose flag callbacks can
-    access to control their output.  For example the default instance
-    repr prints all attributes and methods that are not prefixed by an
-    underscore if the printer is in verbose mode.
-
-    """
-
-    def __init__(
-        self,
-        output,
-        verbose=False,
-        max_width=79,
-        newline="\n",
-        singleton_pprinters=None,
-        type_pprinters=None,
-        deferred_pprinters=None,
-        max_seq_length=MAX_SEQ_LENGTH,
-    ):
-
-        super().__init__(output, max_width, newline, max_seq_length=max_seq_length)
-        self.verbose = verbose
-        self.stack = 
-        if singleton_pprinters is None:
-            singleton_pprinters = _singleton_pprinters.copy()
-        self.singleton_pprinters = singleton_pprinters
-        if type_pprinters is None:
-            type_pprinters = _type_pprinters.copy()
-        self.type_pprinters = type_pprinters
-        if deferred_pprinters is None:
-            deferred_pprinters = _deferred_type_pprinters.copy()
-        self.deferred_pprinters = deferred_pprinters
-
-    def pretty(self, obj):
-        """Pretty print the given object."""
-        obj_id = id(obj)
-        cycle = obj_id in self.stack
-        self.stack.append(obj_id)
-        self.begin_group()
-        try:
-            obj_class = _safe_getattr(obj, "__class__", None) or type(obj)
-            # First try to find registered singleton printers for the type.
-            try:
-                printer = self.singleton_pprintersobj_id
-            except (TypeError, KeyError):
-                pass
-            else:
-                return printer(obj, self, cycle)
-            # Next walk the mro and check for either:
-            #   1) a registered printer
-            #   2) a _repr_pretty_ method
-            for cls in _get_mro(obj_class):
-                if cls in self.type_pprinters:
-                    # printer registered in self.type_pprinters
-                    return self.type_pprinterscls(obj, self, cycle)
-                else:
-                    # deferred printer
-                    printer = self._in_deferred_types(cls)
-                    if printer is not None:
-                        return printer(obj, self, cycle)
-                    else:
-                        # Finally look for special method names.
-                        # Some objects automatically create any requested
-                        # attribute. Try to ignore most of them by checking for
-                        # callability.
-                        if "_repr_pretty_" in cls.__dict__:
-                            meth = cls._repr_pretty_
-                            if callable(meth):
-                                return meth(obj, self, cycle)
-            return _default_pprint(obj, self, cycle)
-        finally:
-            self.end_group()
-            self.stack.pop()
-
-    def _in_deferred_types(self, cls):
-        """Check if the given class is specified in the deferred type registry.
-
-        Returns the printer from the registry if it exists, and None if
-        the class is not in the registry. Successful matches will be
-        moved to the regular type registry for future use.
-
-        """
-        mod = _safe_getattr(cls, "__module__", None)
-        name = _safe_getattr(cls, "__name__", None)
-        key = (mod, name)
-        printer = None
-        if key in self.deferred_pprinters:
-            # Move the printer over to the regular registry.
-            printer = self.deferred_pprinters.pop(key)
-            self.type_pprinterscls = printer
-        return printer
-
-
-class Printable:
-    def output(self, stream, output_width):  # pragma: no cover
-        raise NotImplementedError()
-
-
-class Text(Printable):
-    def __init__(self):
-        self.objs = 
-        self.width = 0
-
-    def output(self, stream, output_width):
-        for obj in self.objs:
-            stream.write(obj)
-        return output_width + self.width
-
-    def add(self, obj, width):
-        self.objs.append(obj)
-        self.width += width
-
-
-class Breakable(Printable):
-    def __init__(self, seq, width, pretty):
-        self.obj = seq
-        self.width = width
-        self.pretty = pretty
-        self.indentation = pretty.indentation
-        self.group = pretty.group_stack-1
-        self.group.breakables.append(self)
-
-    def output(self, stream, output_width):
-        self.group.breakables.popleft()
-        if self.group.want_break:
-            stream.write(self.pretty.newline)
-            stream.write(" " * self.indentation)
-            return self.indentation
-        if not self.group.breakables:
-            self.pretty.group_queue.remove(self.group)
-        stream.write(self.obj)
-        return output_width + self.width
-
-
-class Group(Printable):
-    def __init__(self, depth):
-        self.depth = depth
-        self.breakables = deque()
-        self.want_break = False
-
-
-class GroupQueue:
-    def __init__(self, *groups):
-        self.queue = 
-        for group in groups:
-            self.enq(group)
-
-    def enq(self, group):
-        depth = group.depth
-        while depth > len(self.queue) - 1:
-            self.queue.append()
-        self.queuedepth.append(group)
-
-    def deq(self):
-        for stack in self.queue:
-            for idx, group in enumerate(reversed(stack)):
-                if group.breakables:
-                    del stackidx
-                    group.want_break = True
-                    return group
-            for group in stack:
-                group.want_break = True
-            del stack:
-
-    def remove(self, group):
-        try:
-            self.queuegroup.depth.remove(group)
-        except ValueError:
-            pass
-
-
-def _default_pprint(obj, p, cycle):
-    """The default print function.
-
-    Used if an object does not provide one and it's none of the builtin
-    objects.
-
-    """
-    klass = _safe_getattr(obj, "__class__", None) or type(obj)
-    if _safe_getattr(klass, "__repr__", None) is not object.__repr__:
-        # A user-provided repr. Find newlines and replace them with p.break_()
-        _repr_pprint(obj, p, cycle)
-        return
-    p.begin_group(1, "<")
-    p.pretty(klass)
-    p.text(f" at 0x{id(obj):x}")
-    if cycle:
-        p.text(" ...")
-    elif p.verbose:
-        first = True
-        for key in dir(obj):
-            if not key.startswith("_"):
-                try:
-                    value = getattr(obj, key)
-                except AttributeError:
-                    continue
-                if isinstance(value, types.MethodType):
-                    continue
-                if not first:
-                    p.text(",")
-                p.breakable()
-                p.text(key)
-                p.text("=")
-                step = len(key) + 1
-                p.indentation += step
-                p.pretty(value)
-                p.indentation -= step
-                first = False
-    p.end_group(1, ">")
-
-
-def _seq_pprinter_factory(start, end, basetype):
-    """Factory that returns a pprint function useful for sequences.
-
-    Used by the default pprint for tuples, dicts, and lists.
-
-    """
-
-    def inner(obj, p, cycle):
-        typ = type(obj)
-        if (
-            basetype is not None
-            and typ is not basetype
-            and typ.__repr__ != basetype.__repr__
-        ):
-            # If the subclass provides its own repr, use it instead.
-            return p.text(typ.__repr__(obj))
-
-        if cycle:
-            return p.text(start + "..." + end)
-        step = len(start)
-        p.begin_group(step, start)
-        for idx, x in p._enumerate(obj):
-            if idx:
-                p.text(",")
-                p.breakable()
-            p.pretty(x)
-        if len(obj) == 1 and type(obj) is tuple:
-            # Special case for 1-item tuples.
-            p.text(",")
-        p.end_group(step, end)
-
-    return inner
-
-
-def _set_pprinter_factory(start, end, basetype):
-    """Factory that returns a pprint function useful for sets and
-    frozensets."""
-
-    def inner(obj, p, cycle):
-        typ = type(obj)
-        if (
-            basetype is not None
-            and typ is not basetype
-            and typ.__repr__ != basetype.__repr__
-        ):
-            # If the subclass provides its own repr, use it instead.
-            return p.text(typ.__repr__(obj))
-
-        if cycle:
-            return p.text(start + "..." + end)
-        if not obj:
-            # Special case.
-            p.text(basetype.__name__ + "()")
-        else:
-            step = len(start)
-            p.begin_group(step, start)
-            # Like dictionary keys, we will try to sort the items if there
-            # aren't too many
-            items = obj
-            if not (p.max_seq_length and len(obj) >= p.max_seq_length):
-                try:
-                    items = sorted(obj)
-                except Exception:
-                    # Sometimes the items don't sort.
-                    pass
-            for idx, x in p._enumerate(items):
-                if idx:
-                    p.text(",")
-                    p.breakable()
-                p.pretty(x)
-            p.end_group(step, end)
-
-    return inner
-
-
-def _dict_pprinter_factory(start, end, basetype=None):
-    """Factory that returns a pprint function used by the default pprint of
-    dicts and dict proxies."""
-
-    def inner(obj, p, cycle):
-        typ = type(obj)
-        if (
-            basetype is not None
-            and typ is not basetype
-            and typ.__repr__ != basetype.__repr__
-        ):
-            # If the subclass provides its own repr, use it instead.
-            return p.text(typ.__repr__(obj))
-
-        if cycle:
-            return p.text("{...}")
-        p.begin_group(1, start)
-        keys = obj.keys()
-        # if dict isn't large enough to be truncated, sort keys before
-        # displaying
-        if not (p.max_seq_length and len(obj) >= p.max_seq_length):
-            try:
-                keys = sorted(keys)
-            except Exception:
-                # Sometimes the keys don't sort.
-                pass
-        for idx, key in p._enumerate(keys):
-            if idx:
-                p.text(",")
-                p.breakable()
-            p.pretty(key)
-            p.text(": ")
-            p.pretty(objkey)
-        p.end_group(1, end)
-
-    inner.__name__ = f"_dict_pprinter_factory({start!r}, {end!r}, {basetype!r})"
-    return inner
-
-
-def _super_pprint(obj, p, cycle):
-    """The pprint for the super type."""
-    try:
-        # This section works around various pypy versions that don't do
-        # have the same attributes on super objects
-        obj.__thisclass__
-        obj.__self__
-    except AttributeError:  # pragma: no cover
-        assert PYPY
-        _repr_pprint(obj, p, cycle)
-        return
-    p.begin_group(8, "<super: ")
-    p.pretty(obj.__thisclass__)
-    p.text(",")
-    p.breakable()
-    p.pretty(obj.__self__)
-    p.end_group(8, ">")
-
-
-def _re_pattern_pprint(obj, p, cycle):
-    """The pprint function for regular expression patterns."""
-    p.text("re.compile(")
-    pattern = repr(obj.pattern)
-    if pattern:1 in "uU":  # pragma: no cover
-        pattern = pattern1:
-        prefix = "ur"
-    else:
-        prefix = "r"
-    pattern = prefix + pattern.replace("\\\\", "\\")
-    p.text(pattern)
-    if obj.flags:
-        p.text(",")
-        p.breakable()
-        done_one = False
-        for flag in (
-            "TEMPLATE",
-            "IGNORECASE",
-            "LOCALE",
-            "MULTILINE",
-            "DOTALL",
-            "UNICODE",
-            "VERBOSE",
-            "DEBUG",
-        ):
-            if obj.flags & getattr(re, flag, 0):
-                if done_one:
-                    p.text("|")
-                p.text("re." + flag)
-                done_one = True
-    p.text(")")
-
-
-def _type_pprint(obj, p, cycle):
-    """The pprint for classes and types."""
-    # Heap allocated types might not have the module attribute,
-    # and others may set it to None.
-
-    # Checks for a __repr__ override in the metaclass
-    # != rather than is not because pypy compatibility
-    if type(obj).__repr__ != type.__repr__:
-        _repr_pprint(obj, p, cycle)
-        return
-
-    mod = _safe_getattr(obj, "__module__", None)
-    try:
-        name = obj.__qualname__
-        if not isinstance(name, str):  # pragma: no cover
-            # This can happen if the type implements __qualname__ as a property
-            # or other descriptor in Python 2.
-            raise Exception("Try __name__")
-    except Exception:  # pragma: no cover
-        name = obj.__name__
-        if not isinstance(name, str):
-            name = "<unknown type>"
-
-    if mod in (None, "__builtin__", "builtins", "exceptions"):
-        p.text(name)
-    else:
-        p.text(mod + "." + name)
-
-
-def _repr_pprint(obj, p, cycle):
-    """A pprint that just redirects to the normal repr function."""
-    # Find newlines and replace them with p.break_()
-    output = repr(obj)
-    for idx, output_line in enumerate(output.splitlines()):
-        if idx:
-            p.break_()
-        p.text(output_line)
-
-
-def _function_pprint(obj, p, cycle):
-    """Base pprint for all functions and builtin functions."""
-    from hypothesis.internal.reflection import get_pretty_function_description
-
-    p.text(get_pretty_function_description(obj))
-
-
-def _exception_pprint(obj, p, cycle):
-    """Base pprint for all exceptions."""
-    name = getattr(obj.__class__, "__qualname__", obj.__class__.__name__)
-    if obj.__class__.__module__ not in ("exceptions", "builtins"):
-        name = f"{obj.__class__.__module__}.{name}"
-    step = len(name) + 1
-    p.begin_group(step, name + "(")
-    for idx, arg in enumerate(getattr(obj, "args", ())):
-        if idx:
-            p.text(",")
-            p.breakable()
-        p.pretty(arg)
-    p.end_group(step, ")")
-
-
-def _repr_float_counting_nans(obj, p, cycle):
-    if isnan(obj) and hasattr(p, "snans"):
-        if struct.pack("!d", abs(obj)) != struct.pack("!d", float("nan")):
-            p.snans += 1
-        if copysign(1.0, obj) == -1.0:
-            p.text("-nan")
-            return
-    p.text(repr(obj))
-
-
-#: printers for builtin types
-_type_pprinters = {
-    int: _repr_pprint,
-    float: _repr_float_counting_nans,
-    str: _repr_pprint,
-    tuple: _seq_pprinter_factory("(", ")", tuple),
-    list: _seq_pprinter_factory("", "", list),
-    dict: _dict_pprinter_factory("{", "}", dict),
-    set: _set_pprinter_factory("{", "}", set),
-    frozenset: _set_pprinter_factory("frozenset({", "})", frozenset),
-    super: _super_pprint,
-    _re_pattern_type: _re_pattern_pprint,
-    type: _type_pprint,
-    types.FunctionType: _function_pprint,
-    types.BuiltinFunctionType: _function_pprint,
-    types.MethodType: _repr_pprint,
-    datetime.datetime: _repr_pprint,
-    datetime.timedelta: _repr_pprint,
-    BaseException: _exception_pprint,
-    slice: _repr_pprint,
-    range: _repr_pprint,
-    bytes: _repr_pprint,
-}
-
-#: printers for types specified by name
-_deferred_type_pprinters = {}  # type: ignore
-
-
-def for_type_by_name(type_module, type_name, func):
-    """Add a pretty printer for a type specified by the module and name of a
-    type rather than the type object itself."""
-    key = (type_module, type_name)
-    oldfunc = _deferred_type_pprinters.get(key, None)
-    _deferred_type_pprinterskey = func
-    return oldfunc
-
-
-#: printers for the default singletons
-_singleton_pprinters = dict.fromkeys(
-    map(id, None, True, False, Ellipsis, NotImplemented), _repr_pprint
-)
-
-
-def _defaultdict_pprint(obj, p, cycle):
-    name = obj.__class__.__name__
-    with p.group(len(name) + 1, name + "(", ")"):
-        if cycle:
-            p.text("...")
-        else:
-            p.pretty(obj.default_factory)
-            p.text(",")
-            p.breakable()
-            p.pretty(dict(obj))
-
-
-def _ordereddict_pprint(obj, p, cycle):
-    name = obj.__class__.__name__
-    with p.group(len(name) + 1, name + "(", ")"):
-        if cycle:
-            p.text("...")
-        elif obj:
-            p.pretty(list(obj.items()))
-
-
-def _deque_pprint(obj, p, cycle):
-    name = obj.__class__.__name__
-    with p.group(len(name) + 1, name + "(", ")"):
-        if cycle:
-            p.text("...")
-        else:
-            p.pretty(list(obj))
-
-
-def _counter_pprint(obj, p, cycle):
-    name = obj.__class__.__name__
-    with p.group(len(name) + 1, name + "(", ")"):
-        if cycle:
-            p.text("...")
-        elif obj:
-            p.pretty(dict(obj))
-
-
-def _repr_dataframe(obj, p, cycle):  # pragma: no cover
-    with p.indent(4):
-        p.break_()
-        _repr_pprint(obj, p, cycle)
-    p.break_()
-
-
-for_type_by_name("collections", "defaultdict", _defaultdict_pprint)
-for_type_by_name("collections", "OrderedDict", _ordereddict_pprint)
-for_type_by_name("ordereddict", "OrderedDict", _ordereddict_pprint)
-for_type_by_name("collections", "deque", _deque_pprint)
-for_type_by_name("collections", "Counter", _counter_pprint)
-for_type_by_name("pandas.core.frame", "DataFrame", _repr_dataframe)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/vendor/tlds-alpha-by-domain.txt Deleted

@@ -1,1488 +0,0 @@
-# Version 2022040900, Last Updated Sat Apr  9 07:07:02 2022 UTC
-AAA
-AARP
-ABARTH
-ABB
-ABBOTT
-ABBVIE
-ABC
-ABLE
-ABOGADO
-ABUDHABI
-AC
-ACADEMY
-ACCENTURE
-ACCOUNTANT
-ACCOUNTANTS
-ACO
-ACTOR
-AD
-ADAC
-ADS
-ADULT
-AE
-AEG
-AERO
-AETNA
-AF
-AFL
-AFRICA
-AG
-AGAKHAN
-AGENCY
-AI
-AIG
-AIRBUS
-AIRFORCE
-AIRTEL
-AKDN
-AL
-ALFAROMEO
-ALIBABA
-ALIPAY
-ALLFINANZ
-ALLSTATE
-ALLY
-ALSACE
-ALSTOM
-AM
-AMAZON
-AMERICANEXPRESS
-AMERICANFAMILY
-AMEX
-AMFAM
-AMICA
-AMSTERDAM
-ANALYTICS
-ANDROID
-ANQUAN
-ANZ
-AO
-AOL
-APARTMENTS
-APP
-APPLE
-AQ
-AQUARELLE
-AR
-ARAB
-ARAMCO
-ARCHI
-ARMY
-ARPA
-ART
-ARTE
-AS
-ASDA
-ASIA
-ASSOCIATES
-AT
-ATHLETA
-ATTORNEY
-AU
-AUCTION
-AUDI
-AUDIBLE
-AUDIO
-AUSPOST
-AUTHOR
-AUTO
-AUTOS
-AVIANCA
-AW
-AWS
-AX
-AXA
-AZ
-AZURE
-BA
-BABY
-BAIDU
-BANAMEX
-BANANAREPUBLIC
-BAND
-BANK
-BAR
-BARCELONA
-BARCLAYCARD
-BARCLAYS
-BAREFOOT
-BARGAINS
-BASEBALL
-BASKETBALL
-BAUHAUS
-BAYERN
-BB
-BBC
-BBT
-BBVA
-BCG
-BCN
-BD
-BE
-BEATS
-BEAUTY
-BEER
-BENTLEY
-BERLIN
-BEST
-BESTBUY
-BET
-BF
-BG
-BH
-BHARTI
-BI
-BIBLE
-BID
-BIKE
-BING
-BINGO
-BIO
-BIZ
-BJ
-BLACK
-BLACKFRIDAY
-BLOCKBUSTER
-BLOG
-BLOOMBERG
-BLUE
-BM
-BMS
-BMW
-BN
-BNPPARIBAS
-BO
-BOATS
-BOEHRINGER
-BOFA
-BOM
-BOND
-BOO
-BOOK
-BOOKING
-BOSCH
-BOSTIK
-BOSTON
-BOT
-BOUTIQUE
-BOX
-BR
-BRADESCO
-BRIDGESTONE
-BROADWAY
-BROKER
-BROTHER
-BRUSSELS
-BS
-BT
-BUGATTI
-BUILD
-BUILDERS
-BUSINESS
-BUY
-BUZZ
-BV
-BW
-BY
-BZ
-BZH
-CA
-CAB
-CAFE
-CAL
-CALL
-CALVINKLEIN
-CAM
-CAMERA
-CAMP
-CANCERRESEARCH
-CANON
-CAPETOWN
-CAPITAL
-CAPITALONE
-CAR
-CARAVAN
-CARDS
-CARE
-CAREER
-CAREERS
-CARS
-CASA
-CASE
-CASH
-CASINO
-CAT
-CATERING
-CATHOLIC
-CBA
-CBN
-CBRE
-CBS
-CC
-CD
-CENTER
-CEO
-CERN
-CF
-CFA
-CFD
-CG
-CH
-CHANEL
-CHANNEL
-CHARITY
-CHASE
-CHAT
-CHEAP
-CHINTAI
-CHRISTMAS
-CHROME
-CHURCH
-CI
-CIPRIANI
-CIRCLE
-CISCO
-CITADEL
-CITI
-CITIC
-CITY
-CITYEATS
-CK
-CL
-CLAIMS
-CLEANING
-CLICK
-CLINIC
-CLINIQUE
-CLOTHING
-CLOUD
-CLUB
-CLUBMED
-CM
-CN
-CO
-COACH
-CODES
-COFFEE
-COLLEGE
-COLOGNE
-COM
-COMCAST
-COMMBANK
-COMMUNITY
-COMPANY
-COMPARE
-COMPUTER
-COMSEC
-CONDOS
-CONSTRUCTION
-CONSULTING
-CONTACT
-CONTRACTORS
-COOKING
-COOKINGCHANNEL
-COOL
-COOP
-CORSICA
-COUNTRY
-COUPON
-COUPONS
-COURSES
-CPA
-CR
-CREDIT
-CREDITCARD
-CREDITUNION
-CRICKET
-CROWN
-CRS
-CRUISE
-CRUISES
-CU
-CUISINELLA
-CV
-CW
-CX
-CY
-CYMRU
-CYOU
-CZ
-DABUR
-DAD
-DANCE
-DATA
-DATE
-DATING
-DATSUN
-DAY
-DCLK
-DDS
-DE
-DEAL
-DEALER
-DEALS
-DEGREE
-DELIVERY
-DELL
-DELOITTE
-DELTA
-DEMOCRAT
-DENTAL
-DENTIST
-DESI
-DESIGN
-DEV
-DHL
-DIAMONDS
-DIET
-DIGITAL
-DIRECT
-DIRECTORY
-DISCOUNT
-DISCOVER
-DISH
-DIY
-DJ
-DK
-DM
-DNP
-DO
-DOCS
-DOCTOR
-DOG
-DOMAINS
-DOT
-DOWNLOAD
-DRIVE
-DTV
-DUBAI
-DUNLOP
-DUPONT
-DURBAN
-DVAG
-DVR
-DZ
-EARTH
-EAT
-EC
-ECO
-EDEKA
-EDU
-EDUCATION
-EE
-EG
-EMAIL
-EMERCK
-ENERGY
-ENGINEER
-ENGINEERING
-ENTERPRISES
-EPSON
-EQUIPMENT
-ER
-ERICSSON
-ERNI
-ES
-ESQ
-ESTATE
-ET
-ETISALAT
-EU
-EUROVISION
-EUS
-EVENTS
-EXCHANGE
-EXPERT
-EXPOSED
-EXPRESS
-EXTRASPACE
-FAGE
-FAIL
-FAIRWINDS
-FAITH
-FAMILY
-FAN
-FANS
-FARM
-FARMERS
-FASHION
-FAST
-FEDEX
-FEEDBACK
-FERRARI
-FERRERO
-FI
-FIAT
-FIDELITY
-FIDO
-FILM
-FINAL
-FINANCE
-FINANCIAL
-FIRE
-FIRESTONE
-FIRMDALE
-FISH
-FISHING
-FIT
-FITNESS
-FJ
-FK
-FLICKR
-FLIGHTS
-FLIR
-FLORIST
-FLOWERS
-FLY
-FM
-FO
-FOO
-FOOD
-FOODNETWORK
-FOOTBALL
-FORD
-FOREX
-FORSALE
-FORUM
-FOUNDATION
-FOX
-FR
-FREE
-FRESENIUS
-FRL
-FROGANS
-FRONTDOOR
-FRONTIER
-FTR
-FUJITSU
-FUN
-FUND
-FURNITURE
-FUTBOL
-FYI
-GA
-GAL
-GALLERY
-GALLO
-GALLUP
-GAME
-GAMES
-GAP
-GARDEN
-GAY
-GB
-GBIZ
-GD
-GDN
-GE
-GEA
-GENT
-GENTING
-GEORGE
-GF
-GG
-GGEE
-GH
-GI
-GIFT
-GIFTS
-GIVES
-GIVING
-GL
-GLASS
-GLE
-GLOBAL
-GLOBO
-GM
-GMAIL
-GMBH
-GMO
-GMX
-GN
-GODADDY
-GOLD
-GOLDPOINT
-GOLF
-GOO
-GOODYEAR
-GOOG
-GOOGLE
-GOP
-GOT
-GOV
-GP
-GQ
-GR
-GRAINGER
-GRAPHICS
-GRATIS
-GREEN
-GRIPE
-GROCERY
-GROUP
-GS
-GT
-GU
-GUARDIAN
-GUCCI
-GUGE
-GUIDE
-GUITARS
-GURU
-GW
-GY
-HAIR
-HAMBURG
-HANGOUT
-HAUS
-HBO
-HDFC
-HDFCBANK
-HEALTH
-HEALTHCARE
-HELP
-HELSINKI
-HERE
-HERMES
-HGTV
-HIPHOP
-HISAMITSU
-HITACHI
-HIV
-HK
-HKT
-HM
-HN
-HOCKEY
-HOLDINGS
-HOLIDAY
-HOMEDEPOT
-HOMEGOODS
-HOMES
-HOMESENSE
-HONDA
-HORSE
-HOSPITAL
-HOST
-HOSTING
-HOT
-HOTELES
-HOTELS
-HOTMAIL
-HOUSE
-HOW
-HR
-HSBC
-HT
-HU
-HUGHES
-HYATT
-HYUNDAI
-IBM
-ICBC
-ICE
-ICU
-ID
-IE
-IEEE
-IFM
-IKANO
-IL
-IM
-IMAMAT
-IMDB
-IMMO
-IMMOBILIEN
-IN
-INC
-INDUSTRIES
-INFINITI
-INFO
-ING
-INK
-INSTITUTE
-INSURANCE
-INSURE
-INT
-INTERNATIONAL
-INTUIT
-INVESTMENTS
-IO
-IPIRANGA
-IQ
-IR
-IRISH
-IS
-ISMAILI
-IST
-ISTANBUL
-IT
-ITAU
-ITV
-JAGUAR
-JAVA
-JCB
-JE
-JEEP
-JETZT
-JEWELRY
-JIO
-JLL
-JM
-JMP
-JNJ
-JO
-JOBS
-JOBURG
-JOT
-JOY
-JP
-JPMORGAN
-JPRS
-JUEGOS
-JUNIPER
-KAUFEN
-KDDI
-KE
-KERRYHOTELS
-KERRYLOGISTICS
-KERRYPROPERTIES
-KFH
-KG
-KH
-KI
-KIA
-KIDS
-KIM
-KINDER
-KINDLE
-KITCHEN
-KIWI
-KM
-KN
-KOELN
-KOMATSU
-KOSHER
-KP
-KPMG
-KPN
-KR
-KRD
-KRED
-KUOKGROUP
-KW
-KY
-KYOTO
-KZ
-LA
-LACAIXA
-LAMBORGHINI
-LAMER
-LANCASTER
-LANCIA
-LAND
-LANDROVER
-LANXESS
-LASALLE
-LAT
-LATINO
-LATROBE
-LAW
-LAWYER
-LB
-LC
-LDS
-LEASE
-LECLERC
-LEFRAK
-LEGAL
-LEGO
-LEXUS
-LGBT
-LI
-LIDL
-LIFE
-LIFEINSURANCE
-LIFESTYLE
-LIGHTING
-LIKE
-LILLY
-LIMITED
-LIMO
-LINCOLN
-LINDE
-LINK
-LIPSY
-LIVE
-LIVING
-LK
-LLC
-LLP
-LOAN
-LOANS
-LOCKER
-LOCUS
-LOFT
-LOL
-LONDON
-LOTTE
-LOTTO
-LOVE
-LPL
-LPLFINANCIAL
-LR
-LS
-LT
-LTD
-LTDA
-LU
-LUNDBECK
-LUXE
-LUXURY
-LV
-LY
-MA
-MACYS
-MADRID
-MAIF
-MAISON
-MAKEUP
-MAN
-MANAGEMENT
-MANGO
-MAP
-MARKET
-MARKETING
-MARKETS
-MARRIOTT
-MARSHALLS
-MASERATI
-MATTEL
-MBA
-MC
-MCKINSEY
-MD
-ME
-MED
-MEDIA
-MEET
-MELBOURNE
-MEME
-MEMORIAL
-MEN
-MENU
-MERCKMSD
-MG
-MH
-MIAMI
-MICROSOFT
-MIL
-MINI
-MINT
-MIT
-MITSUBISHI
-MK
-ML
-MLB
-MLS
-MM
-MMA
-MN
-MO
-MOBI
-MOBILE
-MODA
-MOE
-MOI
-MOM
-MONASH
-MONEY
-MONSTER
-MORMON
-MORTGAGE
-MOSCOW
-MOTO
-MOTORCYCLES
-MOV
-MOVIE
-MP
-MQ
-MR
-MS
-MSD
-MT
-MTN
-MTR
-MU
-MUSEUM
-MUSIC
-MUTUAL
-MV
-MW
-MX
-MY
-MZ
-NA
-NAB
-NAGOYA
-NAME
-NATURA
-NAVY
-NBA
-NC
-NE
-NEC
-NET
-NETBANK
-NETFLIX
-NETWORK
-NEUSTAR
-NEW
-NEWS
-NEXT
-NEXTDIRECT
-NEXUS
-NF
-NFL
-NG
-NGO
-NHK
-NI
-NICO
-NIKE
-NIKON
-NINJA
-NISSAN
-NISSAY
-NL
-NO
-NOKIA
-NORTHWESTERNMUTUAL
-NORTON
-NOW
-NOWRUZ
-NOWTV
-NP
-NR
-NRA
-NRW
-NTT
-NU
-NYC
-NZ
-OBI
-OBSERVER
-OFFICE
-OKINAWA
-OLAYAN
-OLAYANGROUP
-OLDNAVY
-OLLO
-OM
-OMEGA
-ONE
-ONG
-ONL
-ONLINE
-OOO
-OPEN
-ORACLE
-ORANGE
-ORG
-ORGANIC
-ORIGINS
-OSAKA
-OTSUKA
-OTT
-OVH
-PA
-PAGE
-PANASONIC
-PARIS
-PARS
-PARTNERS
-PARTS
-PARTY
-PASSAGENS
-PAY
-PCCW
-PE
-PET
-PF
-PFIZER
-PG
-PH
-PHARMACY
-PHD
-PHILIPS
-PHONE
-PHOTO
-PHOTOGRAPHY
-PHOTOS
-PHYSIO
-PICS
-PICTET
-PICTURES
-PID
-PIN
-PING
-PINK
-PIONEER
-PIZZA
-PK
-PL
-PLACE
-PLAY
-PLAYSTATION
-PLUMBING
-PLUS
-PM
-PN
-PNC
-POHL
-POKER
-POLITIE
-PORN
-POST
-PR
-PRAMERICA
-PRAXI
-PRESS
-PRIME
-PRO
-PROD
-PRODUCTIONS
-PROF
-PROGRESSIVE
-PROMO
-PROPERTIES
-PROPERTY
-PROTECTION
-PRU
-PRUDENTIAL
-PS
-PT
-PUB
-PW
-PWC
-PY
-QA
-QPON
-QUEBEC
-QUEST
-RACING
-RADIO
-RE
-READ
-REALESTATE
-REALTOR
-REALTY
-RECIPES
-RED
-REDSTONE
-REDUMBRELLA
-REHAB
-REISE
-REISEN
-REIT
-RELIANCE
-REN
-RENT
-RENTALS
-REPAIR
-REPORT
-REPUBLICAN
-REST
-RESTAURANT
-REVIEW
-REVIEWS
-REXROTH
-RICH
-RICHARDLI
-RICOH
-RIL
-RIO
-RIP
-RO
-ROCHER
-ROCKS
-RODEO
-ROGERS
-ROOM
-RS
-RSVP
-RU
-RUGBY
-RUHR
-RUN
-RW
-RWE
-RYUKYU
-SA
-SAARLAND
-SAFE
-SAFETY
-SAKURA
-SALE
-SALON
-SAMSCLUB
-SAMSUNG
-SANDVIK
-SANDVIKCOROMANT
-SANOFI
-SAP
-SARL
-SAS
-SAVE
-SAXO
-SB
-SBI
-SBS
-SC
-SCA
-SCB
-SCHAEFFLER
-SCHMIDT
-SCHOLARSHIPS
-SCHOOL
-SCHULE
-SCHWARZ
-SCIENCE
-SCOT
-SD
-SE
-SEARCH
-SEAT
-SECURE
-SECURITY
-SEEK
-SELECT
-SENER
-SERVICES
-SES
-SEVEN
-SEW
-SEX
-SEXY
-SFR
-SG
-SH
-SHANGRILA
-SHARP
-SHAW
-SHELL
-SHIA
-SHIKSHA
-SHOES
-SHOP
-SHOPPING
-SHOUJI
-SHOW
-SHOWTIME
-SI
-SILK
-SINA
-SINGLES
-SITE
-SJ
-SK
-SKI
-SKIN
-SKY
-SKYPE
-SL
-SLING
-SM
-SMART
-SMILE
-SN
-SNCF
-SO
-SOCCER
-SOCIAL
-SOFTBANK
-SOFTWARE
-SOHU
-SOLAR
-SOLUTIONS
-SONG
-SONY
-SOY
-SPA
-SPACE
-SPORT
-SPOT
-SR
-SRL
-SS
-ST
-STADA
-STAPLES
-STAR
-STATEBANK
-STATEFARM
-STC
-STCGROUP
-STOCKHOLM
-STORAGE
-STORE
-STREAM
-STUDIO
-STUDY
-STYLE
-SU
-SUCKS
-SUPPLIES
-SUPPLY
-SUPPORT
-SURF
-SURGERY
-SUZUKI
-SV
-SWATCH
-SWISS
-SX
-SY
-SYDNEY
-SYSTEMS
-SZ
-TAB
-TAIPEI
-TALK
-TAOBAO
-TARGET
-TATAMOTORS
-TATAR
-TATTOO
-TAX
-TAXI
-TC
-TCI
-TD
-TDK
-TEAM
-TECH
-TECHNOLOGY
-TEL
-TEMASEK
-TENNIS
-TEVA
-TF
-TG
-TH
-THD
-THEATER
-THEATRE
-TIAA
-TICKETS
-TIENDA
-TIFFANY
-TIPS
-TIRES
-TIROL
-TJ
-TJMAXX
-TJX
-TK
-TKMAXX
-TL
-TM
-TMALL
-TN
-TO
-TODAY
-TOKYO
-TOOLS
-TOP
-TORAY
-TOSHIBA
-TOTAL
-TOURS
-TOWN
-TOYOTA
-TOYS
-TR
-TRADE
-TRADING
-TRAINING
-TRAVEL
-TRAVELCHANNEL
-TRAVELERS
-TRAVELERSINSURANCE
-TRUST
-TRV
-TT
-TUBE
-TUI
-TUNES
-TUSHU
-TV
-TVS
-TW
-TZ
-UA
-UBANK
-UBS
-UG
-UK
-UNICOM
-UNIVERSITY
-UNO
-UOL
-UPS
-US
-UY
-UZ
-VA
-VACATIONS
-VANA
-VANGUARD
-VC
-VE
-VEGAS
-VENTURES
-VERISIGN
-VERSICHERUNG
-VET
-VG
-VI
-VIAJES
-VIDEO
-VIG
-VIKING
-VILLAS
-VIN
-VIP
-VIRGIN
-VISA
-VISION
-VIVA
-VIVO
-VLAANDEREN
-VN
-VODKA
-VOLKSWAGEN
-VOLVO
-VOTE
-VOTING
-VOTO
-VOYAGE
-VU
-VUELOS
-WALES
-WALMART
-WALTER
-WANG
-WANGGOU
-WATCH
-WATCHES
-WEATHER
-WEATHERCHANNEL
-WEBCAM
-WEBER
-WEBSITE
-WED
-WEDDING
-WEIBO
-WEIR
-WF
-WHOSWHO
-WIEN
-WIKI
-WILLIAMHILL
-WIN
-WINDOWS
-WINE
-WINNERS
-WME
-WOLTERSKLUWER
-WOODSIDE
-WORK
-WORKS
-WORLD
-WOW
-WS
-WTC
-WTF
-XBOX
-XEROX
-XFINITY
-XIHUAN
-XIN
-XN--11B4C3D
-XN--1CK2E1B
-XN--1QQW23A
-XN--2SCRJ9C
-XN--30RR7Y
-XN--3BST00M
-XN--3DS443G
-XN--3E0B707E
-XN--3HCRJ9C
-XN--3PXU8K
-XN--42C2D9A
-XN--45BR5CYL
-XN--45BRJ9C
-XN--45Q11C
-XN--4DBRK0CE
-XN--4GBRIM
-XN--54B7FTA0CC
-XN--55QW42G
-XN--55QX5D
-XN--5SU34J936BGSG
-XN--5TZM5G
-XN--6FRZ82G
-XN--6QQ986B3XL
-XN--80ADXHKS
-XN--80AO21A
-XN--80AQECDR1A
-XN--80ASEHDB
-XN--80ASWG
-XN--8Y0A063A
-XN--90A3AC
-XN--90AE
-XN--90AIS
-XN--9DBQ2A
-XN--9ET52U
-XN--9KRT00A
-XN--B4W605FERD
-XN--BCK1B9A5DRE4C
-XN--C1AVG
-XN--C2BR7G
-XN--CCK2B3B
-XN--CCKWCXETD
-XN--CG4BKI
-XN--CLCHC0EA0B2G2A9GCD
-XN--CZR694B
-XN--CZRS0T
-XN--CZRU2D
-XN--D1ACJ3B
-XN--D1ALF
-XN--E1A4C
-XN--ECKVDTC9D
-XN--EFVY88H
-XN--FCT429K
-XN--FHBEI
-XN--FIQ228C5HS
-XN--FIQ64B
-XN--FIQS8S
-XN--FIQZ9S
-XN--FJQ720A
-XN--FLW351E
-XN--FPCRJ9C3D
-XN--FZC2C9E2C
-XN--FZYS8D69UVGM
-XN--G2XX48C
-XN--GCKR3F0F
-XN--GECRJ9C
-XN--GK3AT1E
-XN--H2BREG3EVE
-XN--H2BRJ9C
-XN--H2BRJ9C8C
-XN--HXT814E
-XN--I1B6B1A6A2E
-XN--IMR513N
-XN--IO0A7I
-XN--J1AEF
-XN--J1AMH
-XN--J6W193G
-XN--JLQ480N2RG
-XN--JLQ61U9W7B
-XN--JVR189M
-XN--KCRX77D1X4A
-XN--KPRW13D
-XN--KPRY57D
-XN--KPUT3I
-XN--L1ACC
-XN--LGBBAT1AD8J
-XN--MGB9AWBF
-XN--MGBA3A3EJT
-XN--MGBA3A4F16A
-XN--MGBA7C0BBN0A
-XN--MGBAAKC7DVF
-XN--MGBAAM7A8H
-XN--MGBAB2BD
-XN--MGBAH1A3HJKRD
-XN--MGBAI9AZGQP6J
-XN--MGBAYH7GPA
-XN--MGBBH1A
-XN--MGBBH1A71E
-XN--MGBC0A9AZCG
-XN--MGBCA7DZDO
-XN--MGBCPQ6GPA1A
-XN--MGBERP4A5D4AR
-XN--MGBGU82A
-XN--MGBI4ECEXP
-XN--MGBPL2FH
-XN--MGBT3DHD
-XN--MGBTX2B
-XN--MGBX4CD0AB
-XN--MIX891F
-XN--MK1BU44C
-XN--MXTQ1M
-XN--NGBC5AZD
-XN--NGBE9E0A
-XN--NGBRX
-XN--NODE
-XN--NQV7F
-XN--NQV7FS00EMA
-XN--NYQY26A
-XN--O3CW4H
-XN--OGBPF8FL
-XN--OTU796D
-XN--P1ACF
-XN--P1AI
-XN--PGBS0DH
-XN--PSSY2U
-XN--Q7CE6A
-XN--Q9JYB4C
-XN--QCKA1PMC
-XN--QXA6A
-XN--QXAM
-XN--RHQV96G
-XN--ROVU88B
-XN--RVC1E0AM3E
-XN--S9BRJ9C
-XN--SES554G
-XN--T60B56A
-XN--TCKWE
-XN--TIQ49XQYJ
-XN--UNUP4Y
-XN--VERMGENSBERATER-CTB
-XN--VERMGENSBERATUNG-PWB
-XN--VHQUV
-XN--VUQ861B
-XN--W4R85EL8FHU5DNRA
-XN--W4RS40L
-XN--WGBH1C
-XN--WGBL6A
-XN--XHQ521B
-XN--XKC2AL3HYE2A
-XN--XKC2DL3A5EE0H
-XN--Y9A3AQ
-XN--YFRO4I67O
-XN--YGBI2AMMX
-XN--ZFR164B
-XXX
-XYZ
-YACHTS
-YAHOO
-YAMAXUN
-YANDEX
-YE
-YODOBASHI
-YOGA
-YOKOHAMA
-YOU
-YOUTUBE
-YT
-YUN
-ZA
-ZAPPOS
-ZARA
-ZERO
-ZIP
-ZM
-ZONE
-ZUERICH
-ZW

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/src/hypothesis/version.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/README.rst Deleted

@@ -1,117 +0,0 @@
-===========
-Don't Panic
-===========
-
-The Hypothesis test suite is large, but we've written these notes to help you
-out.  It's aimed at contributors (new and old!) who know they need to add tests
-*somewhere*, but aren't sure where - or maybe need some hints on what kinds of
-tests might be useful.  Others might just be interested in how a testing
-library tests itself!
-
-
-The very short version
-======================
-
-- To improve code coverage (eg because ``make check-coverage`` or CI is failing),
-  go to ``cover/``
-- For longer / system / integration tests, look in ``nocover/``
-- For tests that require an optional dependency, look in the directory
-  named for that dependency.
-
-.. note::
-    If you get stuck, just ask a maintainer to help out by mentioning
-    ``@HypothesisWorks/hypothesis-python-contributors`` on GitHub.
-    We'd love to help - and also get feedback on how this document could
-    be better!
-
-
-Some scenarios
-==============
-
-**I'm adding or changing a strategy**
-    Check for a file specific to that strategy (eg ``test_uuids.py`` for
-    the ``uuids()`` strategy).  Write tests for all invalid argument handling
-    in ``test_direct_strategies.py``.  Strategies with optional dependencies
-    should go in ``hypothesis.extras``, and the tests in their own module
-    (ie not in ``cover``).  When you think you might be done, push and let
-    our CI system point out any failing tests or non-covered code!
-
-**I've made some internal changes**
-    That's not very specific - you should probably refer to the test-finding
-    tips in the next section.  Remember that ``tests/cover`` is reasonably
-    quick unit-test style tests - you should consider writing more intensive
-    integration tests too, but put them in ``tests/nocover`` with the others.
-
-
-Finding particular tests
-========================
-
-With the sheer size and variety in this directory finding a specific thing
-can be tricky.  Tips:
-
-- Check for filenames that are relevant to your contribution.
-- Use ``git grep`` to search for keywords, e.g. the name of a strategy you've changed.
-- Deliberately break something related to your code, and see which tests fail.
-- Ask a maintainer!  Sometimes the structure is just arbitrary, and other tactics
-  don't work - but we *want* to help!
-
-
-About each group of tests
-=========================
-
-Still here?  Here's a note on what to expect in each directory.
-
-``common/``
-    Useful shared testing code, including test setup and a few helper
-    functions in ``utils.py``.  Also read up on
-    `pytest <https://docs.pytest.org/en/latest/contents.html>`_
-    features such as ``mark.parametrize``, ``mark.skipif``, and ``raises``
-    for other functions that are often useful when writing tests.
-
-``conjecture/``
-    As for ``cover/``, but specific to ``hypothesis.internal.conjecture``.
-
-``cover/``
-    The home of enough tests to get 100% branch coverage, as quickly as possible
-    without compromising on test power.  This can be an intimidating target,
-    but it's entirely achievable and the maintainers are (still) here to help.
-
-    This directory alone has around two-thirds of the tests for Hypothesis
-    (~8k of ~12k lines of code).  If you're adding or fixing tests, chances
-    are therefore good that they're in here!
-
-``datetime/``
-    Tests which depend on the ``pytz`` or ``dateutil`` packages for timezones.
-
-``django/``
-    Tests for the Django extra.  Includes a toy application, to give us lots
-    of models to generate.
-
-``lark/``
-    Tests for the Lark extra for context-free grammars, which depend on the
-    ``lark-parser`` package.
-
-``nocover/``
-    More expensive and longer-running tests, typically used to test trickier
-    interactions or check for regressions in expensive bugs.  Lots of tests
-    about how values shrink, databases, compatibility, etc.
-
-    New tests that are not required for full coverage of code branches or
-    behaviour should also go in ``nocover``, to keep ``cover`` reasonably fast.
-
-``numpy/``
-    Tests for the Numpy extra.
-
-``pandas/``
-    Tests for the Pandas extra.
-
-``pytest/``
-    Hypothesis has excellent integration with ``pytest``, though we are careful
-    to support other test runners including unittest and nose.  This is where we
-    test that our pytest integration is working properly.
-
-``quality/``
-    Tests that various hard-to-find examples do in fact get found by Hypothesis,
-    as well as some stuff about example shrinking.  Mostly intended for tests
-    of the form "Hypothesis finds an example of this condition" + assertions
-    about which example it finds.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/README.md Deleted

@@ -1,32 +0,0 @@
-This folder contains tests for `hypothesis.extra.array_api`.
-
-## Running against different array modules
-
-By default it will run against `numpy.array_api`. If that's not available
-(likely because an older NumPy version is installed), these tests will fallback
-to using the mock defined at the bottom of `src/hypothesis/extra/array_api.py`.
-
-You can test other array modules which adopt the Array API via the
-`HYPOTHESIS_TEST_ARRAY_API` environment variable. There are two recognized
-options:
-
-* `"default"`: only uses `numpy.array_api`, or if not available, fallbacks to the mock.
-* `"all"`: uses all array modules found via entry points, _and_ the mock.
-
-If neither of these, the test suite will then try resolve the variable like so:
-
-1. If the variable matches a name of an available entry point, load said entry point.
-2. If the variables matches a valid import path, import said path.
-
-For example, to specify NumPy's Array API implementation, you could use its
-entry point (**1.**),
-
-    HYPOTHESIS_TEST_ARRAY_API=numpy pytest tests/array_api
-
-or use the import path (**2.**),
-
-    HYPOTHESIS_TEST_ARRAY_API=numpy.array_api pytest tests/array_api
-
-The former method is more ergonomic, but as entry points are optional for
-adopting the Array API, you will need to use the latter method for libraries
-that opt-out.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/common.py Deleted

@@ -1,50 +0,0 @@
-# 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/.
-
-from importlib.metadata import EntryPoint, entry_points  # type: ignore
-from typing import Dict
-
-from hypothesis.internal.floats import next_up
-
-__all__ = 
-    "installed_array_modules",
-    "flushes_to_zero",
-
-
-
-def installed_array_modules() -> Dictstr, EntryPoint:
-    """Returns a dictionary of array module names paired to their entry points
-
-    A convenience wrapper for importlib.metadata.entry_points(). It has the
-    added benefit of working with both the original dict interface and the new
-    select interface, so this can be used warning-free in all modern Python
-    versions.
-    """
-    try:
-        eps = entry_points(group="array_api")
-    except TypeError:
-        # The select interface for entry_points was introduced in py3.10,
-        # supplanting its dict interface. We fallback to the dict interface so
-        # we can still find entry points in py3.8 and py3.9.
-        eps = entry_points().get("array_api", )
-    return {ep.name: ep for ep in eps}
-
-
-def flushes_to_zero(xp, width: int) -> bool:
-    """Infer whether build of array module has its float dtype of the specified
-    width flush subnormals to zero
-
-    We do this per-width because compilers might FTZ for one dtype but allow
-    subnormals in the other.
-    """
-    if width not in 32, 64:
-        raise ValueError(f"{width=}, but should be either 32 or 64")
-    dtype = getattr(xp, f"float{width}")
-    return bool(xp.asarray(next_up(0.0, width=width), dtype=dtype) == 0)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/conftest.py Deleted

@@ -1,72 +0,0 @@
-# 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 warnings
-from importlib import import_module
-from os import getenv
-
-import pytest
-
-from hypothesis.errors import HypothesisWarning
-from hypothesis.extra.array_api import make_strategies_namespace, mock_xp
-
-from tests.array_api.common import installed_array_modules
-
-with pytest.warns(HypothesisWarning):
-    mock_xps = make_strategies_namespace(mock_xp)
-
-# See README.md in regards to the HYPOTHESIS_TEST_ARRAY_API env variable
-test_xp_option = getenv("HYPOTHESIS_TEST_ARRAY_API", "default")
-name_to_entry_point = installed_array_modules()
-with warnings.catch_warnings():
-    # We ignore all warnings here as many array modules warn on import
-    warnings.simplefilter("ignore")
-    # We go through the steps described in README.md to define `params`, which
-    # contains the array module(s) to be ran against the test suite.
-    # Specifically `params` is a list of pytest parameters, with each parameter
-    # containing the array module and its respective strategies namespace.
-    if test_xp_option == "default":
-        try:
-            xp = name_to_entry_point"numpy".load()
-            xps = make_strategies_namespace(xp)
-            params = pytest.param(xp, xps, id="numpy")
-        except KeyError:
-            params = pytest.param(mock_xp, mock_xps, id="mock")
-    elif test_xp_option == "all":
-        if len(name_to_entry_point) == 0:
-            raise ValueError(
-                "HYPOTHESIS_TEST_ARRAY_API='all', but no entry points where found"
-            )
-        params = pytest.param(mock_xp, mock_xps, id="mock")
-        for name, ep in name_to_entry_point.items():
-            xp = ep.load()
-            xps = make_strategies_namespace(xp)
-            params.append(pytest.param(xp, xps, id=name))
-    elif test_xp_option in name_to_entry_point.keys():
-        ep = name_to_entry_pointtest_xp_option
-        xp = ep.load()
-        xps = make_strategies_namespace(xp)
-        params = pytest.param(xp, xps, id=test_xp_option)
-    else:
-        try:
-            xp = import_module(test_xp_option)
-            xps = make_strategies_namespace(xp)
-            params = pytest.param(xp, xps, id=test_xp_option)
-        except ImportError as e:
-            raise ValueError(
-                f"HYPOTHESIS_TEST_ARRAY_API='{test_xp_option}' is not a valid "
-                "option ('default' or 'all'), name of an available entry point, "
-                "or a valid import path."
-            ) from e
-
-
-def pytest_generate_tests(metafunc):
-    if "xp" in metafunc.fixturenames and "xps" in metafunc.fixturenames:
-        metafunc.parametrize("xp, xps", params)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_argument_validation.py Deleted

@@ -1,216 +0,0 @@
-# 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 pytest
-
-from hypothesis.errors import InvalidArgument
-
-
-def e(name, **kwargs):
-    kw = ", ".join(f"{k}={v!r}" for k, v in kwargs.items())
-    return pytest.param(name, kwargs, id=f"{name}({kw})")
-
-
-@pytest.mark.parametrize(
-    ("strat_name", "kwargs"),
-    
-        e("arrays", dtype=1, shape=5),
-        e("arrays", dtype=None, shape=5),
-        e("arrays", dtype="int8", shape=(0.5,)),
-        e("arrays", dtype="int8", shape=1, fill=3),
-        e("arrays", dtype="int8", shape=1, elements="not a strategy"),
-        e("arrays", dtype="int8", shape="not a shape or strategy"),
-        e("array_shapes", min_side=2, max_side=1),
-        e("array_shapes", min_dims=3, max_dims=2),
-        e("array_shapes", min_dims=-1),
-        e("array_shapes", min_side=-1),
-        e("array_shapes", min_side="not an int"),
-        e("array_shapes", max_side="not an int"),
-        e("array_shapes", min_dims="not an int"),
-        e("array_shapes", max_dims="not an int"),
-        e("from_dtype", dtype=1),
-        e("from_dtype", dtype=None),
-        e("from_dtype", dtype="int8", min_value="not an int"),
-        e("from_dtype", dtype="int8", max_value="not an int"),
-        e("from_dtype", dtype="float32", min_value="not a float"),
-        e("from_dtype", dtype="float32", max_value="not a float"),
-        e("from_dtype", dtype="int8", min_value=10, max_value=5),
-        e("from_dtype", dtype="float32", min_value=10, max_value=5),
-        e("from_dtype", dtype="int8", min_value=-999),
-        e("from_dtype", dtype="int8", max_value=-999),
-        e("from_dtype", dtype="int8", min_value=999),
-        e("from_dtype", dtype="int8", max_value=999),
-        e("from_dtype", dtype="uint8", min_value=-999),
-        e("from_dtype", dtype="uint8", max_value=-999),
-        e("from_dtype", dtype="uint8", min_value=999),
-        e("from_dtype", dtype="uint8", max_value=999),
-        e("from_dtype", dtype="float32", min_value=-4e38),
-        e("from_dtype", dtype="float32", max_value=-4e38),
-        e("from_dtype", dtype="float32", min_value=4e38),
-        e("from_dtype", dtype="float32", max_value=4e38),
-        e("integer_dtypes", sizes=()),
-        e("integer_dtypes", sizes=(3,)),
-        e("unsigned_integer_dtypes", sizes=()),
-        e("unsigned_integer_dtypes", sizes=(3,)),
-        e("floating_dtypes", sizes=()),
-        e("floating_dtypes", sizes=(3,)),
-        e("valid_tuple_axes", ndim=-1),
-        e("valid_tuple_axes", ndim=2, min_size=-1),
-        e("valid_tuple_axes", ndim=2, min_size=3, max_size=10),
-        e("valid_tuple_axes", ndim=2, min_size=2, max_size=1),
-        e("valid_tuple_axes", ndim=2.0, min_size=2, max_size=1),
-        e("valid_tuple_axes", ndim=2, min_size=1.0, max_size=2),
-        e("valid_tuple_axes", ndim=2, min_size=1, max_size=2.0),
-        e("valid_tuple_axes", ndim=2, min_size=1, max_size=3),
-        e("broadcastable_shapes", shape="a"),
-        e("broadcastable_shapes", shape=(2, 2), min_side="a"),
-        e("broadcastable_shapes", shape=(2, 2), min_dims="a"),
-        e("broadcastable_shapes", shape=(2, 2), max_side="a"),
-        e("broadcastable_shapes", shape=(2, 2), max_dims="a"),
-        e("broadcastable_shapes", shape=(2, 2), min_side=-1),
-        e("broadcastable_shapes", shape=(2, 2), min_dims=-1),
-        e("broadcastable_shapes", shape=(2, 2), min_side=1, max_side=0),
-        e("broadcastable_shapes", shape=(2, 2), min_dims=1, max_dims=0),
-        e(
-            "broadcastable_shapes",  # max_side too small
-            shape=(5, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            "broadcastable_shapes",  # min_side too large
-            shape=(0, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            "broadcastable_shapes",  # default max_dims unsatisfiable
-            shape=(5, 3, 2, 1),
-            min_dims=3,
-            max_dims=None,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            "broadcastable_shapes",  # default max_dims unsatisfiable
-            shape=(0, 3, 2, 1),
-            min_dims=3,
-            max_dims=None,
-            min_side=2,
-            max_side=3,
-        ),
-        e("mutually_broadcastable_shapes", num_shapes=0),
-        e("mutually_broadcastable_shapes", num_shapes="a"),
-        e("mutually_broadcastable_shapes", num_shapes=2, base_shape="a"),
-        e(
-            "mutually_broadcastable_shapes",  # min_side is invalid type
-            num_shapes=2,
-            min_side="a",
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # min_dims is invalid type
-            num_shapes=2,
-            min_dims="a",
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # max_side is invalid type
-            num_shapes=2,
-            max_side="a",
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # max_side is invalid type
-            num_shapes=2,
-            max_dims="a",
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # min_side is out of domain
-            num_shapes=2,
-            min_side=-1,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # min_dims is out of domain
-            num_shapes=2,
-            min_dims=-1,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # max_side < min_side
-            num_shapes=2,
-            min_side=1,
-            max_side=0,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # max_dims < min_dims
-            num_shapes=2,
-            min_dims=1,
-            max_dims=0,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # max_side too small
-            num_shapes=2,
-            base_shape=(5, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # min_side too large
-            num_shapes=2,
-            base_shape=(0, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # user-specified max_dims unsatisfiable
-            num_shapes=1,
-            base_shape=(5, 3, 2, 1),
-            min_dims=3,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            "mutually_broadcastable_shapes",  # user-specified max_dims unsatisfiable
-            num_shapes=2,
-            base_shape=(0, 3, 2, 1),
-            min_dims=3,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e("indices", shape=0),
-        e("indices", shape=("1", "2")),
-        e("indices", shape=(0, -1)),
-        e("indices", shape=(0, 0), allow_newaxis=None),
-        e("indices", shape=(0, 0), allow_ellipsis=None),
-        e("indices", shape=(0, 0), min_dims=-1),
-        e("indices", shape=(0, 0), min_dims=1.0),
-        e("indices", shape=(0, 0), max_dims=-1),
-        e("indices", shape=(0, 0), max_dims=1.0),
-        e("indices", shape=(0, 0), min_dims=2, max_dims=1),
-        e("indices", shape=(3, 3, 3), min_dims=4),
-        e("indices", shape=(3, 3, 3), max_dims=5),
-        e("indices", shape=5, min_dims=0),
-        e("indices", shape=(5,), min_dims=2),
-        e("indices", shape=(5,), max_dims=2),
-    ,
-)
-def test_raise_invalid_argument(xp, xps, strat_name, kwargs):
-    """Strategies raise helpful error with invalid arguments."""
-    strat_func = getattr(xps, strat_name)
-    strat = strat_func(**kwargs)
-    with pytest.raises(InvalidArgument):
-        strat.example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_arrays.py Deleted

@@ -1,497 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.array_api import DTYPE_NAMES, NUMERIC_NAMES
-from hypothesis.internal.floats import width_smallest_normals
-
-from tests.array_api.common import flushes_to_zero
-from tests.common.debug import assert_all_examples, find_any, minimal
-from tests.common.utils import flaky
-
-
-def skip_on_missing_unique_values(xp):
-    if not hasattr(xp, "unique_values"):
-        pytest.mark.skip("xp.unique_values() is not required to exist")
-
-
-def xfail_on_indistinct_nans(xp):
-    """
-    xp.unique_value() should return distinct NaNs - if not, tests that (rightly)
-    assume such behaviour will likely fail. For example, NumPy 1.22 treats NaNs
-    as indistinct, so tests that use this function will be marked as xfail.
-    See https://mail.python.org/pipermail/numpy-discussion/2021-August/081995.html
-    """
-    skip_on_missing_unique_values(xp)
-    two_nans = xp.asarray(float("nan"), float("nan"))
-    if xp.unique_values(two_nans).size != 2:
-        pytest.xfail("NaNs not distinct")
-
-
-@pytest.mark.parametrize("dtype_name", DTYPE_NAMES)
-def test_draw_arrays_from_dtype(xp, xps, dtype_name):
-    """Draw arrays from dtypes."""
-    dtype = getattr(xp, dtype_name)
-    assert_all_examples(xps.arrays(dtype, ()), lambda x: x.dtype == dtype)
-
-
-@pytest.mark.parametrize("dtype_name", DTYPE_NAMES)
-def test_draw_arrays_from_scalar_names(xp, xps, dtype_name):
-    """Draw arrays from dtype names."""
-    dtype = getattr(xp, dtype_name)
-    assert_all_examples(xps.arrays(dtype_name, ()), lambda x: x.dtype == dtype)
-
-
-@given(data=st.data())
-def test_draw_arrays_from_shapes(xp, xps, data):
-    """Draw arrays from shapes."""
-    shape = data.draw(xps.array_shapes())
-    x = data.draw(xps.arrays(xp.int8, shape))
-    assert x.ndim == len(shape)
-    assert x.shape == shape
-
-
-@given(data=st.data())
-def test_draw_arrays_from_int_shapes(xp, xps, data):
-    """Draw arrays from integers as shapes."""
-    size = data.draw(st.integers(0, 10))
-    x = data.draw(xps.arrays(xp.int8, size))
-    assert x.shape == (size,)
-
-
-@pytest.mark.parametrize(
-    "strat_name",
-    
-        "scalar_dtypes",
-        "boolean_dtypes",
-        "integer_dtypes",
-        "unsigned_integer_dtypes",
-        "floating_dtypes",
-    ,
-)
-def test_draw_arrays_from_dtype_strategies(xp, xps, strat_name):
-    """Draw arrays from dtype strategies."""
-    strat_func = getattr(xps, strat_name)
-    strat = strat_func()
-    find_any(xps.arrays(strat, ()))
-
-
-@given(
-    strat=st.lists(st.sampled_from(DTYPE_NAMES), min_size=1, unique=True).flatmap(
-        st.sampled_from
-    )
-)
-def test_draw_arrays_from_dtype_name_strategies(xp, xps, strat):
-    """Draw arrays from dtype name strategies."""
-    find_any(xps.arrays(strat, ()))
-
-
-def test_generate_arrays_from_shapes_strategy(xp, xps):
-    """Generate arrays from shapes strategy."""
-    find_any(xps.arrays(xp.int8, xps.array_shapes()))
-
-
-def test_generate_arrays_from_integers_strategy_as_shape(xp, xps):
-    """Generate arrays from integers strategy as shapes strategy."""
-    find_any(xps.arrays(xp.int8, st.integers(0, 100)))
-
-
-def test_generate_arrays_from_zero_dimensions(xp, xps):
-    """Generate arrays from empty shape."""
-    assert_all_examples(xps.arrays(xp.int8, ()), lambda x: x.shape == ())
-
-
-@given(data=st.data())
-def test_generate_arrays_from_zero_sided_shapes(xp, xps, data):
-    """Generate arrays from shapes with at least one 0-sized dimension."""
-    shape = data.draw(xps.array_shapes(min_side=0).filter(lambda s: 0 in s))
-    assert_all_examples(xps.arrays(xp.int8, shape), lambda x: x.shape == shape)
-
-
-def test_generate_arrays_from_unsigned_ints(xp, xps):
-    """Generate arrays from unsigned integer dtype."""
-    assert_all_examples(xps.arrays(xp.uint32, (5, 5)), lambda x: xp.all(x >= 0))
-    # Ensure we're not just picking non-negative signed integers
-    signed_max = xp.iinfo(xp.int32).max
-    find_any(xps.arrays(xp.uint32, (5, 5)), lambda x: xp.any(x > signed_max))
-
-
-def test_generate_arrays_from_0d_arrays(xp, xps):
-    """Generate arrays from 0d array elements."""
-    assert_all_examples(
-        xps.arrays(
-            dtype=xp.uint8,
-            shape=(5, 5),
-            elements=xps.from_dtype(xp.uint8).map(
-                lambda e: xp.asarray(e, dtype=xp.uint8)
-            ),
-        ),
-        lambda x: x.shape == (5, 5),
-    )
-
-
-def test_minimize_arrays_with_default_dtype_shape_strategies(xp, xps):
-    """Strategy with default scalar_dtypes and array_shapes strategies minimize
-    to a boolean 1-dimensional array of size 1."""
-    smallest = minimal(xps.arrays(xps.scalar_dtypes(), xps.array_shapes()))
-    assert smallest.shape == (1,)
-    assert smallest.dtype == xp.bool
-    assert not xp.any(smallest)
-
-
-def test_minimize_arrays_with_0d_shape_strategy(xp, xps):
-    """Strategy with shape strategy that can generate empty tuples minimizes to
-    0d arrays."""
-    smallest = minimal(xps.arrays(xp.int8, xps.array_shapes(min_dims=0)))
-    assert smallest.shape == ()
-
-
-@pytest.mark.parametrize("dtype", NUMERIC_NAMES)
-def test_minimizes_numeric_arrays(xp, xps, dtype):
-    """Strategies with numeric dtypes minimize to zero-filled arrays."""
-    smallest = minimal(xps.arrays(dtype, (2, 2)))
-    assert xp.all(smallest == 0)
-
-
-def test_minimize_large_uint_arrays(xp, xps):
-    """Strategy with uint dtype and largely sized shape minimizes to a good
-    example."""
-    if not hasattr(xp, "nonzero"):
-        pytest.skip("optional API")
-    smallest = minimal(
-        xps.arrays(xp.uint8, 100),
-        lambda x: xp.any(x) and not xp.all(x),
-        timeout_after=60,
-    )
-    assert xp.all(xp.logical_or(smallest == 0, smallest == 1))
-    idx = xp.nonzero(smallest)0
-    assert idx.size in (1, smallest.size - 1)
-
-
-@pytest.mark.filterwarnings("ignore::RuntimeWarning")
-@flaky(max_runs=50, min_passes=1)
-def test_minimize_float_arrays(xp, xps):
-    """Strategy with float dtype minimizes to a good example.
-
-    We filter runtime warnings and expect flaky array generation for
-    specifically NumPy - this behaviour may not be required when testing
-    with other array libraries.
-    """
-    smallest = minimal(xps.arrays(xp.float32, 50), lambda x: xp.sum(x) >= 1.0)
-    assert xp.sum(smallest) in (1, 50)
-
-
-def test_minimizes_to_fill(xp, xps):
-    """Strategy with single fill value minimizes to arrays only containing said
-    fill value."""
-    smallest = minimal(xps.arrays(xp.float32, 10, fill=st.just(3.0)))
-    assert xp.all(smallest == 3.0)
-
-
-def test_generate_unique_arrays(xp, xps):
-    """Generates unique arrays."""
-    skip_on_missing_unique_values(xp)
-    assert_all_examples(
-        xps.arrays(xp.int8, st.integers(0, 20), unique=True),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-def test_cannot_draw_unique_arrays_with_too_small_elements(xp, xps):
-    """Unique strategy with elements strategy range smaller than its size raises
-    helpful error."""
-    with pytest.raises(InvalidArgument):
-        xps.arrays(xp.int8, 10, elements=st.integers(0, 5), unique=True).example()
-
-
-def test_cannot_fill_arrays_with_non_castable_value(xp, xps):
-    """Strategy with fill not castable to dtype raises helpful error."""
-    with pytest.raises(InvalidArgument):
-        xps.arrays(xp.int8, 10, fill=st.just("not a castable value")).example()
-
-
-def test_generate_unique_arrays_with_high_collision_elements(xp, xps):
-    """Generates unique arrays with just elements of 0.0 and NaN fill."""
-
-    @given(
-        xps.arrays(
-            dtype=xp.float32,
-            shape=st.integers(0, 20),
-            elements=st.just(0.0),
-            fill=st.just(xp.nan),
-            unique=True,
-        )
-    )
-    def test(x):
-        zero_mask = x == 0.0
-        assert xp.sum(xp.astype(zero_mask, xp.uint8)) <= 1
-
-    test()
-
-
-def test_generate_unique_arrays_using_all_elements(xp, xps):
-    """Unique strategy with elements strategy range equal to its size will only
-    generate arrays with one of each possible element."""
-    skip_on_missing_unique_values(xp)
-    assert_all_examples(
-        xps.arrays(xp.int8, (4,), elements=st.integers(0, 3), unique=True),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-def test_may_fill_unique_arrays_with_nan(xp, xps):
-    """Unique strategy with NaN fill can generate arrays holding NaNs."""
-    find_any(
-        xps.arrays(
-            dtype=xp.float32,
-            shape=10,
-            elements={"allow_nan": False},
-            unique=True,
-            fill=st.just(xp.nan),
-        ),
-        lambda x: xp.any(xp.isnan(x)),
-    )
-
-
-def test_may_not_fill_unique_array_with_non_nan(xp, xps):
-    """Unique strategy with just fill elements of 0.0 raises helpful error."""
-    with pytest.raises(InvalidArgument):
-        strat = xps.arrays(
-            dtype=xp.float32,
-            shape=10,
-            elements={"allow_nan": False},
-            unique=True,
-            fill=st.just(0.0),
-        )
-        strat.example()
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        {"elements": st.just(300)},
-        {"elements": st.nothing(), "fill": st.just(300)},
-    ,
-)
-def test_may_not_use_overflowing_integers(xp, xps, kwargs):
-    """Strategy with elements strategy range outside the dtype's bounds raises
-    helpful error."""
-    with pytest.raises(InvalidArgument):
-        xps.arrays(dtype=xp.int8, shape=1, **kwargs).example()
-
-
-@pytest.mark.parametrize("fill", False, True)
-@pytest.mark.parametrize(
-    "dtype, strat",
-    
-        ("float32", st.floats(min_value=10**40, allow_infinity=False)),
-        ("float64", st.floats(min_value=10**40, allow_infinity=False)),
-    ,
-)
-def test_may_not_use_unrepresentable_elements(xp, xps, fill, dtype, strat):
-    """Strategy with elements not representable by the dtype raises helpful error."""
-    if fill:
-        kw = {"elements": st.nothing(), "fill": strat}
-    else:
-        kw = {"elements": strat}
-    with pytest.raises(InvalidArgument):
-        xps.arrays(dtype=dtype, shape=1, **kw).example()
-
-
-def test_floats_can_be_constrained(xp, xps):
-    """Strategy with float dtype and specified elements strategy range
-    (inclusive) generates arrays with elements inside said range."""
-    assert_all_examples(
-        xps.arrays(
-            dtype=xp.float32, shape=10, elements={"min_value": 0, "max_value": 1}
-        ),
-        lambda x: xp.all(x >= 0) and xp.all(x <= 1),
-    )
-
-
-def test_floats_can_be_constrained_excluding_endpoints(xp, xps):
-    """Strategy with float dtype and specified elements strategy range
-    (exclusive) generates arrays with elements inside said range."""
-    assert_all_examples(
-        xps.arrays(
-            dtype=xp.float32,
-            shape=10,
-            elements={
-                "min_value": 0,
-                "max_value": 1,
-                "exclude_min": True,
-                "exclude_max": True,
-            },
-        ),
-        lambda x: xp.all(x > 0) and xp.all(x < 1),
-    )
-
-
-def test_is_still_unique_with_nan_fill(xp, xps):
-    """Unique strategy with NaN fill generates unique arrays."""
-    skip_on_missing_unique_values(xp)
-    xfail_on_indistinct_nans(xp)
-    assert_all_examples(
-        xps.arrays(
-            dtype=xp.float32,
-            elements={"allow_nan": False},
-            shape=10,
-            unique=True,
-            fill=st.just(xp.nan),
-        ),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-def test_unique_array_with_fill_can_use_all_elements(xp, xps):
-    """Unique strategy with elements range equivalent to its size and NaN fill
-    can generate arrays with all possible values."""
-    skip_on_missing_unique_values(xp)
-    xfail_on_indistinct_nans(xp)
-    find_any(
-        xps.arrays(
-            dtype=xp.float32,
-            shape=10,
-            unique=True,
-            elements=st.integers(1, 9),
-            fill=st.just(xp.nan),
-        ),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-def test_generate_unique_arrays_without_fill(xp, xps):
-    """Generate arrays from unique strategy with no fill.
-
-    Covers the collision-related branches for fully dense unique arrays.
-    Choosing 25 of 256 possible values means we're almost certain to see
-    colisions thanks to the birthday paradox, but finding unique values should
-    still be easy.
-    """
-    skip_on_missing_unique_values(xp)
-    assert_all_examples(
-        xps.arrays(dtype=xp.uint8, shape=25, unique=True, fill=st.nothing()),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-def test_efficiently_generate_unique_arrays_using_all_elements(xp, xps):
-    """Unique strategy with elements strategy range equivalent to its size
-    generates arrays with all possible values. Generation is not too slow.
-
-    Avoids the birthday paradox with UniqueSampledListStrategy.
-    """
-    skip_on_missing_unique_values(xp)
-    assert_all_examples(
-        xps.arrays(dtype=xp.int8, shape=255, unique=True),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-@given(st.data(), st.integers(-100, 100), st.integers(1, 100))
-def test_array_element_rewriting(xp, xps, data, start, size):
-    """Unique strategy generates arrays with expected elements."""
-    x = data.draw(
-        xps.arrays(
-            dtype=xp.int64,
-            shape=size,
-            elements=st.integers(start, start + size - 1),
-            unique=True,
-        )
-    )
-    x_set_expect = xp.linspace(start, start + size - 1, size, dtype=xp.int64)
-    x_set = xp.sort(xp.unique_values(x))
-    assert xp.all(x_set == x_set_expect)
-
-
-def test_generate_0d_arrays_with_no_fill(xp, xps):
-    """Generate arrays with zero-dimensions and no fill."""
-    assert_all_examples(
-        xps.arrays(xp.bool, (), fill=st.nothing()),
-        lambda x: x.dtype == xp.bool and x.shape == (),
-    )
-
-
-@pytest.mark.parametrize("dtype", "float32", "float64")
-@pytest.mark.parametrize("low", -2.0, -1.0, 0.0, 1.0)
-@given(st.data())
-def test_excluded_min_in_float_arrays(xp, xps, dtype, low, data):
-    """Strategy with elements strategy excluding min does not generate arrays
-    with elements less or equal to said min."""
-    strat = xps.arrays(
-        dtype=dtype,
-        shape=(),
-        elements={
-            "min_value": low,
-            "max_value": low + 1,
-            "exclude_min": True,
-        },
-    )
-    x = data.draw(strat, label="array")
-    assert xp.all(x > low)
-
-
-@st.composite
-def distinct_int64_integers(draw):
-    used = draw(st.shared(st.builds(set), key="distinct_int64_integers.used"))
-    int64_max = 2**63
-    i = draw(st.integers(1 - int64_max, int64_max).filter(lambda x: x not in used))
-    used.add(i)
-    return i
-
-
-def test_does_not_reuse_distinct_integers(xp, xps):
-    """Strategy with distinct integer elements strategy generates arrays with
-    distinct values."""
-    skip_on_missing_unique_values(xp)
-    assert_all_examples(
-        xps.arrays(xp.int64, 10, elements=distinct_int64_integers()),
-        lambda x: xp.unique_values(x).size == x.size,
-    )
-
-
-def test_may_reuse_distinct_integers_if_asked(xp, xps):
-    """Strategy with shared elements and fill strategies of distinct integers
-    may generate arrays with non-distinct values."""
-    skip_on_missing_unique_values(xp)
-    find_any(
-        xps.arrays(
-            xp.int64,
-            10,
-            elements=distinct_int64_integers(),
-            fill=distinct_int64_integers(),
-        ),
-        lambda x: xp.unique_values(x).size < x.size,
-    )
-
-
-def test_subnormal_elements_validation(xp, xps):
-    """Strategy with subnormal elements strategy is correctly validated.
-
-    For FTZ builds of array modules, a helpful error should raise. Conversely,
-    for builds of array modules which support subnormals, the strategy should
-    generate arrays without raising.
-    """
-    elements = {
-        "min_value": 0.0,
-        "max_value": width_smallest_normals32,
-        "exclude_min": True,
-        "exclude_max": True,
-        "allow_subnormal": True,
-    }
-    strat = xps.arrays(xp.float32, 10, elements=elements)
-    if flushes_to_zero(xp, width=32):
-        with pytest.raises(InvalidArgument, match="Generated subnormal float"):
-            strat.example()
-    else:
-        strat.example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_from_dtype.py Deleted

@@ -1,107 +0,0 @@
-# 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 math
-
-import pytest
-
-from hypothesis.extra.array_api import DTYPE_NAMES, find_castable_builtin_for_dtype
-from hypothesis.internal.floats import width_smallest_normals
-
-from tests.array_api.common import flushes_to_zero
-from tests.common.debug import (
-    assert_all_examples,
-    assert_no_examples,
-    find_any,
-    minimal,
-)
-
-
-@pytest.mark.parametrize("dtype_name", DTYPE_NAMES)
-def test_strategies_have_reusable_values(xp, xps, dtype_name):
-    """Inferred strategies have reusable values."""
-    strat = xps.from_dtype(dtype_name)
-    assert strat.has_reusable_values
-
-
-@pytest.mark.parametrize("dtype_name", DTYPE_NAMES)
-def test_produces_castable_instances_from_dtype(xp, xps, dtype_name):
-    """Strategies inferred by dtype generate values of a builtin type castable
-    to the dtype."""
-    dtype = getattr(xp, dtype_name)
-    builtin = find_castable_builtin_for_dtype(xp, dtype)
-    assert_all_examples(xps.from_dtype(dtype), lambda v: isinstance(v, builtin))
-
-
-@pytest.mark.parametrize("dtype_name", DTYPE_NAMES)
-def test_produces_castable_instances_from_name(xp, xps, dtype_name):
-    """Strategies inferred by dtype name generate values of a builtin type
-    castable to the dtype."""
-    dtype = getattr(xp, dtype_name)
-    builtin = find_castable_builtin_for_dtype(xp, dtype)
-    assert_all_examples(xps.from_dtype(dtype_name), lambda v: isinstance(v, builtin))
-
-
-@pytest.mark.parametrize("dtype_name", DTYPE_NAMES)
-def test_passing_inferred_strategies_in_arrays(xp, xps, dtype_name):
-    """Inferred strategies usable in arrays strategy."""
-    elements = xps.from_dtype(dtype_name)
-    find_any(xps.arrays(dtype_name, 10, elements=elements))
-
-
-@pytest.mark.parametrize(
-    "dtype, kwargs, predicate",
-    
-        # Floating point: bounds, exclusive bounds, and excluding nonfinites
-        ("float32", {"min_value": 1, "max_value": 2}, lambda x: 1 <= x <= 2),
-        (
-            "float32",
-            {"min_value": 1, "max_value": 2, "exclude_min": True, "exclude_max": True},
-            lambda x: 1 < x < 2,
-        ),
-        ("float32", {"allow_nan": False}, lambda x: not math.isnan(x)),
-        ("float32", {"allow_infinity": False}, lambda x: not math.isinf(x)),
-        ("float32", {"allow_nan": False, "allow_infinity": False}, math.isfinite),
-        # Integer bounds, limited to the representable range
-        ("int8", {"min_value": -1, "max_value": 1}, lambda x: -1 <= x <= 1),
-        ("uint8", {"min_value": 1, "max_value": 2}, lambda x: 1 <= x <= 2),
-    ,
-)
-def test_from_dtype_with_kwargs(xp, xps, dtype, kwargs, predicate):
-    """Strategies inferred with kwargs generate values in bounds."""
-    strat = xps.from_dtype(dtype, **kwargs)
-    assert_all_examples(strat, predicate)
-
-
-def test_can_minimize_floats(xp, xps):
-    """Inferred float strategy minimizes to a good example."""
-    smallest = minimal(xps.from_dtype(xp.float32), lambda n: n >= 1.0)
-    assert smallest == 1
-
-
-smallest_normal = width_smallest_normals32
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        {},
-        {"min_value": -1},
-        {"max_value": 1},
-        {"min_value": -1, "max_value": 1},
-    ,
-)
-def test_subnormal_generation(xp, xps, kwargs):
-    """Generation of subnormals is dependent on FTZ behaviour of array module."""
-    strat = xps.from_dtype(xp.float32, **kwargs).filter(lambda n: n != 0)
-    if flushes_to_zero(xp, width=32):
-        assert_no_examples(strat, lambda n: -smallest_normal < n < smallest_normal)
-    else:
-        find_any(strat, lambda n: -smallest_normal < n < smallest_normal)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_indices.py Deleted

@@ -1,171 +0,0 @@
-# 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 math
-
-import pytest
-
-from hypothesis import assume, given, note, strategies as st
-from hypothesis.extra._array_helpers import NDIM_MAX
-
-from tests.common.debug import assert_all_examples, find_any
-
-
-@pytest.mark.parametrize(
-    "condition",
-    
-        lambda ix: Ellipsis in ix,
-        lambda ix: Ellipsis not in ix,
-        lambda ix: None in ix,
-        lambda ix: None not in ix,
-    ,
-)
-def test_generate_optional_indices(xp, xps, condition):
-    """Strategy can generate indices with optional values."""
-    strat = (
-        xps.array_shapes(min_dims=1, max_dims=32)
-        .flatmap(lambda s: xps.indices(s, allow_newaxis=True))
-        .map(lambda idx: idx if isinstance(idx, tuple) else (idx,))
-    )
-    find_any(strat, condition)
-
-
-def test_cannot_generate_newaxis_when_disabled(xp, xps):
-    """Strategy does not generate newaxis when disabled (i.e. the default)."""
-    assert_all_examples(
-        xps.indices((3, 3, 3)), lambda idx: idx == ... or None not in idx
-    )
-
-
-def test_generate_indices_for_0d_shape(xp, xps):
-    """Strategy only generates empty tuples or Ellipsis as indices for an empty
-    shape."""
-    assert_all_examples(
-        xps.indices(shape=(), allow_ellipsis=True),
-        lambda idx: idx in (), Ellipsis, (Ellipsis,),
-    )
-
-
-def test_generate_tuples_and_non_tuples_for_1d_shape(xp, xps):
-    """Strategy can generate tuple and non-tuple indices with a 1-dimensional shape."""
-    strat = xps.indices(shape=(1,), allow_ellipsis=True)
-    find_any(strat, lambda ix: isinstance(ix, tuple))
-    find_any(strat, lambda ix: not isinstance(ix, tuple))
-
-
-def test_generate_long_ellipsis(xp, xps):
-    """Strategy can replace runs of slice(None) with Ellipsis.
-
-    We specifically test if 0,...,0 is generated alongside 0,:,:,:,0
-    """
-    strat = xps.indices(shape=(1, 0, 0, 0, 1), max_dims=3, allow_ellipsis=True)
-    find_any(strat, lambda ix: len(ix) == 3 and ix1 == Ellipsis)
-    find_any(
-        strat,
-        lambda ix: len(ix) == 5
-        and all(isinstance(key, slice) and key == slice(None) for key in ix1:3),
-    )
-
-
-def test_indices_replaces_whole_axis_slices_with_ellipsis(xp, xps):
-    # `slice(None)` (aka `:`) is the only valid index for an axis of size
-    # zero, so if all dimensions are 0 then a `...` will replace all the
-    # slices because we generate `...` for entire contiguous runs of `:`
-    assert_all_examples(
-        xps.indices(shape=(0, 0, 0, 0, 0), max_dims=5).filter(
-            lambda idx: isinstance(idx, tuple) and Ellipsis in idx
-        ),
-        lambda idx: slice(None) not in idx,
-    )
-
-
-def test_efficiently_generate_indexers(xp, xps):
-    """Generation is not too slow."""
-    find_any(xps.indices((3, 3, 3, 3, 3)))
-
-
-@given(allow_newaxis=st.booleans(), allow_ellipsis=st.booleans(), data=st.data())
-def test_generate_valid_indices(xp, xps, allow_newaxis, allow_ellipsis, data):
-    """Strategy generates valid indices."""
-    try:
-        import numpy.array_api
-    except ImportError:
-        pass
-    else:
-        if allow_newaxis and xp is numpy.array_api:
-            # Special case NumPy due to https://github.com/numpy/numpy/issues/21373
-            x = xp.ones(5)
-            try:
-                xNone, :
-            except IndexError:
-                note("Forcing `allow_newaxis=False` for np.array_api")
-                allow_newaxis = False
-            else:
-                raise AssertionError(
-                    "numpy.array_api looks to now support newaxis indexing, "
-                    "so this try/except/else special case should be removed."
-                )
-
-    shape = data.draw(
-        xps.array_shapes(min_dims=1, max_side=4)
-        | xps.array_shapes(min_dims=1, min_side=0, max_side=10),
-        label="shape",
-    )
-    min_dims = data.draw(
-        st.integers(0, len(shape) if not allow_newaxis else len(shape) + 2),
-        label="min_dims",
-    )
-    max_dims = data.draw(
-        st.none()
-        | st.integers(min_dims, len(shape) if not allow_newaxis else NDIM_MAX),
-        label="max_dims",
-    )
-    indexer = data.draw(
-        xps.indices(
-            shape,
-            min_dims=min_dims,
-            max_dims=max_dims,
-            allow_newaxis=allow_newaxis,
-            allow_ellipsis=allow_ellipsis,
-        ),
-        label="indexer",
-    )
-
-    _indexer = indexer if isinstance(indexer, tuple) else (indexer,)
-    # Check that disallowed things are indeed absent
-    if not allow_ellipsis:
-        assert Ellipsis not in _indexer
-    if not allow_newaxis:
-        assert None not in _indexer  # i.e. xp.newaxis
-    # Check index is composed of valid objects
-    for i in _indexer:
-        assert isinstance(i, int) or isinstance(i, slice) or i is None or i == Ellipsis
-    # Check indexer does not flat index
-    nonexpanding_indexer = i for i in _indexer if i is not None
-    if Ellipsis in _indexer:
-        assert sum(i == Ellipsis for i in _indexer) == 1
-        # Note ellipsis can index 0 axes
-        assert len(nonexpanding_indexer) <= len(shape) + 1
-    else:
-        assert len(nonexpanding_indexer) == len(shape)
-
-    if 0 in shape:
-        # If there's a zero in the shape, the array will have no elements.
-        array = xp.zeros(shape)
-        assert array.size == 0  # sanity check
-    elif math.prod(shape) <= 10**5:
-        # If it's small enough to instantiate, do so with distinct elements.
-        array = xp.reshape(xp.arange(math.prod(shape)), shape)
-    else:
-        # We can't cheat on this one, so just try another.
-        assume(False)
-    # Finally, check that we can use our indexer without error
-    note(f"{array=}")
-    arrayindexer

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_partial_adoptors.py Deleted

@@ -1,117 +0,0 @@
-# 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/.
-
-from copy import copy
-from functools import lru_cache
-from types import SimpleNamespace
-from typing import Tuple
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import HypothesisWarning, InvalidArgument
-from hypothesis.extra.array_api import (
-    DTYPE_NAMES,
-    FLOAT_NAMES,
-    INT_NAMES,
-    UINT_NAMES,
-    make_strategies_namespace,
-    mock_xp,
-)
-
-MOCK_WARN_MSG = f"determine.*{mock_xp.__name__}.*Array API"
-
-
-@lru_cache()
-def make_mock_xp(exclude: Tuplestr, ... = ()) -> SimpleNamespace:
-    xp = copy(mock_xp)
-    for attr in exclude:
-        delattr(xp, attr)
-    return xp
-
-
-def test_warning_on_noncompliant_xp():
-    """Using non-compliant array modules raises helpful warning"""
-    xp = make_mock_xp()
-    with pytest.warns(HypothesisWarning, match=MOCK_WARN_MSG):
-        make_strategies_namespace(xp)
-
-
-@pytest.mark.filterwarnings(f"ignore:.*{MOCK_WARN_MSG}.*")
-@pytest.mark.parametrize(
-    "stratname, args, attr",
-    ("from_dtype", "int8", "iinfo"), ("arrays", "int8", 5, "full"),
-)
-def test_error_on_missing_attr(stratname, args, attr):
-    """Strategies raise helpful error when using array modules that lack
-    required attributes."""
-    xp = make_mock_xp(exclude=(attr,))
-    xps = make_strategies_namespace(xp)
-    func = getattr(xps, stratname)
-    with pytest.raises(InvalidArgument, match=f"{mock_xp.__name__}.*required.*{attr}"):
-        func(*args).example()
-
-
-dtypeless_xp = make_mock_xp(exclude=tuple(DTYPE_NAMES))
-with pytest.warns(HypothesisWarning):
-    dtypeless_xps = make_strategies_namespace(dtypeless_xp)
-
-
-@pytest.mark.parametrize(
-    "stratname",
-    
-        "scalar_dtypes",
-        "boolean_dtypes",
-        "numeric_dtypes",
-        "integer_dtypes",
-        "unsigned_integer_dtypes",
-        "floating_dtypes",
-    ,
-)
-def test_error_on_missing_dtypes(stratname):
-    """Strategies raise helpful error when using array modules that lack
-    required dtypes."""
-    func = getattr(dtypeless_xps, stratname)
-    with pytest.raises(InvalidArgument, match=f"{mock_xp.__name__}.*dtype.*namespace"):
-        func().example()
-
-
-@pytest.mark.filterwarnings(f"ignore:.*{MOCK_WARN_MSG}.*")
-@pytest.mark.parametrize(
-    "stratname, keep_anys",
-    
-        ("scalar_dtypes", INT_NAMES, UINT_NAMES, FLOAT_NAMES),
-        ("numeric_dtypes", INT_NAMES, UINT_NAMES, FLOAT_NAMES),
-        ("integer_dtypes", INT_NAMES),
-        ("unsigned_integer_dtypes", UINT_NAMES),
-        ("floating_dtypes", FLOAT_NAMES),
-    ,
-)
-@given(st.data())
-def test_warning_on_partial_dtypes(stratname, keep_anys, data):
-    """Strategies using array modules with at least one of a dtype in the
-    necessary category/categories execute with a warning."""
-    exclude = 
-    for keep_any in keep_anys:
-        exclude.extend(
-            data.draw(
-                st.lists(
-                    st.sampled_from(keep_any),
-                    min_size=1,
-                    max_size=len(keep_any) - 1,
-                    unique=True,
-                )
-            )
-        )
-    xp = make_mock_xp(exclude=tuple(exclude))
-    xps = make_strategies_namespace(xp)
-    func = getattr(xps, stratname)
-    with pytest.warns(HypothesisWarning, match=f"{mock_xp.__name__}.*dtype.*namespace"):
-        data.draw(func())

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_pretty.py Deleted

@@ -1,77 +0,0 @@
-# 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/.
-
-from inspect import signature
-
-import pytest
-
-
-@pytest.mark.parametrize(
-    "name",
-    
-        "from_dtype",
-        "arrays",
-        "array_shapes",
-        "scalar_dtypes",
-        "boolean_dtypes",
-        "numeric_dtypes",
-        "integer_dtypes",
-        "unsigned_integer_dtypes",
-        "floating_dtypes",
-        "valid_tuple_axes",
-        "broadcastable_shapes",
-        "mutually_broadcastable_shapes",
-        "indices",
-    ,
-)
-def test_namespaced_methods_meta(xp, xps, name):
-    """Namespaced method objects have good meta attributes."""
-    func = getattr(xps, name)
-    assert func.__name__ == name
-    assert func.__doc__ is not None
-    # The (private) top-level strategy methods may expose a xp argument in their
-    # function signatures. make_strategies_namespace() exists to wrap these
-    # top-level methods by binding the passed xp argument, and so the namespace
-    # it returns should not expose xp in any of its function signatures.
-    assert "xp" not in signature(func).parameters.keys()
-
-
-@pytest.mark.parametrize(
-    "name, valid_args",
-    
-        ("from_dtype", "int8"),
-        ("arrays", "int8", 5),
-        ("array_shapes", ),
-        ("scalar_dtypes", ),
-        ("boolean_dtypes", ),
-        ("numeric_dtypes", ),
-        ("integer_dtypes", ),
-        ("unsigned_integer_dtypes", ),
-        ("floating_dtypes", ),
-        ("valid_tuple_axes", 0),
-        ("broadcastable_shapes", ()),
-        ("mutually_broadcastable_shapes", 3),
-        ("indices", (5,)),
-    ,
-)
-def test_namespaced_strategies_repr(xp, xps, name, valid_args):
-    """Namespaced strategies have good repr."""
-    func = getattr(xps, name)
-    strat = func(*valid_args)
-    assert repr(strat).startswith(name + "("), f"{name} not in strat repr {strat!r}"
-    assert len(repr(strat)) < 100, "strat repr looks too long"
-    assert xp.__name__ not in repr(strat), f"{xp.__name__} in strat repr"
-
-
-def test_strategies_namespace_repr(xp, xps):
-    """Strategies namespace has good repr."""
-    expected = f"make_strategies_namespace({xp.__name__})"
-    assert repr(xps) == expected
-    assert str(xps) == expected

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/array_api/test_scalar_dtypes.py Deleted

@@ -1,70 +0,0 @@
-# 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 pytest
-
-from hypothesis.extra.array_api import (
-    DTYPE_NAMES,
-    FLOAT_NAMES,
-    INT_NAMES,
-    NUMERIC_NAMES,
-    UINT_NAMES,
-)
-
-from tests.common.debug import assert_all_examples, find_any, minimal
-
-
-def test_can_generate_scalar_dtypes(xp, xps):
-    dtypes = getattr(xp, name) for name in DTYPE_NAMES
-    assert_all_examples(xps.scalar_dtypes(), lambda dtype: dtype in dtypes)
-
-
-def test_can_generate_boolean_dtypes(xp, xps):
-    assert_all_examples(xps.boolean_dtypes(), lambda dtype: dtype == xp.bool)
-
-
-def test_can_generate_numeric_dtypes(xp, xps):
-    numeric_dtypes = getattr(xp, name) for name in NUMERIC_NAMES
-    assert_all_examples(xps.numeric_dtypes(), lambda dtype: dtype in numeric_dtypes)
-
-
-def test_can_generate_integer_dtypes(xp, xps):
-    int_dtypes = getattr(xp, name) for name in INT_NAMES
-    assert_all_examples(xps.integer_dtypes(), lambda dtype: dtype in int_dtypes)
-
-
-def test_can_generate_unsigned_integer_dtypes(xp, xps):
-    uint_dtypes = getattr(xp, name) for name in UINT_NAMES
-    assert_all_examples(
-        xps.unsigned_integer_dtypes(), lambda dtype: dtype in uint_dtypes
-    )
-
-
-def test_can_generate_floating_dtypes(xp, xps):
-    float_dtypes = getattr(xp, name) for name in FLOAT_NAMES
-    assert_all_examples(xps.floating_dtypes(), lambda dtype: dtype in float_dtypes)
-
-
-def test_minimise_scalar_dtypes(xp, xps):
-    assert minimal(xps.scalar_dtypes()) == xp.bool
-
-
-@pytest.mark.parametrize(
-    "strat_name, sizes",
-    
-        ("integer_dtypes", 8),
-        ("unsigned_integer_dtypes", 8),
-        ("floating_dtypes", 32),
-    ,
-)
-def test_can_specify_sizes_as_an_int(xp, xps, strat_name, sizes):
-    strat_func = getattr(xps, strat_name)
-    strat = strat_func(sizes=sizes)
-    find_any(strat)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/codemods Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/codemods/test_codemod_cli.py Deleted

@@ -1,68 +0,0 @@
-# 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 subprocess
-
-BEFORE = """
-from hypothesis.strategies import complex_numbers, complex_numbers as cn
-
-complex_numbers(min_magnitude=None)  # simple call to fix
-complex_numbers(min_magnitude=None, max_magnitude=1)  # plus arg after
-complex_numbers(allow_infinity=False, min_magnitude=None)  # plus arg before
-cn(min_magnitude=None)  # imported as alias
-"""
-AFTER = BEFORE.replace("None", "0")
-_unchanged = """
-complex_numbers(min_magnitude=1)  # value OK
-
-class Foo:
-    def complex_numbers(self, **kw): pass
-
-    complex_numbers(min_magnitude=None)  # defined in a different scope
-"""
-BEFORE += _unchanged
-AFTER += _unchanged
-del _unchanged
-
-
-def run(command, tmpdir=None, input=None):
-    return subprocess.run(
-        command,
-        input=input,
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-
-
-def test_codemod_single_file(tmpdir):
-    fname = tmpdir / "mycode.py"
-    fname.write(BEFORE)
-    result = run("hypothesis codemod mycode.py", tmpdir)
-    assert result.returncode == 0
-    assert fname.read() == AFTER
-
-
-def test_codemod_multiple_files(tmpdir):
-    # LibCST had some trouble with multiprocessing on Windows
-    files = tmpdir / "mycode1.py", tmpdir / "mycode2.py"
-    for f in files:
-        f.write(BEFORE)
-    result = run("hypothesis codemod mycode1.py mycode2.py", tmpdir)
-    assert result.returncode == 0
-    for f in files:
-        assert f.read() == AFTER
-
-
-def test_codemod_from_stdin():
-    result = run("hypothesis codemod -", input=BEFORE)
-    assert result.returncode == 0
-    assert result.stdout.rstrip() == AFTER.rstrip()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/codemods/test_codemods.py Deleted

@@ -1,133 +0,0 @@
-# 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/.
-
-from libcst.codemod import CodemodTest
-
-from hypothesis.extra import codemods
-
-
-def test_refactor_function_is_idempotent():
-    before = (
-        "from hypothesis.strategies import complex_numbers\n\n"
-        + "complex_numbers(None)\n"
-    )
-    after = codemods.refactor(before)
-    assert before.replace("None", "min_magnitude=0") == after
-    assert codemods.refactor(after) == after
-
-
-class TestFixComplexMinMagnitude(CodemodTest):
-    TRANSFORM = codemods.HypothesisFixComplexMinMagnitude
-
-    def test_noop(self) -> None:
-        before = """
-            from hypothesis.strategies import complex_numbers, complex_numbers as cn
-
-            complex_numbers(min_magnitude=1)  # value OK
-            complex_numbers(max_magnitude=None)  # different argument
-
-            class Foo:
-                def complex_numbers(self, **kw): pass
-
-                complex_numbers(min_magnitude=None)  # defined in a different scope
-        """
-        self.assertCodemod(before=before, after=before)
-
-    def test_substitution(self) -> None:
-        before = """
-            from hypothesis.strategies import complex_numbers, complex_numbers as cn
-
-            complex_numbers(min_magnitude=None)  # simple call to fix
-            complex_numbers(min_magnitude=None, max_magnitude=1)  # plus arg after
-            complex_numbers(allow_infinity=False, min_magnitude=None)  # plus arg before
-            cn(min_magnitude=None)  # imported as alias
-        """
-        self.assertCodemod(before=before, after=before.replace("None", "0"))
-
-
-class TestFixPositionalKeywonlyArgs(CodemodTest):
-    TRANSFORM = codemods.HypothesisFixPositionalKeywonlyArgs
-
-    def test_substitution(self) -> None:
-        before = """
-            import hypothesis.strategies as st
-
-            st.floats(0, 1, False, False, 32)
-            st.fractions(0, 1, 9)
-        """
-        after = """
-            import hypothesis.strategies as st
-
-            st.floats(0, 1, allow_nan=False, allow_infinity=False, width=32)
-            st.fractions(0, 1, max_denominator=9)
-        """
-        self.assertCodemod(before=before, after=after)
-
-    def test_noop_with_new_floats_kw(self) -> None:
-        before = """
-            import hypothesis.strategies as st
-
-            st.floats(0, 1, False, False, True, 32, False, False)  # allow_subnormal=True
-        """
-        self.assertCodemod(before=before, after=before)
-
-    def test_noop_if_unsure(self) -> None:
-        before = """
-            import random
-
-            if random.getrandbits(1):
-                from hypothesis import target
-                from hypothesis.strategies import lists as sets
-
-                def fractions(*args):
-                    pass
-
-            else:
-                from hypothesis import target
-                from hypothesis.strategies import fractions, sets
-
-            fractions(0, 1, 9)
-            sets(None, 1)
-            target(0, 'label')
-        """
-        after = before.replace("'label'", "label='label'")
-        self.assertCodemod(before=before, after=after)
-
-    def test_stateful_rule_noop(self):
-        # `rule()(lambda self: None)` is a call with a positional argument, and
-        # so we need an additional check that the "func" node is a Name rather than
-        # itself being a Call, lest we rewrite the outer instead of the inner.
-        # (this may be an upstream bug in metadata processing)
-        before = """
-            from hypothesis.stateful import RuleBasedStateMachine, rule
-
-            class MultipleRulesSameFuncMachine(RuleBasedStateMachine):
-                rule1 = rule()(lambda self: None)
-        """
-        self.assertCodemod(before=before, after=before)
-
-    def test_kwargs_noop(self):
-        before = """
-            from hypothesis import target
-
-            kwargs = {"observation": 1, "label": "foobar"}
-            target(**kwargs)
-        """
-        self.assertCodemod(before=before, after=before)
-
-    def test_noop_with_too_many_arguments_passed(self) -> None:
-        # If there are too many arguments, we should leave this alone to raise
-        # TypeError on older versions instead of deleting the additional args.
-        before = """
-            import hypothesis.strategies as st
-
-            st.sets(st.integers(), 0, 1, True)
-        """
-        self.assertCodemod(before=before, after=before)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/__init__.py Deleted

@@ -1,108 +0,0 @@
-# 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 sys
-from collections import namedtuple
-
-from hypothesis.strategies import (
-    binary,
-    booleans,
-    builds,
-    complex_numbers,
-    decimals,
-    dictionaries,
-    fixed_dictionaries,
-    floats,
-    fractions,
-    frozensets,
-    integers,
-    just,
-    lists,
-    none,
-    one_of,
-    randoms,
-    recursive,
-    sampled_from,
-    sets,
-    text,
-    tuples,
-)
-
-from tests.common.debug import TIME_INCREMENT
-
-__all__ = "standard_types", "OrderedPair", "TIME_INCREMENT"
-
-OrderedPair = namedtuple("OrderedPair", ("left", "right"))
-
-ordered_pair = integers().flatmap(
-    lambda right: integers(min_value=0).map(
-        lambda length: OrderedPair(right - length, right)
-    )
-)
-
-
-def constant_list(strat):
-    return strat.flatmap(lambda v: lists(just(v)))
-
-
-ABC = namedtuple("ABC", ("a", "b", "c"))
-
-
-def abc(x, y, z):
-    return builds(ABC, x, y, z)
-
-
-standard_types = 
-    lists(none(), max_size=0),
-    tuples(),
-    sets(none(), max_size=0),
-    frozensets(none(), max_size=0),
-    fixed_dictionaries({}),
-    abc(booleans(), booleans(), booleans()),
-    abc(booleans(), booleans(), integers()),
-    fixed_dictionaries({"a": integers(), "b": booleans()}),
-    dictionaries(booleans(), integers()),
-    dictionaries(text(), booleans()),
-    one_of(integers(), tuples(booleans())),
-    sampled_from(range(10)),
-    one_of(just("a"), just("b"), just("c")),
-    sampled_from(("a", "b", "c")),
-    integers(),
-    integers(min_value=3),
-    integers(min_value=(-(2**32)), max_value=(2**64)),
-    floats(),
-    floats(min_value=-2.0, max_value=3.0),
-    floats(),
-    floats(min_value=-2.0),
-    floats(),
-    floats(max_value=-0.0),
-    floats(),
-    floats(min_value=0.0),
-    floats(min_value=3.14, max_value=3.14),
-    text(),
-    binary(),
-    booleans(),
-    tuples(booleans(), booleans()),
-    frozensets(integers()),
-    sets(frozensets(booleans())),
-    complex_numbers(),
-    fractions(),
-    decimals(),
-    lists(lists(booleans())),
-    lists(floats(0.0, 0.0)),
-    ordered_pair,
-    constant_list(integers()),
-    integers().filter(lambda x: abs(x) > 100),
-    floats(min_value=-sys.float_info.max, max_value=sys.float_info.max),
-    none(),
-    randoms(use_true_random=True),
-    booleans().flatmap(lambda x: booleans() if x else complex_numbers()),
-    recursive(base=booleans(), extend=lambda x: lists(x, max_size=3), max_leaves=10),
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/arguments.py Deleted

@@ -1,40 +0,0 @@
-# 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 pytest
-
-from hypothesis import given
-from hypothesis.errors import InvalidArgument
-
-
-def e(a, *args, **kwargs):
-    return (a, args, kwargs)
-
-
-def e_to_str(elt):
-    f, args, kwargs = elt
-    bits = list(map(repr, args))
-    bits.extend(sorted(f"{k}={v!r}" for k, v in kwargs.items()))
-    return "{}({})".format(f.__name__, ", ".join(bits))
-
-
-def argument_validation_test(bad_args):
-    @pytest.mark.parametrize(
-        ("function", "args", "kwargs"), bad_args, ids=list(map(e_to_str, bad_args))
-    )
-    def test_raise_invalid_argument(function, args, kwargs):
-        @given(function(*args, **kwargs))
-        def test(x):
-            pass
-
-        with pytest.raises(InvalidArgument):
-            test()
-
-    return test_raise_invalid_argument

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/costbounds.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/debug.py Deleted

@@ -1,120 +0,0 @@
-# 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/.
-
-from hypothesis import (
-    HealthCheck,
-    Verbosity,
-    given,
-    settings as Settings,
-    strategies as st,
-)
-from hypothesis.errors import Found, NoSuchExample, Unsatisfiable
-from hypothesis.internal.conjecture.data import ConjectureData, StopTest
-from hypothesis.internal.reflection import get_pretty_function_description
-
-from tests.common.utils import no_shrink
-
-TIME_INCREMENT = 0.01
-
-
-class Timeout(BaseException):
-    pass
-
-
-def minimal(definition, condition=lambda x: True, settings=None, timeout_after=10):
-    def wrapped_condition(x):
-        if timeout_after is not None:
-            if runtime:
-                runtime0 += TIME_INCREMENT
-                if runtime0 >= timeout_after:
-                    raise Timeout()
-        result = condition(x)
-        if result and not runtime:
-            runtime.append(0.0)
-        return result
-
-    if settings is None:
-        settings = Settings(max_examples=50000)
-
-    verbosity = settings.verbosity
-    if verbosity == Verbosity.normal:
-        verbosity = Verbosity.quiet
-
-    @given(definition)
-    @Settings(
-        parent=settings,
-        suppress_health_check=HealthCheck.all(),
-        report_multiple_bugs=False,
-        derandomize=True,
-        database=None,
-        verbosity=verbosity,
-    )
-    def inner(x):
-        if wrapped_condition(x):
-            result: = x
-            raise Found
-
-    definition.validate()
-    runtime = 
-    result = 
-    try:
-        inner()
-    except Found:
-        return result0
-    raise Unsatisfiable(
-        "Could not find any examples from %r that satisfied %s"
-        % (definition, get_pretty_function_description(condition))
-    )
-
-
-def find_any(definition, condition=lambda _: True, settings=None):
-    settings = settings or Settings.default
-    return minimal(
-        definition,
-        condition,
-        settings=Settings(
-            settings, phases=no_shrink, max_examples=max(1000, settings.max_examples)
-        ),
-    )
-
-
-def assert_no_examples(strategy, condition=lambda _: True):
-    try:
-        result = find_any(strategy, condition)
-        raise AssertionError(f"Expected no results but found {result!r}")
-    except (Unsatisfiable, NoSuchExample):
-        pass
-
-
-def assert_all_examples(strategy, predicate):
-    """Asserts that all examples of the given strategy match the predicate.
-
-    :param strategy: Hypothesis strategy to check
-    :param predicate: (callable) Predicate that takes example and returns bool
-    """
-
-    @given(strategy)
-    def assert_examples(s):
-        msg = f"Found {s!r} using strategy {strategy} which does not match"
-        assert predicate(s), msg
-
-    assert_examples()
-
-
-def assert_can_trigger_event(strategy, predicate):
-    def test(buf):
-        data = ConjectureData.for_buffer(buf)
-        try:
-            data.draw(strategy)
-        except StopTest:
-            pass
-        return any(predicate(e) for e in data.events)
-
-    find_any(st.binary(), test)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/setup.py Deleted

@@ -1,87 +0,0 @@
-# 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 os
-from tempfile import mkdtemp
-from warnings import filterwarnings
-
-from hypothesis import Verbosity, settings
-from hypothesis._settings import not_set
-from hypothesis.configuration import set_hypothesis_home_dir
-from hypothesis.errors import NonInteractiveExampleWarning
-from hypothesis.internal import charmap
-from hypothesis.internal.coverage import IN_COVERAGE_TESTS
-
-
-def run():
-    filterwarnings("error")
-    filterwarnings("ignore", category=ImportWarning)
-    filterwarnings("ignore", category=FutureWarning, module="pandas._version")
-
-    # Fixed in recent versions but allowed by pytest=3.0.0; see #1630
-    filterwarnings("ignore", category=DeprecationWarning, module="pluggy")
-
-    # See https://github.com/numpy/numpy/pull/432
-    filterwarnings("ignore", message="numpy.dtype size changed")
-    filterwarnings("ignore", message="numpy.ufunc size changed")
-
-    # See https://github.com/HypothesisWorks/hypothesis/issues/1674
-    filterwarnings(
-        "ignore",
-        message=(
-            "The virtualenv distutils package at .+ appears to be in the "
-            "same location as the system distutils?"
-        ),
-        category=UserWarning,
-    )
-
-    # Imported by Pandas in version 1.9, but fixed in later versions.
-    filterwarnings(
-        "ignore", message="Importing from numpy.testing.decorators is deprecated"
-    )
-    filterwarnings(
-        "ignore", message="Importing from numpy.testing.nosetester is deprecated"
-    )
-
-    # User-facing warning which does not apply to our own tests
-    filterwarnings("ignore", category=NonInteractiveExampleWarning)
-
-    new_home = mkdtemp()
-    set_hypothesis_home_dir(new_home)
-    assert settings.default.database.path.startswith(new_home)
-
-    # Remove the cache because we might have saved this before setting the new home dir
-    charmap._charmap = None
-    charmap.charmap()
-    assert os.path.exists(charmap.charmap_file()), charmap.charmap_file()
-    assert isinstance(settings, type)
-
-    # We do a smoke test here before we mess around with settings.
-    x = settings()
-
-    from hypothesis import _settings as settings_module
-
-    for s in settings_module.all_settings.values():
-        v = getattr(x, s.name)
-        # Check if it has a dynamically defined default and if so skip comparison.
-        if getattr(settings, s.name).show_default:
-            assert v == s.default, "({!r} == x.{}) != (s.{} == {!r})".format(
-                v, s.name, s.name, s.default
-            )
-
-    settings.register_profile(
-        "default", settings(max_examples=20 if IN_COVERAGE_TESTS else not_set)
-    )
-
-    settings.register_profile("speedy", settings(max_examples=5))
-
-    settings.register_profile("debug", settings(verbosity=Verbosity.debug))
-
-    settings.load_profile(os.getenv("HYPOTHESIS_PROFILE", "default"))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/strategies.py Deleted

@@ -1,50 +0,0 @@
-# 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 time
-
-from hypothesis.strategies._internal import SearchStrategy
-
-
-class _Slow(SearchStrategy):
-    def do_draw(self, data):
-        time.sleep(1.0)
-        data.draw_bytes(2)
-        return None
-
-
-SLOW = _Slow()
-
-
-class HardToShrink(SearchStrategy):
-    def __init__(self):
-        self.__last = None
-        self.accepted = set()
-
-    def do_draw(self, data):
-        x = bytes(data.draw_bits(8) for _ in range(100))
-        if x in self.accepted:
-            return True
-        ls = self.__last
-        if ls is None:
-            if all(x):
-                self.__last = x
-                self.accepted.add(x)
-                return True
-            else:
-                return False
-        diffs = i for i in range(len(x)) if xi != lsi
-        if len(diffs) == 1:
-            i = diffs0
-            if xi + 1 == lsi:
-                self.__last = x
-                self.accepted.add(x)
-                return True
-        return False

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/common/utils.py Deleted

@@ -1,210 +0,0 @@
-# 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 contextlib
-import sys
-from io import StringIO
-
-from hypothesis import Phase, settings
-from hypothesis.errors import HypothesisDeprecationWarning
-from hypothesis.internal.entropy import deterministic_PRNG
-from hypothesis.internal.floats import next_down
-from hypothesis.internal.reflection import proxies
-from hypothesis.reporting import default, with_reporter
-from hypothesis.strategies._internal.core import from_type, register_type_strategy
-from hypothesis.strategies._internal.types import _global_type_lookup
-
-try:
-    from pytest import raises
-except ModuleNotFoundError:
-    # We are currently running under a test framework other than pytest,
-    # so use our own simplified implementation of `pytest.raises`.
-
-    @contextlib.contextmanager
-    def raises(expected_exception, match=None):
-        try:
-            yield
-        except expected_exception as e:
-            if match is not None:
-                import re
-
-                assert re.search(match, e.args0)
-        else:
-            # This needs to be outside the try/except, so that the helper doesn't
-            # trick itself into thinking that an AssertionError was thrown.
-            raise AssertionError(
-                f"Expected to raise an exception ({expected_exception!r}) but didn't"
-            ) from None
-
-
-no_shrink = tuple(set(settings.default.phases) - {Phase.shrink})
-
-
-def flaky(max_runs, min_passes):
-    assert isinstance(max_runs, int)
-    assert isinstance(min_passes, int)
-    assert 0 < min_passes <= max_runs <= 50  # arbitrary cap
-
-    def accept(func):
-        @proxies(func)
-        def inner(*args, **kwargs):
-            runs = passes = 0
-            while passes < min_passes:
-                runs += 1
-                try:
-                    func(*args, **kwargs)
-                    passes += 1
-                except BaseException:
-                    if runs >= max_runs:
-                        raise
-
-        return inner
-
-    return accept
-
-
-@contextlib.contextmanager
-def capture_out():
-    old_out = sys.stdout
-    try:
-        new_out = StringIO()
-        sys.stdout = new_out
-        with with_reporter(default):
-            yield new_out
-    finally:
-        sys.stdout = old_out
-
-
-class ExcInfo:
-    pass
-
-
-def fails_with(e):
-    def accepts(f):
-        @proxies(f)
-        def inverted_test(*arguments, **kwargs):
-            # Most of these expected-failure tests are non-deterministic, so
-            # we rig the PRNG to avoid occasional flakiness. We do this outside
-            # the `raises` context manager so that any problems in rigging the
-            # PRNG don't accidentally count as the expected failure.
-            with deterministic_PRNG():
-                with raises(e):
-                    f(*arguments, **kwargs)
-
-        return inverted_test
-
-    return accepts
-
-
-fails = fails_with(AssertionError)
-
-
-class NotDeprecated(Exception):
-    pass
-
-
-@contextlib.contextmanager
-def validate_deprecation():
-    import warnings
-
-    try:
-        warnings.simplefilter("always", HypothesisDeprecationWarning)
-        with warnings.catch_warnings(record=True) as w:
-            yield
-    finally:
-        warnings.simplefilter("error", HypothesisDeprecationWarning)
-        if not any(e.category == HypothesisDeprecationWarning for e in w):
-            raise NotDeprecated(
-                f"Expected a deprecation warning but got {e.category for e in w!r}"
-            )
-
-
-def checks_deprecated_behaviour(func):
-    """A decorator for testing deprecated behaviour."""
-
-    @proxies(func)
-    def _inner(*args, **kwargs):
-        with validate_deprecation():
-            return func(*args, **kwargs)
-
-    return _inner
-
-
-def all_values(db):
-    return {v for vs in db.data.values() for v in vs}
-
-
-def non_covering_examples(database):
-    return {
-        v for k, vs in database.data.items() if not k.endswith(b".pareto") for v in vs
-    }
-
-
-def counts_calls(func):
-    """A decorator that counts how many times a function was called, and
-    stores that value in a ``.calls`` attribute.
-    """
-    assert not hasattr(func, "calls")
-
-    @proxies(func)
-    def _inner(*args, **kwargs):
-        _inner.calls += 1
-        return func(*args, **kwargs)
-
-    _inner.calls = 0
-    return _inner
-
-
-def assert_output_contains_failure(output, test, **kwargs):
-    assert test.__name__ + "(" in output
-    for k, v in kwargs.items():
-        assert f"{k}={v!r}" in output
-
-
-def assert_falsifying_output(
-    test, example_type="Falsifying", expected_exception=AssertionError, **kwargs
-):
-    with capture_out() as out:
-        if expected_exception is None:
-            # Some tests want to check the output of non-failing runs.
-            test()
-        else:
-            with raises(expected_exception):
-                test()
-
-    output = out.getvalue()
-    assert f"{example_type} example:" in output
-    assert_output_contains_failure(output, test, **kwargs)
-
-
-@contextlib.contextmanager
-def temp_registered(type_, strat_or_factory):
-    """Register and un-register a type for st.from_type().
-
-    This not too hard, but there's a subtlety in restoring the
-    previously-registered strategy which we got wrong in a few places.
-    """
-    prev = _global_type_lookup.get(type_)
-    try:
-        register_type_strategy(type_, strat_or_factory)
-        yield
-    finally:
-        del _global_type_lookuptype_
-        from_type.__clear_cache()
-        if prev is not None:
-            register_type_strategy(type_, prev)
-
-
-# Specifies whether we can represent subnormal floating point numbers.
-# IEE-754 requires subnormal support, but it's often disabled anyway by unsafe
-# compiler options like `-ffast-math`.  On most hardware that's even a global
-# config option, so *linking against* something built this way can break us.
-# Everything is terrible
-PYTHON_FTZ = next_down(sys.float_info.min) == 0.0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conftest.py Deleted

@@ -1,120 +0,0 @@
-# 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 gc
-import random
-import sys
-import time as time_module
-
-import pytest
-
-from hypothesis._settings import is_in_ci
-from hypothesis.internal.detection import is_hypothesis_test
-
-from tests.common import TIME_INCREMENT
-from tests.common.setup import run
-
-run()
-
-# Skip collection of tests which require the Django test runner,
-# or that don't work on the current version of Python.
-collect_ignore_glob = "django/*"
-if sys.version_info < (3, 8):
-    collect_ignore_glob.append("array_api")
-    collect_ignore_glob.append("cover/*py38*")
-if sys.version_info < (3, 9):
-    collect_ignore_glob.append("cover/*py39*")
-if sys.version_info < (3, 10):
-    collect_ignore_glob.append("cover/*py310*")
-
-if sys.version_info >= (3, 11):
-    collect_ignore_glob.append("cover/test_asyncio.py")  # @asyncio.coroutine removed
-
-
-def pytest_configure(config):
-    config.addinivalue_line("markers", "slow: pandas expects this marker to exist.")
-
-
-def pytest_addoption(parser):
-    parser.addoption("--hypothesis-update-outputs", action="store_true")
-    parser.addoption("--hypothesis-learn-to-normalize", action="store_true")
-
-
-@pytest.fixture(scope="function", autouse=True)
-def gc_before_each_test():
-    gc.collect()
-
-
-@pytest.fixture(scope="function", autouse=True)
-def consistently_increment_time(monkeypatch):
-    """Rather than rely on real system time we monkey patch time.time so that
-    it passes at a consistent rate between calls.
-
-    The reason for this is that when these tests run in CI, their performance is
-    extremely variable and the VM the tests are on might go to sleep for a bit,
-    introducing arbitrary delays. This can cause a number of tests to fail
-    flakily.
-
-    Replacing time with a fake version under our control avoids this problem.
-    """
-    frozen = False
-
-    current_time = time_module.time()
-
-    def time():
-        if not frozen0:
-            current_time0 += TIME_INCREMENT
-        return current_time0
-
-    def sleep(naptime):
-        current_time0 += naptime
-
-    def freeze():
-        frozen0 = True
-
-    monkeypatch.setattr(time_module, "time", time)
-    monkeypatch.setattr(time_module, "monotonic", time)
-    monkeypatch.setattr(time_module, "perf_counter", time)
-    monkeypatch.setattr(time_module, "sleep", sleep)
-    monkeypatch.setattr(time_module, "freeze", freeze, raising=False)
-
-
-random_states_after_tests = {}
-independent_random = random.Random()
-
-
-@pytest.hookimpl(hookwrapper=True)
-def pytest_runtest_call(item):
-    # This hookwrapper checks for PRNG state leaks from Hypothesis tests.
-    # See: https://github.com/HypothesisWorks/hypothesis/issues/1919
-    if not (hasattr(item, "obj") and is_hypothesis_test(item.obj)):
-        yield
-    elif "pytest_randomly" in sys.modules:
-        # See https://github.com/HypothesisWorks/hypothesis/issues/3041 - this
-        # branch exists to make it easier on external contributors, but should
-        # never run in our CI (because that would disable the check entirely).
-        assert not is_in_ci()
-        yield
-    else:
-        # We start by peturbing the state of the PRNG, because repeatedly
-        # leaking PRNG state resets state_after to the (previously leaked)
-        # state_before, and that just shows as "no use of random".
-        random.seed(independent_random.randrange(2**32))
-        before = random.getstate()
-        yield
-        after = random.getstate()
-        if before != after:
-            if after in random_states_after_tests:
-                raise Exception(
-                    f"{item.nodeid!r} and {random_states_after_testsafter!r} "
-                    "both used the `random` module, and finished with the "
-                    "same global `random.getstate()`; this is probably a nasty bug!"
-                )
-            random_states_after_testsafter = item.nodeid

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/common.py Deleted

@@ -1,69 +0,0 @@
-# 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/.
-
-from contextlib import contextmanager
-
-from hypothesis import HealthCheck, settings
-from hypothesis.internal.conjecture import engine as engine_module
-from hypothesis.internal.conjecture.data import Status
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.conjecture.utils import calc_label_from_name
-from hypothesis.internal.entropy import deterministic_PRNG
-
-SOME_LABEL = calc_label_from_name("some label")
-
-
-TEST_SETTINGS = settings(
-    max_examples=5000, database=None, suppress_health_check=HealthCheck.all()
-)
-
-
-def run_to_data(f):
-    with deterministic_PRNG():
-        runner = ConjectureRunner(f, settings=TEST_SETTINGS)
-        runner.run()
-        assert runner.interesting_examples
-        (last_data,) = runner.interesting_examples.values()
-        return last_data
-
-
-def run_to_buffer(f):
-    return bytes(run_to_data(f).buffer)
-
-
-@contextmanager
-def buffer_size_limit(n):
-    original = engine_module.BUFFER_SIZE
-    try:
-        engine_module.BUFFER_SIZE = n
-        yield
-    finally:
-        engine_module.BUFFER_SIZE = original
-
-
-def shrinking_from(start):
-    def accept(f):
-        with deterministic_PRNG():
-            runner = ConjectureRunner(
-                f,
-                settings=settings(
-                    max_examples=5000,
-                    database=None,
-                    suppress_health_check=HealthCheck.all(),
-                ),
-            )
-            runner.cached_test_function(start)
-            assert runner.interesting_examples
-            (last_data,) = runner.interesting_examples.values()
-            return runner.new_shrinker(
-                last_data, lambda d: d.status == Status.INTERESTING
-            )
-
-    return accept

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_choice_tree.py Deleted

@@ -1,146 +0,0 @@
-# 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/.
-
-from random import Random
-
-from hypothesis import given, strategies as st
-from hypothesis.internal.conjecture.choicetree import (
-    ChoiceTree,
-    prefix_selection_order,
-    random_selection_order,
-)
-
-
-def select(*args):
-    return prefix_selection_order(args)
-
-
-def exhaust(f):
-    tree = ChoiceTree()
-
-    results = 
-
-    prefix = ()
-
-    while not tree.exhausted:
-        prefix = tree.step(
-            prefix_selection_order(prefix), lambda chooser: results.append(f(chooser))
-        )
-    return results
-
-
-@given(st.lists(st.integers()))
-def test_can_enumerate_a_shallow_set(ls):
-    results = exhaust(lambda chooser: chooser.choose(ls))
-
-    assert sorted(results) == sorted(ls)
-
-
-def test_can_enumerate_a_nested_set():
-    @exhaust
-    def nested(chooser):
-        i = chooser.choose(range(10))
-        j = chooser.choose(range(10), condition=lambda j: j > i)
-        return (i, j)
-
-    assert sorted(nested) == (i, j) for i in range(10) for j in range(i + 1, 10)
-
-
-def test_can_enumerate_empty():
-    @exhaust
-    def empty(chooser):
-        return 1
-
-    assert empty == 1
-
-
-def test_all_filtered_child():
-    @exhaust
-    def all_filtered(chooser):
-        chooser.choose(range(10), condition=lambda j: False)
-
-    assert all_filtered == 
-
-
-def test_skips_over_exhausted_children():
-
-    results = 
-
-    def f(chooser):
-        results.append(
-            (
-                chooser.choose(range(3), condition=lambda x: x > 0),
-                chooser.choose(range(2)),
-            )
-        )
-
-    tree = ChoiceTree()
-
-    tree.step(select(1, 0), f)
-    tree.step(select(1, 1), f)
-    tree.step(select(0, 0), f)
-
-    assert results == (1, 0), (1, 1), (2, 0)
-
-
-def test_extends_prefix_from_right():
-    def f(chooser):
-        chooser.choose(range(4))
-
-    tree = ChoiceTree()
-    result = tree.step(select(), f)
-    assert result == (3,)
-
-
-def test_starts_from_the_end():
-    def f(chooser):
-        chooser.choose(range(3))
-
-    tree = ChoiceTree()
-    assert tree.step(select(), f) == (2,)
-
-
-def test_skips_over_exhausted_subtree():
-    def f(chooser):
-        chooser.choose(range(10))
-
-    tree = ChoiceTree()
-    assert tree.step(select(8), f) == (8,)
-    assert tree.step(select(8), f) == (7,)
-
-
-def test_exhausts_randomly():
-    def f(chooser):
-        chooser.choose(range(10))
-
-    tree = ChoiceTree()
-
-    random = Random()
-
-    seen = set()
-
-    for _ in range(10):
-        seen.add(tree.step(random_selection_order(random), f))
-
-    assert len(seen) == 10
-    assert tree.exhausted
-
-
-def test_exhausts_randomly_when_filtering():
-    def f(chooser):
-        chooser.choose(range(10), lambda x: False)
-
-    tree = ChoiceTree()
-
-    random = Random()
-
-    tree.step(random_selection_order(random), f)
-
-    assert tree.exhausted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_data_tree.py Deleted

@@ -1,365 +0,0 @@
-# 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/.
-
-from random import Random
-
-import pytest
-
-from hypothesis import HealthCheck, settings
-from hypothesis.errors import Flaky
-from hypothesis.internal.conjecture.data import ConjectureData, Status, StopTest
-from hypothesis.internal.conjecture.datatree import DataTree
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-
-TEST_SETTINGS = settings(
-    max_examples=5000, database=None, suppress_health_check=HealthCheck.all()
-)
-
-
-def runner_for(*examples):
-    if len(examples) == 1 and isinstance(examples0, list):
-        examples = examples0
-
-    def accept(tf):
-        runner = ConjectureRunner(tf, settings=TEST_SETTINGS, random=Random(0))
-        runner.exit_with = lambda reason: None
-        ran_examples = 
-        for e in examples:
-            e = bytes(e)
-            data = runner.cached_test_function(e)
-            ran_examples.append((e, data))
-        for e, d in ran_examples:
-            rewritten, status = runner.tree.rewrite(e)
-            assert status == d.status
-            assert rewritten == d.buffer
-        return runner
-
-    return accept
-
-
-def test_can_lookup_cached_examples():
-    @runner_for(b"\0\0", b"\0\1")
-    def runner(data):
-        data.draw_bits(8)
-        data.draw_bits(8)
-
-
-def test_can_lookup_cached_examples_with_forced():
-    @runner_for(b"\0\0", b"\0\1")
-    def runner(data):
-        data.write(b"\1")
-        data.draw_bits(8)
-
-
-def test_can_detect_when_tree_is_exhausted():
-    @runner_for(b"\0", b"\1")
-    def runner(data):
-        data.draw_bits(1)
-
-    assert runner.tree.is_exhausted
-
-
-def test_can_detect_when_tree_is_exhausted_variable_size():
-    @runner_for(b"\0", b"\1\0", b"\1\1")
-    def runner(data):
-        if data.draw_bits(1):
-            data.draw_bits(1)
-
-    assert runner.tree.is_exhausted
-
-
-def test_one_dead_branch():
-    @runner_for(0, i for i in range(16) + i for i in range(1, 16))
-    def runner(data):
-        i = data.draw_bits(4)
-        if i > 0:
-            data.mark_invalid()
-        data.draw_bits(4)
-
-    assert runner.tree.is_exhausted
-
-
-def test_non_dead_root():
-    @runner_for(b"\0\0", b"\1\0", b"\1\1")
-    def runner(data):
-        data.draw_bits(1)
-        data.draw_bits(1)
-
-
-def test_can_reexecute_dead_examples():
-    @runner_for(b"\0\0", b"\0\1", b"\0\0")
-    def runner(data):
-        data.draw_bits(1)
-        data.draw_bits(1)
-
-
-def test_novel_prefixes_are_novel():
-    def tf(data):
-        for _ in range(4):
-            data.write(b"\0")
-            data.draw_bits(2)
-
-    runner = ConjectureRunner(tf, settings=TEST_SETTINGS, random=Random(0))
-    for _ in range(100):
-        prefix = runner.tree.generate_novel_prefix(runner.random)
-        example = prefix + bytes(8 - len(prefix))
-        assert runner.tree.rewrite(example)1 is None
-        result = runner.cached_test_function(example)
-        assert runner.tree.rewrite(example)0 == result.buffer
-
-
-def test_overruns_if_not_enough_bytes_for_block():
-    runner = ConjectureRunner(
-        lambda data: data.draw_bytes(2), settings=TEST_SETTINGS, random=Random(0)
-    )
-    runner.cached_test_function(b"\0\0")
-    assert runner.tree.rewrite(b"\0")1 == Status.OVERRUN
-
-
-def test_overruns_if_prefix():
-    runner = ConjectureRunner(
-        lambda data: data.draw_bits(1) for _ in range(2),
-        settings=TEST_SETTINGS,
-        random=Random(0),
-    )
-    runner.cached_test_function(b"\0\0")
-    assert runner.tree.rewrite(b"\0")1 == Status.OVERRUN
-
-
-def test_stores_the_tree_flat_until_needed():
-    @runner_for(bytes(10))
-    def runner(data):
-        for _ in range(10):
-            data.draw_bits(1)
-        data.mark_interesting()
-
-    root = runner.tree.root
-    assert len(root.bit_lengths) == 10
-    assert len(root.values) == 10
-    assert root.transition.status == Status.INTERESTING
-
-
-def test_split_in_the_middle():
-    @runner_for(0, 0, 2, 0, 1, 3)
-    def runner(data):
-        data.draw_bits(1)
-        data.draw_bits(1)
-        data.draw_bits(4)
-        data.mark_interesting()
-
-    root = runner.tree.root
-    assert len(root.bit_lengths) == len(root.values) == 1
-    assert list(root.transition.children0.values) == 2
-    assert list(root.transition.children1.values) == 3
-
-
-def test_stores_forced_nodes():
-    @runner_for(bytes(3))
-    def runner(data):
-        data.draw_bits(1, forced=0)
-        data.draw_bits(1)
-        data.draw_bits(1, forced=0)
-        data.mark_interesting()
-
-    root = runner.tree.root
-    assert root.forced == {0, 2}
-
-
-def test_correctly_relocates_forced_nodes():
-    @runner_for(0, 0, 1, 0)
-    def runner(data):
-        data.draw_bits(1)
-        data.draw_bits(1, forced=0)
-        data.mark_interesting()
-
-    root = runner.tree.root
-    assert root.transition.children1.forced == {0}
-    assert root.transition.children0.forced == {0}
-
-
-def test_can_go_from_interesting_to_valid():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"", observer=tree.new_observer())
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"", observer=tree.new_observer())
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.VALID)
-
-
-def test_going_from_interesting_to_invalid_is_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"", observer=tree.new_observer())
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"", observer=tree.new_observer())
-    with pytest.raises(Flaky):
-        data.conclude_test(Status.INVALID)
-
-
-def test_concluding_at_prefix_is_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    data.draw_bits(1)
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"", observer=tree.new_observer())
-    with pytest.raises(Flaky):
-        data.conclude_test(Status.INVALID)
-
-
-def test_concluding_with_overrun_at_prefix_is_not_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    data.draw_bits(1)
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"", observer=tree.new_observer())
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.OVERRUN)
-
-
-def test_changing_n_bits_is_flaky_in_prefix():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    data.draw_bits(1)
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    with pytest.raises(Flaky):
-        data.draw_bits(2)
-
-
-def test_changing_n_bits_is_flaky_in_branch():
-    tree = DataTree()
-
-    for i in 0, 1:
-        data = ConjectureData.for_buffer(i, observer=tree.new_observer())
-        data.draw_bits(1)
-        with pytest.raises(StopTest):
-            data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    with pytest.raises(Flaky):
-        data.draw_bits(2)
-
-
-def test_extending_past_conclusion_is_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    data.draw_bits(1)
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"\1\0", observer=tree.new_observer())
-    data.draw_bits(1)
-
-    with pytest.raises(Flaky):
-        data.draw_bits(1)
-
-
-def test_changing_to_forced_is_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    data.draw_bits(1)
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"\1\0", observer=tree.new_observer())
-
-    with pytest.raises(Flaky):
-        data.draw_bits(1, forced=0)
-
-
-def test_changing_value_of_forced_is_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(b"\1", observer=tree.new_observer())
-    data.draw_bits(1, forced=1)
-    with pytest.raises(StopTest):
-        data.conclude_test(Status.INTERESTING)
-
-    data = ConjectureData.for_buffer(b"\1\0", observer=tree.new_observer())
-
-    with pytest.raises(Flaky):
-        data.draw_bits(1, forced=0)
-
-
-def test_does_not_truncate_if_unseen():
-    tree = DataTree()
-    b = bytes(1, 2, 3, 4)
-    assert tree.rewrite(b) == (b, None)
-
-
-def test_truncates_if_seen():
-    tree = DataTree()
-
-    b = bytes(1, 2, 3, 4)
-
-    data = ConjectureData.for_buffer(b, observer=tree.new_observer())
-    data.draw_bits(8)
-    data.draw_bits(8)
-    data.freeze()
-
-    assert tree.rewrite(b) == (b:2, Status.VALID)
-
-
-def test_child_becomes_exhausted_after_split():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(0, 0, observer=tree.new_observer())
-    data.draw_bits(8)
-    data.draw_bits(8, forced=0)
-    data.freeze()
-
-    data = ConjectureData.for_buffer(1, 0, observer=tree.new_observer())
-    data.draw_bits(8)
-    data.draw_bits(8)
-    data.freeze()
-
-    assert not tree.is_exhausted
-    assert tree.root.transition.children0.is_exhausted
-
-
-def test_will_generate_novel_prefix_to_avoid_exhausted_branches():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(1, observer=tree.new_observer())
-    data.draw_bits(1)
-    data.freeze()
-
-    data = ConjectureData.for_buffer(0, 1, observer=tree.new_observer())
-    data.draw_bits(1)
-    data.draw_bits(8)
-    data.freeze()
-
-    prefix = list(tree.generate_novel_prefix(Random(0)))
-
-    assert len(prefix) == 2
-    assert prefix0 == 0
-
-
-def test_will_mark_changes_in_discard_as_flaky():
-    tree = DataTree()
-    data = ConjectureData.for_buffer(1, 1, observer=tree.new_observer())
-    data.start_example(10)
-    data.draw_bits(1)
-    data.stop_example()
-    data.draw_bits(1)
-    data.freeze()
-
-    data = ConjectureData.for_buffer(1, 1, observer=tree.new_observer())
-    data.start_example(10)
-    data.draw_bits(1)
-
-    with pytest.raises(Flaky):
-        data.stop_example(discard=True)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_dfa.py Deleted

@@ -1,199 +0,0 @@
-# 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 itertools
-import math
-from math import inf
-
-import pytest
-
-from hypothesis import assume, example, given, note, reject, settings, strategies as st
-from hypothesis.internal.conjecture.dfa import DEAD, ConcreteDFA
-
-
-def test_enumeration_when_sizes_do_not_agree():
-    dfa = ConcreteDFA({0: 1, 1: 2}, {}, {1: 3}, {}, {1, 3})  # 0  # 1  # 2  # 3
-
-    assert list(dfa.all_matching_strings()) == b"\0", b"\1\1"
-
-
-def test_enumeration_of_very_long_strings():
-    """This test is mainly testing that it terminates. If we were
-    to use a naive breadth first search for this it would take
-    forever to run because it would run in time roughly 256 ** 50.
-    """
-    size = 50
-    dfa = ConcreteDFA(
-        {c: n + 1 for c in range(256)} for n in range(100) + {}, {size}
-    )
-
-    for i, s in enumerate(dfa.all_matching_strings()):
-        assert len(s) == size
-        assert int.from_bytes(s, "big") == i
-        if i >= 1000:
-            break
-
-
-def test_is_dead_with_cache_reuse():
-    dfa = ConcreteDFA({0: i + 1, 1: 11} for i in range(10) + {}, {}, {10})
-    for n in range(10, -1, -1):
-        assert not dfa.is_dead(n)
-
-
-def test_max_length_of_empty_dfa_is_zero():
-    dfa = ConcreteDFA({}, {0})
-    assert dfa.max_length(dfa.start) == 0
-
-
-def test_mixed_dfa_initialization():
-    d = ConcreteDFA((2, 1), (0, 5, 2), {4: 0, 3: 1}, {0})
-
-    assert d.transition(0, 2) == 1
-    assert d.transition(0, 3) == DEAD
-
-    for n in range(6):
-        assert d.transition(1, n) == 2
-    assert d.transition(1, 6) == DEAD
-
-    assert d.transition(2, 4) == 0
-    assert d.transition(2, 3) == 1
-    assert d.transition(2, 5) == DEAD
-
-
-@st.composite
-def dfas(draw):
-    states = draw(st.integers(1, 20))
-
-    a_state = st.integers(0, states - 1)
-    a_byte = st.integers(0, 255)
-
-    start = draw(a_state)
-    accepting = draw(st.sets(a_state, min_size=1))
-
-    transitions = draw(st.dictionaries(a_byte, a_state)) for _ in range(states)
-
-    return ConcreteDFA(transitions, accepting, start)
-
-
-@settings(max_examples=20)
-@given(dfas(), st.booleans())
-@example(
-    ConcreteDFA(
-        transitions=(0, 2), (1, 255, 1), (0, 2), (1, 255, 0), ,
-        accepting={2},
-    ),
-    False,
-)
-def test_canonicalised_matches_same_strings(dfa, via_repr):
-    canon = dfa.canonicalise()
-    note(canon)
-
-    if via_repr:
-        canon = eval(repr(canon))
-
-    assert dfa.max_length(dfa.start) == canon.max_length(canon.start)
-
-    try:
-        minimal = next(dfa.all_matching_strings())
-    except StopIteration:
-        reject()
-
-    assert minimal == next(canon.all_matching_strings())
-
-    assert dfa.count_strings(dfa.start, len(minimal)) == canon.count_strings(
-        canon.start, len(minimal)
-    )
-
-
-@settings(max_examples=20)
-@given(dfas())
-def test_has_string_of_max_length(dfa):
-    length = dfa.max_length(dfa.start)
-    assume(math.isfinite(length))
-    assume(not dfa.is_dead(dfa.start))
-
-    assert dfa.count_strings(dfa.start, length) > 0
-
-
-def test_converts_long_tables_to_dicts():
-    dfa = ConcreteDFA(
-        (0, 0), (1, 1), (2, 2), (3, 1), (4, 0), (7, 10, 1), (0, 0), , {2}
-    )
-    assert dfa.transition(0, 2) == 2
-    assert dfa.transition(1, 0) == 0
-
-    assert isinstance(dfa._ConcreteDFA__transitions0, dict)
-    assert isinstance(dfa._ConcreteDFA__transitions1, list)
-
-
-@settings(max_examples=20)
-@given(dfas(), dfas())
-def test_dfa_with_different_string_is_not_equivalent(x, y):
-    assume(not x.is_dead(x.start))
-
-    s = next(x.all_matching_strings())
-    assume(not y.matches(s))
-
-    assert not x.equivalent(y)
-
-
-@example(x=b"", y=b"\0", z=b"\0")
-@given(x=st.binary(), y=st.binary(min_size=1), z=st.binary())
-def test_all_matching_regions_include_all_matches(x, y, z):
-    y_matcher = ConcreteDFA({c: i + 1} for i, c in enumerate(y) + , {len(y)})
-    assert y_matcher.matches(y)
-
-    s = x + y + z
-
-    assert (len(x), len(x) + len(y)) in y_matcher.all_matching_regions(s)
-
-
-@pytest.mark.parametrize("n", 1, 10, 100, 1000)
-def test_max_length_of_long_dfa(n):
-    dfa = ConcreteDFA({0: i + 1} for i in range(n) + {}, {n})
-    assert not dfa.is_dead(dfa.start)
-    assert dfa.max_length(dfa.start) == n
-
-
-def test_dfa_with_cached_dead():
-    dfa = ConcreteDFA({0: 1, 1: 2}, , , {2})
-
-    assert dfa.is_dead(1)
-    assert dfa.is_dead(0)
-
-
-@pytest.mark.parametrize("order", itertools.permutations((0, 1, 2)))
-def test_dead_nodes(order):
-    dfa = ConcreteDFA({0: 1, 1: 2}, {}, {}, {2})
-    for i in order:
-        assert dfa.is_dead(i) == (i == 1)
-
-
-@given(st.permutations(range(5)))
-def test_max_length_of_recursive_dfa(order):
-    dfa = ConcreteDFA({0: 1, 1: 2, 2: 3}, {0: 2}, {0: 1}, {0: 0, 1: 4}, {}, {4})
-    for i in order:
-        dfa.max_length(i)
-
-    assert dfa.max_length(0) == inf
-    assert dfa.max_length(1) == 0
-    assert dfa.max_length(2) == 0
-    assert dfa.max_length(3) == inf
-    assert dfa.max_length(4) == 0
-
-
-def test_transitions_out_of_dead_are_empty():
-    dfa = ConcreteDFA({}, {0})
-    assert list(dfa.raw_transitions(DEAD)) == 
-
-
-def test_can_transition_from_dead():
-    dfa = ConcreteDFA({}, {0})
-    assert dfa.transition(DEAD, 0) == DEAD

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_engine.py Deleted

@@ -1,1589 +0,0 @@
-# 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 re
-import time
-from random import Random
-from unittest.mock import Mock
-
-import pytest
-
-from hypothesis import HealthCheck, Phase, Verbosity, settings
-from hypothesis.database import ExampleDatabase, InMemoryExampleDatabase
-from hypothesis.errors import FailedHealthCheck, Flaky
-from hypothesis.internal.compat import int_from_bytes
-from hypothesis.internal.conjecture import engine as engine_module
-from hypothesis.internal.conjecture.data import ConjectureData, Overrun, Status
-from hypothesis.internal.conjecture.engine import (
-    MIN_TEST_CALLS,
-    ConjectureRunner,
-    ExitReason,
-    RunIsComplete,
-)
-from hypothesis.internal.conjecture.pareto import DominanceRelation, dominance
-from hypothesis.internal.conjecture.shrinker import Shrinker, block_program
-from hypothesis.internal.conjecture.utils import integer_range
-from hypothesis.internal.entropy import deterministic_PRNG
-
-from tests.common.strategies import SLOW, HardToShrink
-from tests.common.utils import no_shrink
-from tests.conjecture.common import (
-    SOME_LABEL,
-    TEST_SETTINGS,
-    buffer_size_limit,
-    run_to_buffer,
-    run_to_data,
-    shrinking_from,
-)
-
-
-def test_can_index_results():
-    @run_to_buffer
-    def f(data):
-        data.draw_bytes(5)
-        data.mark_interesting()
-
-    assert f.index(0) == 0
-    assert f.count(0) == 5
-
-
-def test_non_cloneable_intervals():
-    @run_to_buffer
-    def x(data):
-        data.draw_bytes(10)
-        data.draw_bytes(9)
-        data.mark_interesting()
-
-    assert x == bytes(19)
-
-
-def test_deletable_draws():
-    @run_to_buffer
-    def x(data):
-        while True:
-            x = data.draw_bytes(2)
-            if x0 == 255:
-                data.mark_interesting()
-
-    assert x == bytes(255, 0)
-
-
-def zero_dist(random, n):
-    return bytes(n)
-
-
-def test_can_load_data_from_a_corpus():
-    key = b"hi there"
-    db = ExampleDatabase()
-    value = b"=\xc3\xe4l\x81\xe1\xc2H\xc9\xfb\x1a\xb6bM\xa8\x7f"
-    db.save(key, value)
-
-    def f(data):
-        if data.draw_bytes(len(value)) == value:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(f, settings=settings(database=db), database_key=key)
-    runner.run()
-    (last_data,) = runner.interesting_examples.values()
-    assert last_data.buffer == value
-    assert len(list(db.fetch(key))) == 1
-
-
-def slow_shrinker():
-    strat = HardToShrink()
-
-    def accept(data):
-        if data.draw(strat):
-            data.mark_interesting()
-
-    return accept
-
-
-@pytest.mark.parametrize("n", 1, 5)
-def test_terminates_shrinks(n, monkeypatch):
-    db = InMemoryExampleDatabase()
-
-    def generate_new_examples(self):
-        self.cached_test_function(255 * 1000)
-
-    monkeypatch.setattr(
-        ConjectureRunner, "generate_new_examples", generate_new_examples
-    )
-    monkeypatch.setattr(engine_module, "MAX_SHRINKS", n)
-
-    runner = ConjectureRunner(
-        slow_shrinker(),
-        settings=settings(max_examples=5000, database=db),
-        random=Random(0),
-        database_key=b"key",
-    )
-    runner.run()
-    (last_data,) = runner.interesting_examples.values()
-    assert last_data.status == Status.INTERESTING
-    assert runner.shrinks == n
-    in_db = set(db.datarunner.secondary_key)
-    assert len(in_db) == n
-
-
-def test_detects_flakiness():
-    failed_once = False
-    count = 0
-
-    def tf(data):
-        data.draw_bytes(1)
-        count0 += 1
-        if not failed_once0:
-            failed_once0 = True
-            data.mark_interesting()
-
-    runner = ConjectureRunner(tf)
-    runner.run()
-    assert runner.exit_reason == ExitReason.flaky
-    assert count == MIN_TEST_CALLS + 1
-
-
-def recur(i, data):
-    if i >= 1:
-        recur(i - 1, data)
-
-
-def test_recursion_error_is_not_flaky():
-    def tf(data):
-        i = data.draw_bits(16)
-        try:
-            recur(i, data)
-        except RecursionError:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(tf)
-    runner.run()
-    assert runner.exit_reason == ExitReason.finished
-
-
-def test_variadic_draw():
-    def draw_list(data):
-        result = 
-        while True:
-            data.start_example(SOME_LABEL)
-            d = data.draw_bytes(1)0 & 7
-            if d:
-                result.append(data.draw_bytes(d))
-            data.stop_example()
-            if not d:
-                break
-        return result
-
-    @run_to_buffer
-    def b(data):
-        if any(all(d) for d in draw_list(data)):
-            data.mark_interesting()
-
-    ls = draw_list(ConjectureData.for_buffer(b))
-    assert len(ls) == 1
-    assert len(ls0) == 1
-
-
-def test_draw_to_overrun():
-    @run_to_buffer
-    def x(data):
-        d = (data.draw_bytes(1)0 - 8) & 0xFF
-        data.draw_bytes(128 * d)
-        if d >= 2:
-            data.mark_interesting()
-
-    assert x == bytes(10) + bytes(128 * 2)
-
-
-def test_can_navigate_to_a_valid_example():
-    def f(data):
-        i = int_from_bytes(data.draw_bytes(2))
-        data.draw_bytes(i)
-        data.mark_interesting()
-
-    runner = ConjectureRunner(f, settings=settings(max_examples=5000, database=None))
-    with buffer_size_limit(2):
-        runner.run()
-    assert runner.interesting_examples
-
-
-def test_stops_after_max_examples_when_reading():
-    key = b"key"
-
-    db = ExampleDatabase(":memory:")
-    for i in range(10):
-        db.save(key, bytes(i))
-
-    seen = 
-
-    def f(data):
-        seen.append(data.draw_bytes(1))
-
-    runner = ConjectureRunner(
-        f, settings=settings(max_examples=1, database=db), database_key=key
-    )
-    runner.run()
-    assert len(seen) == 1
-
-
-def test_stops_after_max_examples_when_generating():
-    seen = 
-
-    def f(data):
-        seen.append(data.draw_bytes(1))
-
-    runner = ConjectureRunner(f, settings=settings(max_examples=1, database=None))
-    runner.run()
-    assert len(seen) == 1
-
-
-@pytest.mark.parametrize("examples", 1, 5, 20, 50)
-def test_stops_after_max_examples_when_generating_more_bugs(examples):
-    seen = 
-    bad = False, False
-
-    def f(data):
-        seen.append(data.draw_bits(32))
-        # Rare, potentially multi-error conditions
-        if seen-1 > 2**31:
-            bad0 = True
-            raise ValueError
-        bad1 = True
-        raise Exception
-
-    runner = ConjectureRunner(
-        f, settings=settings(max_examples=examples, phases=Phase.generate)
-    )
-    try:
-        runner.run()
-    except Exception:
-        pass
-    # No matter what, whether examples is larger or smalller than MAX_TEST_CALLS,
-    # we stop looking at max_examples.  (and re-run each failure for the traceback)
-    assert len(seen) <= examples + sum(bad)
-
-
-def test_interleaving_engines():
-    children = 
-
-    @run_to_buffer
-    def x(data):
-        rnd = Random(data.draw_bytes(1))
-
-        def g(d2):
-            d2.draw_bytes(1)
-            data.mark_interesting()
-
-        runner = ConjectureRunner(g, random=rnd)
-        children.append(runner)
-        runner.run()
-        if runner.interesting_examples:
-            data.mark_interesting()
-
-    assert x == b"\0"
-    for c in children:
-        assert not c.interesting_examples
-
-
-def test_phases_can_disable_shrinking():
-    seen = set()
-
-    def f(data):
-        seen.add(bytes(data.draw_bytes(32)))
-        data.mark_interesting()
-
-    runner = ConjectureRunner(
-        f, settings=settings(database=None, phases=(Phase.reuse, Phase.generate))
-    )
-    runner.run()
-    assert len(seen) == 1
-
-
-def test_reuse_phase_runs_for_max_examples_if_generation_is_disabled():
-    with deterministic_PRNG():
-        db = InMemoryExampleDatabase()
-        for i in range(256):
-            db.save(b"key", bytes(i))
-        seen = set()
-
-        def test(data):
-            seen.add(data.draw_bits(8))
-
-        ConjectureRunner(
-            test,
-            settings=settings(max_examples=100, database=db, phases=Phase.reuse),
-            database_key=b"key",
-        ).run()
-
-        assert len(seen) == 100
-
-
-def test_erratic_draws():
-    n = 0
-
-    with pytest.raises(Flaky):
-
-        @run_to_buffer
-        def x(data):
-            data.draw_bytes(n0)
-            data.draw_bytes(255 - n0)
-            if n0 == 255:
-                data.mark_interesting()
-            else:
-                n0 += 1
-
-
-def test_no_read_no_shrink():
-    count = 0
-
-    @run_to_buffer
-    def x(data):
-        count0 += 1
-        data.mark_interesting()
-
-    assert x == b""
-    assert count == 1
-
-
-def test_one_dead_branch():
-    with deterministic_PRNG():
-        seen = set()
-
-        @run_to_buffer
-        def x(data):
-            i = data.draw_bytes(1)0
-            if i > 0:
-                data.mark_invalid()
-            i = data.draw_bytes(1)0
-            if len(seen) < 255:
-                seen.add(i)
-            elif i not in seen:
-                data.mark_interesting()
-
-
-def test_does_not_save_on_interrupt():
-    def interrupts(data):
-        raise KeyboardInterrupt()
-
-    db = InMemoryExampleDatabase()
-
-    runner = ConjectureRunner(
-        interrupts, settings=settings(database=db), database_key=b"key"
-    )
-
-    with pytest.raises(KeyboardInterrupt):
-        runner.run()
-    assert not db.data
-
-
-def test_returns_written():
-    value = b"\0\1\2\3"
-
-    @run_to_buffer
-    def written(data):
-        data.write(value)
-        data.mark_interesting()
-
-    assert value == written
-
-
-def fails_health_check(label, **kwargs):
-    def accept(f):
-        runner = ConjectureRunner(
-            f,
-            settings=settings(
-                max_examples=100, phases=no_shrink, database=None, **kwargs
-            ),
-        )
-
-        with pytest.raises(FailedHealthCheck) as e:
-            runner.run()
-        assert e.value.health_check == label
-        assert not runner.interesting_examples
-
-    return accept
-
-
-def test_fails_health_check_for_all_invalid():
-    @fails_health_check(HealthCheck.filter_too_much)
-    def _(data):
-        data.draw_bytes(2)
-        data.mark_invalid()
-
-
-def test_fails_health_check_for_large_base():
-    @fails_health_check(HealthCheck.large_base_example)
-    def _(data):
-        data.draw_bytes(10**6)
-
-
-def test_fails_health_check_for_large_non_base():
-    @fails_health_check(HealthCheck.data_too_large)
-    def _(data):
-        if data.draw_bits(8):
-            data.draw_bytes(10**6)
-
-
-def test_fails_health_check_for_slow_draws():
-    @fails_health_check(HealthCheck.too_slow)
-    def _(data):
-        data.draw(SLOW)
-
-
-@pytest.mark.parametrize("n_large", 1, 5, 8, 15)
-def test_can_shrink_variable_draws(n_large):
-    target = 128 * n_large
-
-    @run_to_data
-    def data(data):
-        n = data.draw_bits(4)
-        b = data.draw_bits(8) for _ in range(n)
-        if sum(b) >= target:
-            data.mark_interesting()
-
-    x = data.buffer
-
-    assert x.count(0) == 0
-    assert sum(x1:) == target
-
-
-def test_run_nothing():
-    def f(data):
-        raise AssertionError
-
-    runner = ConjectureRunner(f, settings=settings(phases=()))
-    runner.run()
-    assert runner.call_count == 0
-
-
-class Foo:
-    def __repr__(self):
-        return "stuff"
-
-
-def test_debug_data(capsys):
-    buf = 0, 1, 2
-
-    def f(data):
-        for x in bytes(buf):
-            if data.draw_bits(8) != x:
-                data.mark_invalid()
-            data.start_example(1)
-            data.stop_example()
-        data.mark_interesting()
-
-    runner = ConjectureRunner(
-        f,
-        settings=settings(
-            max_examples=5000,
-            database=None,
-            suppress_health_check=HealthCheck.all(),
-            verbosity=Verbosity.debug,
-        ),
-    )
-    runner.cached_test_function(buf)
-    runner.run()
-
-    out, _ = capsys.readouterr()
-    assert re.match("\\d+ bytes \\.*\\ -> ", out)
-    assert "INTERESTING" in out
-
-
-def test_can_write_bytes_towards_the_end():
-    buf = b"\1\2\3"
-
-    def f(data):
-        if data.draw_bits(1):
-            data.draw_bytes(5)
-            data.write(bytes(buf))
-            assert bytes(data.buffer-len(buf) :) == buf
-
-    with buffer_size_limit(10):
-        ConjectureRunner(f).run()
-
-
-def test_uniqueness_is_preserved_when_writing_at_beginning():
-    seen = set()
-
-    def f(data):
-        data.write(bytes(1))
-        n = data.draw_bits(3)
-        assert n not in seen
-        seen.add(n)
-
-    runner = ConjectureRunner(f, settings=settings(max_examples=50))
-    runner.run()
-    assert runner.valid_examples == len(seen)
-
-
-@pytest.mark.parametrize("skip_target", False, True)
-@pytest.mark.parametrize("initial_attempt", 127, 128)
-def test_clears_out_its_database_on_shrinking(
-    initial_attempt, skip_target, monkeypatch
-):
-    def generate_new_examples(self):
-        self.cached_test_function(initial_attempt)
-
-    monkeypatch.setattr(
-        ConjectureRunner, "generate_new_examples", generate_new_examples
-    )
-
-    key = b"key"
-    db = InMemoryExampleDatabase()
-
-    def f(data):
-        if data.draw_bits(8) >= 127:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        f,
-        settings=settings(database=db, max_examples=256),
-        database_key=key,
-        random=Random(0),
-    )
-
-    for n in range(256):
-        if n != 127 or not skip_target:
-            db.save(runner.secondary_key, bytes(n))
-    runner.run()
-    assert len(runner.interesting_examples) == 1
-    for b in db.fetch(runner.secondary_key):
-        assert b0 >= 127
-    assert len(list(db.fetch(runner.database_key))) == 1
-
-
-def test_detects_too_small_block_starts():
-    call_count = 0
-
-    def f(data):
-        assert call_count0 == 0
-        call_count0 += 1
-        data.draw_bytes(8)
-        data.mark_interesting()
-
-    runner = ConjectureRunner(f, settings=settings(database=None))
-    r = runner.cached_test_function(bytes(8))
-    assert r.status == Status.INTERESTING
-    assert call_count0 == 1
-    r2 = runner.cached_test_function(bytes(255 * 7))
-    assert r2.status == Status.OVERRUN
-    assert call_count0 == 1
-
-
-def test_shrinks_both_interesting_examples(monkeypatch):
-    def generate_new_examples(self):
-        self.cached_test_function(bytes(1))
-
-    monkeypatch.setattr(
-        ConjectureRunner, "generate_new_examples", generate_new_examples
-    )
-
-    def f(data):
-        n = data.draw_bits(8)
-        data.mark_interesting(n & 1)
-
-    runner = ConjectureRunner(f, database_key=b"key")
-    runner.run()
-    assert runner.interesting_examples0.buffer == bytes(0)
-    assert runner.interesting_examples1.buffer == bytes(1)
-
-
-def test_discarding(monkeypatch):
-    monkeypatch.setattr(Shrinker, "shrink", Shrinker.remove_discarded)
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function(bytes(0, 1 * 10)),
-    )
-
-    @run_to_buffer
-    def x(data):
-        count = 0
-        while count < 10:
-            data.start_example(SOME_LABEL)
-            b = data.draw_bits(1)
-            if b:
-                count += 1
-            data.stop_example(discard=not b)
-        data.mark_interesting()
-
-    assert x == bytes(bytes(1) * 10)
-
-
-def test_can_remove_discarded_data():
-    @shrinking_from(bytes(0 * 10 + 11))
-    def shrinker(data):
-        while True:
-            data.start_example(SOME_LABEL)
-            b = data.draw_bits(8)
-            data.stop_example(discard=(b == 0))
-            if b == 11:
-                break
-        data.mark_interesting()
-
-    shrinker.remove_discarded()
-    assert list(shrinker.buffer) == 11
-
-
-def test_discarding_iterates_to_fixed_point():
-    @shrinking_from(bytes(list(range(100, -1, -1))))
-    def shrinker(data):
-        data.start_example(0)
-        data.draw_bits(8)
-        data.stop_example(discard=True)
-        while data.draw_bits(8):
-            pass
-        data.mark_interesting()
-
-    shrinker.remove_discarded()
-    assert list(shrinker.buffer) == 1, 0
-
-
-def test_discarding_is_not_fooled_by_empty_discards():
-    @shrinking_from(bytes(1, 1))
-    def shrinker(data):
-        data.draw_bits(1)
-        data.start_example(0)
-        data.stop_example(discard=True)
-        data.draw_bits(1)
-        data.mark_interesting()
-
-    shrinker.remove_discarded()
-    assert shrinker.shrink_target.has_discards
-
-
-def test_discarding_can_fail(monkeypatch):
-    @shrinking_from(bytes(1))
-    def shrinker(data):
-        data.start_example(0)
-        data.draw_bits(1)
-        data.stop_example(discard=True)
-        data.mark_interesting()
-
-    shrinker.remove_discarded()
-    assert any(e.discarded and e.length > 0 for e in shrinker.shrink_target.examples)
-
-
-def test_shrinking_from_mostly_zero(monkeypatch):
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda self: self.cached_test_function(bytes(5) + bytes(2)),
-    )
-
-    @run_to_buffer
-    def x(data):
-        s = data.draw_bits(8) for _ in range(6)
-        if any(s):
-            data.mark_interesting()
-
-    assert x == bytes(5) + bytes(1)
-
-
-def test_handles_nesting_of_discard_correctly(monkeypatch):
-    monkeypatch.setattr(Shrinker, "shrink", Shrinker.remove_discarded)
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function(bytes(0, 0, 1, 1)),
-    )
-
-    @run_to_buffer
-    def x(data):
-        while True:
-            data.start_example(SOME_LABEL)
-            succeeded = data.draw_bits(1)
-            data.start_example(SOME_LABEL)
-            data.draw_bits(1)
-            data.stop_example(discard=not succeeded)
-            data.stop_example(discard=not succeeded)
-            if succeeded:
-                data.mark_interesting()
-
-    assert x == bytes(1, 1)
-
-
-def test_database_clears_secondary_key():
-    key = b"key"
-    database = InMemoryExampleDatabase()
-
-    def f(data):
-        if data.draw_bits(8) == 10:
-            data.mark_interesting()
-        else:
-            data.mark_invalid()
-
-    runner = ConjectureRunner(
-        f,
-        settings=settings(
-            max_examples=1, database=database, suppress_health_check=HealthCheck.all()
-        ),
-        database_key=key,
-    )
-
-    for i in range(10):
-        database.save(runner.secondary_key, bytes(i))
-
-    runner.cached_test_function(10)
-    assert runner.interesting_examples
-
-    assert len(set(database.fetch(key))) == 1
-    assert len(set(database.fetch(runner.secondary_key))) == 10
-
-    runner.clear_secondary_key()
-
-    assert len(set(database.fetch(key))) == 1
-    assert len(set(database.fetch(runner.secondary_key))) == 0
-
-
-def test_database_uses_values_from_secondary_key():
-    key = b"key"
-    database = InMemoryExampleDatabase()
-
-    def f(data):
-        if data.draw_bits(8) >= 5:
-            data.mark_interesting()
-        else:
-            data.mark_invalid()
-
-    runner = ConjectureRunner(
-        f,
-        settings=settings(
-            max_examples=1, database=database, suppress_health_check=HealthCheck.all()
-        ),
-        database_key=key,
-    )
-
-    for i in range(10):
-        database.save(runner.secondary_key, bytes(i))
-
-    runner.cached_test_function(10)
-    assert runner.interesting_examples
-
-    assert len(set(database.fetch(key))) == 1
-    assert len(set(database.fetch(runner.secondary_key))) == 10
-
-    runner.clear_secondary_key()
-
-    assert len(set(database.fetch(key))) == 1
-    assert set(map(int_from_bytes, database.fetch(runner.secondary_key))) == set(
-        range(6, 11)
-    )
-
-    (v,) = runner.interesting_examples.values()
-
-    assert list(v.buffer) == 5
-
-
-def test_exit_because_max_iterations():
-    def f(data):
-        data.draw_bits(64)
-        data.mark_invalid()
-
-    runner = ConjectureRunner(
-        f,
-        settings=settings(
-            max_examples=1, database=None, suppress_health_check=HealthCheck.all()
-        ),
-    )
-
-    runner.run()
-
-    assert runner.call_count <= 1000
-    assert runner.exit_reason == ExitReason.max_iterations
-
-
-def test_exit_because_shrink_phase_timeout(monkeypatch):
-    val = 0
-
-    def fast_time():
-        val0 += 1000
-        return val0
-
-    def f(data):
-        if data.draw_bits(64) > 2**33:
-            data.mark_interesting()
-
-    monkeypatch.setattr(time, "perf_counter", fast_time)
-    runner = ConjectureRunner(f, settings=settings(database=None))
-    runner.run()
-    assert runner.exit_reason == ExitReason.very_slow_shrinking
-    assert runner.statistics"stopped-because" == "shrinking was very slow"
-
-
-def test_dependent_block_pairs_can_lower_to_zero():
-    @shrinking_from(1, 0, 1)
-    def shrinker(data):
-        if data.draw_bits(1):
-            n = data.draw_bits(16)
-        else:
-            n = data.draw_bits(8)
-
-        if n == 1:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-    assert list(shrinker.shrink_target.buffer) == 0, 1
-
-
-def test_handle_size_too_large_during_dependent_lowering():
-    @shrinking_from(1, 255, 0)
-    def shrinker(data):
-        if data.draw_bits(1):
-            data.draw_bits(16)
-            data.mark_interesting()
-        else:
-            data.draw_bits(8)
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-
-
-def test_block_may_grow_during_lexical_shrinking():
-    initial = bytes(2, 1, 1)
-
-    @shrinking_from(initial)
-    def shrinker(data):
-        n = data.draw_bits(8)
-        if n == 2:
-            data.draw_bits(8)
-            data.draw_bits(8)
-        else:
-            data.draw_bits(16)
-        data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-    assert list(shrinker.shrink_target.buffer) == 0, 0, 0
-
-
-def test_lower_common_block_offset_does_nothing_when_changed_blocks_are_zero():
-    @shrinking_from(1, 0, 1, 0)
-    def shrinker(data):
-        data.draw_bits(1)
-        data.draw_bits(1)
-        data.draw_bits(1)
-        data.draw_bits(1)
-        data.mark_interesting()
-
-    shrinker.mark_changed(1)
-    shrinker.mark_changed(3)
-    shrinker.lower_common_block_offset()
-    assert list(shrinker.shrink_target.buffer) == 1, 0, 1, 0
-
-
-def test_lower_common_block_offset_ignores_zeros():
-    @shrinking_from(2, 2, 0)
-    def shrinker(data):
-        n = data.draw_bits(8)
-        data.draw_bits(8)
-        data.draw_bits(8)
-        if n > 0:
-            data.mark_interesting()
-
-    for i in range(3):
-        shrinker.mark_changed(i)
-    shrinker.lower_common_block_offset()
-    assert list(shrinker.shrink_target.buffer) == 1, 1, 0
-
-
-def test_pandas_hack():
-    @shrinking_from(2, 1, 1, 7)
-    def shrinker(data):
-        n = data.draw_bits(8)
-        m = data.draw_bits(8)
-        if n == 1:
-            if m == 7:
-                data.mark_interesting()
-        data.draw_bits(8)
-        if data.draw_bits(8) == 7:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes(block_program("-XX"))
-    assert list(shrinker.shrink_target.buffer) == 1, 7
-
-
-def test_cached_test_function_returns_right_value():
-    count = 0
-
-    def tf(data):
-        count0 += 1
-        data.draw_bits(2)
-        data.mark_interesting()
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(tf, settings=TEST_SETTINGS)
-        for _ in range(2):
-            for b in (b"\0", b"\1"):
-                d = runner.cached_test_function(b)
-                assert d.status == Status.INTERESTING
-                assert d.buffer == b
-        assert count0 == 2
-
-
-def test_cached_test_function_does_not_reinvoke_on_prefix():
-    call_count = 0
-
-    def test_function(data):
-        call_count0 += 1
-        data.draw_bits(8)
-        data.write(bytes(7))
-        data.draw_bits(8)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test_function, settings=TEST_SETTINGS)
-
-        data = runner.cached_test_function(bytes(3))
-        assert data.status == Status.VALID
-        for n in 2, 1, 0:
-            prefix_data = runner.cached_test_function(bytes(n))
-            assert prefix_data is Overrun
-        assert call_count0 == 1
-
-
-def test_will_evict_entries_from_the_cache(monkeypatch):
-    monkeypatch.setattr(engine_module, "CACHE_SIZE", 5)
-    count = 0
-
-    def tf(data):
-        data.draw_bytes(1)
-        count0 += 1
-
-    runner = ConjectureRunner(tf, settings=TEST_SETTINGS)
-
-    for _ in range(3):
-        for n in range(10):
-            runner.cached_test_function(n)
-
-    # Because we exceeded the cache size, our previous
-    # calls will have been evicted, so each call to
-    # cached_test_function will have to reexecute.
-    assert count0 == 30
-
-
-def test_branch_ending_in_write():
-    seen = set()
-
-    def tf(data):
-        count = 0
-        while data.draw_bits(1):
-            count += 1
-
-        if count > 1:
-            data.draw_bits(1, forced=0)
-
-        b = bytes(data.buffer)
-        assert b not in seen
-        seen.add(b)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(tf, settings=TEST_SETTINGS)
-
-        for _ in range(100):
-            prefix = runner.generate_novel_prefix()
-            attempt = prefix + bytes(2)
-            data = runner.cached_test_function(attempt)
-            assert data.status == Status.VALID
-            assert attempt.startswith(data.buffer)
-
-
-def test_exhaust_space():
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            lambda data: data.draw_bits(1), settings=TEST_SETTINGS
-        )
-        runner.run()
-        assert runner.tree.is_exhausted
-        assert runner.valid_examples == 2
-
-
-SMALL_COUNT_SETTINGS = settings(TEST_SETTINGS, max_examples=500)
-
-
-def test_discards_kill_branches():
-    starts = set()
-
-    with deterministic_PRNG():
-
-        def test(data):
-            assert runner.call_count <= 256
-            while True:
-                data.start_example(1)
-                b = data.draw_bits(8)
-                data.stop_example(b != 0)
-                if len(data.buffer) == 1:
-                    s = bytes(data.buffer)
-                    assert s not in starts
-                    starts.add(s)
-                if b == 0:
-                    break
-
-        runner = ConjectureRunner(test, settings=SMALL_COUNT_SETTINGS)
-        runner.run()
-        assert runner.call_count == 256
-
-
-@pytest.mark.parametrize("n", range(1, 32))
-def test_number_of_examples_in_integer_range_is_bounded(n):
-    with deterministic_PRNG():
-
-        def test(data):
-            assert runner.call_count <= 2 * n
-            integer_range(data, 0, n)
-
-        runner = ConjectureRunner(test, settings=SMALL_COUNT_SETTINGS)
-        runner.run()
-
-
-def test_prefix_cannot_exceed_buffer_size(monkeypatch):
-    buffer_size = 10
-    monkeypatch.setattr(engine_module, "BUFFER_SIZE", buffer_size)
-
-    with deterministic_PRNG():
-
-        def test(data):
-            while data.draw_bits(1):
-                assert len(data.buffer) <= buffer_size
-            assert len(data.buffer) <= buffer_size
-
-        runner = ConjectureRunner(test, settings=SMALL_COUNT_SETTINGS)
-        runner.run()
-        assert runner.valid_examples == buffer_size
-
-
-def test_does_not_shrink_multiple_bugs_when_told_not_to():
-    def test(data):
-        m = data.draw_bits(8)
-        n = data.draw_bits(8)
-
-        if m > 0:
-            data.mark_interesting(1)
-        if n > 5:
-            data.mark_interesting(2)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, report_multiple_bugs=False)
-        )
-        runner.cached_test_function(255, 255)
-        runner.shrink_interesting_examples()
-
-        results = {d.buffer for d in runner.interesting_examples.values()}
-
-    assert len(results.intersection({bytes(0, 1), bytes(1, 0)})) == 1
-
-
-def test_does_not_keep_generating_when_multiple_bugs():
-    def test(data):
-        if data.draw_bits(64) > 0:
-            data.draw_bits(64)
-            data.mark_interesting()
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                TEST_SETTINGS, report_multiple_bugs=False, phases=Phase.generate
-            ),
-        )
-
-        runner.run()
-
-    assert runner.call_count == 2
-
-
-def test_shrink_after_max_examples():
-    """If we find a bug, keep looking for more, and then hit the valid-example
-    limit, we should still proceed to shrinking.
-    """
-    max_examples = 100
-    fail_at = max_examples - 5
-
-    seen = set()
-    bad = set()
-    post_failure_calls = 0
-
-    def test(data):
-        if bad:
-            post_failure_calls0 += 1
-
-        value = data.draw_bits(8)
-
-        if value in seen and value not in bad:
-            return
-
-        seen.add(value)
-        if len(seen) == fail_at:
-            bad.add(value)
-
-        if value in bad:
-            data.mark_interesting()
-
-    # This shouldn't need to be deterministic, but it makes things much easier
-    # to debug if anything goes wrong.
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                TEST_SETTINGS,
-                max_examples=max_examples,
-                phases=Phase.generate, Phase.shrink,
-                report_multiple_bugs=True,
-            ),
-        )
-        runner.shrink_interesting_examples = Mock(name="shrink_interesting_examples")
-
-        runner.run()
-
-    # First, verify our test assumptions: we found a bug, kept running, and
-    # then hit max-examples.
-    assert runner.interesting_examples
-    assert post_failure_calls0 >= (max_examples - fail_at)
-    assert runner.call_count >= max_examples
-    assert runner.valid_examples == max_examples
-
-    # Now check that we still performed shrinking, even after hitting the
-    # example limit.
-    assert runner.shrink_interesting_examples.call_count == 1
-    assert runner.exit_reason == ExitReason.finished
-
-
-def test_shrink_after_max_iterations():
-    """If we find a bug, keep looking for more, and then hit the test call
-    limit, we should still proceed to shrinking.
-    """
-    max_examples = 10
-    max_iterations = max_examples * 10
-    fail_at = max_iterations - 5
-
-    invalid = set()
-    bad = set()
-    post_failure_calls = 0
-
-    def test(data):
-        if bad:
-            post_failure_calls0 += 1
-
-        value = data.draw_bits(16)
-
-        if value in invalid:
-            data.mark_invalid()
-
-        if value in bad or (not bad and len(invalid) == fail_at):
-            bad.add(value)
-            data.mark_interesting()
-
-        invalid.add(value)
-        data.mark_invalid()
-
-    # This shouldn't need to be deterministic, but it makes things much easier
-    # to debug if anything goes wrong.
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                TEST_SETTINGS,
-                max_examples=max_examples,
-                phases=Phase.generate, Phase.shrink,
-                report_multiple_bugs=True,
-            ),
-        )
-        runner.shrink_interesting_examples = Mock(name="shrink_interesting_examples")
-
-        runner.run()
-
-    # First, verify our test assumptions: we found a bug, kept running, and
-    # then hit the test call limit.
-    assert runner.interesting_examples
-    assert post_failure_calls0 >= (max_iterations - fail_at) - 1
-    assert runner.call_count >= max_iterations
-    assert runner.valid_examples == 0
-
-    # Now check that we still performed shrinking, even after hitting the
-    # test call limit.
-    assert runner.shrink_interesting_examples.call_count == 1
-    assert runner.exit_reason == ExitReason.finished
-
-
-def test_populates_the_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.target_observations"" = data.draw_bits(4)
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=5000,
-                database=InMemoryExampleDatabase(),
-                suppress_health_check=HealthCheck.all(),
-            ),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) == 2**4
-
-
-def test_pareto_front_contains_smallest_valid_when_not_targeting():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.draw_bits(4)
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=5000,
-                database=InMemoryExampleDatabase(),
-                suppress_health_check=HealthCheck.all(),
-            ),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) == 1
-
-
-def test_pareto_front_contains_different_interesting_reasons():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.mark_interesting(data.draw_bits(4))
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=5000,
-                database=InMemoryExampleDatabase(),
-                suppress_health_check=HealthCheck.all(),
-            ),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) == 2**4
-
-
-def test_database_contains_only_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.target_observations"1" = data.draw_bits(4)
-            data.draw_bits(64)
-            data.target_observations"2" = data.draw_bits(8)
-
-        db = InMemoryExampleDatabase()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=500, database=db, suppress_health_check=HealthCheck.all()
-            ),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) <= 500
-
-        for v in runner.pareto_front:
-            assert v.status >= Status.VALID
-
-        assert len(db.data) == 1
-
-        (values,) = db.data.values()
-        values = set(values)
-
-        assert len(values) == len(runner.pareto_front)
-
-        for data in runner.pareto_front:
-            assert data.buffer in values
-            assert data in runner.pareto_front
-
-        for k in values:
-            assert runner.cached_test_function(k) in runner.pareto_front
-
-
-def test_clears_defunct_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.draw_bits(8)
-            data.draw_bits(8)
-
-        db = InMemoryExampleDatabase()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=10000,
-                database=db,
-                suppress_health_check=HealthCheck.all(),
-                phases=Phase.reuse,
-            ),
-            database_key=b"stuff",
-        )
-
-        for i in range(256):
-            db.save(runner.pareto_key, bytes(i, 0))
-
-        runner.run()
-
-        assert len(list(db.fetch(runner.pareto_key))) == 1
-
-
-def test_replaces_all_dominated():
-    def test(data):
-        data.target_observations"m" = 3 - data.draw_bits(2)
-        data.target_observations"n" = 3 - data.draw_bits(2)
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(TEST_SETTINGS, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    d1 = runner.cached_test_function(0, 1).as_result()
-    d2 = runner.cached_test_function(1, 0).as_result()
-
-    assert len(runner.pareto_front) == 2
-
-    assert runner.pareto_front0 == d1
-    assert runner.pareto_front1 == d2
-
-    d3 = runner.cached_test_function(0, 0).as_result()
-    assert len(runner.pareto_front) == 1
-
-    assert runner.pareto_front0 == d3
-
-
-def test_does_not_duplicate_elements():
-    def test(data):
-        data.target_observations"m" = data.draw_bits(8)
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(TEST_SETTINGS, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    d1 = runner.cached_test_function(1).as_result()
-
-    assert len(runner.pareto_front) == 1
-
-    # This can happen in practice if we e.g. reexecute a test because it has
-    # expired from the cache. It's easier just to test it directly though
-    # rather than simulate the failure mode.
-    is_pareto = runner.pareto_front.add(d1)
-
-    assert is_pareto
-
-    assert len(runner.pareto_front) == 1
-
-
-def test_includes_right_hand_side_targets_in_dominance():
-    def test(data):
-        if data.draw_bits(8):
-            data.target_observations"" = 10
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(TEST_SETTINGS, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    d1 = runner.cached_test_function(0).as_result()
-    d2 = runner.cached_test_function(1).as_result()
-
-    assert dominance(d1, d2) == DominanceRelation.NO_DOMINANCE
-
-
-def test_smaller_interesting_dominates_larger_valid():
-    def test(data):
-        if data.draw_bits(8) == 0:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(TEST_SETTINGS, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    d1 = runner.cached_test_function(0).as_result()
-    d2 = runner.cached_test_function(1).as_result()
-    assert dominance(d1, d2) == DominanceRelation.LEFT_DOMINATES
-
-
-def test_runs_full_set_of_examples():
-    def test(data):
-        data.draw_bits(64)
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(TEST_SETTINGS, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    runner.run()
-    assert runner.valid_examples == TEST_SETTINGS.max_examples
-
-
-def test_runs_optimisation_even_if_not_generating():
-    def test(data):
-        data.target_observations"n" = data.draw_bits(16)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, phases=Phase.target)
-        )
-
-        runner.cached_test_function(bytes(2))
-
-        runner.run()
-
-        assert runner.best_observed_targets"n" == (2**16) - 1
-
-
-def test_runs_optimisation_once_when_generating():
-    def test(data):
-        data.target_observations"n" = data.draw_bits(16)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, max_examples=100)
-        )
-
-        runner.optimise_targets = Mock(name="optimise_targets")
-        try:
-            runner.generate_new_examples()
-        except RunIsComplete:
-            pass
-        assert runner.optimise_targets.call_count == 1
-
-
-def test_does_not_run_optimisation_when_max_examples_is_small():
-    def test(data):
-        data.target_observations"n" = data.draw_bits(16)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, max_examples=10)
-        )
-
-        runner.optimise_targets = Mock(name="optimise_targets")
-        try:
-            runner.generate_new_examples()
-        except RunIsComplete:
-            pass
-        assert runner.optimise_targets.call_count == 0
-
-
-def test_does_not_cache_extended_prefix():
-    def test(data):
-        data.draw_bits(64)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-
-        d1 = runner.cached_test_function(b"", extend=8)
-        d2 = runner.cached_test_function(b"", extend=8)
-        assert d1.status == d2.status == Status.VALID
-
-        assert d1.buffer != d2.buffer
-
-
-def test_does_cache_if_extend_is_not_used():
-    calls = 0
-
-    def test(data):
-        calls0 += 1
-        data.draw_bits(8)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-
-        d1 = runner.cached_test_function(b"\0", extend=8)
-        d2 = runner.cached_test_function(b"\0", extend=8)
-        assert d1.status == d2.status == Status.VALID
-        assert d1.buffer == d2.buffer
-        assert calls0 == 1
-
-
-def test_does_result_for_reuse():
-    calls = 0
-
-    def test(data):
-        calls0 += 1
-        data.draw_bits(8)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-
-        d1 = runner.cached_test_function(b"\0", extend=8)
-        d2 = runner.cached_test_function(d1.buffer)
-        assert d1.status == d2.status == Status.VALID
-        assert d1.buffer == d2.buffer
-        assert calls0 == 1
-
-
-def test_does_not_cache_overrun_if_extending():
-    def test(data):
-        data.draw_bits(64)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-
-        d1 = runner.cached_test_function(b"", extend=4)
-        d2 = runner.cached_test_function(b"", extend=8)
-        assert d1.status == Status.OVERRUN
-        assert d2.status == Status.VALID
-
-
-def test_does_cache_overrun_if_not_extending():
-    def test(data):
-        data.draw_bits(64)
-        data.draw_bits(64)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-
-        d1 = runner.cached_test_function(bytes(8), extend=0)
-        d2 = runner.cached_test_function(bytes(8), extend=8)
-        assert d1.status == Status.OVERRUN
-        assert d2.status == Status.VALID
-
-
-def test_does_not_cache_extended_prefix_if_overrun():
-    def test(data):
-        data.draw_bits(64)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-
-        d1 = runner.cached_test_function(b"", extend=4)
-        d2 = runner.cached_test_function(b"", extend=8)
-        assert d1.status == Status.OVERRUN
-        assert d2.status == Status.VALID
-
-
-def test_can_be_set_to_ignore_limits():
-    def test(data):
-        data.draw_bits(8)
-
-    with deterministic_PRNG():
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, max_examples=1), ignore_limits=True
-        )
-
-        for c in range(256):
-            runner.cached_test_function(c)
-
-        assert runner.tree.is_exhausted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_float_encoding.py Deleted

@@ -1,230 +0,0 @@
-# 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 sys
-
-import pytest
-
-from hypothesis import assume, example, given, strategies as st
-from hypothesis.internal.compat import ceil, floor, int_from_bytes, int_to_bytes
-from hypothesis.internal.conjecture import floats as flt
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.floats import float_to_int
-
-EXPONENTS = list(range(0, flt.MAX_EXPONENT + 1))
-assert len(EXPONENTS) == 2**11
-
-
-def assert_reordered_exponents(res):
-    res = list(res)
-    assert len(res) == len(EXPONENTS)
-    for x in res:
-        assert res.count(x) == 1
-        assert 0 <= x <= flt.MAX_EXPONENT
-
-
-def test_encode_permutes_elements():
-    assert_reordered_exponents(map(flt.encode_exponent, EXPONENTS))
-
-
-def test_decode_permutes_elements():
-    assert_reordered_exponents(map(flt.decode_exponent, EXPONENTS))
-
-
-def test_decode_encode():
-    for e in EXPONENTS:
-        assert flt.decode_exponent(flt.encode_exponent(e)) == e
-
-
-def test_encode_decode():
-    for e in EXPONENTS:
-        assert flt.decode_exponent(flt.encode_exponent(e)) == e
-
-
-@given(st.data())
-def test_double_reverse_bounded(data):
-    n = data.draw(st.integers(1, 64))
-    i = data.draw(st.integers(0, 2**n - 1))
-    j = flt.reverse_bits(i, n)
-    assert flt.reverse_bits(j, n) == i
-
-
-@given(st.integers(0, 2**64 - 1))
-def test_double_reverse(i):
-    j = flt.reverse64(i)
-    assert flt.reverse64(j) == i
-
-
-@example(1.25)
-@example(1.0)
-@given(st.floats())
-def test_draw_write_round_trip(f):
-    d = ConjectureData.for_buffer(bytes(10))
-    flt.write_float(d, f)
-    d2 = ConjectureData.for_buffer(d.buffer)
-    g = flt.draw_float(d2)
-
-    if f == f:
-        assert f == g
-
-    assert float_to_int(f) == float_to_int(g)
-
-    d3 = ConjectureData.for_buffer(d2.buffer)
-    flt.draw_float(d3)
-    assert d3.buffer == d2.buffer
-
-
-@example(0.0)
-@example(2.5)
-@example(8.000000000000007)
-@example(3.0)
-@example(2.0)
-@example(1.9999999999999998)
-@example(1.0)
-@given(st.floats(min_value=0.0))
-def test_floats_round_trip(f):
-    i = flt.float_to_lex(f)
-    g = flt.lex_to_float(i)
-
-    assert float_to_int(f) == float_to_int(g)
-
-
-@example(1, 0.5)
-@given(st.integers(1, 2**53), st.floats(0, 1).filter(lambda x: x not in (0, 1)))
-def test_floats_order_worse_than_their_integral_part(n, g):
-    f = n + g
-    assume(int(f) != f)
-    assume(int(f) != 0)
-    i = flt.float_to_lex(f)
-    if f < 0:
-        g = ceil(f)
-    else:
-        g = floor(f)
-
-    assert flt.float_to_lex(float(g)) < i
-
-
-integral_floats = st.floats(allow_infinity=False, allow_nan=False, min_value=0.0).map(
-    lambda x: abs(float(int(x)))
-)
-
-
-@given(integral_floats, integral_floats)
-def test_integral_floats_order_as_integers(x, y):
-    assume(x != y)
-    x, y = sorted((x, y))
-    assert flt.float_to_lex(x) < flt.float_to_lex(y)
-
-
-@given(st.floats(0, 1))
-def test_fractional_floats_are_worse_than_one(f):
-    assume(0 < f < 1)
-    assert flt.float_to_lex(f) > flt.float_to_lex(1)
-
-
-def test_reverse_bits_table_reverses_bits():
-    def bits(x):
-        result = 
-        for _ in range(8):
-            result.append(x & 1)
-            x >>= 1
-        result.reverse()
-        return result
-
-    for i, b in enumerate(flt.REVERSE_BITS_TABLE):
-        assert bits(i) == list(reversed(bits(b)))
-
-
-def test_reverse_bits_table_has_right_elements():
-    assert sorted(flt.REVERSE_BITS_TABLE) == list(range(256))
-
-
-def float_runner(start, condition):
-    def parse_buf(b):
-        return flt.lex_to_float(int_from_bytes(b))
-
-    def test_function(data):
-        f = flt.draw_float(data)
-        if condition(f):
-            data.mark_interesting()
-
-    runner = ConjectureRunner(test_function)
-    runner.cached_test_function(bytes(1) + int_to_bytes(flt.float_to_lex(start), 8))
-    assert runner.interesting_examples
-    return runner
-
-
-def minimal_from(start, condition):
-    runner = float_runner(start, condition)
-    runner.shrink_interesting_examples()
-    (v,) = runner.interesting_examples.values()
-    result = flt.draw_float(ConjectureData.for_buffer(v.buffer))
-    assert condition(result)
-    return result
-
-
-INTERESTING_FLOATS = 0.0, 1.0, 2.0, sys.float_info.max, float("inf"), float("nan")
-
-
-@pytest.mark.parametrize(
-    ("start", "end"),
-    
-        (a, b)
-        for a in INTERESTING_FLOATS
-        for b in INTERESTING_FLOATS
-        if flt.float_to_lex(a) > flt.float_to_lex(b)
-    ,
-)
-def test_can_shrink_downwards(start, end):
-    assert minimal_from(start, lambda x: not (x < end)) == end
-
-
-@pytest.mark.parametrize(
-    "f", 1, 2, 4, 8, 10, 16, 32, 64, 100, 128, 256, 500, 512, 1000, 1024
-)
-@pytest.mark.parametrize("mul", 1.1, 1.5, 9.99, 10)
-def test_shrinks_downwards_to_integers(f, mul):
-    g = minimal_from(f * mul, lambda x: x >= f)
-    assert g == f
-
-
-def test_shrink_to_integer_upper_bound():
-    assert minimal_from(1.1, lambda x: 1 < x <= 2) == 2
-
-
-def test_shrink_up_to_one():
-    assert minimal_from(0.5, lambda x: 0.5 <= x <= 1.5) == 1
-
-
-def test_shrink_down_to_half():
-    assert minimal_from(0.75, lambda x: 0 < x < 1) == 0.5
-
-
-def test_does_not_shrink_across_one():
-    # This is something of an odd special case. Because of our encoding we
-    # prefer all numbers >= 1 to all numbers in 0 < x < 1. For the most part
-    # this is the correct thing to do, but there are some low negative exponent
-    # cases where we get odd behaviour like this.
-
-    # This test primarily exists to validate that we don't try to subtract one
-    # from the starting point and trigger an internal exception.
-    assert minimal_from(1.1, lambda x: x == 1.1 or 0 < x < 1) == 1.1
-
-
-@pytest.mark.parametrize("f", 2.0, 10000000.0)
-def test_converts_floats_to_integer_form(f):
-    assert flt.is_simple(f)
-    buf = int_to_bytes(flt.base_float_to_lex(f), 8)
-
-    runner = float_runner(f, lambda g: g == f)
-    runner.shrink_interesting_examples()
-    (v,) = runner.interesting_examples.values()
-    assert v.buffer:-1 < buf

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_intlist.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_junkdrawer.py Deleted

@@ -1,181 +0,0 @@
-# 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 inspect
-
-import pytest
-
-from hypothesis import example, given, strategies as st
-from hypothesis.internal.conjecture.junkdrawer import (
-    IntList,
-    LazySequenceCopy,
-    NotFound,
-    SelfOrganisingList,
-    binary_search,
-    clamp,
-    replace_all,
-    stack_depth_of_caller,
-)
-
-
-def test_out_of_range():
-    x = LazySequenceCopy(1, 2, 3)
-
-    with pytest.raises(IndexError):
-        x3
-
-    with pytest.raises(IndexError):
-        x-4
-
-
-def test_pass_through():
-    x = LazySequenceCopy(1, 2, 3)
-    assert x0 == 1
-    assert x1 == 2
-    assert x2 == 3
-
-
-def test_can_assign_without_changing_underlying():
-    underlying = 1, 2, 3
-    x = LazySequenceCopy(underlying)
-    x1 = 10
-    assert x1 == 10
-    assert underlying1 == 2
-
-
-def test_pop():
-    x = LazySequenceCopy(2, 3)
-    assert x.pop() == 3
-    assert x.pop() == 2
-
-    with pytest.raises(IndexError):
-        x.pop()
-
-
-@example(1, 5, 10)
-@example(1, 10, 5)
-@example(5, 10, 5)
-@example(5, 1, 10)
-@given(st.integers(), st.integers(), st.integers())
-def test_clamp(lower, value, upper):
-    lower, upper = sorted((lower, upper))
-
-    clamped = clamp(lower, value, upper)
-
-    assert lower <= clamped <= upper
-
-    if lower <= value <= upper:
-        assert value == clamped
-    if lower > value:
-        assert clamped == lower
-    if value > upper:
-        assert clamped == upper
-
-
-def test_pop_without_mask():
-    y = 1, 2, 3
-    x = LazySequenceCopy(y)
-    x.pop()
-    assert list(x) == 1, 2
-    assert y == 1, 2, 3
-
-
-def test_pop_with_mask():
-    y = 1, 2, 3
-    x = LazySequenceCopy(y)
-    x-1 = 5
-    t = x.pop()
-    assert t == 5
-    assert list(x) == 1, 2
-    assert y == 1, 2, 3
-
-
-def test_assignment():
-    y = 1, 2, 3
-    x = LazySequenceCopy(y)
-    x-1 = 5
-    assert list(x) == 1, 2, 5
-    x-1 = 7
-    assert list(x) == 1, 2, 7
-
-
-def test_replacement():
-    result = replace_all(bytes(1, 1, 1, 1), (1, 3, bytes(3, 4)))
-    assert result == bytes(1, 3, 4, 1)
-
-
-def test_int_list_cannot_contain_negative():
-    with pytest.raises(ValueError):
-        IntList(-1)
-
-
-def test_int_list_can_contain_arbitrary_size():
-    n = 2**65
-    assert list(IntList(n)) == n
-
-
-def test_int_list_of_length():
-    assert list(IntList.of_length(10)) == 0 * 10
-
-
-def test_int_list_equality():
-    ls = 1, 2, 3
-    x = IntList(ls)
-    y = IntList(ls)
-
-    assert ls != x
-    assert x != ls
-    assert not (x == ls)
-    assert x == x
-    assert x == y
-
-
-def test_int_list_extend():
-    x = IntList.of_length(3)
-    n = 2**64 - 1
-    x.extend(n)
-    assert list(x) == 0, 0, 0, n
-
-
-@pytest.mark.parametrize("n", 0, 1, 30, 70)
-def test_binary_search(n):
-    i = binary_search(0, 100, lambda i: i <= n)
-    assert i == n
-
-
-def recur(i):
-    assert len(inspect.stack(0)) == stack_depth_of_caller()
-    if i >= 1:
-        recur(i - 1)
-
-
-def test_stack_size_detection():
-    recur(100)
-
-
-def test_self_organising_list_raises_not_found_when_none_satisfy():
-    with pytest.raises(NotFound):
-        SelfOrganisingList(range(20)).find(lambda x: False)
-
-
-def test_self_organising_list_moves_to_front():
-    count = 0
-
-    def zero(n):
-        count0 += 1
-        return n == 0
-
-    x = SelfOrganisingList(range(20))
-
-    assert x.find(zero) == 0
-    assert count0 == 20
-
-    assert x.find(zero) == 0
-    assert count0 == 21

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_lstar.py Deleted

@@ -1,243 +0,0 @@
-# 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 itertools
-
-import pytest
-
-from hypothesis import assume, example, given, strategies as st
-from hypothesis.errors import InvalidState
-from hypothesis.internal.conjecture.dfa.lstar import IntegerNormalizer, LStar
-
-
-def test_can_learn_simple_predicate():
-    learner = LStar(lambda s: len(s) >= 3)
-
-    learner.learn(bytes(3))
-
-    dfa = learner.dfa
-    assert dfa.start == 0
-    assert dfa.transition(0, 0) == 1
-    assert dfa.transition(1, 0) == 2
-    assert dfa.transition(2, 0) == 3
-    assert dfa.transition(3, 0) == 3
-
-    assert not dfa.is_accepting(0)
-    assert not dfa.is_accepting(1)
-    assert not dfa.is_accepting(2)
-    assert dfa.is_accepting(3)
-
-
-def test_relearning_does_not_change_generation():
-    learner = LStar(lambda s: len(s) >= 3)
-
-    prev = learner.generation
-    learner.learn(bytes(3))
-    assert prev != learner.generation
-
-    prev = learner.generation
-    learner.learn(bytes(3))
-    assert prev == learner.generation
-
-
-def test_can_learn_dead_nodes():
-    learner = LStar(lambda s: len(s) == 4 and max(s) <= 1)
-
-    learner.learn(bytes(4))
-
-    assert learner.dfa.matches(bytes(4))
-    assert learner.dfa.matches(bytes(1 * 4))
-    assert learner.dfa.matches(bytes(1 * 4))
-
-    learner.learn(2, 0, 0, 0)
-
-    # Need a length 5 string to distinguish this from
-    # something that just loops back to zero.
-    learner.learn(2, 0, 0, 0, 0)
-
-    dfa = learner.dfa
-
-    assert dfa.is_dead(dfa.transition(dfa.start, 2))
-    assert dfa.is_dead(dfa.transition(dfa.start, 3))
-
-
-def test_iterates_over_learned_strings():
-    upper_bound = bytes(1, 2)
-    learner = LStar(lambda s: len(s) == 2 and max(s) <= 5 and s <= upper_bound)
-
-    learner.learn(upper_bound)
-
-    prev = -1
-    while learner.generation != prev:
-        prev = learner.generation
-        learner.learn(1, 2, 0)
-        learner.learn(6, 1, 2)
-        learner.learn(1, 3)
-        for i in range(7):
-            learner.learn(0, i)
-            learner.learn(1, i)
-        learner.learn(2, 0)
-
-        learner.learn(2, 0, 0, 0)
-        learner.learn(2, 0, 0)
-        learner.learn(0, 6, 0, 0)
-        learner.learn(1, 3, 0, 0)
-        learner.learn(1, 6, 0, 0)
-        learner.learn(0, 0, 0, 0, 0)
-
-    dfa = learner.dfa
-
-    n = 9
-    matches = list(itertools.islice(dfa.all_matching_strings(), n + 1))
-    for m in matches:
-        assert learner.member(m), list(m)
-    assert len(matches) == n
-
-
-def test_iteration_with_dead_nodes():
-    learner = LStar(lambda s: len(s) == 3 and max(s) <= 1 and s1 == 0)
-    learner.learn(1, 0, 1)
-    learner.learn(1, 1, 1)
-    learner.learn(0, 1, 1)
-    learner.learn(1, 1, 0)
-    learner.learn(1, 1, 1, 0, 1)
-    learner.learn(0, 0, 4)
-
-    dfa = learner.dfa
-    i = dfa.transition(dfa.start, 1)
-    assert not dfa.is_dead(i)
-    assert dfa.is_dead(dfa.transition(i, 2))
-
-    assert list(learner.dfa.all_matching_strings()) == 
-        bytes(0, 0, 0),
-        bytes(0, 0, 1),
-        bytes(1, 0, 0),
-        bytes(1, 0, 1),
-    
-
-
-def test_learning_is_just_checking_when_fully_explored():
-    count = 0
-
-    def accept(s):
-        count0 += 1
-        return len(s) <= 5 and all(c == 0 for c in s)
-
-    learner = LStar(accept)
-
-    for c in 0, 1:
-        for n in range(10):
-            learner.learn(bytes(c) * n)
-
-    assert list(learner.dfa.all_matching_strings()) == bytes(n) for n in range(6)
-
-    (prev,) = count
-
-    learner.learn(2 * 11)
-
-    calls = count0 - prev
-
-    assert calls == 1
-
-
-def test_canonicalises_values_to_zero_where_appropriate():
-    calls = 0
-
-    def member(s):
-        calls0 += 1
-        return len(s) == 10
-
-    learner = LStar(member)
-
-    learner.learn(bytes(10))
-    learner.learn(bytes(11))
-
-    (prev,) = calls
-
-    assert learner.dfa.matches(bytes(1 * 10))
-
-    assert calls0 == prev
-
-
-def test_normalizing_defaults_to_zero():
-    normalizer = IntegerNormalizer()
-
-    assert normalizer.normalize(10) == 0
-
-    assert not normalizer.distinguish(10, lambda n: True)
-
-    assert normalizer.normalize(10) == 0
-
-
-def test_normalizing_can_be_made_to_distinguish_values():
-    normalizer = IntegerNormalizer()
-
-    assert normalizer.distinguish(10, lambda n: n >= 5)
-    assert normalizer.normalize(10) == 5
-    assert normalizer.normalize(4) == 0
-
-
-def test_learning_large_dfa():
-    """Mostly the thing this is testing is actually that this runs in reasonable
-    time. A naive breadth first search will run ~forever when trying to find this
-    because it will have to explore all strings of length 19 before it finds one
-    of length 20."""
-
-    learner = LStar(lambda s: len(s) == 20)
-
-    learner.learn(bytes(20))
-
-    for i, s in enumerate(itertools.islice(learner.dfa.all_matching_strings(), 500)):
-        assert len(s) == 20
-        assert i == int.from_bytes(s, "big")
-
-
-def varint_predicate(b):
-    if not b:
-        return False
-    n = b0 & 15
-    if len(b) != n + 1:
-        return False
-    value = int.from_bytes(b1:, "big")
-    return value >= 10
-
-
-@st.composite
-def varint(draw):
-    result = bytearray()
-    result.append(draw(st.integers(1, 255)))
-    n = result0 & 15
-    assume(n > 0)
-    value = draw(st.integers(10, 256**n - 1))
-    result.extend(value.to_bytes(n, "big"))
-    return bytes(result)
-
-
-@example(b"\x02\x01\n")
-@given(st.lists(varint(), min_size=1))
-def test_can_learn_varint_predicate(varints):
-    learner = LStar(varint_predicate)
-    prev = -1
-    while learner.generation != prev:
-        prev = learner.generation
-
-        for s in varints:
-            learner.learn(s)
-
-    for s in varints:
-        assert learner.dfa.matches(s)
-
-
-def test_cannot_reuse_dfa():
-    x = LStar(lambda x: len(x) == 3)
-    dfa = x.dfa
-    x.learn(bytes(3))
-    with pytest.raises(InvalidState):
-        dfa.start

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_minimizer.py Deleted

@@ -1,65 +0,0 @@
-# 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/.
-
-from collections import Counter
-from random import Random
-
-from hypothesis.internal.conjecture.shrinking import Lexical
-
-
-def test_shrink_to_zero():
-    assert Lexical.shrink(bytes(255 * 8), lambda x: True, random=Random(0)) == bytes(
-        8
-    )
-
-
-def test_shrink_to_smallest():
-    assert Lexical.shrink(
-        bytes(255 * 8), lambda x: sum(x) > 10, random=Random(0)
-    ) == bytes(0 * 7 + 11)
-
-
-def test_float_hack_fails():
-    assert Lexical.shrink(
-        bytes(255 * 8), lambda x: x0 >> 7, random=Random(0)
-    ) == bytes(128 + 0 * 7)
-
-
-def test_can_sort_bytes_by_reordering():
-    start = bytes(5, 4, 3, 2, 1, 0)
-    finish = Lexical.shrink(start, lambda x: set(x) == set(start), random=Random(0))
-    assert finish == bytes(0, 1, 2, 3, 4, 5)
-
-
-def test_can_sort_bytes_by_reordering_partially():
-    start = bytes(5, 4, 3, 2, 1, 0)
-    finish = Lexical.shrink(
-        start, lambda x: set(x) == set(start) and x0 > x-1, random=Random(0)
-    )
-    assert finish == bytes(1, 2, 3, 4, 5, 0)
-
-
-def test_can_sort_bytes_by_reordering_partially2():
-    start = bytes(5, 4, 3, 2, 1, 0)
-    finish = Lexical.shrink(
-        start,
-        lambda x: Counter(x) == Counter(start) and x0 > x2,
-        random=Random(0),
-        full=True,
-    )
-    assert finish <= bytes(1, 2, 0, 3, 4, 5)
-
-
-def test_can_sort_bytes_by_reordering_partially_not_cross_stationary_element():
-    start = bytes(5, 3, 0, 2, 1, 4)
-    finish = Lexical.shrink(
-        start, lambda x: set(x) == set(start) and x3 == 2, random=Random(0)
-    )
-    assert finish <= bytes(0, 3, 5, 2, 1, 4)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_optimiser.py Deleted

@@ -1,218 +0,0 @@
-# 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 pytest
-
-from hypothesis import settings
-from hypothesis.internal.compat import int_to_bytes
-from hypothesis.internal.conjecture.data import Status
-from hypothesis.internal.conjecture.engine import ConjectureRunner, RunIsComplete
-from hypothesis.internal.entropy import deterministic_PRNG
-
-from tests.conjecture.common import TEST_SETTINGS, buffer_size_limit
-
-
-def test_optimises_to_maximum():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.target_observations"m" = data.draw_bits(8)
-
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-        runner.cached_test_function(0)
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-
-        assert runner.best_observed_targets"m" == 255
-
-
-def test_optimises_multiple_targets():
-    with deterministic_PRNG():
-
-        def test(data):
-            n = data.draw_bits(8)
-            m = data.draw_bits(8)
-            if n + m > 256:
-                data.mark_invalid()
-            data.target_observations"m" = m
-            data.target_observations"n" = n
-            data.target_observations"m + n" = m + n
-
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-        runner.cached_test_function(200, 0)
-        runner.cached_test_function(0, 200)
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-
-        assert runner.best_observed_targets"m" == 255
-        assert runner.best_observed_targets"n" == 255
-        assert runner.best_observed_targets"m + n" == 256
-
-
-def test_optimises_when_last_element_is_empty():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.target_observations"n" = data.draw_bits(8)
-            data.start_example(1)
-            data.stop_example(1)
-
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-        runner.cached_test_function(250)
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-
-        assert runner.best_observed_targets"n" == 255
-
-
-def test_can_optimise_last_with_following_empty():
-    with deterministic_PRNG():
-
-        def test(data):
-            for _ in range(100):
-                data.draw_bits(2)
-            data.target_observations"" = data.draw_bits(8)
-            data.start_example(1)
-            data.stop_example()
-
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, max_examples=100)
-        )
-        runner.cached_test_function(bytes(101))
-
-        with pytest.raises(RunIsComplete):
-            runner.optimise_targets()
-        assert runner.best_observed_targets"" == 255
-
-
-@pytest.mark.parametrize("lower, upper", (0, 1000), (13, 100), (1000, 2**16 - 1))
-@pytest.mark.parametrize("score_up", False, True)
-def test_can_find_endpoints_of_a_range(lower, upper, score_up):
-    with deterministic_PRNG():
-
-        def test(data):
-            n = data.draw_bits(16)
-            if n < lower or n > upper:
-                data.mark_invalid()
-            if not score_up:
-                n = -n
-            data.target_observations"n" = n
-
-        runner = ConjectureRunner(
-            test, settings=settings(TEST_SETTINGS, max_examples=1000)
-        )
-        runner.cached_test_function(int_to_bytes((lower + upper) // 2, 2))
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-        if score_up:
-            assert runner.best_observed_targets"n" == upper
-        else:
-            assert runner.best_observed_targets"n" == -lower
-
-
-def test_targeting_can_drive_length_very_high():
-    with deterministic_PRNG():
-
-        def test(data):
-            count = 0
-            while data.draw_bits(2) == 3:
-                count += 1
-            data.target_observations"" = min(count, 100)
-
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-        runner.cached_test_function(bytes(10))
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-
-        assert runner.best_observed_targets"" == 100
-
-
-def test_optimiser_when_test_grows_buffer_to_invalid():
-    with deterministic_PRNG():
-
-        def test(data):
-            m = data.draw_bits(8)
-            data.target_observations"m" = m
-            if m > 100:
-                data.draw_bits(16)
-                data.mark_invalid()
-
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-        runner.cached_test_function(bytes(10))
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-
-        assert runner.best_observed_targets"m" == 100
-
-
-def test_can_patch_up_examples():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.start_example(42)
-            m = data.draw_bits(6)
-            data.target_observations"m" = m
-            for _ in range(m):
-                data.draw_bits(1)
-            data.stop_example()
-            for i in range(4):
-                if i != data.draw_bits(8):
-                    data.mark_invalid()
-
-        runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-        d = runner.cached_test_function(0, 0, 1, 2, 3, 4)
-        assert d.status == Status.VALID
-
-        try:
-            runner.optimise_targets()
-        except RunIsComplete:
-            pass
-
-        assert runner.best_observed_targets"m" == 63
-
-
-def test_optimiser_when_test_grows_buffer_to_overflow():
-    with deterministic_PRNG():
-        with buffer_size_limit(2):
-
-            def test(data):
-                m = data.draw_bits(8)
-                data.target_observations"m" = m
-                if m > 100:
-                    data.draw_bits(64)
-                    data.mark_invalid()
-
-            runner = ConjectureRunner(test, settings=TEST_SETTINGS)
-            runner.cached_test_function(bytes(10))
-
-            try:
-                runner.optimise_targets()
-            except RunIsComplete:
-                pass
-
-            assert runner.best_observed_targets"m" == 100

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_order_shrinking.py Deleted

@@ -1,60 +0,0 @@
-# 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/.
-
-from random import Random
-
-from hypothesis import example, given, strategies as st
-from hypothesis.internal.conjecture.shrinking import Ordering
-
-
-@example(0, 1, 1, 1, 1, 1, 1, 0)
-@example(0, 0)
-@example(0, 1, -1)
-@given(st.lists(st.integers()))
-def test_shrinks_down_to_sorted_the_slow_way(ls):
-    # We normally would short-circuit and find that we can sort this
-    # automatically, but here we test that a single run_step could put the
-    # list in sorted order anyway if it had to, and that that is just an
-    # optimisation.
-    shrinker = Ordering(ls, lambda ls: True, random=Random(0), full=False)
-    shrinker.run_step()
-    assert list(shrinker.current) == sorted(ls)
-
-
-def test_can_partially_sort_a_list():
-    finish = Ordering.shrink(
-        5, 4, 3, 2, 1, 0, lambda x: x0 > x-1, random=Random(0)
-    )
-    assert finish == (1, 2, 3, 4, 5, 0)
-
-
-def test_can_partially_sort_a_list_2():
-    finish = Ordering.shrink(
-        5, 4, 3, 2, 1, 0, lambda x: x0 > x2, random=Random(0), full=True
-    )
-    assert finish <= (1, 2, 0, 3, 4, 5)
-
-
-def test_adaptively_shrinks_around_hole():
-    initial = list(range(1000, 0, -1))
-    initial500 = 2000
-
-    intended_result = sorted(initial)
-    intended_result.insert(500, intended_result.pop())
-
-    shrinker = Ordering(
-        initial, lambda ls: ls500 == 2000, random=Random(0), full=True
-    )
-    shrinker.run()
-
-    assert shrinker.current500 == 2000
-
-    assert list(shrinker.current) == intended_result
-    assert shrinker.calls <= 60

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_pareto.py Deleted

@@ -1,252 +0,0 @@
-# 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 pytest
-
-from hypothesis import HealthCheck, Phase, settings
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.internal.compat import int_to_bytes
-from hypothesis.internal.conjecture.data import Status
-from hypothesis.internal.conjecture.engine import ConjectureRunner, RunIsComplete
-from hypothesis.internal.entropy import deterministic_PRNG
-
-
-def test_pareto_front_contains_different_interesting_reasons():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.mark_interesting(data.draw_bits(4))
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=5000,
-                database=InMemoryExampleDatabase(),
-                suppress_health_check=HealthCheck.all(),
-            ),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) == 2**4
-
-
-def test_database_contains_only_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.target_observations"1" = data.draw_bits(4)
-            data.draw_bits(64)
-            data.target_observations"2" = data.draw_bits(8)
-
-        db = InMemoryExampleDatabase()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=500, database=db, suppress_health_check=HealthCheck.all()
-            ),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) <= 500
-
-        for v in runner.pareto_front:
-            assert v.status >= Status.VALID
-
-        assert len(db.data) == 1
-
-        (values,) = db.data.values()
-        values = set(values)
-
-        assert len(values) == len(runner.pareto_front)
-
-        for data in runner.pareto_front:
-            assert data.buffer in values
-            assert data in runner.pareto_front
-
-        for k in values:
-            assert runner.cached_test_function(k) in runner.pareto_front
-
-
-def test_clears_defunct_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.draw_bits(8)
-            data.draw_bits(8)
-
-        db = InMemoryExampleDatabase()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=10000,
-                database=db,
-                suppress_health_check=HealthCheck.all(),
-                phases=Phase.reuse,
-            ),
-            database_key=b"stuff",
-        )
-
-        for i in range(256):
-            db.save(runner.pareto_key, bytes(i, 0))
-
-        runner.run()
-
-        assert len(list(db.fetch(runner.pareto_key))) == 1
-
-
-def test_down_samples_the_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.draw_bits(8)
-            data.draw_bits(8)
-
-        db = InMemoryExampleDatabase()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=1000,
-                database=db,
-                suppress_health_check=HealthCheck.all(),
-                phases=Phase.reuse,
-            ),
-            database_key=b"stuff",
-        )
-
-        for i in range(10000):
-            db.save(runner.pareto_key, int_to_bytes(i, 2))
-
-        with pytest.raises(RunIsComplete):
-            runner.reuse_existing_examples()
-
-        assert runner.valid_examples == 1000
-
-
-def test_stops_loading_pareto_front_if_interesting():
-    with deterministic_PRNG():
-
-        def test(data):
-            data.draw_bits(8)
-            data.draw_bits(8)
-            data.mark_interesting()
-
-        db = InMemoryExampleDatabase()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(
-                max_examples=1000,
-                database=db,
-                suppress_health_check=HealthCheck.all(),
-                phases=Phase.reuse,
-            ),
-            database_key=b"stuff",
-        )
-
-        for i in range(10000):
-            db.save(runner.pareto_key, int_to_bytes(i, 2))
-
-        runner.reuse_existing_examples()
-
-        assert runner.call_count == 1
-
-
-def test_uses_tags_in_calculating_pareto_front():
-    with deterministic_PRNG():
-
-        def test(data):
-            if data.draw_bits(1):
-                data.start_example(11)
-                data.draw_bits(8)
-                data.stop_example()
-
-        runner = ConjectureRunner(
-            test,
-            settings=settings(max_examples=10, database=InMemoryExampleDatabase()),
-            database_key=b"stuff",
-        )
-
-        runner.run()
-
-        assert len(runner.pareto_front) == 2
-
-
-def test_optimises_the_pareto_front():
-    def test(data):
-        count = 0
-        while data.draw_bits(8):
-            count += 1
-
-        data.target_observations"" = min(count, 5)
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(max_examples=10000, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    runner.cached_test_function(255 * 20 + 0)
-
-    runner.pareto_optimise()
-
-    assert len(runner.pareto_front) == 6
-    for i, data in enumerate(runner.pareto_front):
-        assert list(data.buffer) == 1 * i + 0
-
-
-def test_does_not_optimise_the_pareto_front_if_interesting():
-    def test(data):
-        n = data.draw_bits(8)
-        data.target_observations"" = n
-        if n == 255:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(max_examples=10000, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    runner.cached_test_function(0)
-
-    runner.pareto_optimise = None
-
-    runner.optimise_targets()
-
-    assert runner.interesting_examples
-
-
-def test_stops_optimising_once_interesting():
-    hi = 2**16 - 1
-
-    def test(data):
-        n = data.draw_bits(16)
-        data.target_observations"" = n
-        if n < hi:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(max_examples=10000, database=InMemoryExampleDatabase()),
-        database_key=b"stuff",
-    )
-
-    data = runner.cached_test_function(255 * 2)
-    assert data.status == Status.VALID
-    runner.pareto_optimise()
-    assert runner.call_count <= 20
-    assert runner.interesting_examples

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_shrinker.py Deleted

@@ -1,547 +0,0 @@
-# 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 time
-
-import pytest
-
-from hypothesis.internal.compat import int_to_bytes
-from hypothesis.internal.conjecture import floats as flt
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.conjecture.shrinker import (
-    Shrinker,
-    ShrinkPass,
-    StopShrinking,
-    block_program,
-)
-from hypothesis.internal.conjecture.shrinking import Float
-from hypothesis.internal.conjecture.utils import Sampler
-
-from tests.conjecture.common import SOME_LABEL, run_to_buffer, shrinking_from
-
-
-@pytest.mark.parametrize("n", 1, 5, 8, 15)
-def test_can_shrink_variable_draws_with_just_deletion(n, monkeypatch):
-    @shrinking_from(n + 0 * (n - 1) + 1)
-    def shrinker(data):
-        n = data.draw_bits(4)
-        b = data.draw_bits(8) for _ in range(n)
-        if any(b):
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-
-    assert list(shrinker.shrink_target.buffer) == 1, 1
-
-
-def test_deletion_and_lowering_fails_to_shrink(monkeypatch):
-    monkeypatch.setattr(
-        Shrinker,
-        "shrink",
-        lambda self: self.fixate_shrink_passes("minimize_individual_blocks"),
-    )
-
-    def gen(self):
-        self.cached_test_function(10)
-
-    monkeypatch.setattr(ConjectureRunner, "generate_new_examples", gen)
-
-    @run_to_buffer
-    def x(data):
-        for _ in range(10):
-            data.draw_bytes(1)
-        data.mark_interesting()
-
-    assert x == bytes(10)
-
-
-def test_duplicate_blocks_that_go_away():
-    @shrinking_from(1, 1, 1, 2 * 2 + 5 * 2)
-    def shrinker(data):
-        x = data.draw_bits(32)
-        y = data.draw_bits(32)
-        if x != y:
-            data.mark_invalid()
-        b = data.draw_bytes(1) for _ in range(x & 255)
-        if len(set(b)) <= 1:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_duplicated_blocks")
-    assert shrinker.shrink_target.buffer == bytes(8)
-
-
-def test_accidental_duplication(monkeypatch):
-    @shrinking_from(18 * 20)
-    def shrinker(data):
-        x = data.draw_bits(8)
-        y = data.draw_bits(8)
-        if x != y:
-            data.mark_invalid()
-        if x < 5:
-            data.mark_invalid()
-        b = data.draw_bytes(1) for _ in range(x)
-        if len(set(b)) == 1:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_duplicated_blocks")
-    assert list(shrinker.buffer) == 5 * 7
-
-
-def test_can_zero_subintervals(monkeypatch):
-    @shrinking_from(bytes(3, 0, 0, 0, 1) * 10)
-    def shrinker(data):
-        for _ in range(10):
-            data.start_example(SOME_LABEL)
-            n = data.draw_bits(8)
-            data.draw_bytes(n)
-            data.stop_example()
-            if data.draw_bits(8) != 1:
-                return
-        data.mark_interesting()
-
-    shrinker.shrink()
-    assert list(shrinker.buffer) == 0, 1 * 10
-
-
-def test_can_pass_to_an_indirect_descendant(monkeypatch):
-    def tree(data):
-        data.start_example(1)
-        n = data.draw_bits(1)
-        label = data.draw_bits(8)
-        if n:
-            tree(data)
-            tree(data)
-        data.stop_example(1)
-        return label
-
-    initial = bytes(1, 10, 0, 0, 1, 0, 0, 10, 0, 0)
-    target = bytes(0, 10)
-
-    good = {initial, target}
-
-    @shrinking_from(initial)
-    def shrinker(data):
-        tree(data)
-        if bytes(data.buffer) in good:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("pass_to_descendant")
-
-    assert shrinker.shrink_target.buffer == target
-
-
-def shrink(buffer, *passes):
-    def accept(f):
-        shrinker = shrinking_from(buffer)(f)
-
-        shrinker.fixate_shrink_passes(passes)
-
-        return list(shrinker.buffer)
-
-    return accept
-
-
-def test_shrinking_blocks_from_common_offset():
-    @shrinking_from(11, 10)
-    def shrinker(data):
-        m = data.draw_bits(8)
-        n = data.draw_bits(8)
-        if abs(m - n) <= 1 and max(m, n) > 0:
-            data.mark_interesting()
-
-    shrinker.mark_changed(0)
-    shrinker.mark_changed(1)
-    shrinker.lower_common_block_offset()
-
-    x = shrinker.shrink_target.buffer
-
-    assert sorted(x) == 0, 1
-
-
-def test_handle_empty_draws():
-    @run_to_buffer
-    def x(data):
-        while True:
-            data.start_example(SOME_LABEL)
-            n = data.draw_bits(1)
-            data.start_example(SOME_LABEL)
-            data.stop_example()
-            data.stop_example(discard=n > 0)
-            if not n:
-                break
-        data.mark_interesting()
-
-    assert x == bytes(0)
-
-
-def test_can_reorder_examples():
-    @shrinking_from(1, 0, 1, 1, 0, 1, 0, 0, 0)
-    def shrinker(data):
-        total = 0
-        for _ in range(5):
-            data.start_example(0)
-            if data.draw_bits(8):
-                total += data.draw_bits(9)
-            data.stop_example(0)
-        if total == 2:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("reorder_examples")
-
-    assert list(shrinker.buffer) == 0, 0, 0, 1, 0, 1, 1, 0, 1
-
-
-def test_permits_but_ignores_raising_order(monkeypatch):
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function(1),
-    )
-
-    monkeypatch.setattr(
-        Shrinker, "shrink", lambda self: self.incorporate_new_buffer(bytes(2))
-    )
-
-    @run_to_buffer
-    def x(data):
-        data.draw_bits(2)
-        data.mark_interesting()
-
-    assert list(x) == 1
-
-
-def test_block_deletion_can_delete_short_ranges(monkeypatch):
-    @shrinking_from(v for i in range(5) for _ in range(i + 1) for v in 0, i)
-    def shrinker(data):
-        while True:
-            n = data.draw_bits(16)
-            for _ in range(n):
-                if data.draw_bits(16) != n:
-                    data.mark_invalid()
-            if n == 4:
-                data.mark_interesting()
-
-    shrinker.fixate_shrink_passes(block_program("X" * i) for i in range(1, 5))
-    assert list(shrinker.shrink_target.buffer) == 0, 4 * 5
-
-
-def test_try_shrinking_blocks_ignores_overrun_blocks(monkeypatch):
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function(3, 3, 0, 1),
-    )
-
-    monkeypatch.setattr(
-        Shrinker,
-        "shrink",
-        lambda self: self.try_shrinking_blocks((0, 1, 5), bytes(2)),
-    )
-
-    @run_to_buffer
-    def x(data):
-        n1 = data.draw_bits(8)
-        data.draw_bits(8)
-        if n1 == 3:
-            data.draw_bits(8)
-        k = data.draw_bits(8)
-        if k == 1:
-            data.mark_interesting()
-
-    assert list(x) == 2, 2, 1
-
-
-def test_dependent_block_pairs_is_up_to_shrinking_integers():
-    # Unit test extracted from a failure in tests/nocover/test_integers.py
-    distribution = Sampler(4.0, 8.0, 1.0, 1.0, 0.5)
-
-    sizes = 8, 16, 32, 64, 128
-
-    @shrinking_from(b"\x03\x01\x00\x00\x00\x00\x00\x01\x00\x02\x01")
-    def shrinker(data):
-        size = sizesdistribution.sample(data)
-        result = data.draw_bits(size)
-        sign = (-1) ** (result & 1)
-        result = (result >> 1) * sign
-        cap = data.draw_bits(8)
-
-        if result >= 32768 and cap == 1:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-    assert list(shrinker.shrink_target.buffer) == 1, 1, 0, 1, 0, 0, 1
-
-
-def test_finding_a_minimal_balanced_binary_tree():
-    # Tests iteration while the shape of the thing being iterated over can
-    # change. In particular the current example can go from trivial to non
-    # trivial.
-
-    def tree(data):
-        # Returns height of a binary tree and whether it is height balanced.
-        data.start_example("tree")
-        n = data.draw_bits(1)
-        if n == 0:
-            result = (1, True)
-        else:
-            h1, b1 = tree(data)
-            h2, b2 = tree(data)
-            result = (1 + max(h1, h2), b1 and b2 and abs(h1 - h2) <= 1)
-        data.stop_example("tree")
-        return result
-
-    # Starting from an unbalanced tree of depth six
-    @shrinking_from(1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0)
-    def shrinker(data):
-        _, b = tree(data)
-        if not b:
-            data.mark_interesting()
-
-    shrinker.shrink()
-
-    assert list(shrinker.shrink_target.buffer) == 1, 0, 1, 0, 1, 0, 0
-
-
-def test_float_shrink_can_run_when_canonicalisation_does_not_work(monkeypatch):
-    # This should be an error when called
-    monkeypatch.setattr(Float, "shrink", None)
-
-    base_buf = bytes(1) + int_to_bytes(flt.base_float_to_lex(1000.0), 8)
-
-    @shrinking_from(base_buf)
-    def shrinker(data):
-        flt.draw_float(data)
-        if bytes(data.buffer) == base_buf:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("minimize_floats")
-
-    assert shrinker.shrink_target.buffer == base_buf
-
-
-def test_try_shrinking_blocks_out_of_bounds():
-    @shrinking_from(bytes(1))
-    def shrinker(data):
-        data.draw_bits(1)
-        data.mark_interesting()
-
-    assert not shrinker.try_shrinking_blocks((1,), bytes(1))
-
-
-def test_block_programs_are_adaptive():
-    @shrinking_from(bytes(1000) + bytes(1))
-    def shrinker(data):
-        while not data.draw_bits(1):
-            pass
-        data.mark_interesting()
-
-    p = shrinker.add_new_pass(block_program("X"))
-    shrinker.fixate_shrink_passes(p.name)
-
-    assert len(shrinker.shrink_target.buffer) == 1
-    assert shrinker.calls <= 60
-
-
-def test_zero_examples_with_variable_min_size():
-    @shrinking_from(bytes(255) * 100)
-    def shrinker(data):
-        any_nonzero = False
-        for i in range(1, 10):
-            any_nonzero |= data.draw_bits(i * 8) > 0
-        if not any_nonzero:
-            data.mark_invalid()
-        data.mark_interesting()
-
-    shrinker.shrink()
-    assert len(d for d in shrinker.shrink_target.blocks if not d.all_zero) == 1
-
-
-def test_zero_contained_examples():
-    @shrinking_from(bytes(1) * 8)
-    def shrinker(data):
-        for _ in range(4):
-            data.start_example(1)
-            if data.draw_bits(8) == 0:
-                data.mark_invalid()
-            data.start_example(1)
-            data.draw_bits(8)
-            data.stop_example()
-            data.stop_example()
-        data.mark_interesting()
-
-    shrinker.shrink()
-    assert list(shrinker.shrink_target.buffer) == 1, 0 * 4
-
-
-def test_zig_zags_quickly():
-    @shrinking_from(bytes(255) * 4)
-    def shrinker(data):
-        m = data.draw_bits(16)
-        n = data.draw_bits(16)
-        if m == 0 or n == 0:
-            data.mark_invalid()
-        if abs(m - n) <= 1:
-            data.mark_interesting(0)
-        # Two different interesting origins for avoiding slipping in the
-        # shrinker.
-        if abs(m - n) <= 10:
-            data.mark_interesting(1)
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-    assert shrinker.engine.valid_examples <= 100
-    assert list(shrinker.shrink_target.buffer) == 0, 1, 0, 1
-
-
-def test_zero_irregular_examples():
-    @shrinking_from(255 * 6)
-    def shrinker(data):
-        data.start_example(1)
-        data.draw_bits(8)
-        data.draw_bits(16)
-        data.stop_example()
-        data.start_example(1)
-        interesting = data.draw_bits(8) > 0 and data.draw_bits(16) > 0
-        data.stop_example()
-        if interesting:
-            data.mark_interesting()
-
-    shrinker.shrink()
-    assert list(shrinker.shrink_target.buffer) == 0 * 3 + 1, 0, 1
-
-
-def test_retain_end_of_buffer():
-    @shrinking_from(1, 2, 3, 4, 5, 6, 0)
-    def shrinker(data):
-        interesting = False
-        while True:
-            n = data.draw_bits(8)
-            if n == 6:
-                interesting = True
-            if n == 0:
-                break
-        if interesting:
-            data.mark_interesting()
-
-    shrinker.shrink()
-    assert list(shrinker.buffer) == 6, 0
-
-
-def test_can_expand_zeroed_region():
-    @shrinking_from(255 * 5)
-    def shrinker(data):
-        seen_non_zero = False
-        for _ in range(5):
-            if data.draw_bits(8) == 0:
-                if seen_non_zero:
-                    data.mark_invalid()
-            else:
-                seen_non_zero = True
-        data.mark_interesting()
-
-    shrinker.shrink()
-    assert list(shrinker.shrink_target.buffer) == 0 * 5
-
-
-def test_can_expand_deleted_region():
-    @shrinking_from(1, 2, 3, 4, 0, 0)
-    def shrinker(data):
-        def t():
-            data.start_example(1)
-
-            data.start_example(1)
-            m = data.draw_bits(8)
-            data.stop_example()
-
-            data.start_example(1)
-            n = data.draw_bits(8)
-            data.stop_example()
-
-            data.stop_example()
-            return (m, n)
-
-        v1 = t()
-        if v1 == (1, 2):
-            if t() != (3, 4):
-                data.mark_invalid()
-        if v1 == (0, 0) or t() == (0, 0):
-            data.mark_interesting()
-
-    shrinker.shrink()
-    assert list(shrinker.buffer) == 0, 0
-
-
-def test_shrink_pass_method_is_idempotent():
-    @shrinking_from(255)
-    def shrinker(data):
-        data.draw_bits(8)
-        data.mark_interesting()
-
-    sp = shrinker.shrink_pass(block_program("X"))
-    assert isinstance(sp, ShrinkPass)
-    assert shrinker.shrink_pass(sp) is sp
-
-
-def test_will_terminate_stalled_shrinks():
-    # Suppress the time based slow shrinking check - we only want
-    # the one that checks if we're in a stall where we've shrunk
-    # as far as we're going to get.
-    time.freeze()
-
-    @shrinking_from(255 * 100)
-    def shrinker(data):
-        count = 0
-
-        for _ in range(100):
-            if data.draw_bits(8) != 255:
-                count += 1
-                if count >= 10:
-                    return
-        data.mark_interesting()
-
-    shrinker.shrink()
-    assert shrinker.calls <= 1 + 2 * shrinker.max_stall
-
-
-def test_will_let_fixate_shrink_passes_do_a_full_run_through():
-    @shrinking_from(range(50))
-    def shrinker(data):
-        for i in range(50):
-            if data.draw_bits(8) != i:
-                data.mark_invalid()
-        data.mark_interesting()
-
-    shrinker.max_stall = 5
-
-    passes = block_program("X" * i) for i in range(1, 11)
-
-    with pytest.raises(StopShrinking):
-        shrinker.fixate_shrink_passes(passes)
-
-    assert shrinker.shrink_pass(passes-1).calls > 0
-
-
-@pytest.mark.parametrize("n_gap", 0, 1, 2, 3)
-def test_can_simultaneously_lower_non_duplicated_nearby_blocks(n_gap):
-    @shrinking_from(1, 1 + 0 * n_gap + 0, 2)
-    def shrinker(data):
-        # Block off lowering the whole buffer
-        if data.draw_bits(1) == 0:
-            data.mark_invalid()
-        m = data.draw_bits(8)
-        for _ in range(n_gap):
-            data.draw_bits(8)
-        n = data.draw_bits(16)
-
-        if n == m + 1:
-            data.mark_interesting()
-
-    shrinker.fixate_shrink_passes("lower_blocks_together")
-
-    assert list(shrinker.buffer) == 1, 0 + 0 * n_gap + 0, 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_shrinking_dfas.py Deleted

@@ -1,258 +0,0 @@
-# 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 os
-import sys
-from contextlib import contextmanager
-from itertools import islice
-
-import pytest
-
-from hypothesis import settings
-from hypothesis.internal.conjecture.data import Status
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.conjecture.shrinking import dfas
-
-TEST_DFA_NAME = "test name"
-
-
-@contextmanager
-def preserving_dfas():
-    assert TEST_DFA_NAME not in dfas.SHRINKING_DFAS
-    for k in dfas.SHRINKING_DFAS:
-        assert not k.startswith(TEST_DFA_NAME)
-    original = dict(dfas.SHRINKING_DFAS)
-    try:
-        yield
-    finally:
-        dfas.SHRINKING_DFAS.clear()
-        dfas.SHRINKING_DFAS.update(original)
-        dfas.update_learned_dfas()
-    assert TEST_DFA_NAME not in dfas.SHRINKING_DFAS
-    with open(dfas.learned_dfa_file) as i:
-        assert TEST_DFA_NAME not in i.read()
-
-
-def test_updating_the_file_makes_no_changes_normally():
-    with open(dfas.learned_dfa_file) as i:
-        source1 = i.read()
-
-    dfas.update_learned_dfas()
-
-    with open(dfas.learned_dfa_file) as i:
-        source2 = i.read()
-
-    assert source1 == source2
-
-
-def test_updating_the_file_include_new_shrinkers():
-    with preserving_dfas():
-        with open(dfas.learned_dfa_file) as i:
-            source1 = i.read()
-
-        dfas.SHRINKING_DFASTEST_DFA_NAME = "hello"
-
-        dfas.update_learned_dfas()
-
-        with open(dfas.learned_dfa_file) as i:
-            source2 = i.read()
-
-        assert source1 != source2
-        assert repr(TEST_DFA_NAME) in source2
-
-    assert TEST_DFA_NAME not in dfas.SHRINKING_DFAS
-
-    with open(dfas.learned_dfa_file) as i:
-        assert "test name" not in i.read()
-
-
-def called_by_shrinker():
-    frame = sys._getframe(0)
-    while frame:
-        fname = frame.f_globals.get("__file__", "")
-        if os.path.basename(fname) == "shrinker.py":
-            return True
-        frame = frame.f_back
-    return False
-
-
-def a_bad_test_function():
-    """Return a test function that we definitely can't normalize
-    because it cheats shamelessly and checks whether it's being
-    called by the shrinker and refuses to declare any new results
-    interesting."""
-    cache = {0: False}
-
-    def test_function(data):
-        n = data.draw_bits(64)
-        if n < 1000:
-            return
-
-        try:
-            interesting = cachen
-        except KeyError:
-            interesting = cache.setdefault(n, not called_by_shrinker())
-
-        if interesting:
-            data.mark_interesting()
-
-    return test_function
-
-
-def test_will_error_if_does_not_normalise_and_cannot_update():
-    with pytest.raises(dfas.FailedToNormalise) as excinfo:
-        dfas.normalize(
-            "bad",
-            a_bad_test_function(),
-            required_successes=10,
-            allowed_to_update=False,
-        )
-
-    assert "not allowed" in excinfo.value.args0
-
-
-def test_will_error_if_takes_too_long_to_normalize():
-    with preserving_dfas():
-        with pytest.raises(dfas.FailedToNormalise) as excinfo:
-            dfas.normalize(
-                "bad",
-                a_bad_test_function(),
-                required_successes=1000,
-                allowed_to_update=True,
-                max_dfas=0,
-            )
-
-        assert "too hard" in excinfo.value.args0
-
-
-def non_normalized_test_function(data):
-    """This test function has two discrete regions that it
-    is hard to move between. It's basically unreasonable for
-    our shrinker to be able to transform from one to the other
-    because of how different they are."""
-    data.draw_bits(8)
-    if data.draw_bits(1):
-        n = data.draw_bits(10)
-        if 100 < n < 1000:
-            data.draw_bits(8)
-            data.mark_interesting()
-    else:
-        n = data.draw_bits(64)
-        if n > 10000:
-            data.draw_bits(8)
-            data.mark_interesting()
-
-
-def test_can_learn_to_normalize_the_unnormalized():
-    with preserving_dfas():
-        prev = len(dfas.SHRINKING_DFAS)
-
-        dfas.normalize(
-            TEST_DFA_NAME, non_normalized_test_function, allowed_to_update=True
-        )
-
-        assert len(dfas.SHRINKING_DFAS) == prev + 1
-
-
-def test_will_error_on_uninteresting_test():
-    with pytest.raises(AssertionError):
-        dfas.normalize(TEST_DFA_NAME, lambda data: data.draw_bits(64))
-
-
-def test_makes_no_changes_if_already_normalized():
-    def test_function(data):
-        if data.draw_bits(16) >= 1000:
-            data.mark_interesting()
-
-    with preserving_dfas():
-        before = dict(dfas.SHRINKING_DFAS)
-
-        dfas.normalize(TEST_DFA_NAME, test_function, allowed_to_update=True)
-
-        after = dict(dfas.SHRINKING_DFAS)
-
-        assert after == before
-
-
-def test_learns_to_bridge_only_two():
-    def test_function(data):
-        m = data.draw_bits(8)
-        n = data.draw_bits(8)
-
-        if (m, n) in ((10, 100), (2, 8)):
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test_function, settings=settings(database=None), ignore_limits=True
-    )
-
-    dfa = dfas.learn_a_new_dfa(
-        runner, 10, 100, 2, 8, lambda d: d.status == Status.INTERESTING
-    )
-
-    assert dfa.max_length(dfa.start) == 2
-
-    assert list(map(list, dfa.all_matching_strings())) == 
-        2, 8,
-        10, 100,
-    
-
-
-def test_learns_to_bridge_only_two_with_overlap():
-    u = 50, 0, 0, 0, 50
-    v = 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50
-
-    def test_function(data):
-        for i in range(len(u)):
-            c = data.draw_bits(8)
-            if c != ui:
-                if c != vi:
-                    return
-                break
-        else:
-            data.mark_interesting()
-        for j in range(i + 1, len(v)):
-            if data.draw_bits(8) != vj:
-                return
-
-        data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test_function, settings=settings(database=None), ignore_limits=True
-    )
-
-    dfa = dfas.learn_a_new_dfa(runner, u, v, lambda d: d.status == Status.INTERESTING)
-
-    assert list(islice(dfa.all_matching_strings(), 3)) == b"", bytes(len(v) - len(u))
-
-
-def test_learns_to_bridge_only_two_with_suffix():
-    u = 7
-    v = 0 * 10 + 7
-
-    def test_function(data):
-        n = data.draw_bits(8)
-        if n == 7:
-            data.mark_interesting()
-        elif n != 0:
-            return
-        for _ in range(9):
-            if data.draw_bits(8) != 0:
-                return
-        if data.draw_bits(8) == 7:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test_function, settings=settings(database=None), ignore_limits=True
-    )
-
-    dfa = dfas.learn_a_new_dfa(runner, u, v, lambda d: d.status == Status.INTERESTING)
-
-    assert list(islice(dfa.all_matching_strings(), 3)) == b"", bytes(len(v) - len(u))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_shrinking_interface.py Deleted

@@ -1,37 +0,0 @@
-# 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/.
-
-from random import Random
-
-from hypothesis.internal.conjecture.shrinking import Integer
-
-from tests.common.utils import capture_out
-
-
-def test_debug_output():
-    with capture_out() as o:
-        Integer.shrink(10, lambda x: True, debug=True, random=Random(0))
-
-    assert "initial=10" in o.getvalue()
-    assert "shrinking to 0" in o.getvalue()
-
-
-def test_includes_name_in_repr_if_set():
-    assert (
-        repr(Integer(10, lambda x: True, name="hi there", random=Random(0)))
-        == "Integer('hi there', initial=10, current=10)"
-    )
-
-
-def test_normally_contains_no_space_for_name():
-    assert (
-        repr(Integer(10, lambda x: True, random=Random(0)))
-        == "Integer(initial=10, current=10)"
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_test_data.py Deleted

@@ -1,500 +0,0 @@
-# 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 itertools
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import Frozen, InvalidArgument
-from hypothesis.internal.conjecture.data import (
-    MAX_DEPTH,
-    ConjectureData,
-    DataObserver,
-    Overrun,
-    Status,
-    StopTest,
-    structural_coverage,
-)
-from hypothesis.strategies._internal.strategies import SearchStrategy
-
-
-@given(st.binary())
-def test_buffer_draws_as_self(buf):
-    x = ConjectureData.for_buffer(buf)
-    assert x.draw_bytes(len(buf)) == buf
-
-
-def test_cannot_draw_after_freeze():
-    x = ConjectureData.for_buffer(b"hi")
-    x.draw_bytes(1)
-    x.freeze()
-    with pytest.raises(Frozen):
-        x.draw_bytes(1)
-
-
-def test_can_double_freeze():
-    x = ConjectureData.for_buffer(b"hi")
-    x.freeze()
-    assert x.frozen
-    x.freeze()
-    assert x.frozen
-
-
-def test_can_draw_zero_bytes():
-    x = ConjectureData.for_buffer(b"")
-    for _ in range(10):
-        assert x.draw_bytes(0) == b""
-
-
-def test_draw_past_end_sets_overflow():
-    x = ConjectureData.for_buffer(bytes(5))
-    with pytest.raises(StopTest) as e:
-        x.draw_bytes(6)
-    assert e.value.testcounter == x.testcounter
-    assert x.frozen
-    assert x.status == Status.OVERRUN
-
-
-def test_notes_repr():
-    x = ConjectureData.for_buffer(b"")
-    x.note(b"hi")
-    assert repr(b"hi") in x.output
-
-
-def test_can_mark_interesting():
-    x = ConjectureData.for_buffer(b"")
-    with pytest.raises(StopTest):
-        x.mark_interesting()
-    assert x.frozen
-    assert x.status == Status.INTERESTING
-
-
-def test_drawing_zero_bits_is_free():
-    x = ConjectureData.for_buffer(b"")
-    assert x.draw_bits(0) == 0
-
-
-def test_can_mark_invalid():
-    x = ConjectureData.for_buffer(b"")
-    with pytest.raises(StopTest):
-        x.mark_invalid()
-    assert x.frozen
-    assert x.status == Status.INVALID
-
-
-class BoomStrategy(SearchStrategy):
-    def do_draw(self, data):
-        data.draw_bytes(1)
-        raise ValueError()
-
-
-def test_closes_interval_on_error_in_strategy():
-    x = ConjectureData.for_buffer(b"hi")
-    with pytest.raises(ValueError):
-        x.draw(BoomStrategy())
-    x.freeze()
-    assert not any(eg.end is None for eg in x.examples)
-
-
-class BigStrategy(SearchStrategy):
-    def do_draw(self, data):
-        data.draw_bytes(10**6)
-
-
-def test_does_not_double_freeze_in_interval_close():
-    x = ConjectureData.for_buffer(b"hi")
-    with pytest.raises(StopTest):
-        x.draw(BigStrategy())
-    assert x.frozen
-    assert not any(eg.end is None for eg in x.examples)
-
-
-def test_triviality():
-    d = ConjectureData.for_buffer(1, 0, 1)
-
-    d.start_example(1)
-    d.draw_bits(1)
-    d.draw_bits(1)
-    d.stop_example(1)
-
-    d.write(bytes(2))
-    d.freeze()
-
-    def eg(u, v):
-        return ex for ex in d.examples if ex.start == u and ex.end == v0
-
-    assert not eg(0, 2).trivial
-    assert not eg(0, 1).trivial
-    assert eg(1, 2).trivial
-    assert eg(2, 3).trivial
-
-
-def test_example_depth_marking():
-    d = ConjectureData.for_buffer(bytes(24))
-
-    # These draw sizes are chosen so that each example has a unique length.
-    d.draw_bytes(2)
-    d.start_example("inner")
-    d.draw_bytes(3)
-    d.draw_bytes(6)
-    d.stop_example()
-    d.draw_bytes(12)
-    d.freeze()
-
-    assert len(d.examples) == 6
-
-    depths = {(ex.length, ex.depth) for ex in d.examples}
-    assert depths == {(2, 1), (3, 2), (6, 2), (9, 1), (12, 1), (23, 0)}
-
-
-def test_has_examples_even_when_empty():
-    d = ConjectureData.for_buffer(b"")
-    d.draw(st.just(False))
-    d.freeze()
-    assert d.examples
-
-
-def test_has_cached_examples_even_when_overrun():
-    d = ConjectureData.for_buffer(bytes(1))
-    d.start_example(3)
-    d.draw_bits(1)
-    d.stop_example()
-    try:
-        d.draw_bits(1)
-    except StopTest:
-        pass
-    assert d.status == Status.OVERRUN
-    assert any(ex.label == 3 and ex.length == 1 for ex in d.examples)
-    assert d.examples is d.examples
-
-
-def test_can_write_empty_string():
-    d = ConjectureData.for_buffer(1, 1, 1)
-    d.draw_bits(1)
-    d.write(b"")
-    d.draw_bits(1)
-    d.draw_bits(0, forced=0)
-    d.draw_bits(1)
-    assert d.buffer == bytes(1, 1, 1)
-
-
-def test_blocks_preserve_identity():
-    n = 10
-    d = ConjectureData.for_buffer(1 * 10)
-    for _ in range(n):
-        d.draw_bits(1)
-    d.freeze()
-    blocks = d.blocksi for i in range(n)
-    result = d.as_result()
-    for i, b in enumerate(blocks):
-        assert result.blocksi is b
-
-
-def test_compact_blocks_during_generation():
-    d = ConjectureData.for_buffer(1 * 10)
-    for _ in range(5):
-        d.draw_bits(1)
-    assert len(list(d.blocks)) == 5
-    for _ in range(5):
-        d.draw_bits(1)
-    assert len(list(d.blocks)) == 10
-
-
-def test_handles_indices_like_a_list():
-    n = 5
-    d = ConjectureData.for_buffer(1 * n)
-    for _ in range(n):
-        d.draw_bits(1)
-    assert d.blocks-1 is d.blocksn - 1
-    assert d.blocks-n is d.blocks0
-
-    with pytest.raises(IndexError):
-        d.blocksn
-
-    with pytest.raises(IndexError):
-        d.blocks-n - 1
-
-
-def test_can_observe_draws():
-    class LoggingObserver(DataObserver):
-        def __init__(self):
-            self.log = 
-
-        def draw_bits(self, *args):
-            self.log.append(("draw",) + args)
-
-        def conclude_test(self, *args):
-            assert x.frozen
-            self.log.append(("concluded",) + args)
-
-    observer = LoggingObserver()
-    x = ConjectureData.for_buffer(bytes(1, 2, 3), observer=observer)
-
-    x.draw_bits(1)
-    x.draw_bits(7, forced=10)
-    x.draw_bits(8)
-    with pytest.raises(StopTest):
-        x.conclude_test(Status.INTERESTING, interesting_origin="neat")
-
-    assert observer.log == 
-        ("draw", 1, False, 1),
-        ("draw", 7, True, 10),
-        ("draw", 8, False, 3),
-        ("concluded", Status.INTERESTING, "neat"),
-    
-
-
-def test_calls_concluded_implicitly():
-    class NoteConcluded(DataObserver):
-        def conclude_test(self, status, reason):
-            assert x.frozen
-            self.conclusion = (status, reason)
-
-    observer = NoteConcluded()
-
-    x = ConjectureData.for_buffer(bytes(1), observer=observer)
-    x.draw_bits(1)
-    x.freeze()
-
-    assert observer.conclusion == (Status.VALID, None)
-
-
-def test_handles_start_indices_like_a_list():
-    n = 5
-    d = ConjectureData.for_buffer(1 * n)
-    for _ in range(n):
-        d.draw_bits(1)
-
-    for i in range(-2 * n, 2 * n + 1):
-        try:
-            start = d.blocks.start(i)
-        except IndexError:
-            # Directly retrieving the start position failed, so check that
-            # indexing also fails.
-            with pytest.raises(IndexError):
-                d.blocksi
-            continue
-
-        # Directly retrieving the start position succeeded, so check that
-        # indexing also succeeds, and gives the same position.
-        assert start == d.blocksi.start
-
-
-def test_last_block_length():
-    d = ConjectureData.for_buffer(0 * 15)
-
-    with pytest.raises(IndexError):
-        d.blocks.last_block_length
-
-    for n in range(1, 5 + 1):
-        d.draw_bits(n * 8)
-        assert d.blocks.last_block_length == n
-
-
-def test_examples_show_up_as_discarded():
-    d = ConjectureData.for_buffer(1, 0, 1)
-
-    d.start_example(1)
-    d.draw_bits(1)
-    d.stop_example(discard=True)
-    d.start_example(1)
-    d.draw_bits(1)
-    d.stop_example()
-    d.freeze()
-
-    assert len(ex for ex in d.examples if ex.discarded) == 1
-
-
-def test_examples_support_negative_indexing():
-    d = ConjectureData.for_buffer(bytes(2))
-    d.draw_bits(1)
-    d.draw_bits(1)
-    d.freeze()
-    assert d.examples-1.length == 1
-
-
-def test_can_override_label():
-    d = ConjectureData.for_buffer(bytes(2))
-    d.draw(st.booleans(), label=7)
-    d.freeze()
-    assert any(ex.label == 7 for ex in d.examples)
-
-
-def test_will_mark_too_deep_examples_as_invalid():
-    d = ConjectureData.for_buffer(bytes(0))
-
-    s = st.none()
-    for _ in range(MAX_DEPTH + 1):
-        s = s.map(lambda x: None)
-
-    with pytest.raises(StopTest):
-        d.draw(s)
-    assert d.status == Status.INVALID
-
-
-def test_empty_strategy_is_invalid():
-    d = ConjectureData.for_buffer(bytes(0))
-    with pytest.raises(StopTest):
-        d.draw(st.nothing())
-    assert d.status == Status.INVALID
-
-
-def test_will_error_on_find():
-    d = ConjectureData.for_buffer(bytes(0))
-    d.is_find = True
-    with pytest.raises(InvalidArgument):
-        d.draw(st.data())
-
-
-def test_can_note_non_str():
-    d = ConjectureData.for_buffer(bytes(0))
-    x = object()
-    d.note(x)
-    assert repr(x) in d.output
-
-
-def test_can_note_str_as_non_repr():
-    d = ConjectureData.for_buffer(bytes(0))
-    d.note("foo")
-    assert d.output == "foo"
-
-
-def test_result_is_overrun():
-    d = ConjectureData.for_buffer(bytes(0))
-    with pytest.raises(StopTest):
-        d.draw_bits(1)
-    assert d.as_result() is Overrun
-
-
-def test_trivial_before_force_agrees_with_trivial_after():
-    d = ConjectureData.for_buffer(0, 1, 1)
-    d.draw_bits(1)
-    d.draw_bits(1, forced=1)
-    d.draw_bits(1)
-
-    t1 = d.blocks.trivial(i) for i in range(3)
-    d.freeze()
-    r = d.as_result()
-    t2 = b.trivial for b in r.blocks
-    assert d.blocks.owner is None
-    t3 = r.blocks.trivial(i) for i in range(3)
-
-    assert t1 == t2 == t3
-
-
-def test_events_are_noted():
-    d = ConjectureData.for_buffer(())
-    d.note_event("hello")
-    assert "hello" in d.events
-
-
-def test_blocks_end_points():
-    d = ConjectureData.for_buffer(bytes(4))
-    d.draw_bits(1)
-    d.draw_bits(16, forced=1)
-    d.draw_bits(8)
-    assert (
-        list(d.blocks.all_bounds())
-        == b.bounds for b in d.blocks
-        == (0, 1), (1, 3), (3, 4)
-    )
-
-
-def test_blocks_lengths():
-    d = ConjectureData.for_buffer(bytes(7))
-    d.draw_bits(32)
-    d.draw_bits(16)
-    d.draw_bits(1)
-    assert b.length for b in d.blocks == 4, 2, 1
-
-
-def test_child_indices():
-    d = ConjectureData.for_buffer(bytes(4))
-
-    d.start_example(0)  # examples1
-    d.start_example(0)  # examples2
-    d.draw_bits(1)  # examples3
-    d.draw_bits(1)  # examples4
-    d.stop_example()
-    d.stop_example()
-    d.draw_bits(1)  # examples5
-    d.draw_bits(1)  # examples6
-    d.freeze()
-
-    assert list(d.examples.children0) == 1, 5, 6
-    assert list(d.examples.children1) == 2
-    assert list(d.examples.children2) == 3, 4
-
-    assert d.examples0.parent is None
-    for ex in list(d.examples)1::
-        assert ex in d.examplesex.parent.children
-
-
-def test_example_equality():
-    d = ConjectureData.for_buffer(bytes(2))
-
-    d.start_example(0)
-    d.draw_bits(1)
-    d.stop_example()
-    d.start_example(0)
-    d.draw_bits(1)
-    d.stop_example()
-    d.freeze()
-
-    examples = list(d.examples)
-    for ex1, ex2 in itertools.combinations(examples, 2):
-        assert ex1 != ex2
-        assert not (ex1 == ex2)
-
-    for ex in examples:
-        assert ex == ex
-        not (ex != ex)
-
-        assert not (ex == "hello")
-        assert ex != "hello"
-
-
-@given(st.integers(0, 255), st.randoms(use_true_random=True))
-def test_partial_buffer(n, rnd):
-    data = ConjectureData(prefix=n, random=rnd, max_length=2)
-
-    assert data.draw_bytes(2)0 == n
-
-
-def test_structural_coverage_is_cached():
-    assert structural_coverage(50) is structural_coverage(50)
-
-
-def test_examples_create_structural_coverage():
-    data = ConjectureData.for_buffer(bytes(0))
-    data.start_example(42)
-    data.stop_example()
-    data.freeze()
-    assert structural_coverage(42) in data.tags
-
-
-def test_discarded_examples_do_not_create_structural_coverage():
-    data = ConjectureData.for_buffer(bytes(0))
-    data.start_example(42)
-    data.stop_example(discard=True)
-    data.freeze()
-    assert structural_coverage(42) not in data.tags
-
-
-def test_children_of_discarded_examples_do_not_create_structural_coverage():
-    data = ConjectureData.for_buffer(bytes(0))
-    data.start_example(10)
-    data.start_example(42)
-    data.stop_example()
-    data.stop_example(discard=True)
-    data.freeze()
-    assert structural_coverage(42) not in data.tags
-    assert structural_coverage(10) not in data.tags

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/conjecture/test_utils.py Deleted

@@ -1,329 +0,0 @@
-# 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/.
-
-from collections import Counter
-from fractions import Fraction
-
-import numpy as np
-import pytest
-
-from hypothesis import (
-    HealthCheck,
-    Phase,
-    assume,
-    example,
-    given,
-    reject,
-    settings,
-    strategies as st,
-)
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.conjecture.data import ConjectureData, Status, StopTest
-from hypothesis.internal.coverage import IN_COVERAGE_TESTS
-
-
-def test_does_draw_data_for_empty_range():
-    data = ConjectureData.for_buffer(b"\1")
-    assert cu.integer_range(data, 1, 1) == 1
-    data.freeze()
-    assert data.buffer == b"\0"
-
-
-def test_uniform_float_shrinks_to_zero():
-    d = ConjectureData.for_buffer(bytes(7))
-    assert cu.fractional_float(d) == 0.0
-    assert len(d.buffer) == 7
-
-
-def test_uniform_float_can_draw_1():
-    d = ConjectureData.for_buffer(bytes(255 * 7))
-    assert cu.fractional_float(d) == 1.0
-    assert len(d.buffer) == 7
-
-
-def test_coin_biased_towards_truth():
-    p = 1 - 1.0 / 500
-
-    for i in range(1, 255):
-        assert cu.biased_coin(ConjectureData.for_buffer(0, i, 0, 0), p)
-
-    assert not cu.biased_coin(ConjectureData.for_buffer(0, 0, 0, 1), p)
-
-
-def test_coin_biased_towards_falsehood():
-    p = 1.0 / 500
-
-    for i in range(255):
-        if i != 1:
-            assert not cu.biased_coin(ConjectureData.for_buffer(0, i, 0, 1), p)
-    assert cu.biased_coin(ConjectureData.for_buffer(0, 1, 0, 0), p)
-
-
-def test_unbiased_coin_has_no_second_order():
-    counts = Counter()
-
-    for i in range(256):
-        buf = bytes(i)
-        data = ConjectureData.for_buffer(buf)
-        result = cu.biased_coin(data, 0.5)
-        if data.buffer == buf:
-            countsresult += 1
-
-    assert countsFalse == countsTrue > 0
-
-
-def test_drawing_certain_coin_still_writes():
-    data = ConjectureData.for_buffer(0, 1)
-    assert not data.buffer
-    assert cu.biased_coin(data, 1)
-    assert data.buffer
-
-
-def test_drawing_impossible_coin_still_writes():
-    data = ConjectureData.for_buffer(1, 0)
-    assert not data.buffer
-    assert not cu.biased_coin(data, 0)
-    assert data.buffer
-
-
-def test_drawing_an_exact_fraction_coin():
-    count = 0
-    total = 0
-    p = Fraction(3, 8)
-    for i in range(4):
-        for j in range(4):
-            total += 1
-            if cu.biased_coin(ConjectureData.for_buffer(i, j, 0), p):
-                count += 1
-    assert p == Fraction(count, total)
-
-
-def test_too_small_to_be_useful_coin():
-    assert not cu.biased_coin(ConjectureData.for_buffer(1), 0.5**65)
-
-
-@example(Fraction(1, 3), Fraction(1, 3), Fraction(1, 3))
-@example(Fraction(1, 1), Fraction(1, 2))
-@example(Fraction(1, 2), Fraction(4, 10))
-@example(Fraction(1, 1), Fraction(3, 5), Fraction(1, 1))
-@example(Fraction(2, 257), Fraction(2, 5), Fraction(1, 11))
-@example(0, 2, 47)
-@settings(
-    deadline=None,
-    suppress_health_check=HealthCheck.all(),
-    phases=Phase.explicit if IN_COVERAGE_TESTS else settings.default.phases,
-)
-@given(st.lists(st.fractions(min_value=0, max_value=1), min_size=1))
-def test_sampler_distribution(weights):
-    total = sum(weights)
-    n = len(weights)
-
-    assume(total > 0)
-
-    probabilities = w / total for w in weights
-
-    sampler = cu.Sampler(weights)
-
-    calculated = Fraction(0) * n
-    for base, alternate, p_alternate in sampler.table:
-        calculatedbase += (1 - p_alternate) / n
-        calculatedalternate += p_alternate / n
-
-    for expected, actual in zip(probabilities, calculated):
-        if isinstance(actual, Fraction):
-            assert expected == actual
-        else:
-            assert abs(expected - actual) < 0.001
-
-
-def test_sampler_does_not_draw_minimum_if_zero():
-    sampler = cu.Sampler(0, 2, 47)
-    assert sampler.sample(ConjectureData.for_buffer(0, 0)) != 0
-
-
-def test_integer_range_center_upper():
-    assert (
-        cu.integer_range(ConjectureData.for_buffer(0), lower=0, upper=10, center=10)
-        == 10
-    )
-
-
-def test_integer_range_center_lower():
-    assert (
-        cu.integer_range(ConjectureData.for_buffer(0), lower=0, upper=10, center=0)
-        == 0
-    )
-
-
-def test_integer_range_lower_equals_upper():
-    data = ConjectureData.for_buffer(0)
-
-    assert cu.integer_range(data, lower=0, upper=0, center=0) == 0
-
-    assert len(data.buffer) == 1
-
-
-def test_integer_range_center_default():
-    assert (
-        cu.integer_range(ConjectureData.for_buffer(0), lower=0, upper=10, center=None)
-        == 0
-    )
-
-
-def test_center_in_middle_below():
-    assert (
-        cu.integer_range(ConjectureData.for_buffer(0, 0), lower=0, upper=10, center=5)
-        == 5
-    )
-
-
-def test_center_in_middle_above():
-    assert (
-        cu.integer_range(ConjectureData.for_buffer(1, 0), lower=0, upper=10, center=5)
-        == 5
-    )
-
-
-def test_restricted_bits():
-    assert (
-        cu.integer_range(
-            ConjectureData.for_buffer(1, 0, 0, 0, 0), lower=0, upper=2**64 - 1
-        )
-        == 0
-    )
-
-
-def test_sampler_shrinks():
-    sampler = cu.Sampler(4.0, 8.0, 1.0, 1.0, 0.5)
-    assert sampler.sample(ConjectureData.for_buffer(0 * 3)) == 0
-
-
-def test_combine_labels_is_distinct():
-    x = 10
-    y = 100
-    assert cu.combine_labels(x, y) not in (x, y)
-
-
-def test_invalid_numpy_sample():
-    with pytest.raises(InvalidArgument):
-        cu.check_sample(np.array(1, 1, 1, 1), "array")
-
-
-def test_valid_numpy_sample():
-    cu.check_sample(np.array(1, 2, 3), "array")
-
-
-def test_invalid_set_sample():
-    with pytest.raises(InvalidArgument):
-        cu.check_sample({1, 2, 3}, "array")
-
-
-def test_valid_list_sample():
-    cu.check_sample(1, 2, 3, "array")
-
-
-def test_choice():
-    assert cu.choice(ConjectureData.for_buffer(1), 1, 2, 3) == 2
-
-
-def test_fractional_float():
-    assert cu.fractional_float(ConjectureData.for_buffer(0 * 8)) == 0.0
-
-
-def test_fixed_size_draw_many():
-    many = cu.many(
-        ConjectureData.for_buffer(), min_size=3, max_size=3, average_size=3
-    )
-    assert many.more()
-    assert many.more()
-    assert many.more()
-    assert not many.more()
-
-
-def test_astronomically_unlikely_draw_many():
-    # Our internal helper doesn't underflow to zero or negative, but nor
-    # will we ever generate an element for such a low average size.
-    buffer = ConjectureData.for_buffer(1024 * 255)
-    many = cu.many(buffer, min_size=0, max_size=10, average_size=1e-5)
-    assert not many.more()
-
-
-def test_rejection_eventually_terminates_many():
-    many = cu.many(
-        ConjectureData.for_buffer(1 * 1000),
-        min_size=0,
-        max_size=1000,
-        average_size=100,
-    )
-    count = 0
-
-    while many.more():
-        count += 1
-        many.reject()
-
-    assert count <= 100
-
-
-def test_rejection_eventually_terminates_many_invalid_for_min_size():
-    data = ConjectureData.for_buffer(1 * 1000)
-    many = cu.many(data, min_size=1, max_size=1000, average_size=100)
-
-    with pytest.raises(StopTest):
-        while many.more():
-            many.reject()
-
-    assert data.status == Status.INVALID
-
-
-def test_many_with_min_size():
-    many = cu.many(
-        ConjectureData.for_buffer(0 * 10), min_size=2, average_size=10, max_size=1000
-    )
-    assert many.more()
-    assert many.more()
-    assert not many.more()
-
-
-def test_many_with_max_size():
-    many = cu.many(
-        ConjectureData.for_buffer(1 * 10), min_size=0, average_size=1, max_size=2
-    )
-    assert many.more()
-    assert many.more()
-    assert not many.more()
-
-
-def test_biased_coin_can_be_forced():
-    assert cu.biased_coin(ConjectureData.for_buffer(0), p=0.5, forced=True)
-    assert not cu.biased_coin(ConjectureData.for_buffer(1), p=0.5, forced=False)
-
-
-def test_assert_biased_coin_always_treats_one_as_true():
-    assert cu.biased_coin(ConjectureData.for_buffer(0, 1), p=1.0 / 257)
-
-
-@example(p=0.31250000000000006, b=b"\x03\x03\x00")
-@example(p=0.4375000000000001, b=b"\x03\x00")
-@given(st.floats(0, 1), st.binary())
-def test_can_draw_arbitrary_fractions(p, b):
-    try:
-        cu.biased_coin(ConjectureData.for_buffer(b), p)
-    except StopTest:
-        reject()
-
-
-def test_samples_from_a_range_directly():
-    s = cu.check_sample(range(10**1000), "")
-    assert isinstance(s, range)
-
-
-def test_p_continue_to_average_saturates():
-    assert cu._p_continue_to_avg(1.1, 100) == 100

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_annotations.py Deleted

@@ -1,134 +0,0 @@
-# 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/.
-
-from inspect import getfullargspec
-
-import attr
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.reflection import (
-    convert_positional_arguments,
-    define_function_signature,
-    get_pretty_function_description,
-)
-
-
-@given(st.integers())
-def test_has_an_annotation(i: int):
-    pass
-
-
-def universal_acceptor(*args, **kwargs):
-    return args, kwargs
-
-
-def has_annotation(a: int, *b, c=2) -> None:
-    pass
-
-
-@pytest.mark.parametrize("f", has_annotation, lambda *, a: a, lambda *, a=1: a)
-def test_copying_preserves_argspec(f):
-    af = getfullargspec(f)
-    t = define_function_signature("foo", "docstring", af)(universal_acceptor)
-    at = getfullargspec(t)
-    assert af.args == at.args: len(af.args)
-    assert af.varargs == at.varargs
-    assert af.varkw == at.varkw
-    assert len(af.defaults or ()) == len(at.defaults or ())
-    assert af.kwonlyargs == at.kwonlyargs
-    assert af.kwonlydefaults == at.kwonlydefaults
-    assert af.annotations == at.annotations
-
-
-@pytest.mark.parametrize(
-    "lam,source",
-    
-        ((lambda *z, a: a), "lambda *z, a: a"),
-        ((lambda *z, a=1: a), "lambda *z, a=1: a"),
-        ((lambda *, a: a), "lambda *, a: a"),
-        ((lambda *, a=1: a), "lambda *, a=1: a"),
-        ((lambda **kw: kw), "lambda **kw: kw"),
-    ,
-)
-def test_kwonly_lambda_formatting(lam, source):
-    # Testing kwonly lambdas, with and without varargs and default values
-    assert get_pretty_function_description(lam) == source
-
-
-def test_given_notices_missing_kwonly_args():
-    @given(a=st.none())
-    def reqs_kwonly(*, a, b):
-        pass
-
-    with pytest.raises(InvalidArgument):
-        reqs_kwonly()
-
-
-def test_converter_handles_kwonly_args():
-    def f(*, a, b=2):
-        pass
-
-    out = convert_positional_arguments(f, (), {"a": 1})
-    assert out == ((), {"a": 1, "b": 2})
-
-
-def test_converter_notices_missing_kwonly_args():
-    def f(*, a, b=2):
-        pass
-
-    with pytest.raises(TypeError):
-        assert convert_positional_arguments(f, (), {})
-
-
-def pointless_composite(draw: None, strat: bool, nothing: list) -> int:
-    return 3
-
-
-def return_annot() -> int:
-    return 4  # per RFC 1149.5 / xckd 221
-
-
-def first_annot(draw: None):
-    pass
-
-
-def test_composite_edits_annotations():
-    spec_comp = getfullargspec(st.composite(pointless_composite))
-    assert spec_comp.annotations"return" == st.SearchStrategyint
-    assert "nothing" in spec_comp.annotations
-    assert "draw" not in spec_comp.annotations
-
-
-@pytest.mark.parametrize("nargs", 1, 2, 3)
-def test_given_edits_annotations(nargs):
-    spec_given = getfullargspec(given(*(nargs * st.none()))(pointless_composite))
-    assert spec_given.annotations.pop("return") is None
-    assert len(spec_given.annotations) == 3 - nargs
-
-
-def a_converter(x) -> int:
-    return int(x)
-
-
-@attr.s
-class Inferrables:
-    annot_converter = attr.ib(converter=a_converter)
-
-
-@given(st.builds(Inferrables))
-def test_attrs_inference_builds(c):
-    pass
-
-
-@given(st.from_type(Inferrables))
-def test_attrs_inference_from_type(c):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_arbitrary_data.py Deleted

@@ -1,95 +0,0 @@
-# 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 pytest
-from pytest import raises
-
-from hypothesis import find, given, reporting, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.utils import capture_out
-
-
-@given(st.integers(), st.data())
-def test_conditional_draw(x, data):
-    y = data.draw(st.integers(min_value=x))
-    assert y >= x
-
-
-def test_prints_on_failure():
-    @given(st.data())
-    def test(data):
-        x = data.draw(st.lists(st.integers(0, 10), min_size=2))
-        y = data.draw(st.sampled_from(x))
-        x.remove(y)
-        if y in x:
-            raise ValueError()
-
-    with raises(ValueError):
-        with capture_out() as out:
-            with reporting.with_reporter(reporting.default):
-                test()
-    result = out.getvalue()
-    assert "Draw 1: 0, 0" in result
-    assert "Draw 2: 0" in result
-
-
-def test_prints_labels_if_given_on_failure():
-    @given(st.data())
-    def test(data):
-        x = data.draw(st.lists(st.integers(0, 10), min_size=2), label="Some numbers")
-        y = data.draw(st.sampled_from(x), label="A number")
-        assert y in x
-        x.remove(y)
-        assert y not in x
-
-    with raises(AssertionError):
-        with capture_out() as out:
-            with reporting.with_reporter(reporting.default):
-                test()
-    result = out.getvalue()
-    assert "Draw 1 (Some numbers): 0, 0" in result
-    assert "Draw 2 (A number): 0" in result
-
-
-def test_given_twice_is_same():
-    @given(st.data(), st.data())
-    def test(data1, data2):
-        data1.draw(st.integers())
-        data2.draw(st.integers())
-        raise ValueError()
-
-    with raises(ValueError):
-        with capture_out() as out:
-            with reporting.with_reporter(reporting.default):
-                test()
-    result = out.getvalue()
-    assert "Draw 1: 0" in result
-    assert "Draw 2: 0" in result
-
-
-def test_errors_when_used_in_find():
-    with raises(InvalidArgument):
-        find(st.data(), lambda x: x.draw(st.booleans()))
-
-
-@pytest.mark.parametrize("f", "filter", "map", "flatmap")
-def test_errors_when_normal_strategy_functions_are_used(f):
-    with raises(InvalidArgument):
-        getattr(st.data(), f)(lambda x: 1)
-
-
-def test_errors_when_asked_for_example():
-    with raises(InvalidArgument):
-        st.data().example()
-
-
-def test_nice_repr():
-    assert repr(st.data()) == "data()"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_async_def.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_asyncio.py Deleted

@@ -1,78 +0,0 @@
-# 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 asyncio
-import sys
-import warnings
-from unittest import TestCase
-
-import pytest
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.internal.compat import PYPY
-
-if sys.version_info < (3, 8):
-    coro_decorator = asyncio.coroutine
-else:
-
-    def coro_decorator(f):
-        with warnings.catch_warnings():
-            warnings.simplefilter(action="ignore", category=DeprecationWarning)
-            return asyncio.coroutine(f)
-
-
-class TestAsyncio(TestCase):
-
-    timeout = 5
-
-    def setUp(self):
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-
-    def tearDown(self):
-        self.loop.close()
-
-    def execute_example(self, f):
-        error = None
-
-        def g():
-            nonlocal error
-            try:
-                x = f()
-                if x is not None:
-                    yield from x
-            except BaseException as e:
-                error = e
-
-        coro = coro_decorator(g)
-        future = asyncio.wait_for(coro(), timeout=self.timeout)
-        self.loop.run_until_complete(future)
-        if error is not None:
-            raise error
-
-    @pytest.mark.skipif(PYPY, reason="Error in asyncio.new_event_loop()")
-    @given(x=st.text())
-    @coro_decorator
-    def test_foo(self, x):
-        assume(x)
-        yield from asyncio.sleep(0.001)
-        assert x
-
-
-class TestAsyncioRun(TestCase):
-    def execute_example(self, f):
-        asyncio.run(f())
-
-    @given(x=st.text())
-    @coro_decorator
-    def test_foo(self, x):
-        assume(x)
-        yield from asyncio.sleep(0.001)
-        assert x

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_attrs_inference.py Deleted

@@ -1,91 +0,0 @@
-# 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 typing
-
-import attr
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import ResolutionFailed
-
-
-@attr.s
-class Inferrables:
-    type_ = attr.ib(type=int)
-    type_converter = attr.ib(converter=bool)
-    validator_type = attr.ib(validator=attr.validators.instance_of(str))
-    validator_type_tuple = attr.ib(validator=attr.validators.instance_of((str, int)))
-    validator_type_multiple = attr.ib(
-        validator=
-            attr.validators.instance_of(str),
-            attr.validators.instance_of((str, int, bool)),
-        
-    )
-    validator_type_has_overlap = attr.ib(
-        validator=
-            attr.validators.instance_of(str),
-            attr.validators.instance_of((str, list)),
-            attr.validators.instance_of(object),
-        
-    )
-    validator_optional = attr.ib(
-        validator=attr.validators.optional(lambda inst, atrib, val: float(val))
-    )
-    validator_in = attr.ib(validator=attr.validators.in_(1, 2, 3))
-    validator_in_multiple = attr.ib(
-        validator=attr.validators.in_(list(range(100))), attr.validators.in_(1, -1)
-    )
-    validator_in_multiple_strings = attr.ib(
-        validator=attr.validators.in_("abcd"), attr.validators.in_("ab", "cd")
-    )
-
-    typing_list = attr.ib(type=typing.Listint)
-    typing_list_of_list = attr.ib(type=typing.Listtyping.Listint)
-    typing_dict = attr.ib(type=typing.Dictstr, int)
-    typing_union = attr.ib(type=typing.Optionalbool)
-    typing_union = attr.ib(type=typing.Unionstr, int)
-
-    has_default = attr.ib(default=0)
-    has_default_factory = attr.ib(default=attr.Factory(list))
-    has_default_factory_takes_self = attr.ib(  # uninferrable but has default
-        default=attr.Factory(lambda _: , takes_self=True)
-    )
-
-
-@attr.s
-class Required:
-    a = attr.ib()
-
-
-@attr.s
-class UnhelpfulConverter:
-    a = attr.ib(converter=lambda x: x)
-
-
-@given(st.builds(Inferrables, has_default=..., has_default_factory=...))
-def test_attrs_inference_builds(c):
-    pass
-
-
-@given(st.from_type(Inferrables))
-def test_attrs_inference_from_type(c):
-    pass
-
-
-@pytest.mark.parametrize("c", Required, UnhelpfulConverter)
-def test_cannot_infer(c):
-    with pytest.raises(ResolutionFailed):
-        st.builds(c).example()
-
-
-def test_cannot_infer_takes_self():
-    with pytest.raises(ResolutionFailed):
-        st.builds(Inferrables, has_default_factory_takes_self=...).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_cache_implementation.py Deleted

@@ -1,334 +0,0 @@
-# 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 threading
-from functools import partial
-from random import Random
-
-import pytest
-
-from hypothesis import (
-    HealthCheck,
-    assume,
-    example,
-    given,
-    note,
-    settings,
-    strategies as st,
-)
-from hypothesis.internal.cache import GenericCache, LRUReusedCache
-
-
-class LRUCache(GenericCache):
-    __slots__ = ("__tick",)
-
-    def __init__(self, max_size):
-        super().__init__(max_size)
-        self.__tick = 0
-
-    def new_entry(self, key, value):
-        return self.tick()
-
-    def on_access(self, key, value, score):
-        return self.tick()
-
-    def tick(self):
-        self.__tick += 1
-        return self.__tick
-
-
-class LFUCache(GenericCache):
-    def new_entry(self, key, value):
-        return 1
-
-    def on_access(self, key, value, score):
-        return score + 1
-
-
-@st.composite
-def write_pattern(draw, min_size=0):
-    keys = draw(st.lists(st.integers(0, 1000), unique=True, min_size=1))
-    values = draw(st.lists(st.integers(), unique=True, min_size=1))
-    return draw(
-        st.lists(
-            st.tuples(st.sampled_from(keys), st.sampled_from(values)), min_size=min_size
-        )
-    )
-
-
-class ValueScored(GenericCache):
-    def new_entry(self, key, value):
-        return value
-
-
-class RandomCache(GenericCache):
-    def __init__(self, max_size):
-        super().__init__(max_size)
-        self.random = Random(0)
-
-    def new_entry(self, key, value):
-        return self.random.random()
-
-    def on_access(self, key, value, score):
-        return self.random.random()
-
-
-@pytest.mark.parametrize(
-    "implementation", LRUCache, LFUCache, LRUReusedCache, ValueScored, RandomCache
-)
-@example(writes=(0, 0), (3, 0), (1, 0), (2, 0), (2, 0), (1, 0), size=4)
-@example(writes=(0, 0), size=1)
-@example(writes=(1, 0), (2, 0), (0, -1), (1, 0), size=3)
-@given(write_pattern(), st.integers(1, 10))
-def test_behaves_like_a_dict_with_losses(implementation, writes, size):
-    model = {}
-    target = implementation(max_size=size)
-
-    for k, v in writes:
-        try:
-            assert modelk == targetk
-        except KeyError:
-            pass
-        modelk = v
-        targetk = v
-        target.check_valid()
-        assert targetk == v
-        for r, s in model.items():
-            try:
-                assert s == targetr
-            except KeyError:
-                pass
-        assert len(target) <= min(len(model), size)
-
-
-@settings(suppress_health_check=HealthCheck.too_slow, deadline=None)
-@given(write_pattern(min_size=2), st.data())
-def test_always_evicts_the_lowest_scoring_value(writes, data):
-    scores = {}
-
-    n_keys = len({k for k, _ in writes})
-
-    assume(n_keys > 1)
-
-    size = data.draw(st.integers(1, n_keys - 1))
-
-    evicted = set()
-
-    def new_score(key):
-        scoreskey = data.draw(st.integers(0, 1000), label=f"scores{key!r}")
-        return scoreskey
-
-    last_entry = None
-
-    class Cache(GenericCache):
-        def new_entry(self, key, value):
-            last_entry0 = key
-            evicted.discard(key)
-            assert key not in scores
-            return new_score(key)
-
-        def on_access(self, key, value, score):
-            assert key in scores
-            return new_score(key)
-
-        def on_evict(self, key, value, score):
-            note(f"Evicted {key!r}")
-            assert score == scoreskey
-            del scoreskey
-            if len(scores) > 1:
-                assert score <= min(v for k, v in scores.items() if k != last_entry0)
-            evicted.add(key)
-
-    target = Cache(max_size=size)
-    model = {}
-
-    for k, v in writes:
-        targetk = v
-        modelk = v
-
-    assert evicted
-    assert len(evicted) + len(target) == len(model)
-    assert len(scores) == len(target)
-
-    for k, v in model.items():
-        try:
-            assert targetk == v
-            assert k not in evicted
-        except KeyError:
-            assert k in evicted
-
-
-def test_basic_access():
-    cache = ValueScored(max_size=2)
-    cache1 = 0
-    cache1 = 0
-    cache0 = 1
-    cache2 = 0
-    assert cache2 == 0
-    assert cache0 == 1
-    assert len(cache) == 2
-
-
-def test_can_clear_a_cache():
-    x = ValueScored(1)
-    x0 = 1
-    assert len(x) == 1
-    x.clear()
-    assert len(x) == 0
-
-
-def test_max_size_cache_ignores():
-    x = ValueScored(0)
-    x0 = 1
-    with pytest.raises(KeyError):
-        x0
-
-
-def test_pinning_prevents_eviction():
-    cache = LRUReusedCache(max_size=10)
-    cache20 = 1
-    cache.pin(20)
-    for i in range(20):
-        cachei = 0
-    assert cache20 == 1
-
-
-def test_unpinning_allows_eviction():
-    cache = LRUReusedCache(max_size=10)
-    cache20 = True
-    cache.pin(20)
-    for i in range(20):
-        cachei = False
-
-    assert 20 in cache
-
-    cache.unpin(20)
-    cache21 = False
-
-    assert 20 not in cache
-
-
-def test_unpins_must_match_pins():
-    cache = LRUReusedCache(max_size=2)
-    cache1 = 1
-    cache.pin(1)
-    assert cache.is_pinned(1)
-    cache.pin(1)
-    assert cache.is_pinned(1)
-    cache.unpin(1)
-    assert cache.is_pinned(1)
-    cache.unpin(1)
-    assert not cache.is_pinned(1)
-
-
-def test_will_error_instead_of_evicting_pin():
-    cache = LRUReusedCache(max_size=1)
-    cache1 = 1
-    cache.pin(1)
-    with pytest.raises(ValueError):
-        cache2 = 2
-
-
-def test_will_error_for_bad_unpin():
-    cache = LRUReusedCache(max_size=1)
-    cache1 = 1
-    with pytest.raises(ValueError):
-        cache.unpin(1)
-
-
-def test_still_inserts_if_score_is_worse():
-    class TC(GenericCache):
-        def new_entry(self, key, value):
-            return key
-
-    cache = TC(1)
-
-    cache0 = 1
-    cache1 = 1
-
-    assert 0 not in cache
-    assert 1 in cache
-    assert len(cache) == 1
-
-
-def test_does_insert_if_score_is_better():
-    class TC(GenericCache):
-        def new_entry(self, key, value):
-            return value
-
-    cache = TC(1)
-
-    cache0 = 1
-    cache1 = 0
-
-    assert 0 not in cache
-    assert 1 in cache
-    assert len(cache) == 1
-
-
-def test_double_pinning_does_not_increase_pin_count():
-    cache = LRUReusedCache(2)
-    cache0 = 0
-    cache.pin(0)
-    cache.pin(0)
-    cache1 = 1
-    assert len(cache) == 2
-
-
-def test_can_add_new_keys_after_unpinning():
-    cache = LRUReusedCache(1)
-    cache0 = 0
-    cache.pin(0)
-    cache.unpin(0)
-    cache1 = 1
-    assert len(cache) == 1
-    assert 1 in cache
-
-
-def test_iterates_over_remaining_keys():
-    cache = LRUReusedCache(2)
-    for i in range(3):
-        cachei = "hi"
-    assert sorted(cache) == 1, 2
-
-
-def test_cache_is_threadsafe_issue_2433_regression():
-    errors = 
-
-    def target():
-        for _ in range(1000):
-            try:
-                st.builds(partial(str))
-            except Exception as exc:
-                errors.append(exc)
-
-    workers = threading.Thread(target=target) for _ in range(4)
-    for worker in workers:
-        worker.start()
-    for worker in workers:
-        worker.join()
-
-    assert not errors
-
-
-def test_pin_and_unpin_are_noops_if_dropped():
-    # See https://github.com/HypothesisWorks/hypothesis/issues/3169
-    cache = LRUReusedCache(max_size=10)
-    cache30 = True
-    assert 30 in cache
-
-    for i in range(20):
-        cachei = False
-
-    assert 30 not in cache
-    cache.pin(30)
-    assert 30 not in cache
-    cache.unpin(30)
-    assert 30 not in cache

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_caching.py Deleted

@@ -1,46 +0,0 @@
-# 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 pytest
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument
-
-
-def test_no_args():
-    assert st.text() is st.text()
-
-
-def test_tuple_lengths():
-    assert st.tuples(st.integers()) is st.tuples(st.integers())
-    assert st.tuples(st.integers()) is not st.tuples(st.integers(), st.integers())
-
-
-def test_values():
-    assert st.integers() is not st.integers(min_value=1)
-
-
-def test_alphabet_key():
-    assert st.text(alphabet="abcs") is st.text(alphabet="abcs")
-
-
-def test_does_not_error_on_unhashable_posarg():
-    st.text("a", "b", "c")
-
-
-def test_does_not_error_on_unhashable_kwarg():
-    with pytest.raises(InvalidArgument):
-        st.builds(lambda alphabet: 1, alphabet="a", "b", "c").validate()
-
-
-def test_caches_floats_sensitively():
-    assert st.floats(min_value=0.0) is st.floats(min_value=0.0)
-    assert st.floats(min_value=0.0) is not st.floats(min_value=0)
-    assert st.floats(min_value=0.0) is not st.floats(min_value=-0.0)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_cathetus.py Deleted

@@ -1,150 +0,0 @@
-# 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 math
-import sys
-from sys import float_info
-
-import pytest
-
-from hypothesis import assume, given
-from hypothesis.internal.cathetus import cathetus
-from hypothesis.strategies import floats
-
-
-def test_cathetus_subnormal_underflow():
-    u = sys.float_info.min * sys.float_info.epsilon
-    h = 5 * u
-    a = 4 * u
-    assert cathetus(h, a) == 3 * u
-
-
-def test_cathetus_simple_underflow():
-    a = sys.float_info.min
-    h = a * math.sqrt(2)
-    b = cathetus(h, a)
-    assert b > 0, f"expecting positive cathetus({h:g}, {a:g}), got {b:g}"
-
-
-def test_cathetus_huge_no_overflow():
-    h = sys.float_info.max
-    a = h / math.sqrt(2)
-    b = cathetus(h, a)
-    assert math.isfinite(b), f"expecting finite cathetus({h:g}, {a:g}), got {b:g}"
-
-
-def test_cathetus_large_no_overflow():
-    h = sys.float_info.max / 3
-    a = h / math.sqrt(2)
-    b = cathetus(h, a)
-    assert math.isfinite(b), f"expecting finite cathetus({h:g}, {a:g}), got {b:g}"
-
-
-@pytest.mark.parametrize(
-    "h,a",
-    
-        # NaN hypot
-        (math.nan, 3),
-        (math.nan, 0),
-        (math.nan, math.inf),
-        (math.nan, math.nan),
-        # Infeasible
-        (2, 3),
-        (2, -3),
-        (2, math.inf),
-        (2, math.nan),
-        # Surprisingly consistent with c99 hypot()
-        (math.inf, math.inf),
-    ,
-)
-def test_cathetus_nan(h, a):
-    assert math.isnan(cathetus(h, a))
-
-
-@pytest.mark.parametrize(
-    "h,a", (math.inf, 3), (math.inf, -3), (math.inf, 0), (math.inf, math.nan)
-)
-def test_cathetus_infinite(h, a):
-    assert math.isinf(cathetus(h, a))
-
-
-@pytest.mark.parametrize(
-    "h,a,b", (-5, 4, 3), (5, -4, 3), (-5, -4, 3), (0, 0, 0), (1, 0, 1)
-)
-def test_cathetus_signs(h, a, b):
-    assert abs(cathetus(h, a) - b) <= abs(b) * float_info.epsilon
-
-
-@given(
-    h=floats(0) | floats(min_value=1e308, allow_infinity=False),
-    a=floats(0, allow_infinity=False)
-    | floats(min_value=0, max_value=1e250, allow_infinity=False),
-)
-def test_cathetus_always_leq_hypot(h, a):
-    assume(h >= a)
-    b = cathetus(h, a)
-    assert 0 <= b <= h
-
-
-@pytest.mark.parametrize(
-    "a,b,h",
-    
-        (3, 4, 5),
-        (5, 12, 13),
-        (8, 15, 17),
-        (7, 24, 25),
-        (20, 21, 29),
-        (12, 35, 37),
-        (9, 40, 41),
-        (28, 45, 53),
-        (11, 60, 61),
-        (16, 63, 65),
-        (33, 56, 65),
-        (48, 55, 73),
-        (13, 84, 85),
-        (36, 77, 85),
-        (39, 80, 89),
-        (65, 72, 97),
-        (20, 99, 101),
-        (60, 91, 109),
-        (15, 112, 113),
-        (44, 117, 125),
-        (88, 105, 137),
-        (17, 144, 145),
-        (24, 143, 145),
-        (51, 140, 149),
-        (85, 132, 157),
-        (119, 120, 169),
-        (52, 165, 173),
-        (19, 180, 181),
-        (57, 176, 185),
-        (104, 153, 185),
-        (95, 168, 193),
-        (28, 195, 197),
-        (84, 187, 205),
-        (133, 156, 205),
-        (21, 220, 221),
-        (140, 171, 221),
-        (60, 221, 229),
-        (105, 208, 233),
-        (120, 209, 241),
-        (32, 255, 257),
-        (23, 264, 265),
-        (96, 247, 265),
-        (69, 260, 269),
-        (115, 252, 277),
-        (160, 231, 281),
-        (161, 240, 289),
-        (68, 285, 293),
-    ,
-)
-def test_pythagorean_triples(a, b, h):
-    assert abs(math.hypot(a, b) - h) <= abs(h) * float_info.epsilon
-    assert abs(cathetus(h, a) - b) <= abs(b) * float_info.epsilon

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_charmap.py Deleted

@@ -1,196 +0,0 @@
-# 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 os
-import sys
-import tempfile
-import time
-import unicodedata
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.internal import charmap as cm
-
-
-def test_charmap_contains_all_unicode():
-    n = 0
-    for vs in cm.charmap().values():
-        for u, v in vs:
-            n += v - u + 1
-    assert n == sys.maxunicode + 1
-
-
-def test_charmap_has_right_categories():
-    for cat, intervals in cm.charmap().items():
-        for u, v in intervals:
-            for i in range(u, v + 1):
-                real = unicodedata.category(chr(i))
-                assert real == cat, f"{i} is {real} but reported in {cat}"
-
-
-def assert_valid_range_list(ls):
-    for u, v in ls:
-        assert u <= v
-    for i in range(len(ls) - 1):
-        assert lsi <= lsi + 1
-        assert lsi-1 < lsi + 10
-
-
-@given(
-    st.sets(st.sampled_from(cm.categories())),
-    st.sets(st.sampled_from(cm.categories())) | st.none(),
-)
-def test_query_matches_categories(exclude, include):
-    values = cm.query(exclude, include)
-    assert_valid_range_list(values)
-    for u, v in values:
-        for i in (u, v, (u + v) // 2):
-            cat = unicodedata.category(chr(i))
-            if include is not None:
-                assert cat in include
-            assert cat not in exclude
-
-
-@given(
-    st.sets(st.sampled_from(cm.categories())),
-    st.sets(st.sampled_from(cm.categories())) | st.none(),
-    st.integers(0, sys.maxunicode),
-    st.integers(0, sys.maxunicode),
-)
-def test_query_matches_categories_codepoints(exclude, include, m1, m2):
-    m1, m2 = sorted((m1, m2))
-    values = cm.query(exclude, include, min_codepoint=m1, max_codepoint=m2)
-    assert_valid_range_list(values)
-    for u, v in values:
-        assert m1 <= u
-        assert v <= m2
-
-
-@given(st.sampled_from(cm.categories()), st.integers(0, sys.maxunicode))
-def test_exclude_only_excludes_from_that_category(cat, i):
-    c = chr(i)
-    assume(unicodedata.category(c) != cat)
-    intervals = cm.query(exclude_categories=(cat,))
-    assert any(a <= i <= b for a, b in intervals)
-
-
-def test_reload_charmap():
-    x = cm.charmap()
-    assert x is cm.charmap()
-    cm._charmap = None
-    y = cm.charmap()
-    assert x is not y
-    assert x == y
-
-
-def test_recreate_charmap():
-    x = cm.charmap()
-    assert x is cm.charmap()
-    cm._charmap = None
-    os.unlink(cm.charmap_file())
-    y = cm.charmap()
-    assert x is not y
-    assert x == y
-
-
-def test_uses_cached_charmap():
-    cm.charmap()
-
-    # Reset the last-modified time of the cache file to a point in the past.
-    mtime = int(time.time() - 1000)
-    os.utime(cm.charmap_file(), (mtime, mtime))
-    statinfo = os.stat(cm.charmap_file())
-    assert statinfo.st_mtime == mtime
-
-    # Force reload of charmap from cache file and check that mtime is unchanged.
-    cm._charmap = None
-    cm.charmap()
-    statinfo = os.stat(cm.charmap_file())
-    assert statinfo.st_mtime == mtime
-
-
-def test_union_empty():
-    assert cm._union_intervals(, ) == ()
-    assert cm._union_intervals(, 1, 2) == ((1, 2),)
-    assert cm._union_intervals(1, 2, ) == ((1, 2),)
-
-
-def test_union_handles_totally_overlapped_gap():
-    #   < xx  >  Imagine the intervals x and y as bit strings.
-    # | <yy yy>  The bit at position n is set if n falls inside that interval.
-    # = <zzzzz>  In this model _union_intervals() performs bit-wise or.
-    assert cm._union_intervals(2, 3, 1, 2, 4, 5) == ((1, 5),)
-
-
-def test_union_handles_partially_overlapped_gap():
-    #   <  x  >  Imagine the intervals x and y as bit strings.
-    # | <yy  y>  The bit at position n is set if n falls inside that interval.
-    # = <zzz z>  In this model _union_intervals() performs bit-wise or.
-    assert cm._union_intervals(3, 3, 1, 2, 5, 5) == ((1, 3), (5, 5))
-
-
-def test_successive_union():
-    x = 
-    for v in cm.charmap().values():
-        x = cm._union_intervals(x, v)
-    assert x == ((0, sys.maxunicode),)
-
-
-def test_can_handle_race_between_exist_and_create(monkeypatch):
-    x = cm.charmap()
-    cm._charmap = None
-    monkeypatch.setattr(os.path, "exists", lambda p: False)
-    y = cm.charmap()
-    assert x is not y
-    assert x == y
-
-
-def test_exception_in_write_does_not_lead_to_broken_charmap(monkeypatch):
-    def broken(*args, **kwargs):
-        raise ValueError()
-
-    cm._charmap = None
-    monkeypatch.setattr(os.path, "exists", lambda p: False)
-    monkeypatch.setattr(os, "rename", broken)
-
-    cm.charmap()
-    cm.charmap()
-
-
-def test_regenerate_broken_charmap_file():
-    cm.charmap()
-    file_loc = cm.charmap_file()
-
-    with open(file_loc, "wb"):
-        pass
-
-    cm._charmap = None
-    cm.charmap()
-
-
-def test_exclude_characters_are_included_in_key():
-    assert cm.query() != cm.query(exclude_characters="0")
-
-
-def test_error_writing_charmap_file_is_suppressed(monkeypatch):
-    def broken_mkstemp(dir):
-        raise RuntimeError()
-
-    monkeypatch.setattr(tempfile, "mkstemp", broken_mkstemp)
-
-    try:
-        # Cache the charmap to avoid a performance hit the next time
-        # somebody tries to use it.
-        saved = cm._charmap
-        cm._charmap = None
-        os.unlink(cm.charmap_file())
-
-        cm.charmap()
-    finally:
-        cm._charmap = saved

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_compat.py Deleted

@@ -1,47 +0,0 @@
-# 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 math
-from inspect import Parameter, Signature
-
-import pytest
-
-from hypothesis.internal.compat import ceil, floor, get_type_hints
-
-floor_ceil_values = 
-    -10.7,
-    -10.3,
-    -0.5,
-    -0.0,
-    0,
-    0.5,
-    10.3,
-    10.7,
-
-
-
-@pytest.mark.parametrize("value", floor_ceil_values)
-def test_our_floor_agrees_with_math_floor(value):
-    assert floor(value) == math.floor(value)
-
-
-@pytest.mark.parametrize("value", floor_ceil_values)
-def test_our_ceil_agrees_with_math_ceil(value):
-    assert ceil(value) == math.ceil(value)
-
-
-class WeirdSig:
-    __signature__ = Signature(
-        parameters=Parameter(name="args", kind=Parameter.VAR_POSITIONAL)
-    )
-
-
-def test_no_type_hints():
-    assert get_type_hints(WeirdSig) == {}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_complex_numbers.py Deleted

@@ -1,91 +0,0 @@
-# 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 math
-import sys
-
-from hypothesis import given, reject, strategies as st
-from hypothesis.strategies import complex_numbers
-
-from tests.common.debug import minimal
-
-
-def test_minimal():
-    assert minimal(complex_numbers(), lambda x: True) == 0
-
-
-def test_minimal_nonzero_real():
-    assert minimal(complex_numbers(), lambda x: x.real != 0) == 1
-
-
-def test_minimal_nonzero_imaginary():
-    assert minimal(complex_numbers(), lambda x: x.imag != 0) == 1j
-
-
-def test_minimal_quadrant1():
-    assert minimal(complex_numbers(), lambda x: x.imag > 0 and x.real > 0) == 1 + 1j
-
-
-def test_minimal_quadrant2():
-    assert minimal(complex_numbers(), lambda x: x.imag > 0 and x.real < 0) == -1 + 1j
-
-
-def test_minimal_quadrant3():
-    assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real < 0) == -1 - 1j
-
-
-def test_minimal_quadrant4():
-    assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real > 0) == 1 - 1j
-
-
-@given(st.data(), st.integers(-5, 5).map(lambda x: 10**x))
-def test_max_magnitude_respected(data, mag):
-    c = data.draw(complex_numbers(max_magnitude=mag))
-    assert abs(c) <= mag * (1 + sys.float_info.epsilon)
-
-
-@given(complex_numbers(max_magnitude=0))
-def test_max_magnitude_zero(val):
-    assert val == 0
-
-
-@given(st.data(), st.integers(-5, 5).map(lambda x: 10**x))
-def test_min_magnitude_respected(data, mag):
-    c = data.draw(complex_numbers(min_magnitude=mag))
-    assert (
-        abs(c.real) >= mag
-        or abs(c.imag) >= mag
-        or abs(c) >= mag * (1 - sys.float_info.epsilon)
-    )
-
-
-def test_minimal_min_magnitude_zero():
-    assert minimal(complex_numbers(min_magnitude=0), lambda x: True) == 0
-
-
-def test_minimal_min_magnitude_positive():
-    assert minimal(complex_numbers(min_magnitude=0.5), lambda x: True) in (0.5, 1)
-
-
-def test_minimal_minmax_magnitude():
-    assert minimal(
-        complex_numbers(min_magnitude=0.5, max_magnitude=1.5), lambda x: True
-    ) in (0.5, 1)
-
-
-@given(st.data(), st.floats(0, 10e300, allow_infinity=False, allow_nan=False))
-def test_minmax_magnitude_equal(data, mag):
-    val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag))
-    try:
-        # Cap magnitude at 10e300 to avoid float overflow, and imprecision
-        # at very large exponents (which makes math.isclose fail)
-        assert math.isclose(abs(val), mag)
-    except OverflowError:
-        reject()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_composite.py Deleted

@@ -1,178 +0,0 @@
-# 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 pytest
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.debug import minimal
-from tests.common.utils import flaky
-
-
-@st.composite
-def badly_draw_lists(draw, m=0):
-    length = draw(st.integers(m, m + 10))
-    return draw(st.integers()) for _ in range(length)
-
-
-def test_simplify_draws():
-    assert minimal(badly_draw_lists(), lambda x: len(x) >= 3) == 0 * 3
-
-
-def test_can_pass_through_arguments():
-    assert minimal(badly_draw_lists(5), lambda x: True) == 0 * 5
-    assert minimal(badly_draw_lists(m=6), lambda x: True) == 0 * 6
-
-
-@st.composite
-def draw_ordered_with_assume(draw):
-    x = draw(st.floats())
-    y = draw(st.floats())
-    assume(x < y)
-    return (x, y)
-
-
-@given(draw_ordered_with_assume())
-def test_can_assume_in_draw(xy):
-    assert xy0 < xy1
-
-
-def test_uses_definitions_for_reprs():
-    assert repr(badly_draw_lists()) == "badly_draw_lists()"
-    assert repr(badly_draw_lists(1)) == "badly_draw_lists(m=1)"
-    assert repr(badly_draw_lists(m=1)) == "badly_draw_lists(m=1)"
-
-
-def test_errors_given_default_for_draw():
-    with pytest.raises(InvalidArgument):
-
-        @st.composite
-        def foo(x=None):
-            pass
-
-
-def test_errors_given_function_of_no_arguments():
-    with pytest.raises(InvalidArgument):
-
-        @st.composite
-        def foo():
-            pass
-
-
-def test_errors_given_kwargs_only():
-    with pytest.raises(InvalidArgument):
-
-        @st.composite
-        def foo(**kwargs):
-            pass
-
-
-def test_can_use_pure_args():
-    @st.composite
-    def stuff(*args):
-        return args0(st.sampled_from(args1:))
-
-    assert minimal(stuff(1, 2, 3, 4, 5), lambda x: True) == 1
-
-
-def test_composite_of_lists():
-    @st.composite
-    def f(draw):
-        return draw(st.integers()) + draw(st.integers())
-
-    assert minimal(st.lists(f()), lambda x: len(x) >= 10) == 0 * 10
-
-
-@flaky(min_passes=2, max_runs=5)
-def test_can_shrink_matrices_with_length_param():
-    @st.composite
-    def matrix(draw):
-        rows = draw(st.integers(1, 10))
-        columns = draw(st.integers(1, 10))
-        return 
-            draw(st.integers(0, 10000)) for _ in range(columns) for _ in range(rows)
-        
-
-    def transpose(m):
-        return rowi for row in m for i in range(len(m0))
-
-    def is_square(m):
-        return len(m) == len(m0)
-
-    value = minimal(matrix(), lambda m: is_square(m) and transpose(m) != m)
-    assert len(value) == 2
-    assert len(value0) == 2
-    assert sorted(value0 + value1) == 0, 0, 0, 1
-
-
-class MyList(list):
-    pass
-
-
-@given(st.data(), st.lists(st.integers()).map(MyList))
-def test_does_not_change_arguments(data, ls):
-    # regression test for issue #1017 or other argument mutation
-    @st.composite
-    def strat(draw, arg):
-        return arg
-
-    ex = data.draw(strat(ls))
-    assert ex is ls
-
-
-class ClsWithStrategyMethods:
-    @classmethod
-    @st.composite
-    def st_classmethod_then_composite(draw, cls):  # noqa: B902
-        return draw(st.integers(0, 10))
-
-    @st.composite
-    @classmethod
-    def st_composite_then_classmethod(draw, cls):  # noqa: B902
-        return draw(st.integers(0, 10))
-
-    @staticmethod
-    @st.composite
-    def st_staticmethod_then_composite(draw):
-        return draw(st.integers(0, 10))
-
-    @st.composite
-    @staticmethod
-    def st_composite_then_staticmethod(draw):
-        return draw(st.integers(0, 10))
-
-    @st.composite
-    def st_composite_method(draw, self):  # noqa: B902
-        return draw(st.integers(0, 10))
-
-
-@given(st.data())
-def test_applying_composite_decorator_to_methods(data):
-    instance = ClsWithStrategyMethods()
-    for strategy in 
-        ClsWithStrategyMethods.st_classmethod_then_composite(),
-        ClsWithStrategyMethods.st_composite_then_classmethod(),
-        ClsWithStrategyMethods.st_staticmethod_then_composite(),
-        ClsWithStrategyMethods.st_composite_then_staticmethod(),
-        instance.st_classmethod_then_composite(),
-        instance.st_composite_then_classmethod(),
-        instance.st_staticmethod_then_composite(),
-        instance.st_composite_then_staticmethod(),
-        instance.st_composite_method(),
-    :
-        x = data.draw(strategy)
-        assert isinstance(x, int)
-        assert 0 <= x <= 10
-
-
-def test_drawfn_cannot_be_instantiated():
-    with pytest.raises(TypeError):
-        st.DrawFn()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_composite_kwonlyargs.py Deleted

@@ -1,29 +0,0 @@
-# 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/.
-
-from hypothesis import given, strategies as st
-
-# Tests that convert_keyword_arguments in reflection.py can handle
-# composites that only have keyword-only arguments.
-# See https://github.com/HypothesisWorks/hypothesis/issues/1999
-
-
-@st.composite
-def kwonlyargs_composites(draw, *, kwarg1=None):
-    return draw(st.fixed_dictionaries({"kwarg1": st.just(kwarg1), "i": st.integers()}))
-
-
-@given(
-    st.lists(
-        st.one_of(kwonlyargs_composites(kwarg1="test")), unique_by=lambda x: x"i"
-    )
-)
-def test_composite_with_keyword_only_args(a):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_control.py Deleted

@@ -1,174 +0,0 @@
-# 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 pytest
-
-from hypothesis import Verbosity, given, reporting, settings
-from hypothesis.control import (
-    BuildContext,
-    _current_build_context,
-    cleanup,
-    current_build_context,
-    currently_in_test_context,
-    event,
-    note,
-)
-from hypothesis.errors import CleanupFailed, InvalidArgument
-from hypothesis.internal.conjecture.data import ConjectureData as TD
-from hypothesis.stateful import RuleBasedStateMachine, rule
-from hypothesis.strategies import integers
-
-from tests.common.utils import capture_out
-
-
-def bc():
-    return BuildContext(TD.for_buffer(b""))
-
-
-def test_cannot_cleanup_with_no_context():
-    with pytest.raises(InvalidArgument):
-        cleanup(lambda: None)
-    assert _current_build_context.value is None
-
-
-def test_cannot_event_with_no_context():
-    with pytest.raises(InvalidArgument):
-        event("hi")
-    assert _current_build_context.value is None
-
-
-def test_cleanup_executes_on_leaving_build_context():
-    data = 
-    with bc():
-        cleanup(lambda: data.append(1))
-        assert not data
-    assert data == 1
-    assert _current_build_context.value is None
-
-
-def test_can_nest_build_context():
-    data = 
-    with bc():
-        cleanup(lambda: data.append(1))
-        with bc():
-            cleanup(lambda: data.append(2))
-            assert not data
-        assert data == 2
-    assert data == 2, 1
-    assert _current_build_context.value is None
-
-
-def test_does_not_suppress_exceptions():
-    with pytest.raises(AssertionError):
-        with bc():
-            raise AssertionError
-    assert _current_build_context.value is None
-
-
-def test_suppresses_exceptions_in_teardown():
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            with bc():
-
-                def foo():
-                    raise ValueError()
-
-                cleanup(foo)
-                raise AssertionError
-
-    assert "ValueError" in o.getvalue()
-    assert _current_build_context.value is None
-
-
-def test_runs_multiple_cleanup_with_teardown():
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            with bc():
-
-                def foo():
-                    raise ValueError()
-
-                cleanup(foo)
-
-                def bar():
-                    raise TypeError()
-
-                cleanup(foo)
-                cleanup(bar)
-                raise AssertionError
-
-    assert "ValueError" in o.getvalue()
-    assert "TypeError" in o.getvalue()
-    assert _current_build_context.value is None
-
-
-def test_raises_error_if_cleanup_fails_but_block_does_not():
-    with pytest.raises(CleanupFailed):
-        with bc():
-
-            def foo():
-                raise ValueError()
-
-            cleanup(foo)
-    assert _current_build_context.value is None
-
-
-def test_raises_if_note_out_of_context():
-    with pytest.raises(InvalidArgument):
-        note("Hi")
-
-
-def test_raises_if_current_build_context_out_of_context():
-    with pytest.raises(InvalidArgument):
-        current_build_context()
-
-
-def test_current_build_context_is_current():
-    with bc() as a:
-        assert current_build_context() is a
-
-
-def test_prints_all_notes_in_verbose_mode():
-    # slightly roundabout because @example messes with verbosity - see #1521
-    messages = set()
-
-    @settings(verbosity=Verbosity.debug, database=None)
-    @given(integers(1, 10))
-    def test(x):
-        msg = f"x -> {x}"
-        note(msg)
-        messages.add(msg)
-        assert x < 5
-
-    with capture_out() as out:
-        with reporting.with_reporter(reporting.default):
-            with pytest.raises(AssertionError):
-                test()
-    v = out.getvalue()
-    for x in sorted(messages):
-        assert x in v
-
-
-def test_not_currently_in_hypothesis():
-    assert currently_in_test_context() is False
-
-
-@given(integers())
-def test_currently_in_hypothesis(_):
-    assert currently_in_test_context() is True
-
-
-class ContextMachine(RuleBasedStateMachine):
-    @rule()
-    def step(self):
-        assert currently_in_test_context() is True
-
-
-test_currently_in_stateful_test = ContextMachine.TestCase

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_core.py Deleted

@@ -1,113 +0,0 @@
-# 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 pytest
-from _pytest.outcomes import Failed, Skipped
-
-from hypothesis import find, given, reject, settings, strategies as s
-from hypothesis.errors import InvalidArgument, NoSuchExample, Unsatisfiable
-
-
-def test_stops_after_max_examples_if_satisfying():
-    tracker = 
-
-    def track(x):
-        tracker.append(x)
-        return False
-
-    max_examples = 100
-
-    with pytest.raises(NoSuchExample):
-        find(s.integers(0, 10000), track, settings=settings(max_examples=max_examples))
-
-    assert len(tracker) == max_examples
-
-
-def test_stops_after_ten_times_max_examples_if_not_satisfying():
-    count = 0
-
-    def track(x):
-        count0 += 1
-        reject()
-
-    max_examples = 100
-
-    with pytest.raises(Unsatisfiable):
-        find(s.integers(0, 10000), track, settings=settings(max_examples=max_examples))
-
-    # Very occasionally we can generate overflows in generation, which also
-    # count towards our example budget, which means that we don't hit the
-    # maximum.
-    assert count0 <= 10 * max_examples
-
-
-some_normal_settings = settings()
-
-
-def test_is_not_normally_default():
-    assert settings.default is not some_normal_settings
-
-
-@given(s.booleans())
-@some_normal_settings
-def test_settings_are_default_in_given(x):
-    assert settings.default is some_normal_settings
-
-
-def test_given_shrinks_pytest_helper_errors():
-    final_value = None
-
-    @settings(derandomize=True, max_examples=100)
-    @given(s.integers())
-    def inner(x):
-        final_value0 = x
-        if x > 100:
-            pytest.fail(f"x={x!r} is too big!")
-
-    with pytest.raises(Failed):
-        inner()
-    assert final_value0 == 101
-
-
-def test_pytest_skip_skips_shrinking():
-    values = 
-
-    @settings(derandomize=True, max_examples=100)
-    @given(s.integers())
-    def inner(x):
-        values.append(x)
-        if x > 100:
-            pytest.skip(f"x={x!r} is too big!")
-
-    with pytest.raises(Skipped):
-        inner()
-    assert len(x for x in values if x > 100) == 1
-
-
-def test_can_find_with_db_eq_none():
-    find(s.integers(), bool, settings=settings(database=None, max_examples=100))
-
-
-def test_no_such_example():
-    with pytest.raises(NoSuchExample):
-        find(s.none(), bool, database_key=b"no such example")
-
-
-def test_validates_strategies_for_test_method():
-    invalid_strategy = s.lists(s.nothing(), min_size=1)
-
-    class TestStrategyValidation:
-        @given(invalid_strategy)
-        def test_method_with_bad_strategy(self, x):
-            pass
-
-    instance = TestStrategyValidation()
-    with pytest.raises(InvalidArgument):
-        instance.test_method_with_bad_strategy()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_custom_reprs.py Deleted

@@ -1,66 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-
-
-def test_includes_non_default_args_in_repr():
-    assert repr(st.integers()) == "integers()"
-    assert repr(st.integers(min_value=1)) == "integers(min_value=1)"
-
-
-def test_sampled_repr_leaves_range_as_range():
-    huge = 10**100
-    assert repr(st.sampled_from(range(huge))) == f"sampled_from(range(0, {huge}))"
-
-
-def hi(there, stuff):
-    return there
-
-
-def test_supports_positional_and_keyword_args_in_builds():
-    assert (
-        repr(st.builds(hi, st.integers(), there=st.booleans()))
-        == "builds(hi, integers(), there=booleans())"
-    )
-
-
-def test_preserves_sequence_type_of_argument():
-    assert repr(st.sampled_from(0, 1)) == "sampled_from(0, 1)"
-    assert repr(st.sampled_from((0, 1))) == "sampled_from((0, 1))"
-
-
-class IHaveABadRepr:
-    def __repr__(self):
-        raise ValueError("Oh no!")
-
-
-def test_errors_are_deferred_until_repr_is_calculated():
-    s = (
-        st.builds(
-            lambda x, y: 1,
-            st.just(IHaveABadRepr()),
-            y=st.one_of(st.sampled_from((IHaveABadRepr(),)), st.just(IHaveABadRepr())),
-        )
-        .map(lambda t: t)
-        .filter(lambda t: True)
-        .flatmap(lambda t: st.just(IHaveABadRepr()))
-    )
-
-    with pytest.raises(ValueError):
-        repr(s)
-
-
-@given(st.iterables(st.integers()))
-def test_iterables_repr_is_useful(it):
-    # fairly hard-coded but useful; also ensures _values are inexhaustible
-    assert repr(it) == f"iter({it._values!r})"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_database_backend.py Deleted

@@ -1,162 +0,0 @@
-# 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 os
-
-import pytest
-
-from hypothesis import given, settings
-from hypothesis.database import (
-    DirectoryBasedExampleDatabase,
-    ExampleDatabase,
-    InMemoryExampleDatabase,
-    MultiplexedDatabase,
-    ReadOnlyDatabase,
-)
-from hypothesis.strategies import binary, lists, tuples
-
-small_settings = settings(max_examples=50)
-
-
-@given(lists(tuples(binary(), binary())))
-@small_settings
-def test_backend_returns_what_you_put_in(xs):
-    backend = InMemoryExampleDatabase()
-    mapping = {}
-    for key, value in xs:
-        mapping.setdefault(key, set()).add(value)
-        backend.save(key, value)
-    for key, values in mapping.items():
-        backend_contents = list(backend.fetch(key))
-        distinct_backend_contents = set(backend_contents)
-        assert len(backend_contents) == len(distinct_backend_contents)
-        assert distinct_backend_contents == set(values)
-
-
-def test_can_delete_keys():
-    backend = InMemoryExampleDatabase()
-    backend.save(b"foo", b"bar")
-    backend.save(b"foo", b"baz")
-    backend.delete(b"foo", b"bar")
-    assert list(backend.fetch(b"foo")) == b"baz"
-
-
-def test_default_database_is_in_memory():
-    assert isinstance(ExampleDatabase(), InMemoryExampleDatabase)
-
-
-def test_default_on_disk_database_is_dir(tmpdir):
-    assert isinstance(
-        ExampleDatabase(tmpdir.join("foo")), DirectoryBasedExampleDatabase
-    )
-
-
-def test_selects_directory_based_if_already_directory(tmpdir):
-    path = str(tmpdir.join("hi.sqlite3"))
-    DirectoryBasedExampleDatabase(path).save(b"foo", b"bar")
-    assert isinstance(ExampleDatabase(path), DirectoryBasedExampleDatabase)
-
-
-def test_does_not_error_when_fetching_when_not_exist(tmpdir):
-    db = DirectoryBasedExampleDatabase(tmpdir.join("examples"))
-    db.fetch(b"foo")
-
-
-@pytest.fixture(scope="function", params="memory", "directory")
-def exampledatabase(request, tmpdir):
-    if request.param == "memory":
-        return ExampleDatabase()
-    assert request.param == "directory"
-    return DirectoryBasedExampleDatabase(str(tmpdir.join("examples")))
-
-
-def test_can_delete_a_key_that_is_not_present(exampledatabase):
-    exampledatabase.delete(b"foo", b"bar")
-
-
-def test_can_fetch_a_key_that_is_not_present(exampledatabase):
-    assert list(exampledatabase.fetch(b"foo")) == 
-
-
-def test_saving_a_key_twice_fetches_it_once(exampledatabase):
-    exampledatabase.save(b"foo", b"bar")
-    exampledatabase.save(b"foo", b"bar")
-    assert list(exampledatabase.fetch(b"foo")) == b"bar"
-
-
-def test_can_close_a_database_after_saving(exampledatabase):
-    exampledatabase.save(b"foo", b"bar")
-
-
-def test_class_name_is_in_repr(exampledatabase):
-    assert type(exampledatabase).__name__ in repr(exampledatabase)
-
-
-def test_an_absent_value_is_present_after_it_moves(exampledatabase):
-    exampledatabase.move(b"a", b"b", b"c")
-    assert next(exampledatabase.fetch(b"b")) == b"c"
-
-
-def test_an_absent_value_is_present_after_it_moves_to_self(exampledatabase):
-    exampledatabase.move(b"a", b"a", b"b")
-    assert next(exampledatabase.fetch(b"a")) == b"b"
-
-
-def test_two_directory_databases_can_interact(tmpdir):
-    path = str(tmpdir)
-    db1 = DirectoryBasedExampleDatabase(path)
-    db2 = DirectoryBasedExampleDatabase(path)
-    db1.save(b"foo", b"bar")
-    assert list(db2.fetch(b"foo")) == b"bar"
-    db2.save(b"foo", b"bar")
-    db2.save(b"foo", b"baz")
-    assert sorted(db1.fetch(b"foo")) == b"bar", b"baz"
-
-
-def test_can_handle_disappearing_files(tmpdir, monkeypatch):
-    path = str(tmpdir)
-    db = DirectoryBasedExampleDatabase(path)
-    db.save(b"foo", b"bar")
-    base_listdir = os.listdir
-    monkeypatch.setattr(
-        os, "listdir", lambda d: base_listdir(d) + "this-does-not-exist"
-    )
-    assert list(db.fetch(b"foo")) == b"bar"
-
-
-def test_readonly_db_is_not_writable():
-    inner = InMemoryExampleDatabase()
-    wrapped = ReadOnlyDatabase(inner)
-    inner.save(b"key", b"value")
-    inner.save(b"key", b"value2")
-    wrapped.delete(b"key", b"value")
-    wrapped.move(b"key", b"key2", b"value2")
-    wrapped.save(b"key", b"value3")
-    assert set(wrapped.fetch(b"key")) == {b"value", b"value2"}
-    assert set(wrapped.fetch(b"key2")) == set()
-
-
-def test_multiplexed_dbs_read_and_write_all():
-    a = InMemoryExampleDatabase()
-    b = InMemoryExampleDatabase()
-    multi = MultiplexedDatabase(a, b)
-    a.save(b"a", b"aa")
-    b.save(b"b", b"bb")
-    multi.save(b"c", b"cc")
-    multi.move(b"a", b"b", b"aa")
-    for db in (a, b, multi):
-        assert set(db.fetch(b"a")) == set()
-        assert set(db.fetch(b"c")) == {b"cc"}
-    got = list(multi.fetch(b"b"))
-    assert len(got) == 2
-    assert set(got) == {b"aa", b"bb"}
-    multi.delete(b"c", b"cc")
-    for db in (a, b, multi):
-        assert set(db.fetch(b"c")) == set()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_datetimes.py Deleted

@@ -1,146 +0,0 @@
-# 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 datetime as dt
-
-import pytest
-
-from hypothesis import given, settings
-from hypothesis.strategies import dates, datetimes, timedeltas, times
-
-from tests.common.debug import find_any, minimal
-
-
-def test_can_find_positive_delta():
-    assert minimal(timedeltas(), lambda x: x.days > 0) == dt.timedelta(1)
-
-
-def test_can_find_negative_delta():
-    assert minimal(
-        timedeltas(max_value=dt.timedelta(10**6)), lambda x: x.days < 0
-    ) == dt.timedelta(-1)
-
-
-def test_can_find_on_the_second():
-    find_any(timedeltas(), lambda x: x.seconds == 0)
-
-
-def test_can_find_off_the_second():
-    find_any(timedeltas(), lambda x: x.seconds != 0)
-
-
-def test_simplifies_towards_zero_delta():
-    d = minimal(timedeltas())
-    assert d.days == d.seconds == d.microseconds == 0
-
-
-def test_min_value_is_respected():
-    assert minimal(timedeltas(min_value=dt.timedelta(days=10))).days == 10
-
-
-def test_max_value_is_respected():
-    assert minimal(timedeltas(max_value=dt.timedelta(days=-10))).days == -10
-
-
-@given(timedeltas())
-def test_single_timedelta(val):
-    assert find_any(timedeltas(val, val)) is val
-
-
-def test_simplifies_towards_millenium():
-    d = minimal(datetimes())
-    assert d.year == 2000
-    assert d.month == d.day == 1
-    assert d.hour == d.minute == d.second == d.microsecond == 0
-
-
-@given(datetimes())
-def test_default_datetimes_are_naive(dt):
-    assert dt.tzinfo is None
-
-
-def test_bordering_on_a_leap_year():
-    x = minimal(
-        datetimes(
-            dt.datetime.min.replace(year=2003), dt.datetime.max.replace(year=2005)
-        ),
-        lambda x: x.month == 2 and x.day == 29,
-        timeout_after=60,
-    )
-    assert x.year == 2004
-
-
-def test_can_find_after_the_year_2000():
-    assert minimal(dates(), lambda x: x.year > 2000).year == 2001
-
-
-def test_can_find_before_the_year_2000():
-    assert minimal(dates(), lambda x: x.year < 2000).year == 1999
-
-
-@pytest.mark.parametrize("month", range(1, 13))
-def test_can_find_each_month(month):
-    find_any(dates(), lambda x: x.month == month, settings(max_examples=10**6))
-
-
-def test_min_year_is_respected():
-    assert minimal(dates(min_value=dt.date.min.replace(2003))).year == 2003
-
-
-def test_max_year_is_respected():
-    assert minimal(dates(max_value=dt.date.min.replace(1998))).year == 1998
-
-
-@given(dates())
-def test_single_date(val):
-    assert find_any(dates(val, val)) is val
-
-
-def test_can_find_midnight():
-    find_any(times(), lambda x: x.hour == x.minute == x.second == 0)
-
-
-def test_can_find_non_midnight():
-    assert minimal(times(), lambda x: x.hour != 0).hour == 1
-
-
-def test_can_find_on_the_minute():
-    find_any(times(), lambda x: x.second == 0)
-
-
-def test_can_find_off_the_minute():
-    find_any(times(), lambda x: x.second != 0)
-
-
-def test_simplifies_towards_midnight():
-    d = minimal(times())
-    assert d.hour == d.minute == d.second == d.microsecond == 0
-
-
-def test_can_generate_naive_time():
-    find_any(times(), lambda d: not d.tzinfo)
-
-
-@given(times())
-def test_naive_times_are_naive(dt):
-    assert dt.tzinfo is None
-
-
-def test_can_generate_datetime_with_fold_1():
-    find_any(datetimes(), lambda d: d.fold)
-
-
-def test_can_generate_time_with_fold_1():
-    find_any(times(), lambda d: d.fold)
-
-
-@given(datetimes(allow_imaginary=False))
-def test_allow_imaginary_is_not_an_error_for_naive_datetimes(d):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_deadline.py Deleted

@@ -1,137 +0,0 @@
-# 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 time
-
-import pytest
-
-from hypothesis import given, settings, strategies as st
-from hypothesis.errors import DeadlineExceeded, Flaky, InvalidArgument
-
-from tests.common.utils import assert_falsifying_output, capture_out, fails_with
-
-
-def test_raises_deadline_on_slow_test():
-    @settings(deadline=500)
-    @given(st.integers())
-    def slow(i):
-        time.sleep(1)
-
-    with pytest.raises(DeadlineExceeded):
-        slow()
-
-
-@fails_with(DeadlineExceeded)
-@given(st.integers())
-def test_slow_tests_are_errors_by_default(i):
-    time.sleep(1)
-
-
-def test_non_numeric_deadline_is_an_error():
-    with pytest.raises(InvalidArgument):
-        settings(deadline="3 seconds")
-
-
-@given(st.integers())
-@settings(deadline=None)
-def test_slow_with_none_deadline(i):
-    time.sleep(1)
-
-
-def test_raises_flaky_if_a_test_becomes_fast_on_rerun():
-    once = True
-
-    @settings(deadline=500)
-    @given(st.integers())
-    def test_flaky_slow(i):
-        if once0:
-            once0 = False
-            time.sleep(1)
-
-    with pytest.raises(Flaky):
-        test_flaky_slow()
-
-
-def test_deadlines_participate_in_shrinking():
-    @settings(deadline=500, max_examples=1000)
-    @given(st.integers(min_value=0))
-    def slow_if_large(i):
-        if i >= 1000:
-            time.sleep(1)
-
-    assert_falsifying_output(
-        slow_if_large,
-        expected_exception=DeadlineExceeded,
-        i=1000,
-    )
-
-
-def test_keeps_you_well_above_the_deadline():
-    seen = set()
-    failed_once = False
-
-    @settings(deadline=100)
-    @given(st.integers(0, 2000))
-    def slow(i):
-        # Make sure our initial failure isn't something that immediately goes
-        # flaky.
-        if not failed_once0:
-            if i * 0.9 <= 100:
-                return
-            else:
-                failed_once0 = True
-
-        t = i / 1000
-        if i in seen:
-            time.sleep(0.9 * t)
-        else:
-            seen.add(i)
-            time.sleep(t)
-
-    with pytest.raises(DeadlineExceeded):
-        slow()
-
-
-def test_gives_a_deadline_specific_flaky_error_message():
-    once = True
-
-    @settings(deadline=100)
-    @given(st.integers())
-    def slow_once(i):
-        if once0:
-            once0 = False
-            time.sleep(0.2)
-
-    with capture_out() as o:
-        with pytest.raises(Flaky):
-            slow_once()
-    assert "Unreliable test timing" in o.getvalue()
-    assert "took 2" in o.getvalue()
-
-
-@pytest.mark.parametrize("slow_strategy", False, True)
-@pytest.mark.parametrize("slow_test", False, True)
-def test_should_only_fail_a_deadline_if_the_test_is_slow(slow_strategy, slow_test):
-    s = st.integers()
-    if slow_strategy:
-        s = s.map(lambda x: time.sleep(0.08))
-
-    @settings(deadline=50)
-    @given(st.data())
-    def test(data):
-        data.draw(s)
-        if slow_test:
-            time.sleep(0.1)
-
-    if slow_test:
-        with pytest.raises(DeadlineExceeded):
-            test()
-    else:
-        test()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_debug_information.py Deleted

@@ -1,43 +0,0 @@
-# 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 re
-
-import pytest
-
-from hypothesis import Verbosity, given, settings, strategies as st
-
-from tests.common.utils import capture_out
-
-
-def test_reports_passes():
-    @given(st.integers())
-    @settings(verbosity=Verbosity.debug, max_examples=1000)
-    def test(i):
-        assert i < 10
-
-    with capture_out() as out:
-        with pytest.raises(AssertionError):
-            test()
-
-    value = out.getvalue()
-
-    assert "minimize_individual_blocks" in value
-    assert "calls" in value
-    assert "shrinks" in value
-
-    shrinks_info = re.compile(r"call(s?) of which (0-9+) shrank")
-
-    for l in value.splitlines():
-        m = shrinks_info.search(l)
-        if m is not None and int(m.group(2)) != 0:
-            break
-    else:
-        pytest.xfail(reason="Sometimes the first failure is 10, and cannot shrink.")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_deferred_strategies.py Deleted

@@ -1,148 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.debug import assert_no_examples, minimal
-
-
-def test_binary_tree():
-    tree = st.deferred(lambda: st.integers() | st.tuples(tree, tree))
-
-    assert minimal(tree) == 0
-    assert minimal(tree, lambda x: isinstance(x, tuple)) == (0, 0)
-
-
-def test_mutual_recursion():
-    t = st.deferred(lambda: a | b)
-    a = st.deferred(lambda: st.none() | st.tuples(st.just("a"), b))
-    b = st.deferred(lambda: st.none() | st.tuples(st.just("b"), a))
-
-    for c in ("a", "b"):
-        assert minimal(t, lambda x: x is not None and x0 == c) == (c, None)
-
-
-def test_errors_on_non_function_define():
-    x = st.deferred(1)
-    with pytest.raises(InvalidArgument):
-        x.example()
-
-
-def test_errors_if_define_does_not_return_search_strategy():
-    x = st.deferred(lambda: 1)
-    with pytest.raises(InvalidArgument):
-        x.example()
-
-
-def test_errors_on_definition_as_self():
-    x = st.deferred(lambda: x)
-    with pytest.raises(InvalidArgument):
-        x.example()
-
-
-def test_branches_pass_through_deferred():
-    x = st.one_of(st.booleans(), st.integers())
-    y = st.deferred(lambda: x)
-    assert x.branches == y.branches
-
-
-def test_can_draw_one_of_self():
-    x = st.deferred(lambda: st.one_of(st.booleans(), x))
-    assert minimal(x) is False
-    assert len(x.branches) == 1
-
-
-def test_hidden_self_references_just_result_in_no_example():
-    bad = st.deferred(lambda: st.none().flatmap(lambda _: bad))
-    assert_no_examples(bad)
-
-
-def test_self_recursive_flatmap():
-    bad = st.deferred(lambda: bad.flatmap(lambda x: st.none()))
-    assert_no_examples(bad)
-
-
-def test_self_reference_through_one_of_can_detect_emptiness():
-    bad = st.deferred(lambda: st.one_of(bad, bad))
-    assert bad.is_empty
-
-
-def test_self_tuple_draws_nothing():
-    x = st.deferred(lambda: st.tuples(x))
-    assert_no_examples(x)
-
-
-def test_mutually_recursive_tuples_draw_nothing():
-    x = st.deferred(lambda: st.tuples(y))
-    y = st.tuples(x)
-
-    assert_no_examples(x)
-    assert_no_examples(y)
-
-
-def test_literals_strategy_is_valid():
-    literals = st.deferred(
-        lambda: st.one_of(
-            st.booleans(), st.tuples(literals, literals), literals.map(lambda x: x)
-        )
-    )
-
-    @given(literals)
-    def test(e):
-        pass
-
-    test()
-
-    assert not literals.has_reusable_values
-
-
-def test_impossible_self_recursion():
-    x = st.deferred(lambda: st.tuples(st.none(), x))
-    assert x.is_empty
-    assert x.has_reusable_values
-
-
-def test_very_deep_deferral():
-    # This test is designed so that the recursive properties take a very long
-    # time to converge: Although we can rapidly determine them for the original
-    # value, each round in the fixed point calculation only manages to update
-    # a single value in the related strategies, so it takes 100 rounds to
-    # update everything. Most importantly this triggers our infinite loop
-    # detection heuristic and we start tracking duplicates, but we shouldn't
-    # see any because this loop isn't infinite, just long.
-    def strat(i):
-        if i == 0:
-            return st.deferred(lambda: st.one_of(strategies + st.none()))
-        else:
-            return st.deferred(lambda: st.tuples(strategies(i + 1) % len(strategies)))
-
-    strategies = list(map(strat, range(100)))
-
-    assert strategies0.has_reusable_values
-    assert not strategies0.is_empty
-
-
-def test_recursion_in_middle():
-    # This test is significant because the integers().map(abs) is not checked
-    # in the initial pass - when we recurse into x initially we decide that
-    # x is empty, so the tuple is empty, and don't need to check the third
-    # argument. Then when we do the more refined test we've discovered that x
-    # is non-empty, so we need to check the non-emptiness of the last component
-    # to determine the non-emptiness of the tuples.
-    x = st.deferred(lambda: st.tuples(st.none(), x, st.integers().map(abs)) | st.none())
-    assert not x.is_empty
-
-
-def test_deferred_supports_find():
-    nested = st.deferred(lambda: st.integers() | st.lists(nested))
-    assert nested.supports_find

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_detection.py Deleted

@@ -1,55 +0,0 @@
-# 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/.
-
-from hypothesis import given
-from hypothesis.internal.detection import is_hypothesis_test
-from hypothesis.stateful import RuleBasedStateMachine, rule
-from hypothesis.strategies import integers
-
-
-def test_functions_default_to_not_tests():
-    def foo():
-        pass
-
-    assert not is_hypothesis_test(foo)
-
-
-def test_methods_default_to_not_tests():
-    class Foo:
-        def foo(self):
-            pass
-
-    assert not is_hypothesis_test(Foo().foo)
-
-
-def test_detection_of_functions():
-    @given(integers())
-    def test(i):
-        pass
-
-    assert is_hypothesis_test(test)
-
-
-def test_detection_of_methods():
-    class Foo:
-        @given(integers())
-        def test(self, i):
-            pass
-
-    assert is_hypothesis_test(Foo().test)
-
-
-def test_detection_of_stateful_tests():
-    class Stuff(RuleBasedStateMachine):
-        @rule(x=integers())
-        def a_rule(self, x):
-            pass
-
-    assert is_hypothesis_test(Stuff.TestCase().runTest)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_direct_strategies.py Deleted

@@ -1,522 +0,0 @@
-# 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 collections
-import decimal
-import enum
-import fractions
-import math
-from datetime import date, datetime, time, timedelta
-from ipaddress import IPv4Network, IPv6Network
-
-import pytest
-
-from hypothesis import given, settings, strategies as ds
-from hypothesis.errors import InvalidArgument
-from hypothesis.vendor.pretty import pretty
-
-from tests.common.debug import minimal
-
-# Use `pretty` instead of `repr` for building test names, so that set and dict
-# parameters print consistently across multiple worker processes with different
-# PYTHONHASHSEED values.
-
-
-def fn_test(*fnkwargs):
-    fnkwargs = list(fnkwargs)
-    return pytest.mark.parametrize(
-        ("fn", "args"),
-        fnkwargs,
-        ids=
-            "{}({})".format(fn.__name__, ", ".join(map(pretty, args)))
-            for fn, args in fnkwargs
-        ,
-    )
-
-
-def fn_ktest(*fnkwargs):
-    fnkwargs = list(fnkwargs)
-    return pytest.mark.parametrize(
-        ("fn", "kwargs"),
-        fnkwargs,
-        ids=f"{fn.__name__}(**{pretty(kwargs)})" for fn, kwargs in fnkwargs,
-    )
-
-
-@fn_ktest(
-    (ds.integers, {"min_value": math.nan}),
-    (ds.integers, {"min_value": 2, "max_value": 1}),
-    (ds.integers, {"min_value": math.nan}),
-    (ds.integers, {"max_value": math.nan}),
-    (ds.integers, {"min_value": decimal.Decimal("1.5")}),
-    (ds.integers, {"max_value": decimal.Decimal("1.5")}),
-    (ds.integers, {"min_value": -1.5, "max_value": -0.5}),
-    (ds.integers, {"min_value": 0.1, "max_value": 0.2}),
-    (ds.dates, {"min_value": "fish"}),
-    (ds.dates, {"max_value": "fish"}),
-    (ds.dates, {"min_value": date(2017, 8, 22), "max_value": date(2017, 8, 21)}),
-    (ds.datetimes, {"min_value": "fish"}),
-    (ds.datetimes, {"max_value": "fish"}),
-    (ds.datetimes, {"allow_imaginary": 0}),
-    (
-        ds.datetimes,
-        {"min_value": datetime(2017, 8, 22), "max_value": datetime(2017, 8, 21)},
-    ),
-    (ds.decimals, {"min_value": math.nan}),
-    (ds.decimals, {"max_value": math.nan}),
-    (ds.decimals, {"min_value": 2, "max_value": 1}),
-    (ds.decimals, {"max_value": "-snan"}),
-    (ds.decimals, {"max_value": complex(1, 2)}),
-    (ds.decimals, {"places": -1}),
-    (ds.decimals, {"places": 0.5}),
-    (ds.decimals, {"max_value": 0.0, "min_value": 1.0}),
-    (ds.decimals, {"min_value": 1.0, "max_value": 0.0}),
-    (ds.decimals, {"min_value": 0.0, "max_value": 1.0, "allow_infinity": True}),
-    (ds.decimals, {"min_value": "inf"}),
-    (ds.decimals, {"max_value": "-inf"}),
-    (ds.decimals, {"min_value": "-inf", "allow_infinity": False}),
-    (ds.decimals, {"max_value": "inf", "allow_infinity": False}),
-    (ds.decimals, {"min_value": complex(1, 2)}),
-    (ds.decimals, {"min_value": "0.1", "max_value": "0.9", "places": 0}),
-    (
-        ds.dictionaries,
-        {"keys": ds.booleans(), "values": ds.booleans(), "min_size": 10, "max_size": 1},
-    ),
-    (ds.floats, {"min_value": math.nan}),
-    (ds.floats, {"max_value": math.nan}),
-    (ds.floats, {"min_value": complex(1, 2)}),
-    (ds.floats, {"max_value": complex(1, 2)}),
-    (ds.floats, {"exclude_min": None}),
-    (ds.floats, {"exclude_max": None}),
-    (ds.floats, {"exclude_min": True}),  # because min_value=None
-    (ds.floats, {"exclude_max": True}),  # because max_value=None
-    (ds.floats, {"min_value": 1.8, "width": 32}),
-    (ds.floats, {"max_value": 1.8, "width": 32}),
-    (ds.fractions, {"min_value": 2, "max_value": 1}),
-    (ds.fractions, {"min_value": math.nan}),
-    (ds.fractions, {"max_value": math.nan}),
-    (ds.fractions, {"max_denominator": 0}),
-    (ds.fractions, {"max_denominator": 1.5}),
-    (ds.fractions, {"min_value": complex(1, 2)}),
-    (ds.fractions, {"min_value": "1/3", "max_value": "1/2", "max_denominator": 2}),
-    (ds.fractions, {"min_value": "0", "max_value": "1/3", "max_denominator": 2}),
-    (ds.fractions, {"min_value": "1/3", "max_value": "1/3", "max_denominator": 2}),
-    (ds.lists, {"elements": ds.integers(), "min_size": 10, "max_size": 9}),
-    (ds.lists, {"elements": ds.integers(), "min_size": -10, "max_size": -9}),
-    (ds.lists, {"elements": ds.integers(), "max_size": -9}),
-    (ds.lists, {"elements": ds.integers(), "min_size": -10}),
-    (ds.lists, {"elements": ds.integers(), "min_size": math.nan}),
-    (ds.lists, {"elements": ds.nothing(), "max_size": 1}),
-    (ds.lists, {"elements": "hi"}),
-    (ds.lists, {"elements": ds.integers(), "unique_by": 1}),
-    (ds.lists, {"elements": ds.integers(), "unique_by": ()}),
-    (ds.lists, {"elements": ds.integers(), "unique_by": (1,)}),
-    (ds.lists, {"elements": ds.sampled_from(0, 1), "min_size": 3, "unique": True}),
-    (ds.text, {"min_size": 10, "max_size": 9}),
-    (ds.text, {"alphabet": 1}),
-    (ds.text, {"alphabet": "abc"}),
-    (ds.binary, {"min_size": 10, "max_size": 9}),
-    (ds.floats, {"min_value": math.nan}),
-    (ds.floats, {"min_value": "0"}),
-    (ds.floats, {"max_value": "0"}),
-    (ds.floats, {"min_value": 0.0, "max_value": -0.0}),
-    (ds.floats, {"min_value": 0.0, "max_value": 1.0, "allow_infinity": True}),
-    (ds.floats, {"max_value": 0.0, "min_value": 1.0}),
-    (ds.floats, {"min_value": 0.0, "allow_nan": True}),
-    (ds.floats, {"max_value": 0.0, "allow_nan": True}),
-    (ds.floats, {"min_value": 0.0, "max_value": 1.0, "allow_infinity": True}),
-    (ds.floats, {"min_value": math.inf, "allow_infinity": False}),
-    (ds.floats, {"max_value": -math.inf, "allow_infinity": False}),
-    (ds.complex_numbers, {"min_magnitude": None}),
-    (ds.complex_numbers, {"min_magnitude": math.nan}),
-    (ds.complex_numbers, {"max_magnitude": math.nan}),
-    (ds.complex_numbers, {"max_magnitude": complex(1, 2)}),
-    (ds.complex_numbers, {"min_magnitude": -1}),
-    (ds.complex_numbers, {"max_magnitude": -1}),
-    (ds.complex_numbers, {"min_magnitude": 3, "max_magnitude": 2}),
-    (ds.complex_numbers, {"max_magnitude": 2, "allow_infinity": True}),
-    (ds.complex_numbers, {"max_magnitude": 2, "allow_nan": True}),
-    (ds.fixed_dictionaries, {"mapping": "fish"}),
-    (ds.fixed_dictionaries, {"mapping": {1: "fish"}}),
-    (ds.fixed_dictionaries, {"mapping": {}, "optional": "fish"}),
-    (ds.fixed_dictionaries, {"mapping": {}, "optional": {1: "fish"}}),
-    (ds.fixed_dictionaries, {"mapping": {}, "optional": collections.OrderedDict()}),
-    (ds.fixed_dictionaries, {"mapping": {1: ds.none()}, "optional": {1: ds.none()}}),
-    (ds.dictionaries, {"keys": ds.integers(), "values": 1}),
-    (ds.dictionaries, {"keys": 1, "values": ds.integers()}),
-    (ds.text, {"alphabet": "", "min_size": 1}),
-    (ds.timedeltas, {"min_value": "fish"}),
-    (ds.timedeltas, {"max_value": "fish"}),
-    (
-        ds.timedeltas,
-        {"min_value": timedelta(hours=1), "max_value": timedelta(minutes=1)},
-    ),
-    (ds.times, {"min_value": "fish"}),
-    (ds.times, {"max_value": "fish"}),
-    (ds.times, {"min_value": time(2, 0), "max_value": time(1, 0)}),
-    (ds.uuids, {"version": 6}),
-    (ds.characters, {"min_codepoint": -1}),
-    (ds.characters, {"min_codepoint": "1"}),
-    (ds.characters, {"max_codepoint": -1}),
-    (ds.characters, {"max_codepoint": "1"}),
-    (ds.characters, {"whitelist_categories": }),
-    (ds.characters, {"whitelist_categories": "Nd", "blacklist_categories": "Nd"}),
-    (ds.slices, {"size": None}),
-    (ds.slices, {"size": "chips"}),
-    (ds.slices, {"size": -1}),
-    (ds.slices, {"size": 2.3}),
-    (ds.sampled_from, {"elements": ()}),
-    (ds.ip_addresses, {"v": "4"}),
-    (ds.ip_addresses, {"v": 4.0}),
-    (ds.ip_addresses, {"v": 5}),
-    (ds.ip_addresses, {"v": 4, "network": "::/64"}),
-    (ds.ip_addresses, {"v": 6, "network": "127.0.0.0/8"}),
-    (ds.ip_addresses, {"network": b"127.0.0.0/8"}),  # only unicode strings are valid
-    (ds.ip_addresses, {"network": b"::/64"}),
-    (ds.randoms, {"use_true_random": "False"}),
-    (ds.randoms, {"note_method_calls": "True"}),
-)
-def test_validates_keyword_arguments(fn, kwargs):
-    with pytest.raises(InvalidArgument):
-        fn(**kwargs).example()
-
-
-@fn_ktest(
-    (ds.integers, {"min_value": 0}),
-    (ds.integers, {"min_value": 11}),
-    (ds.integers, {"min_value": 11, "max_value": 100}),
-    (ds.integers, {"max_value": 0}),
-    (ds.integers, {"min_value": -2, "max_value": -1}),
-    (ds.decimals, {"min_value": 1.0, "max_value": 1.5}),
-    (ds.decimals, {"min_value": "1.0", "max_value": "1.5"}),
-    (ds.decimals, {"min_value": decimal.Decimal("1.5")}),
-    (ds.decimals, {"max_value": 1.0, "min_value": -1.0, "allow_infinity": False}),
-    (ds.decimals, {"min_value": 1.0, "allow_nan": False}),
-    (ds.decimals, {"max_value": 1.0, "allow_nan": False}),
-    (ds.decimals, {"max_value": 1.0, "min_value": -1.0, "allow_nan": False}),
-    (ds.decimals, {"min_value": "-inf"}),
-    (ds.decimals, {"max_value": "inf"}),
-    (ds.fractions, {"min_value": -1, "max_value": 1, "max_denominator": 1000}),
-    (ds.fractions, {"min_value": 1, "max_value": 1}),
-    (ds.fractions, {"min_value": 1, "max_value": 1, "max_denominator": 2}),
-    (ds.fractions, {"min_value": 1.0}),
-    (ds.fractions, {"min_value": decimal.Decimal("1.0")}),
-    (ds.fractions, {"min_value": fractions.Fraction(1, 2)}),
-    (ds.fractions, {"min_value": "1/2", "max_denominator": 2}),
-    (ds.fractions, {"max_value": "1/2", "max_denominator": 3}),
-    (ds.lists, {"elements": ds.nothing(), "max_size": 0}),
-    (ds.lists, {"elements": ds.integers()}),
-    (ds.lists, {"elements": ds.integers(), "max_size": 5}),
-    (ds.lists, {"elements": ds.booleans(), "min_size": 5}),
-    (ds.lists, {"elements": ds.booleans(), "min_size": 5, "max_size": 10}),
-    (ds.sets, {"min_size": 10, "max_size": 10, "elements": ds.integers()}),
-    (ds.booleans, {}),
-    (ds.just, {"value": "hi"}),
-    (ds.integers, {"min_value": 12, "max_value": 12}),
-    (ds.floats, {}),
-    (ds.floats, {"min_value": 1.0}),
-    (ds.floats, {"max_value": 1.0}),
-    (ds.floats, {"min_value": math.inf}),
-    (ds.floats, {"max_value": -math.inf}),
-    (ds.floats, {"max_value": 1.0, "min_value": -1.0}),
-    (ds.floats, {"max_value": 1.0, "min_value": -1.0, "allow_infinity": False}),
-    (ds.floats, {"min_value": 1.0, "allow_nan": False}),
-    (ds.floats, {"max_value": 1.0, "allow_nan": False}),
-    (ds.floats, {"max_value": 1.0, "min_value": -1.0, "allow_nan": False}),
-    (ds.complex_numbers, {}),
-    (ds.complex_numbers, {"min_magnitude": 3, "max_magnitude": 3}),
-    (ds.complex_numbers, {"max_magnitude": 0}),
-    (ds.complex_numbers, {"allow_nan": True}),
-    (ds.complex_numbers, {"allow_nan": True, "allow_infinity": True}),
-    (ds.complex_numbers, {"allow_nan": True, "allow_infinity": False}),
-    (ds.complex_numbers, {"allow_nan": False}),
-    (ds.complex_numbers, {"allow_nan": False, "allow_infinity": True}),
-    (ds.complex_numbers, {"allow_nan": False, "allow_infinity": False}),
-    (ds.complex_numbers, {"max_magnitude": math.inf, "allow_infinity": True}),
-    (ds.sampled_from, {"elements": 1}),
-    (ds.sampled_from, {"elements": 1, 2, 3}),
-    (ds.fixed_dictionaries, {"mapping": {1: ds.integers()}}),
-    (ds.dictionaries, {"keys": ds.booleans(), "values": ds.integers()}),
-    (ds.text, {"alphabet": "abc"}),
-    (ds.text, {"alphabet": set("abc")}),
-    (ds.text, {"alphabet": ""}),
-    (ds.text, {"alphabet": ds.sampled_from("abc")}),
-    (ds.characters, {"whitelist_categories": "N"}),
-    (ds.characters, {"blacklist_categories": }),
-    (ds.ip_addresses, {}),
-    (ds.ip_addresses, {"v": 4}),
-    (ds.ip_addresses, {"v": 6}),
-    (ds.ip_addresses, {"network": "127.0.0.0/8"}),
-    (ds.ip_addresses, {"network": "::/64"}),
-    (ds.ip_addresses, {"v": 4, "network": "127.0.0.0/8"}),
-    (ds.ip_addresses, {"v": 6, "network": "::/64"}),
-    (ds.ip_addresses, {"network": IPv4Network("127.0.0.0/8")}),
-    (ds.ip_addresses, {"network": IPv6Network("::/64")}),
-    (ds.ip_addresses, {"v": 4, "network": IPv4Network("127.0.0.0/8")}),
-    (ds.ip_addresses, {"v": 6, "network": IPv6Network("::/64")}),
-)
-def test_produces_valid_examples_from_keyword(fn, kwargs):
-    fn(**kwargs).example()
-
-
-@fn_test(
-    (ds.one_of, (1,)),
-    (ds.one_of, (1, ds.integers())),
-    (ds.tuples, (1,)),
-)
-def test_validates_args(fn, args):
-    with pytest.raises(InvalidArgument):
-        fn(*args).example()
-
-
-@fn_test(
-    (ds.one_of, (ds.booleans(), ds.tuples(ds.booleans()))),
-    (ds.one_of, (ds.booleans(),)),
-    (ds.text, ()),
-    (ds.binary, ()),
-    (ds.builds, (lambda x, y: x + y, ds.integers(), ds.integers())),
-)
-def test_produces_valid_examples_from_args(fn, args):
-    fn(*args).example()
-
-
-def test_build_class_with_target_kwarg():
-    NamedTupleWithTargetField = collections.namedtuple("Something", "target")
-    ds.builds(NamedTupleWithTargetField, target=ds.integers()).example()
-
-
-def test_builds_raises_with_no_target():
-    with pytest.raises(TypeError):
-        ds.builds().example()
-
-
-@pytest.mark.parametrize("non_callable", 1, "abc", ds.integers())
-def test_builds_raises_if_non_callable_as_target_kwarg(non_callable):
-    with pytest.raises(TypeError):
-        ds.builds(target=non_callable).example()
-
-
-@pytest.mark.parametrize("non_callable", 1, "abc", ds.integers())
-def test_builds_raises_if_non_callable_as_first_arg(non_callable):
-    # If there are any positional arguments, then the target (which must be
-    # callable) must be specified as the first one.
-    with pytest.raises(InvalidArgument):
-        ds.builds(non_callable, target=lambda x: x).example()
-
-
-def test_tuples_raise_error_on_bad_kwargs():
-    with pytest.raises(TypeError):
-        ds.tuples(stuff="things")
-
-
-@given(ds.lists(ds.booleans(), min_size=10, max_size=10))
-def test_has_specified_length(xs):
-    assert len(xs) == 10
-
-
-@given(ds.integers(max_value=100))
-@settings(max_examples=100)
-def test_has_upper_bound(x):
-    assert x <= 100
-
-
-@given(ds.integers(min_value=100))
-def test_has_lower_bound(x):
-    assert x >= 100
-
-
-@given(ds.integers(min_value=1, max_value=2))
-def test_is_in_bounds(x):
-    assert 1 <= x <= 2
-
-
-@given(ds.fractions(min_value=-1, max_value=1, max_denominator=1000))
-def test_fraction_is_in_bounds(x):
-    assert -1 <= x <= 1 and abs(x.denominator) <= 1000
-
-
-@given(ds.fractions(min_value=fractions.Fraction(1, 2)))
-def test_fraction_gt_positive(x):
-    assert fractions.Fraction(1, 2) <= x
-
-
-@given(ds.fractions(max_value=fractions.Fraction(-1, 2)))
-def test_fraction_lt_negative(x):
-    assert x <= fractions.Fraction(-1, 2)
-
-
-@given(ds.decimals(min_value=-1.5, max_value=1.5))
-def test_decimal_is_in_bounds(x):
-    assert decimal.Decimal("-1.5") <= x <= decimal.Decimal("1.5")
-
-
-def test_float_can_find_max_value_inf():
-    assert minimal(ds.floats(max_value=math.inf), math.isinf) == float("inf")
-    assert minimal(ds.floats(min_value=0.0), math.isinf) == math.inf
-
-
-def test_float_can_find_min_value_inf():
-    minimal(ds.floats(), lambda x: x < 0 and math.isinf(x))
-    minimal(ds.floats(min_value=-math.inf, max_value=0.0), math.isinf)
-
-
-def test_can_find_none_list():
-    assert minimal(ds.lists(ds.none()), lambda x: len(x) >= 3) == None * 3
-
-
-def test_fractions():
-    assert minimal(ds.fractions(), lambda f: f >= 1) == 1
-
-
-def test_decimals():
-    assert minimal(ds.decimals(), lambda f: f.is_finite() and f >= 1) == 1
-
-
-def test_non_float_decimal():
-    minimal(ds.decimals(), lambda d: d.is_finite() and decimal.Decimal(float(d)) != d)
-
-
-def test_produces_dictionaries_of_at_least_minimum_size():
-    t = minimal(
-        ds.dictionaries(ds.booleans(), ds.integers(), min_size=2), lambda x: True
-    )
-    assert t == {False: 0, True: 0}
-
-
-@given(ds.dictionaries(ds.integers(), ds.integers(), max_size=5))
-@settings(max_examples=50)
-def test_dictionaries_respect_size(d):
-    assert len(d) <= 5
-
-
-@given(ds.dictionaries(ds.integers(), ds.integers(), max_size=0))
-@settings(max_examples=50)
-def test_dictionaries_respect_zero_size(d):
-    assert len(d) <= 5
-
-
-@given(ds.lists(ds.none(), max_size=5))
-def test_none_lists_respect_max_size(ls):
-    assert len(ls) <= 5
-
-
-@given(ds.lists(ds.none(), max_size=5, min_size=1))
-def test_none_lists_respect_max_and_min_size(ls):
-    assert 1 <= len(ls) <= 5
-
-
-@given(ds.iterables(ds.integers(), max_size=5, min_size=1))
-def test_iterables_are_exhaustible(it):
-    for _ in it:
-        pass
-    with pytest.raises(StopIteration):
-        next(it)
-
-
-def test_minimal_iterable():
-    assert list(minimal(ds.iterables(ds.integers()), lambda x: True)) == 
-
-
-@pytest.mark.parametrize("parameter_name", "min_value", "max_value")
-@pytest.mark.parametrize("value", -1, 0, 1)
-def test_no_infinity_for_min_max_values(value, parameter_name):
-    kwargs = {"allow_infinity": False, parameter_name: value}
-
-    @given(ds.floats(**kwargs))
-    def test_not_infinite(xs):
-        assert not math.isinf(xs)
-
-    test_not_infinite()
-
-
-@pytest.mark.parametrize("parameter_name", "min_value", "max_value")
-@pytest.mark.parametrize("value", -1, 0, 1)
-def test_no_nan_for_min_max_values(value, parameter_name):
-    kwargs = {"allow_nan": False, parameter_name: value}
-
-    @given(ds.floats(**kwargs))
-    def test_not_nan(xs):
-        assert not math.isnan(xs)
-
-    test_not_nan()
-
-
-class Sneaky:
-    """It's like a strategy, but it's not a strategy."""
-
-    is_empty = False
-    depth = 0
-    label = 0
-
-    def do_draw(self, data):
-        pass
-
-    def validate(self):
-        pass
-
-
-@pytest.mark.parametrize("value", 5, Sneaky())
-@pytest.mark.parametrize("label", None, "not a strategy")
-@given(data=ds.data())
-def test_data_explicitly_rejects_non_strategies(data, value, label):
-    with pytest.raises(InvalidArgument):
-        data.draw(value, label=label)
-
-
-@given(ds.integers().filter(bool).filter(lambda x: x % 3))
-def test_chained_filter(x):
-    assert x and x % 3
-
-
-def test_chained_filter_tracks_all_conditions():
-    s = ds.integers().filter(bool).filter(lambda x: x % 3)
-    assert len(s.wrapped_strategy.flat_conditions) == 2
-
-
-@pytest.mark.parametrize("version", 4, 6)
-@given(data=ds.data())
-def test_ipaddress_from_network_is_always_correct_version(data, version):
-    ip = data.draw(ds.ip_addresses(v=version), label="address")
-    assert ip.version == version
-
-
-@given(data=ds.data(), network=ds.from_type(IPv4Network) | ds.from_type(IPv6Network))
-def test_ipaddress_from_network_is_always_in_network(data, network):
-    ip = data.draw(ds.ip_addresses(network=network), label="address")
-    assert ip in network
-    assert ip.version == network.version
-
-
-class AnEnum(enum.Enum):
-    a = 1
-
-
-def requires_arg(value):
-    """Similar to the enum.Enum.__call__ method."""
-
-
-@given(ds.data())
-def test_builds_error_messages(data):
-    # If we call them directly, we get a simple TypeError in both cases
-    with pytest.raises(TypeError):
-        requires_arg()
-    with pytest.raises(TypeError):
-        AnEnum()
-    # But we have an improved error message if you try to build an Enum
-    assert issubclass(InvalidArgument, TypeError)  # it's a valid substitution
-    with pytest.raises(TypeError):  # which only applies to enums
-        data.draw(ds.builds(requires_arg))
-    with pytest.raises(
-        InvalidArgument,
-        match=r".* try using sampled_from$.+$ instead of builds$.+$",
-    ):
-        data.draw(ds.builds(AnEnum))
-    # and sampled_from() does in fact work
-    data.draw(ds.sampled_from(AnEnum))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_draw_example.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_error_in_draw.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_escalation.py Deleted

@@ -1,64 +0,0 @@
-# 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 os
-
-import pytest
-
-import hypothesis
-from hypothesis.internal import escalation as esc
-
-
-def test_does_not_escalate_errors_in_non_hypothesis_file():
-    try:
-        raise AssertionError
-    except AssertionError:
-        esc.escalate_hypothesis_internal_error()
-
-
-def test_does_escalate_errors_in_hypothesis_file(monkeypatch):
-    monkeypatch.setattr(esc, "is_hypothesis_file", lambda x: True)
-
-    with pytest.raises(AssertionError):
-        try:
-            raise AssertionError
-        except AssertionError:
-            esc.escalate_hypothesis_internal_error()
-
-
-def test_does_not_escalate_errors_in_hypothesis_file_if_disabled(monkeypatch):
-    monkeypatch.setattr(esc, "is_hypothesis_file", lambda x: True)
-    monkeypatch.setattr(esc, "PREVENT_ESCALATION", True)
-
-    try:
-        raise AssertionError
-    except AssertionError:
-        esc.escalate_hypothesis_internal_error()
-
-
-def test_is_hypothesis_file_not_confused_by_prefix(monkeypatch):
-    # Errors in third-party extensions such as `hypothesis-trio` or
-    # `hypothesis-jsonschema` used to be incorrectly considered to be
-    # Hypothesis internal errors, which could result in confusing error
-    # messages. This test makes sure that files like:
-    # `.../python3.7/site-packages/hypothesis_something/...`
-    # are not considered as hypothesis files.
-    root = os.path.dirname(hypothesis.__file__)
-    assert esc.is_hypothesis_file(hypothesis.__file__)
-    assert esc.is_hypothesis_file(esc.__file__)
-
-    assert not esc.is_hypothesis_file(pytest.__file__)
-    assert not esc.is_hypothesis_file(root + "-suffix")
-    assert not esc.is_hypothesis_file(root + "-suffix/something.py")
-
-
-@pytest.mark.parametrize("fname", "", "<ipython-input-18-f7c304bea5eb>")
-def test_is_hypothesis_file_does_not_error_on_invalid_paths_issue_2319(fname):
-    assert not esc.is_hypothesis_file(fname)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_example.py Deleted

@@ -1,86 +0,0 @@
-# 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 sys
-import warnings
-from decimal import Decimal
-
-import pexpect
-import pytest
-
-from hypothesis import example, find, given, strategies as st
-from hypothesis.errors import (
-    HypothesisException,
-    NonInteractiveExampleWarning,
-    Unsatisfiable,
-)
-from hypothesis.internal.compat import WINDOWS
-
-from tests.common.utils import fails_with
-
-
-def test_example_of_none_is_none():
-    assert st.none().example() is None
-
-
-def test_exception_in_compare_can_still_have_example():
-    st.one_of(st.none().map(lambda n: Decimal("snan")), st.just(Decimal(0))).example()
-
-
-def test_does_not_always_give_the_same_example():
-    s = st.integers()
-    assert len({s.example() for _ in range(100)}) >= 10
-
-
-def test_raises_on_no_examples():
-    with pytest.raises(Unsatisfiable):
-        st.nothing().example()
-
-
-@fails_with(HypothesisException)
-@example(False)
-@given(st.booleans())
-def test_example_inside_given(b):
-    st.integers().example()
-
-
-@fails_with(HypothesisException)
-def test_example_inside_find():
-    find(st.integers(0, 100), lambda x: st.integers().example())
-
-
-@fails_with(HypothesisException)
-def test_example_inside_strategy():
-    st.booleans().map(lambda x: st.integers().example()).example()
-
-
-def test_non_interactive_example_emits_warning():
-    # We have this warning disabled for most of our tests, because self-testing
-    # Hypothesis means `.example()` can be a good idea when it never is for users.
-    with warnings.catch_warnings():
-        warnings.simplefilter("always")
-        with pytest.warns(NonInteractiveExampleWarning):
-            st.text().example()
-
-
-@pytest.mark.skipif(WINDOWS, reason="pexpect.spawn not supported on Windows")
-def test_interactive_example_does_not_emit_warning():
-    try:
-        child = pexpect.spawn(f"{sys.executable} -Werror")
-        child.expect(">>> ", timeout=10)
-    except pexpect.exceptions.EOF:
-        pytest.skip(
-            "Unable to run python with -Werror.  This may be because you are "
-            "running from an old virtual environment - update your installed "
-            "copy of `virtualenv` and then create a fresh environment."
-        )
-    child.sendline("from hypothesis.strategies import none")
-    child.sendline("none().example()")
-    child.sendline("quit(code=0)")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_executors.py Deleted

@@ -1,86 +0,0 @@
-# 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 inspect
-from unittest import TestCase
-
-import pytest
-
-from hypothesis import example, given
-from hypothesis.executors import ConjectureRunner
-from hypothesis.strategies import booleans, integers
-
-
-def test_must_use_result_of_test():
-    class DoubleRun:
-        def execute_example(self, function):
-            x = function()
-            if inspect.isfunction(x):
-                return x()
-
-        @given(booleans())
-        def boom(self, b):
-            def f():
-                raise ValueError()
-
-            return f
-
-    with pytest.raises(ValueError):
-        DoubleRun().boom()
-
-
-class TestTryReallyHard(TestCase):
-    @given(integers())
-    def test_something(self, i):
-        pass
-
-    def execute_example(self, f):
-        f()
-        return f()
-
-
-class Valueless:
-    def execute_example(self, f):
-        try:
-            return f()
-        except ValueError:
-            return None
-
-    @given(integers())
-    @example(1)
-    def test_no_boom_on_example(self, x):
-        raise ValueError()
-
-    @given(integers())
-    def test_no_boom(self, x):
-        raise ValueError()
-
-    @given(integers())
-    def test_boom(self, x):
-        raise AssertionError
-
-
-def test_boom():
-    with pytest.raises(AssertionError):
-        Valueless().test_boom()
-
-
-def test_no_boom():
-    Valueless().test_no_boom()
-
-
-def test_no_boom_on_example():
-    Valueless().test_no_boom_on_example()
-
-
-class TestNormal(ConjectureRunner, TestCase):
-    @given(booleans())
-    def test_stuff(self, b):
-        pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_explicit_examples.py Deleted

@@ -1,292 +0,0 @@
-# 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 time
-from unittest import TestCase
-
-import pytest
-
-from hypothesis import (
-    Phase,
-    Verbosity,
-    assume,
-    example,
-    given,
-    note,
-    reporting,
-    settings,
-)
-from hypothesis.errors import (
-    DeadlineExceeded,
-    HypothesisWarning,
-    InvalidArgument,
-    MultipleFailures,
-)
-from hypothesis.strategies import floats, integers, text
-
-from tests.common.utils import assert_falsifying_output, capture_out
-
-
-class TestInstanceMethods(TestCase):
-    @given(integers())
-    @example(1)
-    def test_hi_1(self, x):
-        assert isinstance(x, int)
-
-    @given(integers())
-    @example(x=1)
-    def test_hi_2(self, x):
-        assert isinstance(x, int)
-
-    @given(x=integers())
-    @example(x=1)
-    def test_hi_3(self, x):
-        assert isinstance(x, int)
-
-
-def test_kwarg_example_on_testcase():
-    class Stuff(TestCase):
-        @given(integers())
-        @example(x=1)
-        def test_hi(self, x):
-            assert isinstance(x, int)
-
-    Stuff("test_hi").test_hi()
-
-
-def test_errors_when_run_with_not_enough_args():
-    @given(integers(), int)
-    @example(1)
-    def foo(x, y):
-        pass
-
-    with pytest.raises(TypeError):
-        foo()
-
-
-def test_errors_when_run_with_not_enough_kwargs():
-    @given(integers(), int)
-    @example(x=1)
-    def foo(x, y):
-        pass
-
-    with pytest.raises(TypeError):
-        foo()
-
-
-def test_can_use_examples_after_given():
-    long_str = "This is a very long string that you've no chance of hitting"
-
-    @example(long_str)
-    @given(text())
-    def test_not_long_str(x):
-        assert x != long_str
-
-    with pytest.raises(AssertionError):
-        test_not_long_str()
-
-
-def test_can_use_examples_before_given():
-    long_str = "This is a very long string that you've no chance of hitting"
-
-    @given(text())
-    @example(long_str)
-    def test_not_long_str(x):
-        assert x != long_str
-
-    with pytest.raises(AssertionError):
-        test_not_long_str()
-
-
-def test_can_use_examples_around_given():
-    long_str = "This is a very long string that you've no chance of hitting"
-    short_str = "Still no chance"
-
-    seen = 
-
-    @example(short_str)
-    @given(text())
-    @example(long_str)
-    def test_not_long_str(x):
-        seen.append(x)
-
-    test_not_long_str()
-    assert set(seen:2) == {long_str, short_str}
-
-
-@pytest.mark.parametrize(("x", "y"), (1, False), (2, True))
-@example(z=10)
-@given(z=integers())
-def test_is_a_thing(x, y, z):
-    pass
-
-
-def test_no_args_and_kwargs():
-    with pytest.raises(InvalidArgument):
-        example(1, y=2)
-
-
-def test_no_empty_examples():
-    with pytest.raises(InvalidArgument):
-        example()
-
-
-def test_does_not_print_on_explicit_examples_if_no_failure():
-    @example(1)
-    @given(integers())
-    def test_positive(x):
-        assert x > 0
-
-    with reporting.with_reporter(reporting.default):
-        with pytest.raises(AssertionError):
-            with capture_out() as out:
-                test_positive()
-    out = out.getvalue()
-    assert "Falsifying example: test_positive(1)" not in out
-
-
-def test_prints_output_for_explicit_examples():
-    @example(-1)
-    @given(integers())
-    def test_positive(x):
-        assert x > 0
-
-    assert_falsifying_output(test_positive, "Falsifying explicit", x=-1)
-
-
-def test_prints_verbose_output_for_explicit_examples():
-    @settings(verbosity=Verbosity.verbose)
-    @example("NOT AN INTEGER")
-    @given(integers())
-    def test_always_passes(x):
-        pass
-
-    assert_falsifying_output(
-        test_always_passes,
-        expected_exception=None,
-        example_type="Trying explicit",
-        x="NOT AN INTEGER",
-    )
-
-
-def test_captures_original_repr_of_example():
-    @example(x=)
-    @given(integers())
-    def test_mutation(x):
-        x.append(1)
-        assert not x
-
-    assert_falsifying_output(test_mutation, "Falsifying explicit", x=)
-
-
-def test_examples_are_tried_in_order():
-    @example(x=1)
-    @example(x=2)
-    @given(integers())
-    @settings(phases=Phase.explicit)
-    @example(x=3)
-    def test(x):
-        print(f"x -> {x}")
-
-    with capture_out() as out:
-        with reporting.with_reporter(reporting.default):
-            test()
-    ls = out.getvalue().splitlines()
-    assert ls == "x -> 1", "x -> 2", "x -> 3"
-
-
-def test_prints_note_in_failing_example():
-    @example(x=42)
-    @example(x=43)
-    @given(integers())
-    def test(x):
-        note(f"x -> {x}")
-        assert x == 42
-
-    with capture_out() as out:
-        with reporting.with_reporter(reporting.default):
-            with pytest.raises(AssertionError):
-                test()
-    v = out.getvalue()
-    print(v)
-    assert "x -> 43" in v
-    assert "x -> 42" not in v
-
-
-def test_must_agree_with_number_of_arguments():
-    @example(1, 2)
-    @given(integers())
-    def test(a):
-        pass
-
-    with pytest.raises(InvalidArgument):
-        test()
-
-
-def test_runs_deadline_for_examples():
-    @example(10)
-    @settings(phases=Phase.explicit)
-    @given(integers())
-    def test(x):
-        time.sleep(10)
-
-    with pytest.raises(DeadlineExceeded):
-        test()
-
-
-@given(value=floats(0, 1))
-@example(value=0.56789)
-@pytest.mark.parametrize("threshold", 0.5, 1)
-def test_unsatisfied_assumption_during_explicit_example(threshold, value):
-    # Regression test, expected to pass / skip depending on parametrize.
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2125
-    assume(value < threshold)
-
-
-@pytest.mark.parametrize("exc", MultipleFailures, AssertionError)
-def test_multiple_example_reporting(exc):
-    @example(1)
-    @example(2)
-    @settings(report_multiple_bugs=exc is MultipleFailures, phases=Phase.explicit)
-    @given(integers())
-    def inner_test_multiple_failing_examples(x):
-        assert x < 2
-        assert x < 1
-
-    with pytest.raises(exc):
-        inner_test_multiple_failing_examples()
-
-
-@example(text())
-@given(text())
-def test_example_decorator_accepts_strategies(s):
-    """The custom error message only happens when the test has already failed."""
-
-
-def test_helpful_message_when_example_fails_because_it_was_passed_a_strategy():
-    @example(text())
-    @given(text())
-    def t(s):
-        assert isinstance(s, str)
-
-    try:
-        t()
-    except HypothesisWarning as err:
-        assert isinstance(err.__cause__, AssertionError)
-    else:
-        raise NotImplementedError("should be unreachable")
-
-
-def test_stop_silently_dropping_examples_when_decorator_is_applied_to_itself():
-    def f():
-        pass
-
-    test = example("outer")(example("inner"))(f)
-    assert len(test.hypothesis_explicit_examples) == 2

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_falsifying_example_output.py Deleted

@@ -1,61 +0,0 @@
-# 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 pytest
-
-from hypothesis import example, given, strategies as st
-
-from tests.common.utils import capture_out
-
-OUTPUT_NO_LINE_BREAK = """
-Falsifying explicit example: test(
-    x=%(input)s, y=%(input)s,
-)
-"""
-
-
-OUTPUT_WITH_LINE_BREAK = """
-Falsifying explicit example: test(
-    x=%(input)s,
-    y=%(input)s,
-)
-"""
-
-
-@pytest.mark.parametrize("line_break,input", (False, "0" * 10), (True, "0" * 100))
-def test_inserts_line_breaks_only_at_appropriate_lengths(line_break, input):
-    @example(input, input)
-    @given(st.text(), st.text())
-    def test(x, y):
-        assert x < y
-
-    with capture_out() as cap:
-        with pytest.raises(AssertionError):
-            test()
-
-    template = OUTPUT_WITH_LINE_BREAK if line_break else OUTPUT_NO_LINE_BREAK
-
-    desired_output = template % {"input": repr(input)}
-
-    actual_output = cap.getvalue()
-
-    assert desired_output.strip() == actual_output.strip()
-
-
-def test_vararg_output():
-    @given(foo=st.text())
-    def test(*args, foo):
-        raise AssertionError
-
-    with capture_out() as cap:
-        with pytest.raises(AssertionError):
-            test(1, 2, 3)
-
-    assert "1, 2, 3" in cap.getvalue()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_feature_flags.py Deleted

@@ -1,80 +0,0 @@
-# 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/.
-
-from hypothesis import given, strategies as st
-from hypothesis.strategies._internal.featureflags import FeatureFlags, FeatureStrategy
-
-from tests.common.debug import find_any, minimal
-
-STRAT = FeatureStrategy()
-
-
-def test_can_all_be_enabled():
-    find_any(STRAT, lambda x: all(x.is_enabled(i) for i in range(100)))
-
-
-def test_minimizes_open():
-    features = range(10)
-
-    flags = minimal(STRAT, lambda x: x.is_enabled(i) for i in features)
-
-    assert all(flags.is_enabled(i) for i in features)
-
-
-def test_minimizes_individual_features_to_open():
-    features = list(range(10))
-
-    flags = minimal(
-        STRAT, lambda x: sum(x.is_enabled(i) for i in features) < len(features)
-    )
-
-    assert all(flags.is_enabled(i) for i in features:-1)
-    assert not flags.is_enabled(features-1)
-
-
-def test_marks_unknown_features_as_enabled():
-    x = find_any(STRAT, lambda v: True)
-
-    assert x.is_enabled("fish")
-
-
-def test_by_default_all_enabled():
-    f = FeatureFlags()
-
-    assert f.is_enabled("foo")
-
-
-def test_eval_featureflags_repr():
-    flags = FeatureFlags(enabled="on", disabled="off")
-    assert flags.is_enabled("on")
-    assert not flags.is_enabled("off")
-    flags2 = eval(repr(flags))
-    assert flags2.is_enabled("on")
-    assert not flags2.is_enabled("off")
-
-
-@given(st.data())
-def test_repr_can_be_evalled(data):
-    flags = data.draw(STRAT)
-
-    features = data.draw(st.lists(st.text(), unique=True))
-
-    for f in features:
-        flags.is_enabled(f)
-
-    flags2 = eval(repr(flags))
-
-    for f in features:
-        assert flags2.is_enabled(f) == flags.is_enabled(f)
-
-    more_features = data.draw(st.lists(st.text().filter(lambda s: s not in features)))
-
-    for f in more_features:
-        assert flags2.is_enabled(f)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_filestorage.py Deleted

@@ -1,49 +0,0 @@
-# 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 os
-
-from hypothesis import configuration as fs
-
-previous_home_dir = None
-
-
-def setup_function(function):
-    global previous_home_dir
-    previous_home_dir = fs.storage_directory()
-    fs.set_hypothesis_home_dir(None)
-
-
-def teardown_function(function):
-    global previous_home_dir
-    fs.set_hypothesis_home_dir(previous_home_dir)
-    previous_home_dir = None
-
-
-def test_defaults_to_the_default():
-    assert fs.storage_directory() == fs.__hypothesis_home_directory_default
-
-
-def test_can_set_homedir_and_it_will_exist(tmpdir):
-    fs.set_hypothesis_home_dir(str(tmpdir.mkdir("kittens")))
-    d = fs.storage_directory()
-    assert "kittens" in d
-    assert os.path.exists(d)
-
-
-def test_will_pick_up_location_from_env(monkeypatch, tmpdir):
-    tmpdir = str(tmpdir)
-    monkeypatch.setattr(os, "environ", {"HYPOTHESIS_STORAGE_DIRECTORY": tmpdir})
-    assert fs.storage_directory() == tmpdir
-
-
-def test_storage_directories_are_not_created_automatically(tmpdir):
-    fs.set_hypothesis_home_dir(str(tmpdir))
-    assert not os.path.exists(fs.storage_directory("badgers"))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_filter_rewriting.py Deleted

@@ -1,248 +0,0 @@
-# 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 decimal
-import math
-import operator
-from functools import partial
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import HypothesisWarning, Unsatisfiable
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.strategies._internal.lazy import LazyStrategy, unwrap_strategies
-from hypothesis.strategies._internal.numbers import IntegersStrategy
-from hypothesis.strategies._internal.strategies import FilteredStrategy
-
-from tests.common.utils import fails_with
-
-
-@pytest.mark.parametrize(
-    "strategy, predicate, start, end",
-    
-        # Integers with integer bounds
-        (st.integers(1, 5), partial(operator.lt, 3), 4, 5),  # lambda x: 3 < x
-        (st.integers(1, 5), partial(operator.le, 3), 3, 5),  # lambda x: 3 <= x
-        (st.integers(1, 5), partial(operator.eq, 3), 3, 3),  # lambda x: 3 == x
-        (st.integers(1, 5), partial(operator.ge, 3), 1, 3),  # lambda x: 3 >= x
-        (st.integers(1, 5), partial(operator.gt, 3), 1, 2),  # lambda x: 3 > x
-        # Integers with non-integer bounds
-        (st.integers(1, 5), partial(operator.lt, 3.5), 4, 5),
-        (st.integers(1, 5), partial(operator.le, 3.5), 4, 5),
-        (st.integers(1, 5), partial(operator.ge, 3.5), 1, 3),
-        (st.integers(1, 5), partial(operator.gt, 3.5), 1, 3),
-        (st.integers(1, 5), partial(operator.lt, -math.inf), 1, 5),
-        (st.integers(1, 5), partial(operator.gt, math.inf), 1, 5),
-        # Integers with only one bound
-        (st.integers(min_value=1), partial(operator.lt, 3), 4, None),
-        (st.integers(min_value=1), partial(operator.le, 3), 3, None),
-        (st.integers(max_value=5), partial(operator.ge, 3), None, 3),
-        (st.integers(max_value=5), partial(operator.gt, 3), None, 2),
-        # Unbounded integers
-        (st.integers(), partial(operator.lt, 3), 4, None),
-        (st.integers(), partial(operator.le, 3), 3, None),
-        (st.integers(), partial(operator.eq, 3), 3, 3),
-        (st.integers(), partial(operator.ge, 3), None, 3),
-        (st.integers(), partial(operator.gt, 3), None, 2),
-        # Simple lambdas
-        (st.integers(), lambda x: x < 3, None, 2),
-        (st.integers(), lambda x: x <= 3, None, 3),
-        (st.integers(), lambda x: x == 3, 3, 3),
-        (st.integers(), lambda x: x >= 3, 3, None),
-        (st.integers(), lambda x: x > 3, 4, None),
-        # Simple lambdas, reverse comparison
-        (st.integers(), lambda x: 3 > x, None, 2),
-        (st.integers(), lambda x: 3 >= x, None, 3),
-        (st.integers(), lambda x: 3 == x, 3, 3),
-        (st.integers(), lambda x: 3 <= x, 3, None),
-        (st.integers(), lambda x: 3 < x, 4, None),
-        # More complicated lambdas
-        (st.integers(), lambda x: 0 < x < 5, 1, 4),
-        (st.integers(), lambda x: 0 < x >= 1, 1, None),
-        (st.integers(), lambda x: 1 > x <= 0, None, 0),
-        (st.integers(), lambda x: x > 0 and x > 0, 1, None),
-        (st.integers(), lambda x: x < 1 and x < 1, None, 0),
-        (st.integers(), lambda x: x > 1 and x > 0, 2, None),
-        (st.integers(), lambda x: x < 1 and x < 2, None, 0),
-    ,
-    ids=get_pretty_function_description,
-)
-@given(data=st.data())
-def test_filter_rewriting(data, strategy, predicate, start, end):
-    s = strategy.filter(predicate)
-    assert isinstance(s, LazyStrategy)
-    assert isinstance(s.wrapped_strategy, IntegersStrategy)
-    assert s.wrapped_strategy.start == start
-    assert s.wrapped_strategy.end == end
-    value = data.draw(s)
-    assert predicate(value)
-
-
-@pytest.mark.parametrize(
-    "s",
-    
-        st.integers(1, 5).filter(partial(operator.lt, 6)),
-        st.integers(1, 5).filter(partial(operator.eq, 3.5)),
-        st.integers(1, 5).filter(partial(operator.eq, "can't compare to strings")),
-        st.integers(1, 5).filter(partial(operator.ge, 0)),
-        st.integers(1, 5).filter(partial(operator.lt, math.inf)),
-        st.integers(1, 5).filter(partial(operator.gt, -math.inf)),
-    ,
-)
-@fails_with(Unsatisfiable)
-@given(data=st.data())
-def test_rewrite_unsatisfiable_filter(data, s):
-    data.draw(s)
-
-
-@given(st.integers(0, 2).filter(partial(operator.ne, 1)))
-def test_unhandled_operator(x):
-    assert x in (0, 2)
-
-
-def test_rewriting_does_not_compare_decimal_snan():
-    s = st.integers(1, 5).filter(partial(operator.eq, decimal.Decimal("snan")))
-    s.wrapped_strategy
-    with pytest.raises(decimal.InvalidOperation):
-        s.example()
-
-
-@pytest.mark.parametrize(
-    "strategy, lo, hi",
-    
-        (st.integers(0, 1), -1, 2),
-    ,
-    ids=repr,
-)
-def test_applying_noop_filter_returns_self(strategy, lo, hi):
-    s = strategy.wrapped_strategy
-    s2 = s.filter(partial(operator.le, -1)).filter(partial(operator.ge, 2))
-    assert s is s2
-
-
-def mod2(x):
-    return x % 2
-
-
-Y = 2**20
-
-
-@given(
-    data=st.data(),
-    predicates=st.permutations(
-        
-            partial(operator.lt, 1),
-            partial(operator.le, 2),
-            partial(operator.ge, 4),
-            partial(operator.gt, 5),
-            mod2,
-            lambda x: x > 2 or x % 7,
-            lambda x: 0 < x <= Y,
-        
-    ),
-)
-def test_rewrite_filter_chains_with_some_unhandled(data, predicates):
-    # Set up our strategy
-    s = st.integers(1, 5)
-    for p in predicates:
-        s = s.filter(p)
-
-    # Whatever value we draw is in fact valid for these strategies
-    value = data.draw(s)
-    for p in predicates:
-        assert p(value), f"p={p!r}, value={value}"
-
-    # No matter the order of the filters, we get the same resulting structure
-    unwrapped = s.wrapped_strategy
-    assert isinstance(unwrapped, FilteredStrategy)
-    assert isinstance(unwrapped.filtered_strategy, IntegersStrategy)
-    for pred in unwrapped.flat_conditions:
-        assert pred is mod2 or pred.__name__ == "<lambda>"
-
-
-class NotAFunction:
-    def __call__(self, bar):
-        return True
-
-
-lambda_without_source = eval("lambda x: x > 2", {}, {})
-assert get_pretty_function_description(lambda_without_source) == "lambda x: <unknown>"
-
-
-@pytest.mark.parametrize(
-    "start, end, predicate",
-    
-        (1, 4, lambda x: 0 < x < 5 and x % 7),
-        (0, 9, lambda x: 0 <= x < 10 and x % 3),
-        (1, None, lambda x: 0 < x <= Y),
-        (None, None, lambda x: x == x),
-        (None, None, lambda x: 1 == 1),
-        (None, None, lambda x: 1 <= 2),
-        (None, None, lambda x: x != 0),
-        (None, None, NotAFunction()),
-        (None, None, lambda_without_source),
-        (None, None, lambda x, y=2: x >= 0),
-    ,
-)
-@given(data=st.data())
-def test_rewriting_partially_understood_filters(data, start, end, predicate):
-    s = st.integers().filter(predicate).wrapped_strategy
-
-    assert isinstance(s, FilteredStrategy)
-    assert isinstance(s.filtered_strategy, IntegersStrategy)
-    assert s.filtered_strategy.start == start
-    assert s.filtered_strategy.end == end
-    assert s.flat_conditions == (predicate,)
-
-    value = data.draw(s)
-    assert predicate(value)
-
-
-@pytest.mark.parametrize(
-    "strategy",
-    
-        st.text(),
-        st.text(min_size=2),
-        st.lists(st.none()),
-        st.lists(st.none(), min_size=2),
-    ,
-)
-@pytest.mark.parametrize(
-    "predicate",
-    bool, len, tuple, list, lambda x: x,
-    ids=get_pretty_function_description,
-)
-def test_sequence_filter_rewriting(strategy, predicate):
-    s = unwrap_strategies(strategy)
-    fs = s.filter(predicate)
-    assert not isinstance(fs, FilteredStrategy)
-    if s.min_size > 0:
-        assert fs is s
-    else:
-        assert fs.min_size == 1
-
-
-@pytest.mark.parametrize("method", str.lower, str.title, str.upper)
-def test_warns_on_suspicious_string_methods(method):
-    s = unwrap_strategies(st.text())
-    with pytest.warns(
-        HypothesisWarning, match="this allows all nonempty strings!  Did you mean"
-    ):
-        fs = s.filter(method)
-    assert fs.min_size == 1
-
-
-@pytest.mark.parametrize("method", str.isidentifier, str.isalnum)
-def test_bumps_min_size_and_filters_for_content_str_methods(method):
-    s = unwrap_strategies(st.text())
-    fs = s.filter(method)
-    assert fs.filtered_strategy.min_size == 1
-    assert fs.flat_conditions == (method,)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_filtered_strategy.py Deleted

@@ -1,43 +0,0 @@
-# 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 hypothesis.strategies as st
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.strategies._internal.strategies import FilteredStrategy
-
-
-def test_filter_iterations_are_marked_as_discarded():
-    variable_equal_to_zero = 0  # non-local references disables filter-rewriting
-    x = st.integers(0, 255).filter(lambda x: x == variable_equal_to_zero)
-
-    data = ConjectureData.for_buffer(2, 1, 0)
-
-    assert data.draw(x) == 0
-
-    assert data.has_discards
-
-
-def test_filtered_branches_are_all_filtered():
-    s = FilteredStrategy(st.integers() | st.text(), (bool,))
-    assert all(isinstance(x, FilteredStrategy) for x in s.branches)
-
-
-def test_filter_conditions_may_be_empty():
-    s = FilteredStrategy(st.integers(), conditions=())
-    s.condition(0)
-
-
-def test_nested_filteredstrategy_flattens_conditions():
-    s = FilteredStrategy(
-        FilteredStrategy(st.text(), conditions=(bool,)),
-        conditions=(len,),
-    )
-    assert s.filtered_strategy is st.text()
-    assert s.flat_conditions == (bool, len)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_find.py Deleted

@@ -1,39 +0,0 @@
-# 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/.
-
-from random import Random
-
-from hypothesis import Phase, find, settings, strategies as st
-
-
-def test_find_uses_provided_random():
-    prev = None
-
-    for _ in range(3):
-        seen = 
-
-        def test(v):
-            if len(v) > 5:
-                if seen:
-                    return v == seen0
-                else:
-                    seen.append(v)
-                    return True
-
-        result = find(
-            st.text(),
-            test,
-            random=Random(13),
-            settings=settings(phases=Phase.generate, max_examples=1000),
-        )
-        if prev is None:
-            prev = result
-        else:
-            assert prev == result

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_flakiness.py Deleted

@@ -1,124 +0,0 @@
-# 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 pytest
-
-from hypothesis import HealthCheck, Verbosity, assume, example, given, reject, settings
-from hypothesis.errors import Flaky, Unsatisfiable, UnsatisfiedAssumption
-from hypothesis.internal.conjecture.engine import MIN_TEST_CALLS
-from hypothesis.strategies import booleans, composite, integers, lists, random_module
-
-from tests.common.utils import no_shrink
-
-
-class Nope(Exception):
-    pass
-
-
-def test_fails_only_once_is_flaky():
-    first_call = True
-
-    @given(integers())
-    def rude(x):
-        if first_call0:
-            first_call0 = False
-            raise Nope()
-
-    with pytest.raises(Flaky):
-        rude()
-
-
-def test_gives_flaky_error_if_assumption_is_flaky():
-    seen = set()
-
-    @given(integers())
-    @settings(verbosity=Verbosity.quiet)
-    def oops(s):
-        assume(s not in seen)
-        seen.add(s)
-        raise AssertionError
-
-    with pytest.raises(Flaky):
-        oops()
-
-
-def test_does_not_attempt_to_shrink_flaky_errors():
-    values = 
-
-    @settings(database=None)
-    @given(integers())
-    def test(x):
-        values.append(x)
-        assert len(values) != 1
-
-    with pytest.raises(Flaky):
-        test()
-    # We try a total of ten calls in the generation phase, each usually a
-    # unique value, looking briefly (and unsuccessfully) for another bug.
-    assert 1 < len(set(values)) <= MIN_TEST_CALLS
-    # We don't try any new values while shrinking, just execute the test
-    # twice more (to check for flakiness and to raise the bug to the user).
-    assert set(values) == set(values:-2)
-
-
-class SatisfyMe(Exception):
-    pass
-
-
-@composite
-def single_bool_lists(draw):
-    n = draw(integers(0, 20))
-    result = False * (n + 1)
-    resultn = True
-    return result
-
-
-@example(True, False, False, False, 3, None)
-@example(False, True, False, False, 3, None)
-@example(False, False, True, False, 3, None)
-@example(False, False, False, True, 3, None)
-@settings(deadline=None)
-@given(lists(booleans()) | single_bool_lists(), lists(integers(1, 3)), random_module())
-def test_failure_sequence_inducing(building, testing, rnd):
-    buildit = iter(building)
-    testit = iter(testing)
-
-    def build(x):
-        try:
-            assume(not next(buildit))
-        except StopIteration:
-            pass
-        return x
-
-    @given(integers().map(build))
-    @settings(
-        verbosity=Verbosity.quiet,
-        database=None,
-        suppress_health_check=HealthCheck.all(),
-        phases=no_shrink,
-    )
-    def test(x):
-        try:
-            i = next(testit)
-        except StopIteration:
-            return
-        if i == 1:
-            return
-        elif i == 2:
-            reject()
-        else:
-            raise Nope()
-
-    try:
-        test()
-    except (Nope, Unsatisfiable, Flaky):
-        pass
-    except UnsatisfiedAssumption:
-        raise SatisfyMe() from None

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_float_nastiness.py Deleted

@@ -1,279 +0,0 @@
-# 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 math
-import sys
-import warnings
-
-import pytest
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.floats import (
-    float_of,
-    float_to_int,
-    int_to_float,
-    is_negative,
-    next_down,
-    next_up,
-)
-
-from tests.common.debug import find_any, minimal
-
-try:
-    import numpy
-except ImportError:
-    numpy = None
-
-
-@pytest.mark.parametrize(
-    ("lower", "upper"),
-    
-        # Exact values don't matter, but they're large enough so that x + y = inf.
-        (9.9792015476736e291, 1.7976931348623157e308),
-        (-sys.float_info.max, sys.float_info.max),
-    ,
-)
-def test_floats_are_in_range(lower, upper):
-    @given(st.floats(lower, upper))
-    def test_is_in_range(t):
-        assert lower <= t <= upper
-
-    test_is_in_range()
-
-
-@pytest.mark.parametrize("sign", -1, 1)
-def test_can_generate_both_zeros(sign):
-    assert minimal(st.floats(), lambda x: math.copysign(1, x) == sign) == sign * 0.0
-
-
-@pytest.mark.parametrize(
-    ("l", "r"),
-    (-1.0, 1.0), (-0.0, 1.0), (-1.0, 0.0), (-sys.float_info.min, sys.float_info.min),
-)
-@pytest.mark.parametrize("sign", -1, 1)
-def test_can_generate_both_zeros_when_in_interval(l, r, sign):
-    assert minimal(st.floats(l, r), lambda x: math.copysign(1, x) == sign) == sign * 0.0
-
-
-@given(st.floats(0.0, 1.0))
-def test_does_not_generate_negative_if_right_boundary_is_positive(x):
-    assert math.copysign(1, x) == 1
-
-
-@given(st.floats(-1.0, -0.0))
-def test_does_not_generate_positive_if_right_boundary_is_negative(x):
-    assert math.copysign(1, x) == -1
-
-
-def test_half_bounded_generates_zero():
-    find_any(st.floats(min_value=-1.0), lambda x: x == 0.0)
-    find_any(st.floats(max_value=1.0), lambda x: x == 0.0)
-
-
-@given(st.floats(max_value=-0.0))
-def test_half_bounded_respects_sign_of_upper_bound(x):
-    assert math.copysign(1, x) == -1
-
-
-@given(st.floats(min_value=0.0))
-def test_half_bounded_respects_sign_of_lower_bound(x):
-    assert math.copysign(1, x) == 1
-
-
-@given(st.floats(allow_nan=False))
-def test_filter_nan(x):
-    assert not math.isnan(x)
-
-
-@given(st.floats(allow_infinity=False))
-def test_filter_infinity(x):
-    assert not math.isinf(x)
-
-
-def test_can_guard_against_draws_of_nan():
-    """In this test we create a NaN value that naturally "tries" to shrink into
-    the first strategy, where it is not permitted. This tests a case that is
-    very unlikely to happen in random generation: When the unconstrained first
-    branch of generating a float just happens to produce a NaN value.
-
-    Here what happens is that we get a NaN from the *second* strategy,
-    but this then shrinks into its unconstrained branch. The natural
-    thing to happen is then to try to zero the branch parameter of the
-    one_of, but that will put an illegal value there, so it's not
-    allowed to happen.
-    """
-    tagged_floats = st.one_of(
-        st.tuples(st.just(0), st.floats(allow_nan=False)),
-        st.tuples(st.just(1), st.floats(allow_nan=True)),
-    )
-
-    tag, f = minimal(tagged_floats, lambda x: math.isnan(x1))
-    assert tag == 1
-
-
-def test_very_narrow_interval():
-    upper_bound = -1.0
-    lower_bound = int_to_float(float_to_int(upper_bound) + 10)
-    assert lower_bound < upper_bound
-
-    @given(st.floats(lower_bound, upper_bound))
-    def test(f):
-        assert lower_bound <= f <= upper_bound
-
-    test()
-
-
-@given(st.floats())
-def test_up_means_greater(x):
-    hi = next_up(x)
-    if not x < hi:
-        assert (
-            (math.isnan(x) and math.isnan(hi))
-            or (x > 0 and math.isinf(x))
-            or (x == hi == 0 and is_negative(x) and not is_negative(hi))
-        )
-
-
-@given(st.floats())
-def test_down_means_lesser(x):
-    lo = next_down(x)
-    if not x > lo:
-        assert (
-            (math.isnan(x) and math.isnan(lo))
-            or (x < 0 and math.isinf(x))
-            or (x == lo == 0 and is_negative(lo) and not is_negative(x))
-        )
-
-
-@given(st.floats(allow_nan=False, allow_infinity=False))
-def test_updown_roundtrip(val):
-    assert val == next_up(next_down(val))
-    assert val == next_down(next_up(val))
-
-
-@given(st.floats(width=32, allow_infinity=False))
-def test_float32_can_exclude_infinity(x):
-    assert not math.isinf(x)
-
-
-@given(st.floats(width=16, allow_infinity=False))
-def test_float16_can_exclude_infinity(x):
-    assert not math.isinf(x)
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        {"min_value": 10**5, "width": 16},
-        {"max_value": 10**5, "width": 16},
-        {"min_value": 10**40, "width": 32},
-        {"max_value": 10**40, "width": 32},
-        {"min_value": 10**400, "width": 64},
-        {"max_value": 10**400, "width": 64},
-        {"min_value": 10**400},
-        {"max_value": 10**400},
-    ,
-)
-def test_out_of_range(kwargs):
-    with pytest.raises(OverflowError):
-        st.floats(**kwargs).validate()
-
-
-def test_disallowed_width():
-    with pytest.raises(InvalidArgument):
-        st.floats(width=128).validate()
-
-
-def test_no_single_floats_in_range():
-    low = 2.0**25 + 1
-    high = low + 2
-    st.floats(low, high).validate()  # Note: OK for 64bit floats
-    with pytest.raises(InvalidArgument):
-        """Unrepresentable bounds are deprecated; but we're not testing that
-        here."""
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            st.floats(low, high, width=32).validate()
-
-
-# If the floats() strategy adds random floats to a value as large as 10^304
-# without handling overflow, we are very likely to generate infinity.
-@given(st.floats(min_value=1e304, allow_infinity=False))
-def test_finite_min_bound_does_not_overflow(x):
-    assert not math.isinf(x)
-
-
-@given(st.floats(max_value=-1e304, allow_infinity=False))
-def test_finite_max_bound_does_not_overflow(x):
-    assert not math.isinf(x)
-
-
-@given(st.floats(0, 1, exclude_min=True, exclude_max=True))
-def test_can_exclude_endpoints(x):
-    assert 0 < x < 1
-
-
-@given(st.floats(-math.inf, -1e307, exclude_min=True))
-def test_can_exclude_neg_infinite_endpoint(x):
-    assert not math.isinf(x)
-
-
-@given(st.floats(1e307, math.inf, exclude_max=True))
-def test_can_exclude_pos_infinite_endpoint(x):
-    assert not math.isinf(x)
-
-
-def test_exclude_infinite_endpoint_is_invalid():
-    with pytest.raises(InvalidArgument):
-        st.floats(min_value=math.inf, exclude_min=True).validate()
-    with pytest.raises(InvalidArgument):
-        st.floats(max_value=-math.inf, exclude_max=True).validate()
-
-
-@pytest.mark.parametrize("lo,hi", (True, False), (False, True), (True, True))
-@given(bound=st.floats(allow_nan=False, allow_infinity=False).filter(bool))
-def test_exclude_entire_interval(lo, hi, bound):
-    with pytest.raises(InvalidArgument, match="exclude_min=.+ and exclude_max="):
-        st.floats(bound, bound, exclude_min=lo, exclude_max=hi).validate()
-
-
-def test_zero_intervals_are_OK():
-    st.floats(0.0, 0.0).validate()
-    st.floats(-0.0, 0.0).validate()
-    st.floats(-0.0, -0.0).validate()
-
-
-@pytest.mark.parametrize("lo", 0.0, -0.0)
-@pytest.mark.parametrize("hi", 0.0, -0.0)
-@pytest.mark.parametrize("exmin,exmax", (True, False), (False, True), (True, True))
-def test_cannot_exclude_endpoint_with_zero_interval(lo, hi, exmin, exmax):
-    with pytest.raises(InvalidArgument):
-        st.floats(lo, hi, exclude_min=exmin, exclude_max=exmax).validate()
-
-
-WIDTHS = (64, 32, 16)
-
-
-@pytest.mark.parametrize("nonfloat", st.nothing(), st.none())
-@given(data=st.data(), width=st.sampled_from(WIDTHS))
-def test_fuzzing_floats_bounds(data, width, nonfloat):
-    lo = data.draw(nonfloat | st.floats(allow_nan=False, width=width), label="lo")
-    hi = data.draw(nonfloat | st.floats(allow_nan=False, width=width), label="hi")
-    if lo is not None and hi is not None and lo > hi:
-        lo, hi = hi, lo
-    assume(lo != 0 or hi != 0)
-    value = data.draw(
-        st.floats(min_value=lo, max_value=hi, width=width, allow_nan=False),
-        label="value",
-    )
-    assert value == float_of(value, width=width)
-    assert lo is None or lo <= value
-    assert hi is None or value <= hi

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_float_utils.py Deleted

@@ -1,81 +0,0 @@
-# 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 math
-from sys import float_info
-
-import pytest
-
-from hypothesis import example, given, strategies as st
-from hypothesis.internal.floats import (
-    count_between_floats,
-    make_float_clamper,
-    next_down,
-    next_up,
-)
-
-
-def test_can_handle_straddling_zero():
-    assert count_between_floats(-0.0, 0.0) == 2
-
-
-@pytest.mark.parametrize(
-    "func,val",
-    
-        (next_up, math.nan),
-        (next_up, math.inf),
-        (next_up, -0.0),
-        (next_down, math.nan),
-        (next_down, -math.inf),
-        (next_down, 0.0),
-    ,
-)
-def test_next_float_equal(func, val):
-    if math.isnan(val):
-        assert math.isnan(func(val))
-    else:
-        assert func(val) == val
-
-
-# exponent comparisons:
-@example(1, float_info.max, 0)
-@example(1, float_info.max, 1)
-@example(1, float_info.max, 10)
-@example(1, float_info.max, float_info.max)
-@example(1, float_info.max, math.inf)
-# mantissa comparisons:
-@example(100.0001, 100.0003, 100.0001)
-@example(100.0001, 100.0003, 100.0002)
-@example(100.0001, 100.0003, 100.0003)
-@given(st.floats(min_value=0), st.floats(min_value=0), st.floats(min_value=0))
-def test_float_clamper(min_value, max_value, input_value):
-    clamper = make_float_clamper(min_value, max_value, allow_zero=False)
-    if max_value < min_value:
-        assert clamper is None
-        return
-    clamped = clamper(input_value)
-    if min_value <= input_value <= max_value:
-        assert input_value == clamped
-    else:
-        assert min_value <= clamped <= max_value
-
-
-@example(0.01, math.inf, 0.0)
-@given(st.floats(min_value=0), st.floats(min_value=0), st.floats(min_value=0))
-def test_float_clamper_with_allowed_zeros(min_value, max_value, input_value):
-    clamper = make_float_clamper(min_value, max_value, allow_zero=True)
-    assert clamper is not None
-    clamped = clamper(input_value)
-    if input_value == 0.0 or max_value < min_value:
-        assert clamped == 0.0
-    elif min_value <= input_value <= max_value:
-        assert input_value == clamped
-    else:
-        assert min_value <= clamped <= max_value

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_functions.py Deleted

@@ -1,202 +0,0 @@
-# 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/.
-
-from inspect import getfullargspec
-
-import pytest
-
-from hypothesis import Verbosity, assume, given, settings
-from hypothesis.errors import InvalidArgument, InvalidState
-from hypothesis.reporting import with_reporter
-from hypothesis.strategies import booleans, functions, integers
-
-
-def func_a():
-    pass
-
-
-@given(functions(like=func_a, returns=booleans()))
-def test_functions_no_args(f):
-    assert f.__name__ == "func_a"
-    assert f is not func_a
-    assert isinstance(f(), bool)
-
-
-def func_b(a, b, c):
-    pass
-
-
-@given(functions(like=func_b, returns=booleans()))
-def test_functions_with_args(f):
-    assert f.__name__ == "func_b"
-    assert f is not func_b
-    with pytest.raises(TypeError):
-        f()
-    assert isinstance(f(1, 2, 3), bool)
-
-
-def func_c(**kwargs):
-    pass
-
-
-@given(functions(like=func_c, returns=booleans()))
-def test_functions_kw_args(f):
-    assert f.__name__ == "func_c"
-    assert f is not func_c
-    with pytest.raises(TypeError):
-        f(1, 2, 3)
-    assert isinstance(f(a=1, b=2, c=3), bool)
-
-
-@given(functions(like=lambda: None, returns=booleans()))
-def test_functions_argless_lambda(f):
-    assert f.__name__ == "<lambda>"
-    with pytest.raises(TypeError):
-        f(1)
-    assert isinstance(f(), bool)
-
-
-@given(functions(like=lambda a: None, returns=booleans()))
-def test_functions_lambda_with_arg(f):
-    assert f.__name__ == "<lambda>"
-    with pytest.raises(TypeError):
-        f()
-    assert isinstance(f(1), bool)
-
-
-@pytest.mark.parametrize(
-    "like,returns,pure",
-    
-        (None, booleans(), False),
-        (lambda: None, "not a strategy", True),
-        (lambda: None, booleans(), None),
-    ,
-)
-def test_invalid_arguments(like, returns, pure):
-    with pytest.raises(InvalidArgument):
-        functions(like=like, returns=returns, pure=pure).example()
-
-
-def func_returns_str() -> str:
-    return "a string"
-
-
-@given(functions(like=func_returns_str))
-def test_functions_strategy_return_type_inference(f):
-    result = f()
-    assume(result != "a string")
-    assert isinstance(result, str)
-
-
-def test_functions_valid_within_given_invalid_outside():
-    cache = None
-
-    @given(functions())
-    def t(f):
-        assert f() is None
-        cache0 = f
-
-    t()
-    with pytest.raises(InvalidState):
-        cache0()
-
-
-def test_can_call_default_like_arg():
-    # This test is somewhat silly, but coverage complains about the uncovered
-    # branch for calling it otherwise and alternative workarounds are worse.
-    defaults = getfullargspec(functions).kwonlydefaults
-    assert defaults"like"() is None
-    assert defaults"returns" is ...
-
-
-def func(arg, *, kwonly_arg):
-    pass
-
-
-@given(functions(like=func))
-def test_functions_strategy_with_kwonly_args(f):
-    with pytest.raises(TypeError):
-        f(1, 2)
-    f(1, kwonly_arg=2)
-    f(kwonly_arg=2, arg=1)
-
-
-def pure_func(arg1, arg2):
-    pass
-
-
-@given(
-    f=functions(like=pure_func, returns=integers(), pure=True),
-    arg1=integers(),
-    arg2=integers(),
-)
-def test_functions_pure_with_same_args(f, arg1, arg2):
-    # Same regardless of calling convention, unlike functools.lru_cache()
-    expected = f(arg1, arg2)
-    assert f(arg1, arg2) == expected
-    assert f(arg1, arg2=arg2) == expected
-    assert f(arg1=arg1, arg2=arg2) == expected
-    assert f(arg2=arg2, arg1=arg1) == expected
-
-
-@given(
-    f=functions(like=pure_func, returns=integers(), pure=True),
-    arg1=integers(),
-    arg2=integers(),
-)
-def test_functions_pure_with_different_args(f, arg1, arg2):
-    r1 = f(arg1, arg2)
-    r2 = f(arg2, arg1)
-    assume(r1 != r2)
-    # If this is never true, the test will fail with Unsatisfiable
-
-
-@given(
-    f1=functions(like=pure_func, returns=integers(), pure=True),
-    f2=functions(like=pure_func, returns=integers(), pure=True),
-)
-def test_functions_pure_two_functions_different_args_different_result(f1, f2):
-    r1 = f1(1, 2)
-    r2 = f2(3, 4)
-    assume(r1 != r2)
-    # If this is never true, the test will fail with Unsatisfiable
-
-
-@given(
-    f1=functions(like=pure_func, returns=integers(), pure=True),
-    f2=functions(like=pure_func, returns=integers(), pure=True),
-    arg1=integers(),
-    arg2=integers(),
-)
-def test_functions_pure_two_functions_same_args_different_result(f1, f2, arg1, arg2):
-    r1 = f1(arg1, arg2)
-    r2 = f2(arg1, arg2)
-    assume(r1 != r2)
-    # If this is never true, the test will fail with Unsatisfiable
-
-
-@settings(verbosity=Verbosity.verbose)
-@given(functions(pure=False))
-def test_functions_note_all_calls_to_impure_functions(f):
-    ls = 
-    with with_reporter(ls.append):
-        f()
-        f()
-    assert len(ls) == 2
-
-
-@settings(verbosity=Verbosity.verbose)
-@given(functions(pure=True))
-def test_functions_note_only_first_to_pure_functions(f):
-    ls = 
-    with with_reporter(ls.append):
-        f()
-        f()
-    assert len(ls) == 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_fuzz_one_input.py Deleted

@@ -1,168 +0,0 @@
-# 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 io
-from operator import attrgetter
-
-import pytest
-
-from hypothesis import Phase, given, settings, strategies as st
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.conjecture.shrinker import sort_key
-
-try:
-    from random import randbytes
-except ImportError:  # New in Python 3.9
-    from secrets import token_bytes as randbytes
-
-
-@pytest.mark.parametrize(
-    "buffer_type",
-    bytes, bytearray, memoryview, io.BytesIO,
-    ids=attrgetter("__name__"),
-)
-def test_fuzz_one_input(buffer_type):
-    db = InMemoryExampleDatabase()
-    seen = 
-    seeds = 
-
-    # This is a standard `@given` test, which we can also use as a fuzz target.
-    # Note that we specify the DB so we can make more precise assertions,
-    # and tighten the phases so we can be sure the failing examples come from fuzzing.
-    @given(st.text())
-    @settings(database=db, phases=Phase.reuse, Phase.shrink)
-    def test(s):
-        seen.append(s)
-        assert "\0" not in s, repr(s)
-
-    # Before running fuzz_one_input, there's nothing in `db`, and so the test passes
-    # (because example generation is disabled by the custom settings)
-    test()
-    assert len(seen) == 0
-
-    # If we run a lot of random bytestrings through fuzz_one_input, we'll eventually
-    # find a failing example.
-    with pytest.raises(AssertionError):
-        for _ in range(1000):
-            buf = randbytes(1000)
-            seeds.append(buf)
-            test.hypothesis.fuzz_one_input(buffer_type(buf))
-
-    # fuzz_one_input returns False for invalid bytestrings, due to e.g. assume(False)
-    assert len(seen) <= len(seeds)
-
-    # `db` contains exactly one failing example, which is either the most
-    # recent seed that we tried or the pruned-and-canonicalised form of it.
-    (saved_examples,) = db.data.values()
-    assert len(saved_examples) == 1
-    assert sort_key(seeds-1) >= sort_key(list(saved_examples)0)
-
-    # Now that we have a failure in `db`, re-running our test is sufficient to
-    # reproduce it, *and shrink to a minimal example*.
-    with pytest.raises(AssertionError):
-        test()
-    assert seen-1 == "\0"
-
-
-def test_can_fuzz_with_database_eq_None():
-    # This test exists to cover the can't-record-failure branch.
-
-    @given(st.none())
-    @settings(database=None)
-    def test(s):
-        raise AssertionError
-
-    with pytest.raises(AssertionError):
-        test.hypothesis.fuzz_one_input(b"\x00\x00")
-
-
-def test_fuzzing_unsatisfiable_test_always_returns_None():
-    # There are no examples of `st.none().filter(bool)`, but while the Hypothesis
-    # engine would give up, fuzz_one_input will just return None each time.
-
-    @given(st.none().filter(bool))
-    @settings(database=None)
-    def test(s):
-        raise AssertionError("Unreachable because there are no valid examples")
-
-    for _ in range(100):
-        buf = randbytes(3)
-        ret = test.hypothesis.fuzz_one_input(buf)
-        assert ret is None
-
-
-def test_autopruning_of_returned_buffer():
-    @given(st.binary(min_size=4, max_size=4))
-    @settings(database=None)
-    def test(s):
-        pass
-
-    # Unused portions of the input buffer are discarded from output.
-    # (and canonicalised, but that's a no-op for fixed-length `binary()`)
-    assert test.hypothesis.fuzz_one_input(b"deadbeef") == b"dead"
-
-
-STRAT = st.builds(object)
-
-
-@given(x=STRAT)
-def addx(x, y):
-    pass
-
-
-@given(STRAT)
-def addy(x, y):
-    pass
-
-
-def test_can_access_strategy_for_wrapped_test():
-    assert addx.hypothesis._given_kwargs == {"x": STRAT}
-    assert addy.hypothesis._given_kwargs == {"y": STRAT}
-
-
-@pytest.mark.parametrize(
-    "buffers,db_size",
-    
-        (b"aa", b"bb", b"cc", b"dd", 1),  # ascending -> only saves first
-        (b"dd", b"cc", b"bb", b"aa", 4),  # descending -> saves all
-        (b"cc", b"dd", b"aa", b"bb", 2),  # sawtooth -> saves cc then aa
-        (b"aa", b"bb", b"cc", b"XX", 2),  # two distinct errors -> saves both
-    ,
-)
-def test_fuzz_one_input_does_not_add_redundant_entries_to_database(buffers, db_size):
-    db = InMemoryExampleDatabase()
-    seen = 
-
-    @given(st.binary(min_size=2, max_size=2))
-    @settings(database=db)
-    def test(s):
-        seen.append(s)
-        assert s != b"XX"
-        raise AssertionError
-
-    for buf in buffers:
-        with pytest.raises(AssertionError):
-            test.hypothesis.fuzz_one_input(buf)
-
-    (saved_examples,) = db.data.values()
-    assert seen == buffers
-    assert len(saved_examples) == db_size
-
-
-def test_fuzzing_invalid_test_raises_error():
-    # Invalid: @given with too many positional arguments
-    @given(st.integers(), st.integers())
-    def invalid_test(s):
-        pass
-
-    with pytest.raises(InvalidArgument, match="Too many positional arguments"):
-        # access the property to check error happens during setup
-        invalid_test.hypothesis.fuzz_one_input

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_given_error_conditions.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_health_checks.py Deleted

@@ -1,294 +0,0 @@
-# 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 time
-
-import pytest
-from pytest import raises
-
-from hypothesis import HealthCheck, Phase, given, settings, strategies as st
-from hypothesis.control import assume
-from hypothesis.errors import FailedHealthCheck, InvalidArgument
-from hypothesis.internal.compat import int_from_bytes
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.internal.entropy import deterministic_PRNG
-from hypothesis.stateful import (
-    RuleBasedStateMachine,
-    initialize,
-    invariant,
-    rule,
-    run_state_machine_as_test,
-)
-from hypothesis.strategies._internal.lazy import LazyStrategy
-from hypothesis.strategies._internal.strategies import SearchStrategy
-
-from tests.common.utils import no_shrink
-
-HEALTH_CHECK_SETTINGS = settings(max_examples=11, database=None)
-
-
-def test_slow_generation_fails_a_health_check():
-    @HEALTH_CHECK_SETTINGS
-    @given(st.integers().map(lambda x: time.sleep(0.2)))
-    def test(x):
-        pass
-
-    with raises(FailedHealthCheck):
-        test()
-
-
-def test_slow_generation_inline_fails_a_health_check():
-    @settings(HEALTH_CHECK_SETTINGS, deadline=None)
-    @given(st.data())
-    def test(data):
-        data.draw(st.integers().map(lambda x: time.sleep(0.2)))
-
-    with raises(FailedHealthCheck):
-        test()
-
-
-def test_default_health_check_can_weaken_specific():
-    import random
-
-    @settings(HEALTH_CHECK_SETTINGS, suppress_health_check=HealthCheck.all())
-    @given(st.lists(st.integers(), min_size=1))
-    def test(x):
-        random.choice(x)
-
-    test()
-
-
-def test_suppressing_filtering_health_check():
-    forbidden = set()
-
-    def unhealthy_filter(x):
-        if len(forbidden) < 200:
-            forbidden.add(x)
-        return x not in forbidden
-
-    @HEALTH_CHECK_SETTINGS
-    @given(st.integers().filter(unhealthy_filter))
-    def test1(x):
-        raise ValueError()
-
-    with raises(FailedHealthCheck):
-        test1()
-
-    forbidden = set()
-
-    @settings(suppress_health_check=HealthCheck.filter_too_much, HealthCheck.too_slow)
-    @given(st.integers().filter(unhealthy_filter))
-    def test2(x):
-        raise ValueError()
-
-    with raises(ValueError):
-        test2()
-
-
-def test_filtering_everything_fails_a_health_check():
-    @given(st.integers().filter(lambda x: False))
-    @settings(database=None)
-    def test(x):
-        pass
-
-    with raises(FailedHealthCheck) as e:
-        test()
-    assert "filter" in e.value.args0
-
-
-class fails_regularly(SearchStrategy):
-    def do_draw(self, data):
-        b = int_from_bytes(data.draw_bytes(2))
-        assume(b == 3)
-        print("ohai")
-
-
-def test_filtering_most_things_fails_a_health_check():
-    @given(fails_regularly())
-    @settings(database=None, phases=no_shrink)
-    def test(x):
-        pass
-
-    with raises(FailedHealthCheck) as e:
-        test()
-    assert "filter" in e.value.args0
-
-
-def test_large_data_will_fail_a_health_check():
-    @given(st.none() | st.binary(min_size=10**5, max_size=10**5))
-    @settings(database=None)
-    def test(x):
-        pass
-
-    with raises(FailedHealthCheck) as e:
-        test()
-    assert "allowable size" in e.value.args0
-
-
-def test_returning_non_none_is_forbidden():
-    @given(st.integers())
-    def a(x):
-        return 1
-
-    with raises(FailedHealthCheck):
-        a()
-
-
-def test_the_slow_test_health_check_can_be_disabled():
-    @given(st.integers())
-    @settings(deadline=None)
-    def a(x):
-        time.sleep(1000)
-
-    a()
-
-
-def test_the_slow_test_health_only_runs_if_health_checks_are_on():
-    @given(st.integers())
-    @settings(suppress_health_check=HealthCheck.all(), deadline=None)
-    def a(x):
-        time.sleep(1000)
-
-    a()
-
-
-def test_returning_non_none_does_not_fail_if_health_check_disabled():
-    @given(st.integers())
-    @settings(suppress_health_check=HealthCheck.all())
-    def a(x):
-        return 1
-
-    a()
-
-
-def test_large_base_example_fails_health_check():
-    @given(st.binary(min_size=7000, max_size=7000))
-    def test(b):
-        pass
-
-    with pytest.raises(FailedHealthCheck) as exc:
-        test()
-
-    assert exc.value.health_check == HealthCheck.large_base_example
-
-
-def test_example_that_shrinks_to_overrun_fails_health_check():
-    @given(st.binary(min_size=9000, max_size=9000) | st.none())
-    def test(b):
-        pass
-
-    with pytest.raises(FailedHealthCheck) as exc:
-        test()
-
-    assert exc.value.health_check == HealthCheck.large_base_example
-
-
-def test_it_is_an_error_to_suppress_non_iterables():
-    with raises(InvalidArgument):
-        settings(suppress_health_check=1)
-
-
-def test_it_is_an_error_to_suppress_non_healthchecks():
-    with raises(InvalidArgument):
-        settings(suppress_health_check=1)
-
-
-slow_down_init = True
-
-
-def slow_init_integers(*args, **kwargs):
-    # This mimics st.characters() or st.text(), which perform some
-    # expensive Unicode calculations when the cache is empty.
-    global slow_down_init
-    if slow_down_init:
-        time.sleep(0.5)  # We monkeypatch time, so this is fast
-        slow_down_init = False
-    return st.integers(*args, **kwargs)
-
-
-@given(st.data())
-def test_lazy_slow_initialization_issue_2108_regression(data):
-    # Slow init in strategies wrapped in a LazyStrategy, inside an interactive draw,
-    # should be attributed to drawing from the strategy (not the test function).
-    # Specifically, this used to fail with a DeadlineExceeded error.
-    data.draw(LazyStrategy(slow_init_integers, (), {}))
-
-
-def test_does_not_trigger_health_check_on_simple_strategies(monkeypatch):
-    existing_draw_bits = ConjectureData.draw_bits
-
-    # We need to make drawing data artificially slow in order to trigger this
-    # effect. This isn't actually slow because time is fake in our CI, but
-    # we need it to pretend to be.
-    def draw_bits(self, n, forced=None):
-        time.sleep(0.001)
-        return existing_draw_bits(self, n, forced=forced)
-
-    monkeypatch.setattr(ConjectureData, "draw_bits", draw_bits)
-
-    with deterministic_PRNG():
-        for _ in range(100):
-            # Setting max_examples=11 ensures we have enough examples for the
-            # health checks to finish running, but cuts the generation short
-            # after that point to allow this test to run in reasonable time.
-            @settings(database=None, max_examples=11, phases=Phase.generate)
-            @given(st.binary())
-            def test(b):
-                pass
-
-            test()
-
-
-def test_does_not_trigger_health_check_when_most_examples_are_small(monkeypatch):
-    with deterministic_PRNG():
-        for _ in range(100):
-            # Setting max_examples=11 ensures we have enough examples for the
-            # health checks to finish running, but cuts the generation short
-            # after that point to allow this test to run in reasonable time.
-            @settings(database=None, max_examples=11, phases=Phase.generate)
-            @given(
-                st.integers(0, 100).flatmap(
-                    lambda n: st.binary(min_size=n * 100, max_size=n * 100)
-                )
-            )
-            def test(b):
-                pass
-
-            test()
-
-
-class ReturningRuleMachine(RuleBasedStateMachine):
-    @rule()
-    def r(self):
-        return "any non-None value"
-
-
-class ReturningInitializeMachine(RuleBasedStateMachine):
-    _ = rule()(lambda self: None)
-
-    @initialize()
-    def r(self):
-        return "any non-None value"
-
-
-class ReturningInvariantMachine(RuleBasedStateMachine):
-    _ = rule()(lambda self: None)
-
-    @invariant(check_during_init=True)
-    def r(self):
-        return "any non-None value"
-
-
-@pytest.mark.parametrize(
-    "cls", ReturningRuleMachine, ReturningInitializeMachine, ReturningInvariantMachine
-)
-def test_stateful_returnvalue_healthcheck(cls):
-    with pytest.raises(FailedHealthCheck):
-        run_state_machine_as_test(cls, settings=settings())

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_internal_helpers.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_intervalset.py Deleted

@@ -1,105 +0,0 @@
-# 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 pytest
-
-from hypothesis import HealthCheck, assume, example, given, settings, strategies as st
-from hypothesis.internal.charmap import _subtract_intervals
-from hypothesis.internal.intervalsets import IntervalSet
-
-
-def build_intervals(ls):
-    ls.sort()
-    result = 
-    for u, l in ls:
-        v = u + l
-        if result:
-            a, b = result-1
-            if u <= b + 1:
-                result-1 = (a, v)
-                continue
-        result.append((u, v))
-    return result
-
-
-def IntervalLists(min_size=0):
-    return st.lists(
-        st.tuples(st.integers(0, 200), st.integers(0, 20)),
-        min_size=min_size,
-    ).map(build_intervals)
-
-
-Intervals = st.builds(IntervalSet, IntervalLists())
-
-
-@given(Intervals)
-def test_intervals_are_equivalent_to_their_lists(intervals):
-    ls = list(intervals)
-    assert len(ls) == len(intervals)
-    for i in range(len(ls)):
-        assert lsi == intervalsi
-    for i in range(1, len(ls) - 1):
-        assert ls-i == intervals-i
-
-
-@given(Intervals)
-def test_intervals_match_indexes(intervals):
-    ls = list(intervals)
-    for v in ls:
-        assert ls.index(v) == intervals.index(v)
-
-
-@example(intervals=IntervalSet(((1, 1),)), v=0)
-@example(intervals=IntervalSet(()), v=0)
-@given(Intervals, st.integers())
-def test_error_for_index_of_not_present_value(intervals, v):
-    assume(v not in intervals)
-    with pytest.raises(ValueError):
-        intervals.index(v)
-
-
-def test_validates_index():
-    with pytest.raises(IndexError):
-        IntervalSet()1
-
-    with pytest.raises(IndexError):
-        IntervalSet(1, 10)11
-
-    with pytest.raises(IndexError):
-        IntervalSet(1, 10)-11
-
-
-def test_index_above_is_index_if_present():
-    assert IntervalSet(1, 10).index_above(1) == 0
-    assert IntervalSet(1, 10).index_above(2) == 1
-
-
-def test_index_above_is_length_if_higher():
-    assert IntervalSet(1, 10).index_above(100) == 10
-
-
-def intervals_to_set(ints):
-    return set(IntervalSet(ints))
-
-
-@settings(suppress_health_check=HealthCheck.filter_too_much)
-@example(x=(0, 1), (3, 3), y=(1, 3))
-@example(x=(0, 1), y=(0, 0), (1, 1))
-@example(x=(0, 1), y=(1, 1))
-@given(IntervalLists(min_size=1), IntervalLists(min_size=1))
-def test_subtraction_of_intervals(x, y):
-    xs = intervals_to_set(x)
-    ys = intervals_to_set(y)
-    assume(not xs.isdisjoint(ys))
-    z = _subtract_intervals(x, y)
-    assert z == tuple(sorted(z))
-    for a, b in z:
-        assert a <= b
-    assert intervals_to_set(z) == intervals_to_set(x) - intervals_to_set(y)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lambda_formatting.py Deleted

@@ -1,180 +0,0 @@
-# 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/.
-
-from hypothesis.internal.reflection import get_pretty_function_description
-
-
-def test_bracket_whitespace_is_striped():
-    assert get_pretty_function_description(lambda x: (x + 1)) == "lambda x: (x + 1)"
-
-
-def test_no_whitespace_before_colon_with_no_args():
-    assert get_pretty_function_description(eval("lambda: None")) == "lambda: <unknown>"
-
-
-def test_can_have_unicode_in_lambda_sources():
-    t = lambda x: "é" not in x
-    assert get_pretty_function_description(t) == 'lambda x: "é" not in x'
-
-
-# fmt: off
-ordered_pair = (
-    lambda right: .map(
-        lambda length: ()))
-# fmt: on
-
-
-def test_can_get_descriptions_of_nested_lambdas_with_different_names():
-    assert (
-        get_pretty_function_description(ordered_pair)
-        == "lambda right: .map(lambda length: ())"
-    )
-
-
-def test_does_not_error_on_unparsable_source():
-    # fmt: off
-    t = 
-        lambda x: \
-        # This will break ast.parse, but the brackets are needed for the real
-        # parser to accept this lambda
-        x0
-    # fmt: on
-    assert get_pretty_function_description(t) == "lambda x: <unknown>"
-
-
-def test_source_of_lambda_is_pretty():
-    assert get_pretty_function_description(lambda x: True) == "lambda x: True"
-
-
-def test_variable_names_are_not_pretty():
-    t = lambda x: True
-    assert get_pretty_function_description(t) == "lambda x: True"
-
-
-def test_does_not_error_on_dynamically_defined_functions():
-    x = eval("lambda t: 1")
-    get_pretty_function_description(x)
-
-
-def test_collapses_whitespace_nicely():
-    # fmt: off
-    t = (
-        lambda x,       y:           1
-    )
-    # fmt: on
-    assert get_pretty_function_description(t) == "lambda x, y: 1"
-
-
-def test_is_not_confused_by_tuples():
-    p = (lambda x: x > 1, 2)0
-
-    assert get_pretty_function_description(p) == "lambda x: x > 1"
-
-
-def test_strips_comments_from_the_end():
-    t = lambda x: 1  # A lambda comment
-    assert get_pretty_function_description(t) == "lambda x: 1"
-
-
-def test_does_not_strip_hashes_within_a_string():
-    t = lambda x: "#"
-    assert get_pretty_function_description(t) == 'lambda x: "#"'
-
-
-def test_can_distinguish_between_two_lambdas_with_different_args():
-    a, b = (lambda x: 1, lambda y: 2)
-    assert get_pretty_function_description(a) == "lambda x: 1"
-    assert get_pretty_function_description(b) == "lambda y: 2"
-
-
-def test_does_not_error_if_it_cannot_distinguish_between_two_lambdas():
-    a, b = (lambda x: 1, lambda x: 2)
-    assert "lambda x:" in get_pretty_function_description(a)
-    assert "lambda x:" in get_pretty_function_description(b)
-
-
-def test_lambda_source_break_after_def_with_brackets():
-    # fmt: off
-    f = (lambda n:
-         'aaa')
-    # fmt: on
-
-    source = get_pretty_function_description(f)
-    assert source == "lambda n: 'aaa'"
-
-
-def test_lambda_source_break_after_def_with_line_continuation():
-    # fmt: off
-    f = lambda n:\
-        'aaa'
-    # fmt: on
-
-    source = get_pretty_function_description(f)
-    assert source == "lambda n: 'aaa'"
-
-
-def arg_decorator(*s):
-    def accept(f):
-        return s
-
-    return accept
-
-
-@arg_decorator(lambda x: x + 1)
-def plus_one():
-    pass
-
-
-@arg_decorator(lambda x: x + 1, lambda y: y * 2)
-def two_decorators():
-    pass
-
-
-def test_can_extract_lambda_repr_in_a_decorator():
-    assert get_pretty_function_description(plus_one0) == "lambda x: x + 1"
-
-
-def test_can_extract_two_lambdas_from_a_decorator_if_args_differ():
-    a, b = two_decorators
-    assert get_pretty_function_description(a) == "lambda x: x + 1"
-    assert get_pretty_function_description(b) == "lambda y: y * 2"
-
-
-@arg_decorator(lambda x: x + 1)
-def decorator_with_space():
-    pass
-
-
-def test_can_extract_lambda_repr_in_a_decorator_with_spaces():
-    assert get_pretty_function_description(decorator_with_space0) == "lambda x: x + 1"
-
-
-@arg_decorator(lambda: ())
-def to_brackets():
-    pass
-
-
-def test_can_handle_brackets_in_decorator_argument():
-    assert get_pretty_function_description(to_brackets0) == "lambda: ()"
-
-
-def identity(x):
-    return x
-
-
-@arg_decorator(identity(lambda x: x + 1))
-def decorator_with_wrapper():
-    pass
-
-
-def test_can_handle_nested_lambda_in_decorator_argument():
-    assert (
-        get_pretty_function_description(decorator_with_wrapper0) == "lambda x: x + 1"
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lazy_import.py Deleted

@@ -1,48 +0,0 @@
-# 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 subprocess
-import sys
-
-SHOULD_NOT_IMPORT_TEST_RUNNERS = """
-import sys
-import unittest
-from hypothesis import given, strategies as st
-
-class TestDoesNotImportRunners(unittest.TestCase):
-    strat = st.integers() | st.floats() | st.sampled_from("a", "b")
-
-    @given(strat)
-    def test_does_not_import_unittest2(self, x):
-        assert "unittest2" not in sys.modules
-
-    @given(strat)
-    def test_does_not_import_nose(self, x):
-        assert "nose" not in sys.modules
-
-    @given(strat)
-    def test_does_not_import_pytest(self, x):
-        assert "pytest" not in sys.modules
-
-if __name__ == '__main__':
-    unittest.main()
-"""
-
-
-def test_hypothesis_does_not_import_test_runners(tmp_path):
-    # We obviously can't use pytest to check that pytest is not imported,
-    # so for consistency we use unittest for all three non-stdlib test runners.
-    # It's unclear which of our dependencies is importing unittest, but
-    # since I doubt it's causing any spurious failures I don't really care.
-    # See https://github.com/HypothesisWorks/hypothesis/pull/2204
-    fname = str(tmp_path / "test.py")
-    with open(fname, "w") as f:
-        f.write(SHOULD_NOT_IMPORT_TEST_RUNNERS)
-    subprocess.check_call(sys.executable, fname)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lookup.py Deleted

@@ -1,908 +0,0 @@
-# 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 abc
-import builtins
-import collections
-import datetime
-import enum
-import inspect
-import io
-import re
-import string
-import sys
-import typing
-from inspect import signature
-from numbers import Real
-
-import pytest
-
-from hypothesis import HealthCheck, assume, given, settings, strategies as st
-from hypothesis.errors import InvalidArgument, ResolutionFailed
-from hypothesis.internal.compat import get_type_hints
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.strategies import from_type
-from hypothesis.strategies._internal import types
-
-from tests.common.debug import assert_all_examples, find_any, minimal
-from tests.common.utils import fails_with, temp_registered
-
-sentinel = object()
-BUILTIN_TYPES = tuple(
-    v
-    for v in vars(builtins).values()
-    if isinstance(v, type) and v.__name__ != "BuiltinImporter"
-)
-generics = sorted(
-    (
-        t
-        for t in types._global_type_lookup
-        # We ignore TypeVar, because it is not a Generic type:
-        if isinstance(t, types.typing_root_type) and t != typing.TypeVar
-    ),
-    key=str,
-)
-
-
-@pytest.mark.parametrize("typ", generics, ids=repr)
-@settings(
-    suppress_health_check=HealthCheck.too_slow, HealthCheck.filter_too_much,
-    database=None,
-)
-@given(data=st.data())
-def test_resolve_typing_module(data, typ):
-    ex = data.draw(from_type(typ))
-
-    if typ in (typing.BinaryIO, typing.TextIO):
-        assert isinstance(ex, io.IOBase)
-    elif isinstance(typ, typing._ProtocolMeta):
-        pass
-    elif typ is typing.Type and not isinstance(typing.Type, type):
-        assert ex is type or isinstance(ex, typing.TypeVar)
-    else:
-        assert isinstance(ex, typ)
-
-
-@pytest.mark.parametrize("typ", typing.Any, typing.Union)
-def test_does_not_resolve_special_cases(typ):
-    with pytest.raises(InvalidArgument):
-        from_type(typ).example()
-
-
-@pytest.mark.parametrize(
-    "typ,instance_of",
-    (typing.Unionint, str, (int, str)), (typing.Optionalint, (int, type(None))),
-)
-@given(data=st.data())
-def test_specialised_scalar_types(data, typ, instance_of):
-    ex = data.draw(from_type(typ))
-    assert isinstance(ex, instance_of)
-
-
-def test_typing_Type_int():
-    assert from_type(typing.Typeint).example() is int
-
-
-@given(from_type(typing.Typetyping.Unionstr, list))
-def test_typing_Type_Union(ex):
-    assert ex in (str, list)
-
-
-@pytest.mark.parametrize(
-    "typ",
-    
-        collections.abc.ByteString,
-        typing.Match,
-        typing.Pattern,
-        re.Match,
-        re.Pattern,
-    ,
-    ids=repr,
-)
-@given(data=st.data())
-def test_rare_types(data, typ):
-    ex = data.draw(from_type(typ))
-    assert isinstance(ex, typ)
-
-
-class Elem:
-    pass
-
-
-@pytest.mark.parametrize(
-    "typ,coll_type",
-    
-        (typing.SetElem, set),
-        (typing.FrozenSetElem, frozenset),
-        (typing.DictElem, None, dict),
-        (typing.DefaultDictElem, None, collections.defaultdict),
-        (typing.KeysViewElem, type({}.keys())),
-        (typing.ValuesViewElem, type({}.values())),
-        (typing.ListElem, list),
-        (typing.TupleElem, tuple),
-        (typing.TupleElem, ..., tuple),
-        (typing.IteratorElem, typing.Iterator),
-        (typing.SequenceElem, typing.Sequence),
-        (typing.IterableElem, typing.Iterable),
-        (typing.MappingElem, None, typing.Mapping),
-        (typing.ContainerElem, typing.Container),
-        (typing.NamedTuple("A_NamedTuple", (("elem", Elem),)), tuple),
-        (typing.CounterElem, typing.Counter),
-        (typing.DequeElem, typing.Deque),
-    ,
-    ids=repr,
-)
-@given(data=st.data())
-def test_specialised_collection_types(data, typ, coll_type):
-    ex = data.draw(from_type(typ))
-    assert isinstance(ex, coll_type)
-    instances = isinstance(elem, Elem) for elem in ex
-    assert all(instances)
-    assume(instances)  # non-empty collections without calling len(iterator)
-
-
-class ElemValue:
-    pass
-
-
-@pytest.mark.parametrize(
-    "typ,coll_type",
-    
-        (typing.ChainMapElem, ElemValue, typing.ChainMap),
-        (typing.DefaultDictElem, ElemValue, typing.DefaultDict),
-    
-    + (
-        (typing.OrderedDictElem, ElemValue, typing.OrderedDict)
-        if hasattr(typing, "OrderedDict")  # Python 3.7.2 and later
-        else 
-    ),
-    ids=repr,
-)
-@given(data=st.data())
-def test_specialised_mapping_types(data, typ, coll_type):
-    ex = data.draw(from_type(typ).filter(len))
-    assert isinstance(ex, coll_type)
-    instances = isinstance(elem, Elem) for elem in ex
-    assert all(instances)
-    assert all(isinstance(elem, ElemValue) for elem in ex.values())
-
-
-@given(from_type(typing.ItemsViewElem, Elem).filter(len))
-def test_ItemsView(ex):
-    # See https://github.com/python/typing/issues/177
-    assert isinstance(ex, type({}.items()))
-    assert all(isinstance(elem, tuple) and len(elem) == 2 for elem in ex)
-    assert all(all(isinstance(e, Elem) for e in elem) for elem in ex)
-
-
-@pytest.mark.parametrize("generic", typing.Match, typing.Pattern)
-@pytest.mark.parametrize("typ", bytes, str)
-@given(data=st.data())
-def test_regex_types(data, generic, typ):
-    x = data.draw(from_type(generictyp))
-    assert isinstance(x0 if generic is typing.Match else x.pattern, typ)
-
-
-@given(x=...)
-def test_Generator(x: typing.GeneratorElem, None, ElemValue):
-    assert isinstance(x, typing.Generator)
-    try:
-        while True:
-            e = next(x)
-            assert isinstance(e, Elem)
-            x.send(None)  # The generators we create don't check the send type
-    except StopIteration as stop:
-        assert isinstance(stop.value, ElemValue)
-
-
-def test_Optional_minimises_to_None():
-    assert minimal(from_type(typing.Optionalint), lambda ex: True) is None
-
-
-@pytest.mark.parametrize("n", range(10))
-def test_variable_length_tuples(n):
-    type_ = typing.Tupleint, ...
-    from_type(type_).filter(lambda ex: len(ex) == n).example()
-
-
-def test_lookup_overrides_defaults():
-    sentinel = object()
-    with temp_registered(int, st.just(sentinel)):
-
-        @given(from_type(typing.Listint))
-        def inner_1(ex):
-            assert all(elem is sentinel for elem in ex)
-
-        inner_1()
-
-    @given(from_type(typing.Listint))
-    def inner_2(ex):
-        assert all(isinstance(elem, int) for elem in ex)
-
-    inner_2()
-
-
-def test_register_generic_typing_strats():
-    # I don't expect anyone to do this, but good to check it works as expected
-    with temp_registered(typing.Sequence, types._global_type_lookuptyping.Set):
-        # We register sets for the abstract sequence type, which masks subtypes
-        # from supertype resolution but not direct resolution
-        assert_all_examples(
-            from_type(typing.Sequenceint), lambda ex: isinstance(ex, set)
-        )
-        assert_all_examples(
-            from_type(typing.Containerint),
-            lambda ex: not isinstance(ex, typing.Sequence),
-        )
-        assert_all_examples(
-            from_type(typing.Listint), lambda ex: isinstance(ex, list)
-        )
-
-
-def if_available(name):
-    try:
-        return getattr(typing, name)
-    except AttributeError:
-        return pytest.param(name, marks=pytest.mark.skip)
-
-
-@pytest.mark.parametrize(
-    "typ",
-    
-        typing.Sequence,
-        typing.Container,
-        typing.Mapping,
-        typing.Reversible,
-        typing.SupportsBytes,
-        typing.SupportsAbs,
-        typing.SupportsComplex,
-        typing.SupportsFloat,
-        typing.SupportsInt,
-        typing.SupportsRound,
-        if_available("SupportsIndex"),
-    ,
-    ids=get_pretty_function_description,
-)
-def test_resolves_weird_types(typ):
-    from_type(typ).example()
-
-
-class Foo:
-    def __init__(self, x):
-        pass
-
-
-class Bar(Foo):
-    pass
-
-
-class Baz(Foo):
-    pass
-
-
-st.register_type_strategy(Bar, st.builds(Bar, st.integers()))
-st.register_type_strategy(Baz, st.builds(Baz, st.integers()))
-
-
-@pytest.mark.parametrize(
-    "var,expected",
-    
-        (typing.TypeVar("V"), object),
-        (typing.TypeVar("V", bound=int), int),
-        (typing.TypeVar("V", bound=Foo), (Bar, Baz)),
-        (typing.TypeVar("V", bound=typing.Unionint, str), (int, str)),
-        (typing.TypeVar("V", int, str), (int, str)),
-    ,
-)
-@settings(suppress_health_check=HealthCheck.too_slow)
-@given(data=st.data())
-def test_typevar_type_is_consistent(data, var, expected):
-    strat = st.from_type(var)
-    v1 = data.draw(strat)
-    v2 = data.draw(strat)
-    assume(v1 != v2)  # Values may vary, just not types
-    assert type(v1) == type(v2)
-    assert isinstance(v1, expected)
-
-
-def test_distinct_typevars_same_constraint():
-    A = typing.TypeVar("A", int, str)
-    B = typing.TypeVar("B", int, str)
-    find_any(
-        st.tuples(st.from_type(A), st.from_type(B)),
-        lambda ab: type(ab0) != type(ab1),  # noqa
-    )
-
-
-def test_distinct_typevars_distinct_type():
-    """Ensures that two different type vars have at least one different type in their strategies."""
-    A = typing.TypeVar("A")
-    B = typing.TypeVar("B")
-    find_any(
-        st.tuples(st.from_type(A), st.from_type(B)),
-        lambda ab: type(ab0) != type(ab1),  # noqa
-    )
-
-
-A = typing.TypeVar("A")
-
-
-def same_type_args(a: A, b: A):
-    assert type(a) == type(b)
-
-
-@given(st.builds(same_type_args))
-def test_same_typevars_same_type(_):
-    """Ensures that single type argument will always have the same type in a single context."""
-
-
-def test_typevars_can_be_redefined():
-    """We test that one can register a custom strategy for all type vars."""
-    A = typing.TypeVar("A")
-
-    with temp_registered(typing.TypeVar, st.just(1)):
-        assert_all_examples(st.from_type(A), lambda obj: obj == 1)
-
-
-def test_typevars_can_be_redefine_with_factory():
-    """We test that one can register a custom strategy for all type vars."""
-    A = typing.TypeVar("A")
-
-    with temp_registered(typing.TypeVar, lambda thing: st.just(thing.__name__)):
-        assert_all_examples(st.from_type(A), lambda obj: obj == "A")
-
-
-def annotated_func(a: int, b: int = 2, *, c: int, d: int = 4):
-    return a + b + c + d
-
-
-def test_issue_946_regression():
-    # Turned type hints into kwargs even if the required posarg was passed
-    st.builds(annotated_func, st.integers()).example()
-
-
-@pytest.mark.parametrize(
-    "thing",
-    
-        annotated_func,  # Works via typing.get_type_hints
-        typing.NamedTuple("N", ("a", int)),  # Falls back to inspection
-        int,  # Fails; returns empty dict
-    ,
-)
-def test_can_get_type_hints(thing):
-    assert isinstance(get_type_hints(thing), dict)
-
-
-def test_force_builds_to_infer_strategies_for_default_args():
-    # By default, leaves args with defaults and minimises to 2+4=6
-    assert minimal(st.builds(annotated_func), lambda ex: True) == 6
-    # Inferring integers() for args makes it minimise to zero
-    assert minimal(st.builds(annotated_func, b=..., d=...), lambda ex: True) == 0
-
-
-def non_annotated_func(a, b=2, *, c, d=4):
-    pass
-
-
-def test_cannot_pass_infer_as_posarg():
-    with pytest.raises(InvalidArgument):
-        st.builds(annotated_func, ...).example()
-
-
-def test_cannot_force_inference_for_unannotated_arg():
-    with pytest.raises(InvalidArgument):
-        st.builds(non_annotated_func, a=..., c=st.none()).example()
-    with pytest.raises(InvalidArgument):
-        st.builds(non_annotated_func, a=st.none(), c=...).example()
-
-
-class UnknownType:
-    def __init__(self, arg):
-        pass
-
-
-class UnknownAnnotatedType:
-    def __init__(self, arg: int):
-        pass
-
-
-@given(st.from_type(UnknownAnnotatedType))
-def test_builds_for_unknown_annotated_type(ex):
-    assert isinstance(ex, UnknownAnnotatedType)
-
-
-def unknown_annotated_func(a: UnknownType, b=2, *, c: UnknownType, d=4):
-    pass
-
-
-def test_raises_for_arg_with_unresolvable_annotation():
-    with pytest.raises(ResolutionFailed):
-        st.builds(unknown_annotated_func).example()
-    with pytest.raises(ResolutionFailed):
-        st.builds(unknown_annotated_func, a=st.none(), c=...).example()
-
-
-@given(a=..., b=...)
-def test_can_use_type_hints(a: int, b: float):
-    assert isinstance(a, int) and isinstance(b, float)
-
-
-def test_error_if_has_unresolvable_hints():
-    @given(a=...)
-    def inner(a: UnknownType):
-        pass
-
-    with pytest.raises(InvalidArgument):
-        inner()
-
-
-def test_resolves_NewType():
-    typ = typing.NewType("T", int)
-    nested = typing.NewType("NestedT", typ)
-    uni = typing.NewType("UnionT", typing.Optionalint)
-    assert isinstance(from_type(typ).example(), int)
-    assert isinstance(from_type(nested).example(), int)
-    assert isinstance(from_type(uni).example(), (int, type(None)))
-
-
-E = enum.Enum("E", "a b c")
-
-
-@given(from_type(E))
-def test_resolves_enum(ex):
-    assert isinstance(ex, E)
-
-
-@pytest.mark.parametrize("resolver", from_type, st.sampled_from)
-def test_resolves_flag_enum(resolver):
-    # Storing all combinations takes O(2^n) memory.  Using an enum of 52
-    # members in this test ensures that we won't try!
-    F = enum.Flag("F", " ".join(string.ascii_letters))
-    # Filter to check that we can generate compound members of enum.Flags
-
-    @given(resolver(F).filter(lambda ex: ex not in tuple(F)))
-    def inner(ex):
-        assert isinstance(ex, F)
-
-    inner()
-
-
-class AnnotatedTarget:
-    def __init__(self, a: int, b: int):
-        pass
-
-    def method(self, a: int, b: int):
-        pass
-
-
-@pytest.mark.parametrize("target", AnnotatedTarget, AnnotatedTarget(1, 2).method)
-@pytest.mark.parametrize(
-    "args,kwargs",
-    
-        ((), {}),
-        ((1,), {}),
-        ((1, 2), {}),
-        ((), {"a": 1}),
-        ((), {"b": 2}),
-        ((), {"a": 1, "b": 2}),
-    ,
-)
-def test_required_args(target, args, kwargs):
-    # Mostly checking that `self` (and only self) is correctly excluded
-    st.builds(
-        target, *map(st.just, args), **{k: st.just(v) for k, v in kwargs.items()}
-    ).example()
-
-
-class AnnotatedNamedTuple(typing.NamedTuple):
-    a: str
-
-
-@given(st.builds(AnnotatedNamedTuple))
-def test_infers_args_for_namedtuple_builds(thing):
-    assert isinstance(thing.a, str)
-
-
-@given(st.from_type(AnnotatedNamedTuple))
-def test_infers_args_for_namedtuple_from_type(thing):
-    assert isinstance(thing.a, str)
-
-
-@given(st.builds(AnnotatedNamedTuple, a=st.none()))
-def test_override_args_for_namedtuple(thing):
-    assert thing.a is None
-
-
-@pytest.mark.parametrize("thing", typing.Optional, typing.List, typing.Type)
-def test_cannot_resolve_bare_forward_reference(thing):
-    with pytest.raises(InvalidArgument):
-        t = thing"ConcreteFoo"
-        st.from_type(t).example()
-
-
-class Tree:
-    def __init__(self, left: typing.Optional"Tree", right: typing.Optional"Tree"):
-        self.left = left
-        self.right = right
-
-    def __repr__(self):
-        return f"Tree({self.left}, {self.right})"
-
-
-def test_resolving_recursive_type():
-    assert isinstance(st.builds(Tree).example(), Tree)
-
-
-class SomeClass:
-    def __init__(self, value: int, next_node: typing.Optional"SomeClass") -> None:
-        assert value > 0
-        self.value = value
-        self.next_node = next_node
-
-    def __repr__(self) -> str:
-        return f"SomeClass({self.value}, next_node={self.next_node})"
-
-
-def test_resolving_recursive_type_with_registered_constraint():
-    with temp_registered(
-        SomeClass, st.builds(SomeClass, value=st.integers(min_value=1))
-    ):
-        find_any(st.from_type(SomeClass), lambda s: s.next_node is None)
-        find_any(st.from_type(SomeClass), lambda s: s.next_node is not None)
-
-
-@given(from_type(typing.Tuple()))
-def test_resolves_empty_Tuple_issue_1583_regression(ex):
-    # See e.g. https://github.com/python/mypy/commit/71332d58
-    assert ex == ()
-
-
-def test_can_register_NewType():
-    Name = typing.NewType("Name", str)
-    st.register_type_strategy(Name, st.just("Eric Idle"))
-    assert st.from_type(Name).example() == "Eric Idle"
-
-
-@given(st.from_type(typing.Callable))
-def test_resolves_bare_callable_to_function(f):
-    val = f()
-    assert val is None
-    with pytest.raises(TypeError):
-        f(1)
-
-
-@given(st.from_type(typing.Callablestr, int))
-def test_resolves_callable_with_arg_to_function(f):
-    val = f("1")
-    assert isinstance(val, int)
-
-
-@given(st.from_type(typing.Callable..., int))
-def test_resolves_ellipses_callable_to_function(f):
-    val = f()
-    assert isinstance(val, int)
-    f(1)
-    f(1, 2, 3)
-    f(accepts_kwargs_too=1)
-
-
-class AbstractFoo(abc.ABC):
-    @abc.abstractmethod
-    def foo(self):
-        pass
-
-
-class ConcreteFoo(AbstractFoo):
-    def foo(self):
-        pass
-
-
-@given(st.from_type(AbstractFoo))
-def test_can_resolve_abstract_class(instance):
-    assert isinstance(instance, ConcreteFoo)
-    instance.foo()
-
-
-class AbstractBar(abc.ABC):
-    @abc.abstractmethod
-    def bar(self):
-        pass
-
-
-@fails_with(ResolutionFailed)
-@given(st.from_type(AbstractBar))
-def test_cannot_resolve_abstract_class_with_no_concrete_subclass(instance):
-    raise AssertionError("test body unreachable as strategy cannot resolve")
-
-
-@fails_with(ResolutionFailed)
-@given(st.from_type(typing.Type"ConcreteFoo"))
-def test_cannot_resolve_type_with_forwardref(instance):
-    raise AssertionError("test body unreachable as strategy cannot resolve")
-
-
-@pytest.mark.parametrize("typ", typing.Hashable, typing.Sized)
-@given(data=st.data())
-def test_inference_on_generic_collections_abc_aliases(typ, data):
-    # regression test for inference bug on types that are just aliases
-    # types for simple interfaces in collections abc and take no args
-    # the typing module such as Hashable and Sized
-    # see https://github.com/HypothesisWorks/hypothesis/issues/2272
-    value = data.draw(st.from_type(typ))
-    assert isinstance(value, typ)
-
-
-@given(st.from_type(typing.Sequenceset))
-def test_bytestring_not_treated_as_generic_sequence(val):
-    # Check that we don't fall into the specific problem from
-    # https://github.com/HypothesisWorks/hypothesis/issues/2257
-    assert not isinstance(val, typing.ByteString)
-    # Check it hasn't happened again from some other non-generic sequence type.
-    for x in val:
-        assert isinstance(x, set)
-
-
-@pytest.mark.parametrize(
-    "type_", int, Real, object, typing.Unionint, str, typing.UnionReal, str
-)
-def test_bytestring_is_valid_sequence_of_int_and_parent_classes(type_):
-    find_any(
-        st.from_type(typing.Sequencetype_),
-        lambda val: isinstance(val, typing.ByteString),
-    )
-
-
-@pytest.mark.parametrize("protocol", typing.SupportsAbs, typing.SupportsRound)
-@given(data=st.data())
-def test_supportsop_types_support_protocol(protocol, data):
-    # test values drawn from SupportsOp types are indeed considered instances
-    # of that type.
-    value = data.draw(st.from_type(protocol))
-    # check that we aren't somehow generating instances of the protocol itself
-    assert value.__class__ != protocol
-    assert issubclass(type(value), protocol)
-
-
-@pytest.mark.parametrize(
-    "protocol, typ",
-    
-        (typing.SupportsFloat, float),
-        (typing.SupportsInt, int),
-        (typing.SupportsBytes, bytes),
-        (typing.SupportsComplex, complex),
-    ,
-)
-@given(data=st.data())
-def test_supportscast_types_support_protocol_or_are_castable(protocol, typ, data):
-    value = data.draw(st.from_type(protocol))
-    # check that we aren't somehow generating instances of the protocol itself
-    assert value.__class__ != protocol
-    # test values drawn from the protocol types either support the protocol
-    # or can be cast to typ
-    assert issubclass(type(value), protocol) or types.can_cast(typ, value)
-
-
-def test_can_cast():
-    assert types.can_cast(int, "0")
-    assert not types.can_cast(int, "abc")
-
-
-@pytest.mark.parametrize("type_", datetime.timezone, datetime.tzinfo)
-def test_timezone_lookup(type_):
-    assert issubclass(type_, datetime.tzinfo)
-    assert_all_examples(st.from_type(type_), lambda t: isinstance(t, type_))
-
-
-@pytest.mark.parametrize(
-    "typ",
-    
-        typing.Settyping.Hashable,
-        typing.FrozenSettyping.Hashable,
-        typing.Dicttyping.Hashable, int,
-    ,
-)
-@settings(suppress_health_check=HealthCheck.data_too_large)
-@given(data=st.data())
-def test_generic_collections_only_use_hashable_elements(typ, data):
-    data.draw(from_type(typ))
-
-
-@given(st.sets(st.integers() | st.binary(), min_size=2))
-def test_no_byteswarning(_):
-    pass
-
-
-def test_hashable_type_unhashable_value():
-    # Decimal("snan") is not hashable; we should be able to generate it.
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2320
-    find_any(
-        from_type(typing.Hashable),
-        lambda x: not types._can_hash(x),
-        settings(max_examples=10**5),
-    )
-
-
-@pytest.mark.parametrize(
-    "typ,repr_",
-    
-        (int, "integers()"),
-        (typing.Liststr, "lists(text())"),
-        ("not a type", "from_type('not a type')"),
-    ,
-)
-def test_repr_passthrough(typ, repr_):
-    assert repr(st.from_type(typ)) == repr_
-
-
-class TreeForwardRefs(typing.NamedTuple):
-    val: int
-    l: typing.Optional"TreeForwardRefs"
-    r: typing.Optional"TreeForwardRefs"
-
-
-@given(st.builds(TreeForwardRefs))
-def test_resolves_forward_references_outside_annotations(t):
-    assert isinstance(t, TreeForwardRefs)
-
-
-def constructor(a: str = None):
-    pass
-
-
-class WithOptionalInSignature:
-    __signature__ = inspect.signature(constructor)
-    __annotations__ = typing.get_type_hints(constructor)
-
-    def __init__(self, **kwargs):
-        assert set(kwargs) == {"a"}
-        self.a = kwargs"a"
-
-
-def test_compat_get_type_hints_aware_of_None_default():
-    # Regression test for https://github.com/HypothesisWorks/hypothesis/issues/2648
-    strategy = st.builds(WithOptionalInSignature, a=...)
-    find_any(strategy, lambda x: x.a is None)
-    find_any(strategy, lambda x: x.a is not None)
-
-    if sys.version_info:2 >= (3, 11):
-        # https://docs.python.org/3.11/library/typing.html#typing.get_type_hints
-        assert typing.get_type_hints(constructor)"a" == str
-    else:
-        assert typing.get_type_hints(constructor)"a" == typing.Optionalstr
-    assert inspect.signature(constructor).parameters"a".annotation == str
-
-
-_ValueType = typing.TypeVar("_ValueType")
-
-
-class Wrapper(typing.Generic_ValueType):
-    _inner_value: _ValueType
-
-    def __init__(self, inner_value: _ValueType) -> None:
-        self._inner_value = inner_value
-
-
-@given(st.builds(Wrapper))
-def test_issue_2603_regression(built):
-    """It was impossible to build annotated classes with constructors."""
-    assert isinstance(built, Wrapper)
-
-
-class AnnotatedConstructor(typing.Generic_ValueType):
-    value: _ValueType  # the same name we have in `__init__`
-
-    def __init__(self, value: int) -> None:
-        """By this example we show, that ``int`` is more important than ``_ValueType``."""
-        assert isinstance(value, int)
-
-
-@given(st.data())
-def test_constructor_is_more_important(data):
-    """Constructor types should take precedence over all other annotations."""
-    data.draw(st.builds(AnnotatedConstructor))
-
-
-def use_signature(self, value: str) -> None:
-    ...
-
-
-class AnnotatedConstructorWithSignature(typing.Generic_ValueType):
-    value: _ValueType  # the same name we have in `__init__`
-
-    __signature__ = signature(use_signature)
-
-    def __init__(self, value: int) -> None:
-        """By this example we show, that ``__signature__`` is the most important source."""
-        assert isinstance(value, str)
-
-
-def selfless_signature(value: str) -> None:
-    ...
-
-
-class AnnotatedConstructorWithSelflessSignature(AnnotatedConstructorWithSignature):
-    __signature__ = signature(selfless_signature)
-
-
-def really_takes_str(value: int) -> None:
-    """By this example we show, that ``__signature__`` is the most important source."""
-    assert isinstance(value, str)
-
-
-really_takes_str.__signature__ = signature(selfless_signature)
-
-
-@pytest.mark.parametrize(
-    "thing",
-    
-        AnnotatedConstructorWithSignature,
-        AnnotatedConstructorWithSelflessSignature,
-        really_takes_str,
-    ,
-)
-def test_signature_is_the_most_important_source(thing):
-    """Signature types should take precedence over all other annotations."""
-    find_any(st.builds(thing))
-
-
-class AnnotatedAndDefault:
-    def __init__(self, foo: bool = None):
-        self.foo = foo
-
-
-def test_from_type_can_be_default_or_annotation():
-    find_any(st.from_type(AnnotatedAndDefault), lambda x: x.foo is None)
-    find_any(st.from_type(AnnotatedAndDefault), lambda x: isinstance(x.foo, bool))
-
-
-@pytest.mark.parametrize("t", BUILTIN_TYPES, ids=lambda t: t.__name__)
-def test_resolves_builtin_types(t):
-    v = st.from_type(t).example()
-    assert isinstance(v, t)
-
-
-@pytest.mark.parametrize("t", BUILTIN_TYPES, ids=lambda t: t.__name__)
-def test_resolves_forwardrefs_to_builtin_types(t):
-    v = st.from_type(typing.ForwardRef(t.__name__)).example()
-    assert isinstance(v, t)
-
-
-@pytest.mark.parametrize("t", BUILTIN_TYPES, ids=lambda t: t.__name__)
-def test_resolves_type_of_builtin_types(t):
-    v = st.from_type(typing.Typet.__name__).example()
-    assert v is t
-
-
-@given(st.from_type(typing.Typetyping.Union"str", "int"))
-def test_resolves_type_of_union_of_forwardrefs_to_builtins(x):
-    assert x in (str, int)
-
-
-@pytest.mark.parametrize("type_", typing.Listint, typing.Optionalint)
-def test_builds_suggests_from_type(type_):
-    with pytest.raises(
-        InvalidArgument, match=re.escape(f"try using from_type({type_!r})")
-    ):
-        st.builds(type_).example()
-    try:
-        st.builds(type_, st.just("has an argument")).example()
-        raise AssertionError("Expected strategy to raise an error")
-    except TypeError as err:
-        assert not isinstance(err, InvalidArgument)
-
-
-def test_builds_mentions_no_type_check():
-    @typing.no_type_check
-    def f(x: int):
-        pass
-
-    msg = "@no_type_check decorator prevented Hypothesis from inferring a strategy"
-    with pytest.raises(TypeError, match=msg):
-        st.builds(f).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lookup_py310.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lookup_py37.py Deleted

@@ -1,264 +0,0 @@
-# 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/.
-
-from __future__ import annotations
-
-import collections
-import collections.abc
-import contextlib
-import re
-import sys
-
-import pytest
-
-from hypothesis import assume, given
-
-# On Python 3.7 and 3.8, `from __future__ import annotations` means
-# that the syntax is supported; but the feature fails at runtime.  On Python
-# 3.9 and later, it should all work.
-#
-# For details, see https://www.python.org/dev/peps/pep-0585/
-
-if sys.version_info < (3, 9):
-    pytestmark = pytest.mark.xfail(
-        raises=Exception, reason="Requires Python 3.9 (PEP 585) or later."
-    )
-
-
-class Elem:
-    pass
-
-
-class Value:
-    pass
-
-
-def check(t, ex):
-    assert isinstance(ex, t)
-    assert all(isinstance(e, Elem) for e in ex)
-    assume(ex)
-
-
-@given(...)
-def test_resolving_standard_tuple1_as_generic(x: tupleElem):
-    check(tuple, x)
-
-
-@given(...)
-def test_resolving_standard_tuple2_as_generic(x: tupleElem, Elem):
-    check(tuple, x)
-
-
-@given(...)
-def test_resolving_standard_tuple_variadic_as_generic(x: tupleElem, ...):
-    check(tuple, x)
-
-
-@given(...)
-def test_resolving_standard_list_as_generic(x: listElem):
-    check(list, x)
-
-
-@given(...)
-def test_resolving_standard_dict_as_generic(x: dictElem, Value):
-    check(dict, x)
-    assert all(isinstance(e, Value) for e in x.values())
-
-
-@given(...)
-def test_resolving_standard_set_as_generic(x: setElem):
-    check(set, x)
-
-
-@given(...)
-def test_resolving_standard_frozenset_as_generic(x: frozensetElem):
-    check(frozenset, x)
-
-
-@given(...)
-def test_resolving_standard_deque_as_generic(x: collections.dequeElem):
-    check(collections.deque, x)
-
-
-@given(...)
-def test_resolving_standard_defaultdict_as_generic(
-    x: collections.defaultdictElem, Value
-):
-    check(collections.defaultdict, x)
-    assert all(isinstance(e, Value) for e in x.values())
-
-
-@given(...)
-def test_resolving_standard_ordered_dict_as_generic(
-    x: collections.OrderedDictElem, Value
-):
-    check(collections.OrderedDict, x)
-    assert all(isinstance(e, Value) for e in x.values())
-
-
-@given(...)
-def test_resolving_standard_counter_as_generic(x: collections.CounterElem):
-    check(collections.Counter, x)
-    assume(any(x.values()))  # Check that we generated at least one nonzero count
-
-
-@given(...)
-def test_resolving_standard_chainmap_as_generic(x: collections.ChainMapElem, Value):
-    check(collections.ChainMap, x)
-    assert all(isinstance(e, Value) for e in x.values())
-
-
-@given(...)
-def test_resolving_standard_iterable_as_generic(x: collections.abc.IterableElem):
-    check(collections.abc.Iterable, x)
-
-
-@given(...)
-def test_resolving_standard_iterator_as_generic(x: collections.abc.IteratorElem):
-    check(collections.abc.Iterator, x)
-
-
-@given(...)
-def test_resolving_standard_generator_as_generic(
-    x: collections.abc.GeneratorElem, None, Value
-):
-    assert isinstance(x, collections.abc.Generator)
-    try:
-        while True:
-            e = next(x)
-            assert isinstance(e, Elem)
-            x.send(None)  # The generators we create don't check the send type
-    except StopIteration as stop:
-        assert isinstance(stop.value, Value)
-
-
-@given(...)
-def test_resolving_standard_reversible_as_generic(x: collections.abc.ReversibleElem):
-    check(collections.abc.Reversible, x)
-
-
-@given(...)
-def test_resolving_standard_container_as_generic(x: collections.abc.ContainerElem):
-    check(collections.abc.Container, x)
-
-
-@given(...)
-def test_resolving_standard_collection_as_generic(x: collections.abc.CollectionElem):
-    check(collections.abc.Collection, x)
-
-
-@given(...)
-def test_resolving_standard_callable_ellipsis(x: collections.abc.Callable..., Elem):
-    assert isinstance(x, collections.abc.Callable)
-    assert callable(x)
-    # ... implies *args, **kwargs; as would any argument types
-    assert isinstance(x(), Elem)
-    assert isinstance(x(1, 2, 3, a=4, b=5, c=6), Elem)
-
-
-@given(...)
-def test_resolving_standard_callable_no_args(x: collections.abc.Callable, Elem):
-    assert isinstance(x, collections.abc.Callable)
-    assert callable(x)
-    #  implies that no arguments are accepted
-    assert isinstance(x(), Elem)
-    with pytest.raises(TypeError):
-        x(1)
-    with pytest.raises(TypeError):
-        x(a=1)
-
-
-@given(...)
-def test_resolving_standard_collections_set_as_generic(x: collections.abc.SetElem):
-    check(collections.abc.Set, x)
-
-
-@given(...)
-def test_resolving_standard_collections_mutableset_as_generic(
-    x: collections.abc.MutableSetElem,
-):
-    check(collections.abc.MutableSet, x)
-
-
-@given(...)
-def test_resolving_standard_mapping_as_generic(x: collections.abc.MappingElem, Value):
-    check(collections.abc.Mapping, x)
-    assert all(isinstance(e, Value) for e in x.values())
-
-
-@given(...)
-def test_resolving_standard_mutable_mapping_as_generic(
-    x: collections.abc.MutableMappingElem, Value,
-):
-    check(collections.abc.MutableMapping, x)
-    assert all(isinstance(e, Value) for e in x.values())
-
-
-@given(...)
-def test_resolving_standard_sequence_as_generic(x: collections.abc.SequenceElem):
-    check(collections.abc.Sequence, x)
-
-
-@given(...)
-def test_resolving_standard_mutable_sequence_as_generic(
-    x: collections.abc.MutableSequenceElem,
-):
-    check(collections.abc.MutableSequence, x)
-
-
-@given(...)
-def test_resolving_standard_keysview_as_generic(x: collections.abc.KeysViewElem):
-    check(collections.abc.KeysView, x)
-
-
-@given(...)
-def test_resolving_standard_itemsview_as_generic(
-    x: collections.abc.ItemsViewElem, Value
-):
-    assert isinstance(x, collections.abc.ItemsView)
-    assert all(isinstance(e, Elem) and isinstance(v, Value) for e, v in x)
-    assume(x)
-
-
-@given(...)
-def test_resolving_standard_valuesview_as_generic(x: collections.abc.ValuesViewElem):
-    check(collections.abc.ValuesView, x)
-
-
-@pytest.mark.xfail  # Weird interaction with fixes in PR #2952
-@given(...)
-def test_resolving_standard_contextmanager_as_generic(
-    x: contextlib.AbstractContextManagerElem,
-):
-    assert isinstance(x, contextlib.AbstractContextManager)
-
-
-@given(...)
-def test_resolving_standard_re_match_bytes_as_generic(x: re.Matchbytes):
-    assert isinstance(x, re.Match)
-    assert isinstance(x0, bytes)
-
-
-@given(...)
-def test_resolving_standard_re_match_str_as_generic(x: re.Matchstr):
-    assert isinstance(x, re.Match)
-    assert isinstance(x0, str)
-
-
-@given(...)
-def test_resolving_standard_re_pattern_bytes_as_generic(x: re.Patternbytes):
-    assert isinstance(x, re.Pattern)
-    assert isinstance(x.pattern, bytes)
-
-
-@given(...)
-def test_resolving_standard_re_pattern_str_as_generic(x: re.Patternstr):
-    assert isinstance(x, re.Pattern)
-    assert isinstance(x.pattern, str)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lookup_py38.py Deleted

@@ -1,151 +0,0 @@
-# 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 dataclasses
-import sys
-import typing
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import Unsatisfiable
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.strategies import from_type
-
-from tests.common.debug import find_any
-from tests.common.utils import temp_registered
-
-
-@given(st.data())
-def test_typing_Final(data):
-    value = data.draw(from_type(typing.Finalint))
-    assert isinstance(value, int)
-
-
-@pytest.mark.parametrize("value", "dog", b"goldfish", 42, 63.4, -80.5, False)
-def test_typing_Literal(value):
-    assert from_type(typing.Literalvalue).example() == value
-
-
-@given(st.data())
-def test_typing_Literal_nested(data):
-    lit = typing.Literal
-    values = 
-        (lit"hamster", 0, ("hamster", 0)),
-        (lit26, False, "bunny", 130, (26, False, "bunny", 130)),
-        (litlit1, {1}),
-        (litlit1, 2, {1, 2}),
-        (lit1, lit2, 3, {1, 2, 3}),
-        (litlitlit1, lit2, litlit3, lit4, {1, 2, 3, 4}),
-    
-    literal_type, flattened_literals = data.draw(st.sampled_from(values))
-    assert data.draw(st.from_type(literal_type)) in flattened_literals
-
-
-class A(typing.TypedDict):
-    a: int
-
-
-@given(from_type(A))
-def test_simple_typeddict(value):
-    assert type(value) == dict
-    assert set(value) == {"a"}
-    assert isinstance(value"a", int)
-
-
-class B(A, total=False):
-    # a is required, b is optional
-    b: bool
-
-
-@given(from_type(B))
-def test_typeddict_with_optional(value):
-    assert type(value) == dict
-    assert set(value).issubset({"a", "b"})
-    assert isinstance(value"a", int)
-    if "b" in value:
-        assert isinstance(value"b", bool)
-
-
-if sys.version_info:2 < (3, 9):
-    xfail_on_38 = pytest.mark.xfail(raises=Unsatisfiable)
-else:
-
-    def xfail_on_38(f):
-        return f
-
-
-@xfail_on_38
-def test_simple_optional_key_is_optional():
-    # Optional keys are not currently supported, as PEP-589 leaves no traces
-    # at runtime.  See https://github.com/python/cpython/pull/17214
-    find_any(from_type(B), lambda d: "b" not in d)
-
-
-class C(B):
-    # a is required, b is optional, c is required again
-    c: str
-
-
-@given(from_type(C))
-def test_typeddict_with_optional_then_required_again(value):
-    assert type(value) == dict
-    assert set(value).issubset({"a", "b", "c"})
-    assert isinstance(value"a", int)
-    if "b" in value:
-        assert isinstance(value"b", bool)
-    assert isinstance(value"c", str)
-
-
-class NestedDict(typing.TypedDict):
-    inner: A
-
-
-@given(from_type(NestedDict))
-def test_typeddict_with_nested_value(value):
-    assert type(value) == dict
-    assert set(value) == {"inner"}
-    assert isinstance(value"inner""a", int)
-
-
-@xfail_on_38
-def test_layered_optional_key_is_optional():
-    # Optional keys are not currently supported, as PEP-589 leaves no traces
-    # at runtime.  See https://github.com/python/cpython/pull/17214
-    find_any(from_type(C), lambda d: "b" not in d)
-
-
-@dataclasses.dataclass()
-class Node:
-    left: typing.Union"Node", int
-    right: typing.Union"Node", int
-
-
-@given(st.builds(Node))
-def test_can_resolve_recursive_dataclass(val):
-    assert isinstance(val, Node)
-
-
-def test_can_register_new_type_for_typeddicts():
-    sentinel = object()
-    with temp_registered(C, st.just(sentinel)):
-        assert st.from_type(C).example() is sentinel
-
-
-@pytest.mark.parametrize(
-    "lam,source",
-    
-        ((lambda a, /, b: a), "lambda a, /, b: a"),
-        ((lambda a=None, /, b=None: a), "lambda a=None, /, b=None: a"),
-    ,
-)
-def test_posonly_lambda_formatting(lam, source):
-    # Testing posonly lambdas, with and without default values
-    assert get_pretty_function_description(lam) == source

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_lookup_py39.py Deleted

@@ -1,93 +0,0 @@
-# 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 dataclasses
-import sys
-import typing
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.debug import find_any
-
-
-@pytest.mark.parametrize(
-    "annotated_type,expected_strategy_repr",
-    
-        (typing.Annotatedint, "foo", "integers()"),
-        (typing.Annotatedtyping.Listfloat, "foo", "lists(floats())"),
-        (typing.Annotatedtyping.Annotatedstr, "foo", "bar", "text()"),
-        (
-            typing.Annotated
-                typing.Annotatedtyping.Listtyping.Dictstr, bool, "foo", "bar"
-            ,
-            "lists(dictionaries(keys=text(), values=booleans()))",
-        ),
-    ,
-)
-def test_typing_Annotated(annotated_type, expected_strategy_repr):
-    assert repr(st.from_type(annotated_type)) == expected_strategy_repr
-
-
-PositiveInt = typing.Annotatedint, st.integers(min_value=1)
-MoreThenTenInt = typing.AnnotatedPositiveInt, st.integers(min_value=10 + 1)
-WithTwoStrategies = typing.Annotatedint, st.integers(), st.none()
-ExtraAnnotationNoStrategy = typing.AnnotatedPositiveInt, "metadata"
-
-
-def arg_positive(x: PositiveInt):
-    assert x > 0
-
-
-def arg_more_than_ten(x: MoreThenTenInt):
-    assert x > 10
-
-
-@given(st.data())
-def test_annotated_positive_int(data):
-    data.draw(st.builds(arg_positive))
-
-
-@given(st.data())
-def test_annotated_more_than_ten(data):
-    data.draw(st.builds(arg_more_than_ten))
-
-
-@given(st.data())
-def test_annotated_with_two_strategies(data):
-    assert data.draw(st.from_type(WithTwoStrategies)) is None
-
-
-@given(st.data())
-def test_annotated_extra_metadata(data):
-    assert data.draw(st.from_type(ExtraAnnotationNoStrategy)) > 0
-
-
-@dataclasses.dataclass
-class User:
-    id: int
-    following: list"User"  # works with typing.List
-
-
-@pytest.mark.skipif(sys.version_info:2 >= (3, 11), reason="works in new Pythons")
-def test_string_forward_ref_message():
-    # See https://github.com/HypothesisWorks/hypothesis/issues/3016
-    s = st.builds(User)
-    with pytest.raises(InvalidArgument, match="`from __future__ import annotations`"):
-        s.example()
-
-
-def test_issue_3080():
-    # Check for https://github.com/HypothesisWorks/hypothesis/issues/3080
-    s = st.from_type(typing.Unionlistint, int)
-    find_any(s, lambda x: isinstance(x, int))
-    find_any(s, lambda x: isinstance(x, list))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_map.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_mock.py Deleted

@@ -1,47 +0,0 @@
-# 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/.
-
-"""Checks that @given, @mock.patch, and pytest fixtures work as expected."""
-
-
-import math
-from unittest import mock
-
-try:
-    from pytest import Config
-except ImportError:  # pytest<7.0.0
-    from _pytest.config import Config
-
-from hypothesis import given, strategies as st
-
-
-@given(thing=st.text())
-@mock.patch("math.atan")
-def test_can_mock_inside_given_without_fixture(atan, thing):
-    assert isinstance(atan, mock.MagicMock)
-    assert isinstance(math.atan, mock.MagicMock)
-
-
-@mock.patch("math.atan")
-@given(thing=st.text())
-def test_can_mock_outside_given_with_fixture(atan, pytestconfig, thing):
-    assert isinstance(atan, mock.MagicMock)
-    assert isinstance(math.atan, mock.MagicMock)
-    assert isinstance(pytestconfig, Config)
-
-
-@given(thing=st.text())
-def test_can_mock_within_test_with_fixture(pytestconfig, thing):
-    assert isinstance(pytestconfig, Config)
-    assert not isinstance(math.atan, mock.MagicMock)
-    with mock.patch("math.atan") as atan:
-        assert isinstance(atan, mock.MagicMock)
-        assert isinstance(math.atan, mock.MagicMock)
-    assert not isinstance(math.atan, mock.MagicMock)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_nothing.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_numerics.py Deleted

@@ -1,201 +0,0 @@
-# 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 decimal
-from math import copysign, inf
-
-import pytest
-
-from hypothesis import HealthCheck, assume, given, reject, settings
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.floats import next_down, next_up
-from hypothesis.strategies import (
-    booleans,
-    data,
-    decimals,
-    floats,
-    fractions,
-    integers,
-    none,
-    sampled_from,
-    tuples,
-)
-
-from tests.common.debug import find_any
-
-
-@settings(suppress_health_check=HealthCheck.all())
-@given(data())
-def test_fuzz_floats_bounds(data):
-    width = data.draw(sampled_from(64, 32, 16))
-    bound = none() | floats(allow_nan=False, width=width)
-    low, high = data.draw(tuples(bound, bound), label="low, high")
-    if low is not None and high is not None and low > high:
-        low, high = high, low
-    if low is not None and high is not None and low > high:
-        low, high = high, low
-    exmin = low is not None and low != inf and data.draw(booleans(), label="ex_min")
-    exmax = high is not None and high != -inf and data.draw(booleans(), label="ex_max")
-
-    if low is not None and high is not None:
-        lo = next_up(low, width) if exmin else low
-        hi = next_down(high, width) if exmax else high
-        # There must actually be floats between these bounds
-        assume(lo <= hi)
-        if lo == hi == 0:
-            assume(not exmin and not exmax and copysign(1.0, lo) <= copysign(1.0, hi))
-
-    s = floats(low, high, exclude_min=exmin, exclude_max=exmax, width=width)
-    val = data.draw(s, label="value")
-    assume(val)  # positive/negative zero is an issue
-
-    if low is not None:
-        assert low <= val
-    if high is not None:
-        assert val <= high
-    if exmin:
-        assert low != val
-    if exmax:
-        assert high != val
-
-
-@given(data())
-def test_fuzz_fractions_bounds(data):
-    denom = data.draw(none() | integers(1, 100), label="denominator")
-    fracs = none() | fractions(max_denominator=denom)
-    low, high = data.draw(tuples(fracs, fracs), label="low, high")
-    if low is not None and high is not None and low > high:
-        low, high = high, low
-    try:
-        val = data.draw(fractions(low, high, max_denominator=denom), label="value")
-    except InvalidArgument:
-        reject()  # fractions too close for given max_denominator
-    if low is not None:
-        assert low <= val
-    if high is not None:
-        assert val <= high
-    if denom is not None:
-        assert 1 <= val.denominator <= denom
-
-
-@given(data())
-def test_fuzz_decimals_bounds(data):
-    places = data.draw(none() | integers(0, 20), label="places")
-    finite_decs = (
-        decimals(allow_nan=False, allow_infinity=False, places=places) | none()
-    )
-    low, high = data.draw(tuples(finite_decs, finite_decs), label="low, high")
-    if low is not None and high is not None and low > high:
-        low, high = high, low
-    ctx = decimal.Context(prec=data.draw(integers(1, 100), label="precision"))
-    try:
-        with decimal.localcontext(ctx):
-            strat = decimals(
-                low, high, allow_nan=False, allow_infinity=False, places=places
-            )
-            val = data.draw(strat, label="value")
-    except InvalidArgument:
-        reject()  # decimals too close for given places
-    if low is not None:
-        assert low <= val
-    if high is not None:
-        assert val <= high
-    if places is not None:
-        assert val.as_tuple().exponent == -places
-
-
-def test_all_decimals_can_be_exact_floats():
-    find_any(
-        decimals(), lambda x: assume(x.is_finite()) and decimal.Decimal(float(x)) == x
-    )
-
-
-@given(fractions(), fractions(), fractions())
-def test_fraction_addition_is_well_behaved(x, y, z):
-    assert x + y + z == y + x + z
-
-
-def test_decimals_include_nan():
-    find_any(decimals(), lambda x: x.is_nan())
-
-
-def test_decimals_include_inf():
-    find_any(decimals(), lambda x: x.is_infinite(), settings(max_examples=10**6))
-
-
-@given(decimals(allow_nan=False))
-def test_decimals_can_disallow_nan(x):
-    assert not x.is_nan()
-
-
-@given(decimals(allow_infinity=False))
-def test_decimals_can_disallow_inf(x):
-    assert not x.is_infinite()
-
-
-@pytest.mark.parametrize("places", range(10))
-def test_decimals_have_correct_places(places):
-    @given(decimals(0, 10, allow_nan=False, places=places))
-    def inner_tst(n):
-        assert n.as_tuple().exponent == -places
-
-    inner_tst()
-
-
-@given(decimals(min_value="0.1", max_value="0.2", allow_nan=False, places=1))
-def test_works_with_few_values(dec):
-    assert dec in (decimal.Decimal("0.1"), decimal.Decimal("0.2"))
-
-
-@given(decimals(places=3, allow_nan=False, allow_infinity=False))
-def test_issue_725_regression(x):
-    pass
-
-
-@given(decimals(min_value="0.1", max_value="0.3"))
-def test_issue_739_regression(x):
-    pass
-
-
-def test_consistent_decimal_error():
-    bad = "invalid argument to Decimal"
-    with pytest.raises(InvalidArgument) as excinfo:
-        decimals(bad).example()
-    with pytest.raises(InvalidArgument) as excinfo2:
-        with decimal.localcontext(decimal.Context(traps=)):
-            decimals(bad).example()
-    assert str(excinfo.value) == str(excinfo2.value)
-
-
-@pytest.mark.parametrize(
-    "s, msg",
-    
-        (
-            floats(min_value=inf, allow_infinity=False),
-            "allow_infinity=False excludes min_value=inf",
-        ),
-        (
-            floats(min_value=next_down(inf), exclude_min=True, allow_infinity=False),
-            "exclude_min=True turns min_value=.+? into inf, but allow_infinity=False",
-        ),
-        (
-            floats(max_value=-inf, allow_infinity=False),
-            "allow_infinity=False excludes max_value=-inf",
-        ),
-        (
-            floats(max_value=next_up(-inf), exclude_max=True, allow_infinity=False),
-            "exclude_max=True turns max_value=.+? into -inf, but allow_infinity=False",
-        ),
-    ,
-)
-def test_floats_message(s, msg):
-    # https://github.com/HypothesisWorks/hypothesis/issues/3207
-    with pytest.raises(InvalidArgument, match=msg):
-        s.validate()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_one_of.py Deleted

@@ -1,48 +0,0 @@
-# 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 re
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.debug import assert_no_examples
-
-
-def test_one_of_empty():
-    e = st.one_of()
-    assert e.is_empty
-    assert_no_examples(e)
-
-
-@given(st.one_of(st.integers().filter(bool)))
-def test_one_of_filtered(i):
-    assert bool(i)
-
-
-@given(st.one_of(st.just(100).flatmap(st.integers)))
-def test_one_of_flatmapped(i):
-    assert i >= 100
-
-
-def test_one_of_single_strategy_is_noop():
-    s = st.integers()
-    assert st.one_of(s) is s
-    assert st.one_of(s) is s
-
-
-def test_one_of_without_strategies_suggests_sampled_from():
-    with pytest.raises(
-        InvalidArgument,
-        match=re.escape("Did you mean st.sampled_from(1, 2, 3)?"),
-    ):
-        st.one_of(1, 2, 3)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_permutations.py Deleted

@@ -1,38 +0,0 @@
-# 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/.
-
-from hypothesis import given
-from hypothesis.errors import InvalidArgument
-from hypothesis.strategies import permutations
-
-from tests.common.debug import minimal
-from tests.common.utils import fails_with
-
-
-def test_can_find_non_trivial_permutation():
-    x = minimal(permutations(list(range(5))), lambda x: x0 != 0)
-
-    assert x == 1, 0, 2, 3, 4
-
-
-@given(permutations(list("abcd")))
-def test_permutation_values_are_permutations(perm):
-    assert len(perm) == 4
-    assert set(perm) == set("abcd")
-
-
-@given(permutations())
-def test_empty_permutations_are_empty(xs):
-    assert xs == 
-
-
-@fails_with(InvalidArgument)
-def test_cannot_permute_non_sequence_types():
-    permutations(set()).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_phases.py Deleted

@@ -1,94 +0,0 @@
-# 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 pytest
-
-from hypothesis import Phase, example, given, settings, strategies as st
-from hypothesis.database import ExampleDatabase, InMemoryExampleDatabase
-from hypothesis.errors import InvalidArgument
-
-
-@example(11)
-@settings(phases=(Phase.explicit,))
-@given(st.integers())
-def test_only_runs_explicit_examples(i):
-    assert i == 11
-
-
-@example("hello world")
-@settings(phases=(Phase.reuse, Phase.generate, Phase.shrink))
-@given(st.booleans())
-def test_does_not_use_explicit_examples(i):
-    assert isinstance(i, bool)
-
-
-@settings(phases=(Phase.reuse, Phase.shrink))
-@given(st.booleans())
-def test_this_would_fail_if_you_ran_it(b):
-    raise AssertionError
-
-
-@pytest.mark.parametrize(
-    "arg,expected",
-    
-        (tuple(Phase)::-1, tuple(Phase)),
-        (Phase.explicit, Phase.explicit, (Phase.explicit,)),
-    ,
-)
-def test_sorts_and_dedupes_phases(arg, expected):
-    assert settings(phases=arg).phases == expected
-
-
-def test_phases_default_to_all_except_explain():
-    assert settings().phases + (Phase.explain,) == tuple(Phase)
-
-
-def test_does_not_reuse_saved_examples_if_reuse_not_in_phases():
-    class BadDatabase(ExampleDatabase):
-        def save(self, key, value):
-            pass
-
-        def delete(self, key, value):
-            pass
-
-        def fetch(self, key):
-            raise ValueError()
-
-        def close(self):
-            pass
-
-    @settings(database=BadDatabase(), phases=(Phase.generate,))
-    @given(st.integers())
-    def test_usage(i):
-        pass
-
-    test_usage()
-
-
-def test_will_save_when_reuse_not_in_phases():
-    database = InMemoryExampleDatabase()
-
-    assert not database.data
-
-    @settings(database=database, phases=(Phase.generate,))
-    @given(st.integers())
-    def test_usage(i):
-        raise ValueError()
-
-    with pytest.raises(ValueError):
-        test_usage()
-
-    (saved,) = (v for k, v in database.data.items() if b"pareto" not in k)
-    assert len(saved) == 1
-
-
-def test_rejects_non_phases():
-    with pytest.raises(InvalidArgument):
-        settings(phases="cabbage")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_posonly_args_py38.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_pretty.py Deleted

@@ -1,632 +0,0 @@
-# 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/.
-
-"""This file originates in the IPython project and is made use of under the
-following licensing terms:
-
-The IPython licensing terms
-IPython is licensed under the terms of the Modified BSD License (also known as
-New or Revised or 3-Clause BSD), as follows:
-
-Copyright (c) 2008-2014, IPython Development Team
-Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
-Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
-Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-Neither the name of the IPython Development Team nor the names of its
-contributors may be used to endorse or promote products derived from this
-software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-import re
-from collections import Counter, OrderedDict, defaultdict, deque
-from io import StringIO
-
-import pytest
-
-from hypothesis.internal.compat import PYPY
-from hypothesis.strategies._internal.numbers import SIGNALING_NAN
-from hypothesis.vendor import pretty
-
-
-class MyList:
-    def __init__(self, content):
-        self.content = content
-
-    def _repr_pretty_(self, p, cycle):
-        if cycle:
-            p.text("MyList(...)")
-        else:
-            with p.group(3, "MyList(", ")"):
-                for (i, child) in enumerate(self.content):
-                    if i:
-                        p.text(",")
-                        p.breakable()
-                    else:
-                        p.breakable("")
-                    p.pretty(child)
-
-
-class MyDict(dict):
-    def _repr_pretty_(self, p, cycle):
-        p.text("MyDict(...)")
-
-
-class MyObj:
-    def somemethod(self):
-        pass
-
-
-class Dummy1:
-    def _repr_pretty_(self, p, cycle):
-        p.text("Dummy1(...)")
-
-
-class Dummy2(Dummy1):
-    _repr_pretty_ = None
-
-
-class NoModule:
-    pass
-
-
-NoModule.__module__ = None
-
-
-class Breaking:
-    def _repr_pretty_(self, p, cycle):
-        with p.group(4, "TG: ", ":"):
-            p.text("Breaking(")
-            p.break_()
-            p.text(")")
-
-
-class BreakingRepr:
-    def __repr__(self):
-        return "Breaking(\n)"
-
-
-class BreakingReprParent:
-    def _repr_pretty_(self, p, cycle):
-        with p.group(4, "TG: ", ":"):
-            p.pretty(BreakingRepr())
-
-
-class BadRepr:
-    def __repr__(self):
-        return 1 / 0
-
-
-def test_list():
-    assert pretty.pretty() == ""
-    assert pretty.pretty(1) == "1"
-
-
-def test_dict():
-    assert pretty.pretty({}) == "{}"
-    assert pretty.pretty({1: 1}) == "{1: 1}"
-
-
-def test_tuple():
-    assert pretty.pretty(()) == "()"
-    assert pretty.pretty((1,)) == "(1,)"
-    assert pretty.pretty((1, 2)) == "(1, 2)"
-
-
-class ReprDict(dict):
-    def __repr__(self):
-        return "hi"
-
-
-def test_dict_with_custom_repr():
-    assert pretty.pretty(ReprDict()) == "hi"
-
-
-class ReprList(list):
-    def __repr__(self):
-        return "bye"
-
-
-class ReprSet(set):
-    def __repr__(self):
-        return "cat"
-
-
-def test_set_with_custom_repr():
-    assert pretty.pretty(ReprSet()) == "cat"
-
-
-def test_list_with_custom_repr():
-    assert pretty.pretty(ReprList()) == "bye"
-
-
-def test_indentation():
-    """Test correct indentation in groups."""
-    count = 40
-    gotoutput = pretty.pretty(MyList(range(count)))
-    expectedoutput = "MyList(\n" + ",\n".join(f"   {i}" for i in range(count)) + ")"
-
-    assert gotoutput == expectedoutput
-
-
-def test_dispatch():
-    """Test correct dispatching: The _repr_pretty_ method for MyDict must be
-    found before the registered printer for dict."""
-    gotoutput = pretty.pretty(MyDict())
-    expectedoutput = "MyDict(...)"
-
-    assert gotoutput == expectedoutput
-
-
-def test_callability_checking():
-    """Test that the _repr_pretty_ method is tested for callability and skipped
-    if not."""
-    gotoutput = pretty.pretty(Dummy2())
-    expectedoutput = "Dummy1(...)"
-
-    assert gotoutput == expectedoutput
-
-
-def test_sets():
-    """Test that set and frozenset use Python 3 formatting."""
-    objects = 
-        set(),
-        frozenset(),
-        {1},
-        frozenset(1),
-        {1, 2},
-        frozenset(1, 2),
-        {-1, -2, -3},
-    
-    expected = 
-        "set()",
-        "frozenset()",
-        "{1}",
-        "frozenset({1})",
-        "{1, 2}",
-        "frozenset({1, 2})",
-        "{-3, -2, -1}",
-    
-    for obj, expected_output in zip(objects, expected):
-        got_output = pretty.pretty(obj)
-        assert got_output == expected_output
-
-
-def test_unsortable_set():
-    xs = {1, 2, 3, "foo", "bar", "baz", object()}
-    p = pretty.pretty(xs)
-    for x in xs:
-        assert pretty.pretty(x) in p
-
-
-def test_unsortable_dict():
-    xs = {k: 1 for k in 1, 2, 3, "foo", "bar", "baz", object()}
-    p = pretty.pretty(xs)
-    for x in xs:
-        assert pretty.pretty(x) in p
-
-
-def test_pprint_nomod():
-    """Test that pprint works for classes with no __module__."""
-    output = pretty.pretty(NoModule)
-    assert output == "NoModule"
-
-
-def test_pprint_break():
-    """Test that p.break_ produces expected output."""
-    output = pretty.pretty(Breaking())
-    expected = "TG: Breaking(\n    ):"
-    assert output == expected
-
-
-def test_pprint_break_repr():
-    """Test that p.break_ is used in repr."""
-    output = pretty.pretty(BreakingReprParent())
-    expected = "TG: Breaking(\n    ):"
-    assert output == expected
-
-
-def test_bad_repr():
-    """Don't catch bad repr errors."""
-    with pytest.raises(ZeroDivisionError):
-        pretty.pretty(BadRepr())
-
-
-class BadException(Exception):
-    def __str__(self):
-        return -1
-
-
-class ReallyBadRepr:
-    __module__ = 1
-
-    @property
-    def __class__(self):
-        raise ValueError("I am horrible")
-
-    def __repr__(self):
-        raise BadException()
-
-
-def test_really_bad_repr():
-    with pytest.raises(BadException):
-        pretty.pretty(ReallyBadRepr())
-
-
-class SA:
-    pass
-
-
-class SB(SA):
-    pass
-
-
-try:
-    super(SA).__self__
-
-    def test_super_repr():
-        output = pretty.pretty(super(SA))
-        assert "SA" in output
-
-        sb = SB()
-        output = pretty.pretty(super(SA, sb))
-        assert "SA" in output
-
-except AttributeError:
-
-    def test_super_repr():
-        pretty.pretty(super(SA))
-        sb = SB()
-        pretty.pretty(super(SA, sb))
-
-
-def test_long_list():
-    lis = list(range(10000))
-    p = pretty.pretty(lis)
-    last2 = p.rsplit("\n", 2)-2:
-    assert last2 == " 999,", " ..."
-
-
-def test_long_set():
-    s = set(range(10000))
-    p = pretty.pretty(s)
-    last2 = p.rsplit("\n", 2)-2:
-    assert last2 == " 999,", " ...}"
-
-
-def test_long_tuple():
-    tup = tuple(range(10000))
-    p = pretty.pretty(tup)
-    last2 = p.rsplit("\n", 2)-2:
-    assert last2 == " 999,", " ...)"
-
-
-def test_long_dict():
-    d = {n: n for n in range(10000)}
-    p = pretty.pretty(d)
-    last2 = p.rsplit("\n", 2)-2:
-    assert last2 == " 999: 999,", " ...}"
-
-
-def test_unbound_method():
-    assert pretty.pretty(MyObj.somemethod) == "somemethod"
-
-
-class MetaClass(type):
-    def __new__(metacls, name):
-        return type.__new__(metacls, name, (object,), {"name": name})
-
-    def __repr__(cls):
-        return f"CUSTOM REPR FOR CLASS {cls.name}"
-
-
-ClassWithMeta = MetaClass("ClassWithMeta")
-
-
-def test_metaclass_repr():
-    output = pretty.pretty(ClassWithMeta)
-    assert output == "CUSTOM REPR FOR CLASS ClassWithMeta"
-
-
-def test_unicode_repr():
-    u = "üniçodé"
-
-    class C:
-        def __repr__(self):
-            return u
-
-    c = C()
-    p = pretty.pretty(c)
-    assert p == u
-    p = pretty.pretty(c)
-    assert p == f"{u}"
-
-
-def test_basic_class():
-    def type_pprint_wrapper(obj, p, cycle):
-        if obj is MyObj:
-            type_pprint_wrapper.called = True
-        return pretty._type_pprint(obj, p, cycle)
-
-    type_pprint_wrapper.called = False
-
-    stream = StringIO()
-    printer = pretty.RepresentationPrinter(stream)
-    printer.type_pprinterstype = type_pprint_wrapper
-    printer.pretty(MyObj)
-    printer.flush()
-    output = stream.getvalue()
-
-    assert output == f"{__name__}.MyObj"
-    assert type_pprint_wrapper.called
-
-
-def test_collections_defaultdict():
-    # Create defaultdicts with cycles
-    a = defaultdict()
-    a.default_factory = a
-    b = defaultdict(list)
-    b"key" = b
-
-    # Dictionary order cannot be relied on, test against single keys.
-    cases = 
-        (defaultdict(list), "defaultdict(list, {})"),
-        (
-            defaultdict(list, {"key": "-" * 50}),
-            "defaultdict(list,\n"
-            "            {'key': '-----------------------------------------"
-            "---------'})",
-        ),
-        (a, "defaultdict(defaultdict(...), {})"),
-        (b, "defaultdict(list, {'key': defaultdict(...)})"),
-    
-    for obj, expected in cases:
-        assert pretty.pretty(obj) == expected
-
-
-@pytest.mark.skipif(PYPY, reason="slightly different on PyPy3")
-def test_collections_ordereddict():
-    # Create OrderedDict with cycle
-    a = OrderedDict()
-    a"key" = a
-
-    cases = 
-        (OrderedDict(), "OrderedDict()"),
-        (
-            OrderedDict((i, i) for i in range(1000, 1010)),
-            "OrderedDict((1000, 1000),\n"
-            "             (1001, 1001),\n"
-            "             (1002, 1002),\n"
-            "             (1003, 1003),\n"
-            "             (1004, 1004),\n"
-            "             (1005, 1005),\n"
-            "             (1006, 1006),\n"
-            "             (1007, 1007),\n"
-            "             (1008, 1008),\n"
-            "             (1009, 1009))",
-        ),
-        (a, "OrderedDict(('key', OrderedDict(...)))"),
-    
-    for obj, expected in cases:
-        assert pretty.pretty(obj) == expected
-
-
-def test_collections_deque():
-    # Create deque with cycle
-    a = deque()
-    a.append(a)
-
-    cases = 
-        (deque(), "deque()"),
-        (
-            deque(i for i in range(1000, 1020)),
-            "deque(1000,\n"
-            "       1001,\n"
-            "       1002,\n"
-            "       1003,\n"
-            "       1004,\n"
-            "       1005,\n"
-            "       1006,\n"
-            "       1007,\n"
-            "       1008,\n"
-            "       1009,\n"
-            "       1010,\n"
-            "       1011,\n"
-            "       1012,\n"
-            "       1013,\n"
-            "       1014,\n"
-            "       1015,\n"
-            "       1016,\n"
-            "       1017,\n"
-            "       1018,\n"
-            "       1019)",
-        ),
-        (a, "deque(deque(...))"),
-    
-    for obj, expected in cases:
-        assert pretty.pretty(obj) == expected
-
-
-def test_collections_counter():
-    class MyCounter(Counter):
-        pass
-
-    cases = 
-        (Counter(), "Counter()"),
-        (Counter(a=1), "Counter({'a': 1})"),
-        (MyCounter(a=1), "MyCounter({'a': 1})"),
-    
-    for obj, expected in cases:
-        assert pretty.pretty(obj) == expected
-
-
-def test_cyclic_list():
-    x = 
-    x.append(x)
-    assert pretty.pretty(x) == "..."
-
-
-def test_cyclic_dequeue():
-    x = deque()
-    x.append(x)
-    assert pretty.pretty(x) == "deque(deque(...))"
-
-
-class HashItAnyway:
-    def __init__(self, value):
-        self.value = value
-
-    def __hash__(self):
-        return 0
-
-    def __eq__(self, other):
-        return isinstance(other, HashItAnyway) and self.value == other.value
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def _repr_pretty_(self, pretty, cycle):
-        pretty.pretty(self.value)
-
-
-def test_cyclic_counter():
-    c = Counter()
-    k = HashItAnyway(c)
-    ck = 1
-    assert pretty.pretty(c) == "Counter({Counter(...): 1})"
-
-
-def test_cyclic_dict():
-    x = {}
-    k = HashItAnyway(x)
-    xk = x
-    assert pretty.pretty(x) == "{{...}: {...}}"
-
-
-def test_cyclic_set():
-    x = set()
-    x.add(HashItAnyway(x))
-    assert pretty.pretty(x) == "{{...}}"
-
-
-class BigList(list):
-    def _repr_pretty_(self, printer, cycle):
-        if cycle:
-            return "..."
-        else:
-            with printer.group(open="", close=""):
-                with printer.indent(5):
-                    for v in self:
-                        printer.pretty(v)
-                        printer.breakable(",")
-
-
-def test_print_with_indent():
-    pretty.pretty(BigList(1, 2, 3))
-
-
-class MyException(Exception):
-    pass
-
-
-def test_exception():
-    assert pretty.pretty(ValueError("hi")) == "ValueError('hi')"
-    assert pretty.pretty(ValueError("hi", "there")) == "ValueError('hi', 'there')"
-    assert "test_pretty." in pretty.pretty(MyException())
-
-
-def test_re_evals():
-    for r in 
-        re.compile(r"hi"),
-        re.compile(r"b\nc", re.MULTILINE),
-        re.compile(rb"hi", 0),
-        re.compile("foo", re.MULTILINE | re.UNICODE),
-    :
-        r2 = eval(pretty.pretty(r), globals())
-        assert r.pattern == r2.pattern and r.flags == r2.flags
-
-
-class CustomStuff:
-    def __init__(self):
-        self.hi = 1
-        self.bye = "fish"
-        self.spoon = self
-
-    @property
-    def oops(self):
-        raise AttributeError("Nope")
-
-    def squirrels(self):
-        pass
-
-
-def test_custom():
-    assert "bye" not in pretty.pretty(CustomStuff())
-    assert "bye=" in pretty.pretty(CustomStuff(), verbose=True)
-    assert "squirrels" not in pretty.pretty(CustomStuff(), verbose=True)
-
-
-def test_print_builtin_function():
-    assert pretty.pretty(abs) == "abs"
-
-
-def test_pretty_function():
-    assert pretty.pretty(test_pretty_function) == "test_pretty_function"
-
-
-def test_empty_printer():
-    printer = pretty.RepresentationPrinter(
-        StringIO(),
-        singleton_pprinters={},
-        type_pprinters={int: pretty._repr_pprint, list: pretty._repr_pprint},
-        deferred_pprinters={},
-    )
-    printer.pretty(1, 2, 3)
-    assert printer.output.getvalue() == "1, 2, 3"
-
-
-def test_breakable_at_group_boundary():
-    assert "\n" in pretty.pretty(, "000000", max_width=5)
-
-
-@pytest.mark.parametrize(
-    "obj, rep",
-    
-        (float("nan"), "nan"),
-        (-float("nan"), "-nan"),
-        (SIGNALING_NAN, "nan  # Saw 1 signaling NaN"),
-        (-SIGNALING_NAN, "-nan  # Saw 1 signaling NaN"),
-        ((SIGNALING_NAN, SIGNALING_NAN), "(nan, nan)  # Saw 2 signaling NaNs"),
-    ,
-)
-def test_nan_reprs(obj, rep):
-    assert pretty.pretty(obj) == rep

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_provisional_strategies.py Deleted

@@ -1,80 +0,0 @@
-# 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 re
-import string
-
-import pytest
-
-from hypothesis import given, settings
-from hypothesis.errors import InvalidArgument
-from hypothesis.provisional import (
-    FRAGMENT_SAFE_CHARACTERS,
-    _url_fragments_strategy,
-    domains,
-    urls,
-)
-
-from tests.common.debug import find_any
-
-
-@given(urls())
-def test_is_URL(url):
-    allowed_chars = set(string.ascii_letters + string.digits + "$-_.+!*'(),~%/")
-    url_schemeless = url.split("://", 1)1
-    components = url_schemeless.split("#", 1)
-
-    domain_path = components0
-    path = domain_path.split("/", 1)1 if "/" in domain_path else ""
-    assert all(c in allowed_chars for c in path)
-    assert all(
-        re.match("^0-9A-Fa-f{2}", after_perc) for after_perc in path.split("%")1:
-    )
-
-    fragment = components1 if "#" in url_schemeless else ""
-    fragment_allowed_chars = allowed_chars | {"?"}
-    assert all(c in fragment_allowed_chars for c in fragment)
-    assert all(
-        re.match("^0-9A-Fa-f{2}", after_perc)
-        for after_perc in fragment.split("%")1:
-    )
-
-
-@pytest.mark.parametrize("max_length", -1, 0, 3, 4.0, 256)
-@pytest.mark.parametrize("max_element_length", -1, 0, 4.0, 64, 128)
-def test_invalid_domain_arguments(max_length, max_element_length):
-    with pytest.raises(InvalidArgument):
-        domains(max_length=max_length, max_element_length=max_element_length).example()
-
-
-@pytest.mark.parametrize("max_length", None, 4, 8, 255)
-@pytest.mark.parametrize("max_element_length", None, 1, 2, 4, 8, 63)
-def test_valid_domains_arguments(max_length, max_element_length):
-    domains(max_length=max_length, max_element_length=max_element_length).example()
-
-
-@pytest.mark.parametrize("strategy", domains(), urls())
-def test_find_any_non_empty(strategy):
-    find_any(strategy, lambda s: len(s) > 0)
-
-
-@given(_url_fragments_strategy)
-# There's a lambda in the implementation that only gets run if we generate at
-# least one percent-escape sequence, so we derandomize to ensure that coverage
-# isn't flaky.
-@settings(derandomize=True)
-def test_url_fragments_contain_legal_chars(fragment):
-    assert fragment.startswith("#")
-
-    # Strip all legal escape sequences. Any remaining % characters were not
-    # part of a legal escape sequence.
-    without_escapes = re.sub(r"(?ai)%0-9a-f0-9a-f", "", fragment1:)
-
-    assert set(without_escapes).issubset(FRAGMENT_SAFE_CHARACTERS)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_random_module.py Deleted

@@ -1,179 +0,0 @@
-# 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 gc
-import random
-
-import pytest
-
-from hypothesis import core, find, given, register_random, reporting, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal import entropy
-from hypothesis.internal.compat import PYPY
-from hypothesis.internal.entropy import deterministic_PRNG
-
-from tests.common.utils import capture_out
-
-
-def gc_on_pypy():
-    # CPython uses reference counting, so objects (without circular refs)
-    # are collected immediately on `del`, breaking weak references.
-    # PyPy doesn't, so we use this function in tests before counting the
-    # surviving references to ensure that they're deterministic.
-    if PYPY:
-        gc.collect()
-
-
-def test_can_seed_random():
-    with capture_out() as out:
-        with reporting.with_reporter(reporting.default):
-            with pytest.raises(AssertionError):
-
-                @given(st.random_module())
-                def test(r):
-                    raise AssertionError
-
-                test()
-    assert "RandomSeeder(0)" in out.getvalue()
-
-
-@given(st.random_module(), st.random_module())
-def test_seed_random_twice(r, r2):
-    assert repr(r) == repr(r2)
-
-
-@given(st.random_module())
-def test_does_not_fail_health_check_if_randomness_is_used(r):
-    random.getrandbits(128)
-
-
-def test_cannot_register_non_Random():
-    with pytest.raises(InvalidArgument):
-        register_random("not a Random instance")
-
-
-def test_registering_a_Random_is_idempotent():
-    gc_on_pypy()
-    n_registered = len(entropy.RANDOMS_TO_MANAGE)
-    r = random.Random()
-    register_random(r)
-    register_random(r)
-    assert len(entropy.RANDOMS_TO_MANAGE) == n_registered + 1
-    del r
-    gc_on_pypy()
-    assert len(entropy.RANDOMS_TO_MANAGE) == n_registered
-
-
-def test_manages_registered_Random_instance():
-    r = random.Random()
-    register_random(r)
-    state = r.getstate()
-    result = 
-
-    @given(st.integers())
-    def inner(x):
-        v = r.random()
-        if result:
-            assert v == result0
-        else:
-            result.append(v)
-
-    inner()
-    assert state == r.getstate()
-
-
-def test_registered_Random_is_seeded_by_random_module_strategy():
-    r = random.Random()
-    register_random(r)
-    state = r.getstate()
-    results = set()
-    count = 0
-
-    @given(st.integers())
-    def inner(x):
-        results.add(r.random())
-        count0 += 1
-
-    inner()
-    assert count0 > len(results) * 0.9, "too few unique random numbers"
-    assert state == r.getstate()
-
-
-@given(st.random_module())
-def test_will_actually_use_the_random_seed(rnd):
-    a = random.randint(0, 100)
-    b = random.randint(0, 100)
-    random.seed(rnd.seed)
-    assert a == random.randint(0, 100)
-    assert b == random.randint(0, 100)
-
-
-def test_given_does_not_pollute_state():
-    with deterministic_PRNG():
-
-        @given(st.random_module())
-        def test(r):
-            pass
-
-        test()
-        state_a = random.getstate()
-        state_a2 = core._hypothesis_global_random.getstate()
-
-        test()
-        state_b = random.getstate()
-        state_b2 = core._hypothesis_global_random.getstate()
-
-        assert state_a == state_b
-        assert state_a2 != state_b2
-
-
-def test_find_does_not_pollute_state():
-    with deterministic_PRNG():
-
-        find(st.random_module(), lambda r: True)
-        state_a = random.getstate()
-        state_a2 = core._hypothesis_global_random.getstate()
-
-        find(st.random_module(), lambda r: True)
-        state_b = random.getstate()
-        state_b2 = core._hypothesis_global_random.getstate()
-
-        assert state_a == state_b
-        assert state_a2 != state_b2
-
-
-def test_evil_prng_registration_nonsense():
-    gc_on_pypy()
-    n_registered = len(entropy.RANDOMS_TO_MANAGE)
-    r1, r2, r3 = random.Random(1), random.Random(2), random.Random(3)
-    s2 = r2.getstate()
-
-    # We're going to be totally evil here: register two randoms, then
-    # drop one and add another, and finally check that we reset only
-    # the states that we collected before we started
-    register_random(r1)
-    k = max(entropy.RANDOMS_TO_MANAGE)  # get a handle to check if r1 still exists
-    register_random(r2)
-    assert len(entropy.RANDOMS_TO_MANAGE) == n_registered + 2
-
-    with deterministic_PRNG(0):
-        del r1
-        gc_on_pypy()
-        assert k not in entropy.RANDOMS_TO_MANAGE, "r1 has been garbage-collected"
-        assert len(entropy.RANDOMS_TO_MANAGE) == n_registered + 1
-
-        r2.seed(4)
-        register_random(r3)
-        r3.seed(4)
-        s4 = r3.getstate()
-
-    # Implicit check, no exception was raised in __exit__
-    assert r2.getstate() == s2, "reset previously registered random state"
-    assert r3.getstate() == s4, "retained state when registered within the context"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_randoms.py Deleted

@@ -1,383 +0,0 @@
-# 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 inspect
-import math
-import sys
-from copy import copy
-
-import pytest
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.errors import MultipleFailures
-from hypothesis.strategies._internal.random import (
-    RANDOM_METHODS,
-    HypothesisRandom,
-    TrueRandom,
-    convert_kwargs,
-    normalize_zero,
-)
-
-from tests.common.debug import find_any
-from tests.common.utils import capture_out
-
-
-def test_implements_all_random_methods():
-    for name in dir(HypothesisRandom):
-        if not name.startswith("_") or name == "_randbelow":
-            f = getattr(HypothesisRandom, name)
-            if inspect.isfunction(f):
-                assert f.__module__ == "hypothesis.strategies._internal.random", name
-
-
-any_random = st.booleans().flatmap(lambda i: st.randoms(use_true_random=i))
-
-beta_param = st.floats(0.01, 1000)
-seq_param = st.lists(st.integers(), min_size=1)
-
-
-METHOD_STRATEGIES = {}
-
-
-def define_method_strategy(name, **kwargs):
-    METHOD_STRATEGIESname = kwargs
-
-
-define_method_strategy("betavariate", alpha=beta_param, beta=beta_param)
-define_method_strategy("gammavariate", alpha=beta_param, beta=beta_param)
-define_method_strategy("weibullvariate", alpha=beta_param, beta=beta_param)
-define_method_strategy("choice", seq=seq_param)
-define_method_strategy("choices", population=seq_param, k=st.integers(1, 100))
-define_method_strategy("expovariate", lambd=beta_param)
-define_method_strategy("_randbelow", n=st.integers(1, 2**64))
-define_method_strategy("random")
-define_method_strategy("getrandbits", n=st.integers(1, 128))
-define_method_strategy("gauss", mu=st.floats(-1000, 1000), sigma=beta_param)
-define_method_strategy("normalvariate", mu=st.floats(-1000, 1000), sigma=beta_param)
-# the standard library lognormalvariate is weirdly bad at handling large floats
-define_method_strategy(
-    "lognormvariate", mu=st.floats(0.1, 10), sigma=st.floats(0.1, 10)
-)
-define_method_strategy(
-    "vonmisesvariate", mu=st.floats(0, math.pi * 2), kappa=beta_param
-)
-# Small alpha may raise ZeroDivisionError, see https://bugs.python.org/issue41421
-define_method_strategy("paretovariate", alpha=st.floats(min_value=1.0))
-define_method_strategy("shuffle", x=st.lists(st.integers()))
-define_method_strategy("randbytes", n=st.integers(0, 100))
-
-
-INT64 = st.integers(-(2**63), 2**63 - 1)
-
-
-@st.composite
-def any_call_of_method(draw, method):
-    if method == "sample":
-        population = draw(seq_param)
-        k = draw(st.integers(0, len(population)))
-        kwargs = {"population": population, "k": k}
-    elif method == "randint":
-        a = draw(INT64)
-        b = draw(INT64)
-        a, b = sorted((a, b))
-        kwargs = {"a": a, "b": b}
-    elif method == "randrange":
-        a = draw(INT64)
-        b = draw(INT64)
-        assume(a != b)
-        a, b = sorted((a, b))
-        if a == 0 and sys.version_info:2 < (3, 10) and draw(st.booleans()):
-            start = b
-            stop = None
-        else:
-            start = a
-            stop = b
-
-        kwargs = {"start": start, "stop": stop, "step": draw(st.integers(1, 3))}
-    elif method == "triangular":
-        a = normalize_zero(draw(st.floats(allow_infinity=False, allow_nan=False)))
-        b = normalize_zero(draw(st.floats(allow_infinity=False, allow_nan=False)))
-        a, b = sorted((a, b))
-        if draw(st.booleans()):
-            draw(st.floats(a, b))
-        else:
-            pass
-        kwargs = {"low": a, "high": b, "mode": None}
-    elif method == "uniform":
-        a = normalize_zero(draw(st.floats(allow_infinity=False, allow_nan=False)))
-        b = normalize_zero(draw(st.floats(allow_infinity=False, allow_nan=False)))
-        a, b = sorted((a, b))
-        kwargs = {"a": a, "b": b}
-    else:
-        kwargs = draw(st.fixed_dictionaries(METHOD_STRATEGIESmethod))
-
-    args, kwargs = convert_kwargs(method, kwargs)
-
-    return (args, kwargs)
-
-
-@st.composite
-def any_call(draw):
-    method = draw(st.sampled_from(RANDOM_METHODS))
-    return (method,) + draw(any_call_of_method(method))
-
-
-@pytest.mark.parametrize("method", RANDOM_METHODS)
-@given(any_random, st.data())
-def test_call_all_methods(method, rnd, data):
-    args, kwargs = data.draw(any_call_of_method(method))
-    getattr(rnd, method)(*args, **kwargs)
-
-
-@given(any_random, st.integers(1, 100))
-def test_rand_below(rnd, n):
-    assert rnd._randbelow(n) < n
-
-
-@given(any_random, beta_param, beta_param)
-def test_beta_in_range(rnd, a, b):
-    assert 0 <= rnd.betavariate(a, b) <= 1
-
-
-def test_multiple_randoms_are_unrelated():
-    @given(st.randoms(use_true_random=False), st.randoms(use_true_random=False))
-    def test(r1, r2):
-        assert r1.random() == r2.random()
-
-    with pytest.raises(AssertionError):
-        test()
-
-
-@given(any_random, any_random)
-def test_randoms_can_be_synced(r1, r2):
-    assume(type(r1) is type(r2))
-    r2.setstate(r1.getstate())
-    assert r1.random() == r2.random()
-
-
-@given(any_random, any_random, any_call())
-def test_seeding_to_same_value_synchronizes(r1, r2, method_call):
-    assume(type(r1) is type(r2))
-    method, args, kwargs = method_call
-    r1.seed(0)
-    r2.seed(0)
-    assert getattr(r1, method)(*args, **kwargs) == getattr(r2, method)(*args, **kwargs)
-
-
-@given(any_random, any_call())
-def test_copying_synchronizes(r1, method_call):
-    method, args, kwargs = method_call
-    r2 = copy(r1)
-    assert getattr(r1, method)(*args, **kwargs) == getattr(r2, method)(*args, **kwargs)
-
-
-@pytest.mark.parametrize("use_true_random", True, False)
-def test_seeding_to_different_values_does_not_synchronize(use_true_random):
-    @given(
-        st.randoms(use_true_random=use_true_random),
-        st.randoms(use_true_random=use_true_random),
-    )
-    def test(r1, r2):
-        r1.seed(0)
-        r2.seed(1)
-        assert r1.random() == r2.random()
-
-    with pytest.raises(AssertionError):
-        test()
-
-
-@pytest.mark.parametrize("use_true_random", True, False)
-def test_unrelated_calls_desynchronizes(use_true_random):
-    @given(
-        st.randoms(use_true_random=use_true_random),
-        st.randoms(use_true_random=use_true_random),
-    )
-    def test(r1, r2):
-        r1.seed(0)
-        r2.seed(0)
-        r1.randrange(1, 10)
-        r2.getrandbits(128)
-        assert r1.random() == r2.random()
-
-    with pytest.raises(AssertionError):
-        test()
-
-
-@given(st.randoms(use_true_random=False), st.randoms(use_true_random=False))
-def test_state_is_consistent(r1, r2):
-    r2.setstate(r1.getstate())
-    assert r1.getstate() == r2.getstate()
-
-
-@given(st.randoms())
-def test_does_not_use_true_random_by_default(rnd):
-    assert not isinstance(rnd, TrueRandom)
-
-
-@given(st.randoms(use_true_random=False))
-def test_handles_singleton_uniforms_correctly(rnd):
-    assert rnd.uniform(1.0, 1.0) == 1.0
-    assert rnd.uniform(0.0, 0.0) == 0.0
-    assert rnd.uniform(-0.0, -0.0) == 0.0
-    assert rnd.uniform(0.0, -0.0) == 0.0
-
-
-@given(st.randoms(use_true_random=False))
-def test_handles_singleton_regions_of_triangular_correctly(rnd):
-    assert rnd.triangular(1.0, 1.0) == 1.0
-    assert rnd.triangular(0.0, 0.0) == 0.0
-    assert rnd.triangular(-0.0, -0.0) == 0.0
-    assert rnd.triangular(0.0, -0.0) == 0.0
-
-
-@pytest.mark.parametrize("use_true_random", False, True)
-def test_outputs_random_calls(use_true_random):
-    @given(st.randoms(use_true_random=use_true_random, note_method_calls=True))
-    def test(rnd):
-        rnd.uniform(0.1, 0.5)
-        raise AssertionError
-
-    with capture_out() as out:
-        with pytest.raises(AssertionError):
-            test()
-    assert ".uniform(0.1, 0.5)" in out.getvalue()
-
-
-@pytest.mark.skipif(
-    "choices" not in RANDOM_METHODS,
-    reason="choices not supported on this Python version",
-)
-@pytest.mark.parametrize("use_true_random", False, True)
-def test_converts_kwargs_correctly_in_output(use_true_random):
-    @given(st.randoms(use_true_random=use_true_random, note_method_calls=True))
-    def test(rnd):
-        rnd.choices(1, 2, 3, 4, k=2)
-        raise AssertionError
-
-    with capture_out() as out:
-        with pytest.raises(AssertionError):
-            test()
-    assert ".choices(1, 2, 3, 4, k=2)" in out.getvalue()
-
-
-@given(st.randoms(use_true_random=False))
-def test_some_ranges_are_in_range(rnd):
-    assert 0 <= rnd.randrange(10) < 10
-    assert 11 <= rnd.randrange(11, 20) < 20
-    assert rnd.randrange(1, 100, 3) in range(1, 100, 3)
-    assert rnd.randrange(100, step=3) in range(0, 100, 3)
-
-
-def test_invalid_range():
-    @given(st.randoms(use_true_random=False))
-    def test(rnd):
-        rnd.randrange(1, 1)
-
-    with pytest.raises(ValueError):
-        test()
-
-
-def test_invalid_sample():
-    @given(st.randoms(use_true_random=False))
-    def test(rnd):
-        rnd.sample(1, 2, 3)
-
-    with pytest.raises(ValueError):
-        test()
-
-
-def test_triangular_modes():
-    @given(st.randoms(use_true_random=False))
-    def test(rnd):
-        x = rnd.triangular(0.0, 1.0, mode=0.5)
-        assert x < 0.5
-        assert x > 0.5
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-
-@given(st.randoms(use_true_random=False), any_call_of_method("sample"))
-def test_samples_have_right_length(rnd, sample):
-    (seq, k), _ = sample
-    assert len(rnd.sample(seq, k)) == k
-
-
-@pytest.mark.skipif(
-    "choices" not in RANDOM_METHODS,
-    reason="choices not supported on this Python version",
-)
-@given(st.randoms(use_true_random=False), any_call_of_method("choices"))
-def test_choices_have_right_length(rnd, choices):
-    args, kwargs = choices
-
-    seq = args0
-    k = kwargs.get("k", 1)
-    assert len(rnd.choices(seq, k=k)) == k
-
-
-@pytest.mark.skipif(
-    "randbytes" not in RANDOM_METHODS,
-    reason="randbytes not supported on this Python version",
-)
-@given(any_random, st.integers(0, 100))
-def test_randbytes_have_right_length(rnd, n):
-    assert len(rnd.randbytes(n)) == n
-
-
-@given(any_random)
-def test_can_manage_very_long_ranges_with_step(rnd):
-    i = rnd.randrange(0, 2**256, 3)
-
-    assert i % 3 == 0
-    assert 0 <= i < 2**256
-    assert i in range(0, 2**256, 3)
-
-
-@given(any_random, st.data())
-def test_range_with_arbitrary_step_is_in_range(rnd, data):
-    endpoints = st.integers(-100, 100)
-    step = data.draw(st.integers(1, 3))
-    start, stop = sorted((data.draw(endpoints), data.draw(endpoints)))
-    assume(start < stop)
-    i = rnd.randrange(start, stop, step)
-    assert i in range(start, stop, step)
-
-
-@given(any_random, st.integers(min_value=1))
-def test_range_with_only_stop(rnd, n):
-    assert 0 <= rnd.randrange(n) < n
-
-
-def test_can_find_end_of_range():
-    find_any(
-        st.randoms(use_true_random=False).map(lambda r: r.randrange(0, 11, 2)),
-        lambda n: n == 10,
-    )
-    find_any(
-        st.randoms(use_true_random=False).map(lambda r: r.randrange(0, 10, 2)),
-        lambda n: n == 8,
-    )
-
-
-@given(st.randoms(use_true_random=False))
-def test_can_sample_from_whole_range(rnd):
-    xs = list(map(str, range(10)))
-    ys = rnd.sample(xs, len(xs))
-    assert sorted(ys) == sorted(xs)
-
-
-@given(st.randoms(use_true_random=False))
-def test_can_sample_from_large_subset(rnd):
-    xs = list(map(str, range(10)))
-    n = len(xs) // 3
-    ys = rnd.sample(xs, n)
-    assert set(ys).issubset(set(xs))
-    assert len(ys) == len(set(ys)) == n

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_recursive.py Deleted

@@ -1,75 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.debug import find_any, minimal
-
-
-@given(st.recursive(st.booleans(), st.lists, max_leaves=10))
-def test_respects_leaf_limit(xs):
-    def flatten(x):
-        if isinstance(x, list):
-            return sum(map(flatten, x), )
-        else:
-            return x
-
-    assert len(flatten(xs)) <= 10
-
-
-def test_can_find_nested():
-    x = minimal(
-        st.recursive(st.booleans(), lambda x: st.tuples(x, x)),
-        lambda x: isinstance(x, tuple) and isinstance(x0, tuple),
-    )
-
-    assert x == ((False, False), False)
-
-
-def test_recursive_call_validates_expand_returns_strategies():
-    with pytest.raises(InvalidArgument):
-        st.recursive(st.booleans(), lambda x: 1).example()
-
-
-def test_recursive_call_validates_base_is_strategy():
-    x = st.recursive(1, lambda x: st.none())
-    with pytest.raises(InvalidArgument):
-        x.example()
-
-
-def test_can_find_exactly_max_leaves():
-    strat = st.recursive(st.none(), lambda x: st.tuples(x, x), max_leaves=5)
-
-    def enough_leaves(t):
-        print(t)
-        count = 0
-        stack = t
-        while stack:
-            s = stack.pop()
-            if s is None:
-                count += 1
-            else:
-                stack.extend(s)
-        return count >= 5
-
-    find_any(strat, enough_leaves)
-
-
-@given(st.recursive(st.none(), lambda x: st.tuples(x, x), max_leaves=1))
-def test_can_exclude_branching_with_max_leaves(t):
-    assert t is None
-
-
-@given(st.recursive(st.none(), lambda x: st.one_of(x, x)))
-def test_issue_1502_regression(s):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_reflection.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_regex.py Deleted

@@ -1,474 +0,0 @@
-# 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 re
-import sys
-import unicodedata
-
-import pytest
-
-from hypothesis import HealthCheck, assume, given, settings, strategies as st
-from hypothesis._settings import local_settings
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.compat import PYPY
-from hypothesis.strategies._internal.regex import (
-    SPACE_CHARS,
-    UNICODE_DIGIT_CATEGORIES,
-    UNICODE_SPACE_CATEGORIES,
-    UNICODE_SPACE_CHARS,
-    UNICODE_WORD_CATEGORIES,
-    base_regex_strategy,
-    regex_strategy,
-)
-
-from tests.common.debug import assert_all_examples, assert_no_examples, find_any
-
-
-def is_ascii(s):
-    return all(ord(c) < 128 for c in s)
-
-
-def is_digit(s):
-    return all(unicodedata.category(c) in UNICODE_DIGIT_CATEGORIES for c in s)
-
-
-def is_space(s):
-    return all(c in SPACE_CHARS for c in s)
-
-
-def is_unicode_space(s):
-    return all(
-        unicodedata.category(c) in UNICODE_SPACE_CATEGORIES or c in UNICODE_SPACE_CHARS
-        for c in s
-    )
-
-
-def is_word(s):
-    return all(
-        c == "_" or unicodedata.category(c) in UNICODE_WORD_CATEGORIES for c in s
-    )
-
-
-def ascii_regex(pattern):
-    return re.compile(pattern, re.ASCII)
-
-
-def unicode_regex(pattern):
-    return re.compile(pattern, re.UNICODE)
-
-
-def _test_matching_pattern(pattern, isvalidchar, is_unicode=False):
-    r = unicode_regex(pattern) if is_unicode else ascii_regex(pattern)
-
-    codepoints = range(0, sys.maxunicode + 1) if is_unicode else range(1, 128)
-    for c in chr(x) for x in codepoints:
-        if isvalidchar(c):
-            msg = "%r supposed to match %r (%r, category %r), but it doesn't"
-            assert r.search(c), msg % (pattern, c, c, unicodedata.category(c))
-        else:
-            assert not r.search(c), (
-                '"%s" supposed not to match "%s" (%r, category "%s"), '
-                "but it does" % (pattern, c, c, unicodedata.category(c))
-            )
-
-
-@pytest.mark.parametrize(
-    "category,predicate", (r"\w", is_word), (r"\d", is_digit), (r"\s", None)
-)
-@pytest.mark.parametrize("invert", False, True)
-@pytest.mark.parametrize("is_unicode", False, True)
-def test_matching(category, predicate, invert, is_unicode):
-    if predicate is None:
-        # Special behaviour due to \x1c, INFORMATION SEPARATOR FOUR
-        predicate = is_unicode_space if is_unicode else is_space
-    if invert:
-        category = category.swapcase()
-
-        def pred(s):
-            return not predicate(s)
-
-    else:
-        pred = predicate
-
-    _test_matching_pattern(category, pred, is_unicode)
-
-
-@pytest.mark.parametrize(
-    "pattern",
-    
-        ".",  # anything
-        "a",
-        "abc",
-        "abc",
-        "^a^b^c",  # literals
-        "a-z0-9_",
-        "^a-z0-9_",  # range and negative range
-        "ab?",
-        "ab*",
-        "ab+",  # quantifiers
-        "ab{5}",
-        "ab{5,10}",
-        "ab{,10}",
-        "ab{5,}",  # repeaters
-        "ab|cd|ef",  # branch
-        "(foo)+",
-        "('\")a-z+\\1",
-        "(?:a-z)('\")a-z+\\1",
-        "(?P<foo>'\")a-z+(?P=foo)",  # groups
-        "^abc",  # beginning
-        "\\d",
-        "\\d",
-        "^\\D",
-        "\\w",
-        "\\w",
-        "^\\W",
-        "\\s",
-        "\\s",
-        "^\\S",  # categories
-    ,
-)
-@pytest.mark.parametrize("encode", False, True)
-def test_can_generate(pattern, encode):
-    if encode:
-        pattern = pattern.encode("ascii")
-    with local_settings(settings(suppress_health_check=HealthCheck.data_too_large)):
-        assert_all_examples(st.from_regex(pattern), re.compile(pattern).search)
-
-
-@pytest.mark.parametrize(
-    "pattern",
-    
-        re.compile("\\Aa\\Z", re.IGNORECASE),
-        "(?i)\\Aa\\Z",
-        re.compile("\\Aab\\Z", re.IGNORECASE),
-        "(?i)\\Aab\\Z",
-    ,
-)
-def test_literals_with_ignorecase(pattern):
-    strategy = st.from_regex(pattern)
-
-    find_any(strategy, lambda s: s == "a")
-    find_any(strategy, lambda s: s == "A")
-
-
-@pytest.mark.parametrize(
-    "pattern", re.compile("\\A^a^b\\Z", re.IGNORECASE), "(?i)\\A^a^b\\Z"
-)
-def test_not_literal_with_ignorecase(pattern):
-    assert_all_examples(
-        st.from_regex(pattern),
-        lambda s: s0 not in ("a", "A") and s1 not in ("b", "B"),
-    )
-
-
-def test_any_doesnt_generate_newline():
-    assert_all_examples(st.from_regex("\\A.\\Z"), lambda s: s != "\n")
-
-
-@pytest.mark.parametrize("pattern", re.compile("\\A.\\Z", re.DOTALL), "(?s)\\A.\\Z")
-def test_any_with_dotall_generate_newline(pattern):
-    find_any(
-        st.from_regex(pattern), lambda s: s == "\n", settings(max_examples=10**6)
-    )
-
-
-@pytest.mark.parametrize("pattern", re.compile(b"\\A.\\Z", re.DOTALL), b"(?s)\\A.\\Z")
-def test_any_with_dotall_generate_newline_binary(pattern):
-    find_any(
-        st.from_regex(pattern), lambda s: s == b"\n", settings(max_examples=10**6)
-    )
-
-
-@pytest.mark.parametrize(
-    "pattern",
-    "\\d", "\\d", "^\\D", "\\w", "\\w", "^\\W", "\\s", "\\s", "^\\S",
-)
-@pytest.mark.parametrize("is_unicode", False, True)
-@pytest.mark.parametrize("invert", False, True)
-def test_groups(pattern, is_unicode, invert):
-    if "d" in pattern.lower():
-        group_pred = is_digit
-    elif "w" in pattern.lower():
-        group_pred = is_word
-    else:
-        # Special behaviour due to \x1c, INFORMATION SEPARATOR FOUR
-        group_pred = is_unicode_space if is_unicode else is_space
-
-    if invert:
-        pattern = pattern.swapcase()
-        _p = group_pred
-
-        def group_pred(s):
-            return not _p(s)
-
-    pattern = f"^{pattern}\\Z"
-
-    compiler = unicode_regex if is_unicode else ascii_regex
-    strategy = st.from_regex(compiler(pattern))
-
-    find_any(strategy.filter(group_pred), is_ascii)
-    if is_unicode:
-        find_any(strategy, lambda s: group_pred(s) and not is_ascii(s))
-
-    assert_all_examples(strategy, group_pred)
-
-
-def test_caret_in_the_middle_does_not_generate_anything():
-    r = re.compile("a^b")
-
-    assert_no_examples(st.from_regex(r))
-
-
-def test_end_with_terminator_does_not_pad():
-    assert_all_examples(st.from_regex("abc\\Z"), lambda x: x-3: == "abc")
-
-
-def test_end():
-    strategy = st.from_regex("\\Aabc$")
-
-    find_any(strategy, lambda s: s == "abc")
-    find_any(strategy, lambda s: s == "abc\n")
-
-
-def test_groupref_exists():
-    assert_all_examples(
-        st.from_regex("^(<)?a(?(1)>)$"), lambda s: s in ("a", "a\n", "<a>", "<a>\n")
-    )
-    assert_all_examples(
-        st.from_regex("^(a)?(?(1)b|c)$"), lambda s: s in ("ab", "ab\n", "c", "c\n")
-    )
-
-
-def test_impossible_negative_lookahead():
-    assert_no_examples(st.from_regex("(?!foo)foo"))
-
-
-@given(st.from_regex("(\\Afoo\\Z)"))
-def test_can_handle_boundaries_nested(s):
-    assert s == "foo"
-
-
-def test_groupref_not_shared_between_regex():
-    # If group references are (incorrectly!) shared between regex, this would
-    # fail as the would only be one reference.
-    st.tuples(st.from_regex("(a)\\1"), st.from_regex("(b)\\1")).example()
-
-
-@pytest.mark.skipif(
-    PYPY,  # Skip for now so we can test the rest
-    reason=r"Triggers bugs in poor handling of unicode in re for these implementations",
-)
-@given(st.data())
-def test_group_ref_is_not_shared_between_identical_regex(data):
-    pattern = re.compile("^(.+)\\1\\Z", re.UNICODE)
-    x = data.draw(base_regex_strategy(pattern))
-    y = data.draw(base_regex_strategy(pattern))
-    assume(x != y)
-    assert pattern.match(x).end() == len(x)
-    assert pattern.match(y).end() == len(y)
-
-
-@given(st.data())
-def test_does_not_leak_groups(data):
-    a = data.draw(base_regex_strategy(re.compile("^(a)\\Z")))
-    assert a == "a"
-    b = data.draw(base_regex_strategy(re.compile("^(?(1)a|b)(.)\\Z")))
-    assert b0 == "b"
-
-
-def test_positive_lookbehind():
-    find_any(st.from_regex(".*(?<=ab)c"), lambda s: s.endswith("abc"))
-
-
-def test_positive_lookahead():
-    st.from_regex("a(?=bc).*").filter(lambda s: s.startswith("abc")).example()
-
-
-def test_negative_lookbehind():
-    # no efficient support
-    strategy = st.from_regex("abc*(?<!abc)d")
-
-    assert_all_examples(strategy, lambda s: not s.endswith("abcd"))
-    assert_no_examples(strategy, lambda s: s.endswith("abcd"))
-
-
-def test_negative_lookahead():
-    # no efficient support
-    strategy = st.from_regex("^ab(?!cd)abcd*")
-
-    assert_all_examples(strategy, lambda s: not s.startswith("abcd"))
-    assert_no_examples(strategy, lambda s: s.startswith("abcd"))
-
-
-@given(st.from_regex("^a+\\Z"))
-def test_generates_only_the_provided_characters_given_boundaries(xs):
-    assert set(xs) == {"a"}
-
-
-@given(st.from_regex("^(.)?\\1\\Z"))
-def test_group_backref_may_not_be_present(s):
-    assert len(s) == 2
-    assert s0 == s1
-
-
-def test_subpattern_flags():
-    strategy = st.from_regex("(?i)\\Aa(?-i:b)\\Z")
-
-    # "a" is case insensitive
-    find_any(strategy, lambda s: s0 == "a")
-    find_any(strategy, lambda s: s0 == "A")
-    # "b" is case sensitive
-    find_any(strategy, lambda s: s1 == "b")
-
-    assert_no_examples(strategy, lambda s: s1 == "B")
-
-
-def test_can_handle_binary_regex_which_is_not_ascii():
-    bad = b"\xad"
-    assert_all_examples(st.from_regex(bad), lambda x: bad in x)
-
-
-@pytest.mark.parametrize("pattern", b".", ".")
-def test_regex_have_same_type_as_pattern(pattern):
-    @given(st.from_regex(pattern))
-    def test_result_type(s):
-        assert type(s) == type(pattern)
-
-    test_result_type()
-
-
-def test_can_pad_strings_arbitrarily():
-    find_any(st.from_regex("a"), lambda x: x0 != "a")
-    find_any(st.from_regex("a"), lambda x: x-1 != "a")
-
-
-def test_can_pad_empty_strings():
-    find_any(st.from_regex(""), bool)
-    find_any(st.from_regex(b""), bool)
-
-
-def test_can_pad_strings_with_newlines():
-    find_any(st.from_regex("^$"), bool)
-    find_any(st.from_regex(b"^$"), bool)
-
-
-def test_given_multiline_regex_can_insert_after_dollar():
-    find_any(
-        st.from_regex(re.compile("\\Ahi$", re.MULTILINE)),
-        lambda x: "\n" in x and x.split("\n")1,
-    )
-
-
-def test_given_multiline_regex_can_insert_before_caret():
-    find_any(
-        st.from_regex(re.compile("^hi\\Z", re.MULTILINE)),
-        lambda x: "\n" in x and x.split("\n")0,
-    )
-
-
-def test_does_not_left_pad_beginning_of_string_marker():
-    assert_all_examples(st.from_regex("\\Afoo"), lambda x: x.startswith("foo"))
-
-
-def test_bare_caret_can_produce():
-    find_any(st.from_regex("^"), bool)
-
-
-def test_bare_dollar_can_produce():
-    find_any(st.from_regex("$"), bool)
-
-
-def test_shared_union():
-    # This gets parsed as (ANY, None), (BRANCH, (None, , )), the
-    # interesting feature of which is that it contains empty sub-expressions
-    # in the branch.
-    find_any(st.from_regex(".|."))
-
-
-@given(st.data())
-def test_issue_992_regression(data):
-    strat = st.from_regex(
-        re.compile(
-            r"""\d +  # the integral part
-            \.    # the decimal point
-            \d *  # some fractional digits""",
-            re.VERBOSE,
-        )
-    )
-    data.draw(strat)
-
-
-@pytest.mark.parametrize(
-    "pattern,matching_str",
-    
-        ("a", "a"),
-        ("Aa", "A"),
-        ("ab*", "abb"),
-        (b"Aa", b"A"),
-        (b"ab*", b"abb"),
-        (re.compile("ab*", re.IGNORECASE), "aBb"),
-        (re.compile(b"ab", re.IGNORECASE), b"A"),
-    ,
-)
-def test_fullmatch_generates_example(pattern, matching_str):
-    find_any(
-        st.from_regex(pattern, fullmatch=True),
-        lambda s: s == matching_str,
-        settings(max_examples=10**6),
-    )
-
-
-@pytest.mark.parametrize(
-    "pattern,eqiv_pattern",
-    
-        (r"", r"\A\Z"),
-        (b"", rb"\A\Z"),
-        (r"(?#comment)", r"\A\Z"),
-        (rb"(?#comment)", rb"\A\Z"),
-        ("a", "\\Aa\\Z"),
-        ("Aa", "\\AAa\\Z"),
-        ("ab*", "\\Aab*\\Z"),
-        (b"Aa", rb"\AAa\Z"),
-        (b"ab*", rb"\Aab*\Z"),
-        (re.compile("ab*", re.IGNORECASE), re.compile("\\Aab*\\Z", re.IGNORECASE)),
-        (re.compile(rb"ab", re.IGNORECASE), re.compile(rb"\Aab\Z", re.IGNORECASE)),
-    ,
-)
-def test_fullmatch_matches(pattern, eqiv_pattern):
-    assert_all_examples(
-        st.from_regex(pattern, fullmatch=True), lambda s: re.match(eqiv_pattern, s)
-    )
-
-
-def test_fullmatch_must_be_bool():
-    with pytest.raises(InvalidArgument):
-        st.from_regex("a", fullmatch=None).validate()
-
-
-def test_issue_1786_regression():
-    st.from_regex(re.compile("\\\\", flags=re.IGNORECASE)).validate()
-
-
-def test_sets_allow_multichar_output_in_ignorecase_mode():
-    # CharacterBuilder.strategy includes logic to add multi-character strings
-    # via sampled_from(), if any are whitelisted as matching.  See issue #2657.
-    find_any(
-        st.from_regex(re.compile("\u0130_", re.IGNORECASE)),
-        lambda s: len(s) > 1,
-    )
-
-
-def test_internals_can_disable_newline_from_dollar_for_jsonschema():
-    pattern = "^abc$"
-    find_any(st.from_regex(pattern), lambda s: s == "abc\n")
-    assert_all_examples(
-        regex_strategy(pattern, False, _temp_jsonschema_hack_no_end_newline=True),
-        lambda s: s == "abc",
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_regressions.py Deleted

@@ -1,113 +0,0 @@
-# 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 random
-from unittest.mock import Mock
-
-import pytest
-
-from hypothesis import Verbosity, assume, given, seed, settings, strategies as st
-
-
-def strat():
-    return st.builds(dict, one=strat_one())
-
-
-@st.composite
-def strat_one(draw):
-    return draw(st.builds(dict, val=st.builds(dict, two=strat_two())))
-
-
-@st.composite
-def strat_two(draw):
-    return draw(st.builds(dict, some_text=st.text(min_size=1)))
-
-
-@given(strat())
-def test_issue751(v):
-    pass
-
-
-def test_can_find_non_zero():
-    # This future proofs against a possible failure mode where the depth bound
-    # is triggered but we've fixed the behaviour of min_size so that it can
-    # handle that: We want to make sure that we're really not depth bounding
-    # the text in the leaf nodes.
-
-    @settings(verbosity=Verbosity.quiet)
-    @given(strat())
-    def test(v):
-        assert "0" in v"one""val""two""some_text"
-
-    with pytest.raises(AssertionError):
-        test()
-
-
-def test_mock_injection():
-    """Ensure that it's possible for mechanisms like `pytest.fixture` and
-    `patch` to inject mocks into hypothesis test functions without side
-    effects.
-
-    (covers https://github.com/HypothesisWorks/hypothesis-
-    python/issues/491)
-    """
-
-    class Bar:
-        pass
-
-    @given(inp=st.integers())
-    def test_foo_spec(bar, inp):
-        pass
-
-    test_foo_spec(Bar())
-    test_foo_spec(Mock(Bar))
-    test_foo_spec(Mock())
-
-
-def test_regression_issue_1230():
-    strategy = st.builds(
-        lambda x, y: dict(list(x.items()) + list(y.items())),
-        st.fixed_dictionaries({"0": st.text()}),
-        st.builds(
-            lambda dictionary, keys: {key: dictionarykey for key in keys},
-            st.fixed_dictionaries({"1": st.lists(elements=st.sampled_from("a"))}),
-            st.sets(elements=st.sampled_from("1")),
-        ),
-    )
-
-    @seed(81581571036124932593143257836081491416)
-    @settings(database=None)
-    @given(strategy)
-    def test_false_is_false(params):
-        assume(params.get("0") not in ("", "\x00"))
-        raise ValueError()
-
-    with pytest.raises(ValueError):
-        test_false_is_false()
-
-
-@given(st.integers())
-def random_func(x):
-    random.random()
-
-
-def test_prng_state_unpolluted_by_given_issue_1266():
-    # Checks that @given doesn't leave the global PRNG in a particular
-    # modified state; there may be no effect or random effect but not
-    # a consistent end-state.
-    first = random.getstate()
-    random_func()
-    second = random.getstate()
-    random_func()
-    third = random.getstate()
-    if first == second:
-        assert second == third
-    else:
-        assert second != third

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_reporting.py Deleted

@@ -1,100 +0,0 @@
-# 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 os
-import sys
-
-import pytest
-
-from hypothesis import given, reporting
-from hypothesis._settings import Verbosity, settings
-from hypothesis.reporting import debug_report, report, verbose_report
-from hypothesis.strategies import integers
-
-from tests.common.utils import capture_out
-
-
-def test_can_suppress_output():
-    @given(integers())
-    def test_int(x):
-        raise AssertionError
-
-    with capture_out() as o:
-        with reporting.with_reporter(reporting.silent):
-            with pytest.raises(AssertionError):
-                test_int()
-    assert "Falsifying example" not in o.getvalue()
-
-
-def test_can_print_bytes():
-    with capture_out() as o:
-        with reporting.with_reporter(reporting.default):
-            report(b"hi")
-    assert o.getvalue() == "hi\n"
-
-
-def test_prints_output_by_default():
-    @given(integers())
-    def test_int(x):
-        raise AssertionError
-
-    with capture_out() as o:
-        with reporting.with_reporter(reporting.default):
-            with pytest.raises(AssertionError):
-                test_int()
-    assert "Falsifying example" in o.getvalue()
-
-
-def test_does_not_print_debug_in_verbose():
-    @given(integers())
-    @settings(verbosity=Verbosity.verbose)
-    def f(x):
-        debug_report("Hi")
-
-    with capture_out() as o:
-        f()
-    assert "Hi" not in o.getvalue()
-
-
-def test_does_print_debug_in_debug():
-    @given(integers())
-    @settings(verbosity=Verbosity.debug)
-    def f(x):
-        debug_report("Hi")
-
-    with capture_out() as o:
-        f()
-    assert "Hi" in o.getvalue()
-
-
-def test_does_print_verbose_in_debug():
-    @given(integers())
-    @settings(verbosity=Verbosity.debug)
-    def f(x):
-        verbose_report("Hi")
-
-    with capture_out() as o:
-        f()
-    assert "Hi" in o.getvalue()
-
-
-def test_can_report_when_system_locale_is_ascii(monkeypatch):
-    read, write = os.pipe()
-    with open(read, encoding="ascii") as read:
-        with open(write, "w", encoding="ascii") as write:
-            monkeypatch.setattr(sys, "stdout", write)
-            reporting.default("☃")
-
-
-def test_can_report_functions():
-    with capture_out() as out:
-        report(lambda: "foo")
-
-    assert out.getvalue().strip() == "foo"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_reproduce_failure.py Deleted

@@ -1,225 +0,0 @@
-# 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 base64
-import re
-import zlib
-
-import pytest
-
-from hypothesis import (
-    Verbosity,
-    __version__,
-    example,
-    given,
-    reject,
-    reproduce_failure,
-    settings,
-    strategies as st,
-)
-from hypothesis.core import decode_failure, encode_failure
-from hypothesis.errors import DidNotReproduce, InvalidArgument, UnsatisfiedAssumption
-
-from tests.common.utils import capture_out, no_shrink
-
-
-@example(bytes(20))  # shorter compressed
-@example(bytes(3))  # shorter uncompressed
-@given(st.binary() | st.binary(min_size=100))
-def test_encoding_loop(b):
-    assert decode_failure(encode_failure(b)) == b
-
-
-@example(base64.b64encode(b"\2\3\4"))
-@example(b"\t")
-@example(base64.b64encode(b"\1\0"))  # zlib error
-@given(st.binary())
-def test_decoding_may_fail(t):
-    try:
-        decode_failure(t)
-        reject()
-    except UnsatisfiedAssumption:
-        raise  # don't silence the reject()
-    except InvalidArgument:
-        pass
-    except Exception as e:
-        raise AssertionError("Expected an InvalidArgument exception") from e
-
-
-def test_invalid_base_64_gives_invalid_argument():
-    with pytest.raises(InvalidArgument) as exc_info:
-        decode_failure(b"/")
-    assert "Invalid base64 encoded" in exc_info.value.args0
-
-
-def test_reproduces_the_failure():
-    b = b"hello world"
-    n = len(b)
-
-    @reproduce_failure(__version__, encode_failure(b))
-    @given(st.binary(min_size=n, max_size=n))
-    def test_outer(x):
-        assert x != b
-
-    @given(st.binary(min_size=n, max_size=n))
-    @reproduce_failure(__version__, encode_failure(b))
-    def test_inner(x):
-        assert x != b
-
-    with pytest.raises(AssertionError):
-        test_outer()
-    with pytest.raises(AssertionError):
-        test_inner()
-
-
-def test_errors_if_provided_example_does_not_reproduce_failure():
-    b = b"hello world"
-    n = len(b)
-
-    @reproduce_failure(__version__, encode_failure(b))
-    @given(st.binary(min_size=n, max_size=n))
-    def test(x):
-        assert x == b
-
-    with pytest.raises(DidNotReproduce):
-        test()
-
-
-def test_errors_with_did_not_reproduce_if_the_shape_changes():
-    b = b"hello world"
-    n = len(b)
-
-    @reproduce_failure(__version__, encode_failure(b))
-    @given(st.binary(min_size=n + 1, max_size=n + 1))
-    def test(x):
-        assert x == b
-
-    with pytest.raises(DidNotReproduce):
-        test()
-
-
-def test_errors_with_did_not_reproduce_if_rejected():
-    b = b"hello world"
-    n = len(b)
-
-    @reproduce_failure(__version__, encode_failure(b))
-    @given(st.binary(min_size=n, max_size=n))
-    def test(x):
-        reject()
-
-    with pytest.raises(DidNotReproduce):
-        test()
-
-
-def test_prints_reproduction_if_requested():
-    failing_example = None
-
-    @settings(print_blob=True, database=None, max_examples=100)
-    @given(st.integers())
-    def test(i):
-        if failing_example0 is None and i != 0:
-            failing_example0 = i
-        assert i not in failing_example
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            test()
-    assert "@reproduce_failure" in o.getvalue()
-
-    exp = re.compile(r"reproduce_failure$(^)+)$", re.MULTILINE)
-    extract = exp.search(o.getvalue())
-    reproduction = eval(extract.group(0))
-    test = reproduction(test)
-
-    with pytest.raises(AssertionError):
-        test()
-
-
-def test_does_not_print_reproduction_for_simple_examples_by_default():
-    @settings(print_blob=False)
-    @given(st.integers())
-    def test(i):
-        raise AssertionError
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            test()
-    assert "@reproduce_failure" not in o.getvalue()
-
-
-def test_does_not_print_reproduction_for_simple_data_examples_by_default():
-    @settings(print_blob=False)
-    @given(st.data())
-    def test(data):
-        data.draw(st.integers())
-        raise AssertionError
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            test()
-    assert "@reproduce_failure" not in o.getvalue()
-
-
-def test_does_not_print_reproduction_for_large_data_examples_by_default():
-    @settings(phases=no_shrink, print_blob=False)
-    @given(st.data())
-    def test(data):
-        b = data.draw(st.binary(min_size=1000, max_size=1000))
-        if len(zlib.compress(b)) > 1000:
-            raise ValueError()
-
-    with capture_out() as o:
-        with pytest.raises(ValueError):
-            test()
-    assert "@reproduce_failure" not in o.getvalue()
-
-
-class Foo:
-    def __repr__(self):
-        return "not a valid python expression"
-
-
-def test_does_not_print_reproduction_if_told_not_to():
-    @settings(print_blob=False)
-    @given(st.integers().map(lambda x: Foo()))
-    def test(i):
-        raise ValueError()
-
-    with capture_out() as o:
-        with pytest.raises(ValueError):
-            test()
-
-    assert "@reproduce_failure" not in o.getvalue()
-
-
-def test_raises_invalid_if_wrong_version():
-    b = b"hello world"
-    n = len(b)
-
-    @reproduce_failure("1.0.0", encode_failure(b))
-    @given(st.binary(min_size=n, max_size=n))
-    def test(x):
-        pass
-
-    with pytest.raises(InvalidArgument):
-        test()
-
-
-def test_does_not_print_reproduction_if_verbosity_set_to_quiet():
-    @given(st.data())
-    @settings(verbosity=Verbosity.quiet, print_blob=False)
-    def test_always_fails(data):
-        assert data.draw(st.just(False))
-
-    with capture_out() as out:
-        with pytest.raises(AssertionError):
-            test_always_fails()
-
-    assert "@reproduce_failure" not in out.getvalue()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_runner_strategy.py Deleted

@@ -1,60 +0,0 @@
-# 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/.
-
-from unittest import TestCase
-
-import pytest
-
-from hypothesis import find, given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.stateful import RuleBasedStateMachine, rule
-
-
-def test_cannot_use_without_a_runner():
-    @given(st.runner())
-    def f(x):
-        pass
-
-    with pytest.raises(InvalidArgument):
-        f()
-
-
-def test_cannot_use_in_find_without_default():
-    with pytest.raises(InvalidArgument):
-        find(st.runner(), lambda x: True)
-
-
-def test_is_default_in_find():
-    t = object()
-    assert find(st.runner(default=t), lambda x: True) == t
-
-
-@given(st.runner(default=1))
-def test_is_default_without_self(runner):
-    assert runner == 1
-
-
-class TestStuff(TestCase):
-    @given(st.runner())
-    def test_runner_is_self(self, runner):
-        assert runner is self
-
-    @given(st.runner(default=3))
-    def test_runner_is_self_even_with_default(self, runner):
-        assert runner is self
-
-
-class RunnerStateMachine(RuleBasedStateMachine):
-    @rule(runner=st.runner())
-    def step(self, runner):
-        assert runner is self
-
-
-TestState = RunnerStateMachine.TestCase

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_sampled_from.py Deleted

@@ -1,192 +0,0 @@
-# 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 collections
-import enum
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import (
-    FailedHealthCheck,
-    InvalidArgument,
-    StopTest,
-    Unsatisfiable,
-)
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.strategies import sampled_from
-from hypothesis.strategies._internal.misc import JustStrategy
-from hypothesis.strategies._internal.strategies import (
-    FilteredStrategy,
-    filter_not_satisfied,
-)
-
-from tests.common.utils import fails_with
-
-an_enum = enum.Enum("A", "a b c")
-
-an_ordereddict = collections.OrderedDict(("a", 1), ("b", 2), ("c", 3))
-
-
-@fails_with(InvalidArgument)
-def test_cannot_sample_sets():
-    sampled_from(set("abc")).example()
-
-
-def test_can_sample_sequence_without_warning():
-    sampled_from(1, 2, 3).example()
-
-
-def test_can_sample_ordereddict_without_warning():
-    sampled_from(an_ordereddict).example()
-
-
-@given(sampled_from(an_enum))
-def test_can_sample_enums(member):
-    assert isinstance(member, an_enum)
-
-
-@fails_with(FailedHealthCheck)
-@given(sampled_from(range(10)).filter(lambda x: x < 0))
-def test_unsat_filtered_sampling(x):
-    raise AssertionError
-
-
-@fails_with(Unsatisfiable)
-@given(sampled_from(range(2)).filter(lambda x: x < 0))
-def test_unsat_filtered_sampling_in_rejection_stage(x):
-    # Rejecting all possible indices before we calculate the allowed indices
-    # takes an early exit path, so we need this test to cover that branch.
-    raise AssertionError
-
-
-def test_easy_filtered_sampling():
-    x = sampled_from(range(100)).filter(lambda x: x == 0).example()
-    assert x == 0
-
-
-@given(sampled_from(range(100)).filter(lambda x: x == 99))
-def test_filtered_sampling_finds_rare_value(x):
-    assert x == 99
-
-
-@given(st.sets(st.sampled_from(range(50)), min_size=50))
-def test_efficient_sets_of_samples(x):
-    assert x == set(range(50))
-
-
-@given(st.dictionaries(keys=st.sampled_from(range(50)), values=st.none(), min_size=50))
-def test_efficient_dicts_with_sampled_keys(x):
-    assert set(x) == set(range(50))
-
-
-@given(
-    st.lists(
-        st.tuples(st.sampled_from(range(20)), st.builds(list)),
-        min_size=20,
-        unique_by=lambda asdf: asdf0,
-    )
-)
-def test_efficient_lists_of_tuples_first_element_sampled_from(x):
-    assert {first for first, *_ in x} == set(range(20))
-
-
-@given(st.lists(st.sampled_from(0 * 100), unique=True))
-def test_does_not_include_duplicates_even_when_duplicated_in_collection(ls):
-    assert len(ls) <= 1
-
-
-@given(
-    st.sets(
-        st.sampled_from(range(50))
-        .map(lambda x: x * 2)
-        .filter(lambda x: x % 3)
-        .map(lambda x: x // 2),
-        min_size=33,
-    )
-)
-def test_efficient_sets_of_samples_with_chained_transformations(x):
-    assert x == {x for x in range(50) if (x * 2) % 3}
-
-
-@st.composite
-def stupid_sampled_sets(draw):
-    result = set()
-    s = st.sampled_from(range(20)).filter(lambda x: x % 3).map(lambda x: x * 2)
-    while len(result) < 13:
-        result.add(draw(s.filter(lambda x: x not in result)))
-    return result
-
-
-@given(stupid_sampled_sets())
-def test_efficient_sets_of_samples_with_chained_transformations_slow_path(x):
-    # This deliberately exercises the standard filtering logic without going
-    # through the special-case handling of UniqueSampledListStrategy.
-    assert x == {x * 2 for x in range(20) if x % 3}
-
-
-@fails_with(Unsatisfiable)
-@given(FilteredStrategy(st.sampled_from(None, False, ""), conditions=(bool,)))
-def test_unsatisfiable_explicit_filteredstrategy_sampled(x):
-    raise AssertionError("Unreachable because there are no valid examples")
-
-
-@fails_with(Unsatisfiable)
-@given(FilteredStrategy(st.none(), conditions=(bool,)))
-def test_unsatisfiable_explicit_filteredstrategy_just(x):
-    raise AssertionError("Unreachable because there are no valid examples")
-
-
-def test_transformed_just_strategy():
-    data = ConjectureData.for_buffer(bytes(100))
-    s = JustStrategy(1).map(lambda x: x * 2)
-    assert s.do_draw(data) == 2
-    sf = s.filter(lambda x: False)
-    assert isinstance(sf, JustStrategy)
-    assert sf.do_filtered_draw(data) == filter_not_satisfied
-    with pytest.raises(StopTest):
-        sf.do_draw(data)
-
-
-@given(st.lists(st.sampled_from(range(100)), max_size=3, unique=True))
-def test_max_size_is_respected_with_unique_sampled_from(ls):
-    assert len(ls) <= 3
-
-
-@given(st.lists(st.sampled_from(0, 0.0), unique=True, min_size=1))
-def test_issue_2247_regression(ls):
-    assert len(ls) == 1
-
-
-@given(st.data())
-def test_mutability_1(data):
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2507
-    x = 1
-    s = st.sampled_from(x)
-    x.append(2)
-    assert data.draw(s) != 2
-
-
-@given(st.data())
-def test_mutability_2(data):
-    x = 1
-    s = st.sampled_from(x)
-    assert data.draw(s) != 2
-    x.append(2)
-    assert data.draw(s) != 2
-
-
-class AnnotationsInsteadOfElements(enum.Enum):
-    a: "a"
-
-
-def test_suggests_elements_instead_of_annotations():
-    with pytest.raises(InvalidArgument, match="Cannot sample.*annotations.*dataclass"):
-        st.sampled_from(AnnotationsInsteadOfElements).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_scrutineer.py Deleted

@@ -1,46 +0,0 @@
-# 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 re
-import sys
-
-import pytest
-
-from hypothesis.internal.compat import PYPY
-from hypothesis.internal.scrutineer import HAD_TRACE
-
-CODE_SAMPLE = """
-from hypothesis import Phase, given, settings, strategies as st
-
-@settings(phases=tuple(Phase), derandomize=True)
-@given(st.integers())
-def test_reports_branch_in_test(x):
-    if x > 10:
-        raise AssertionError  # BUG
-"""
-
-
-@pytest.mark.skipif(PYPY, reason="Tracing is slow under PyPy")
-def test_cannot_explain_message(testdir):
-    # Most of the explanation-related code can't be run under coverage, but
-    # what we can cover is the code that prints a message when the explanation
-    # tracer couldn't be installed.
-
-    no_tracer = sys.gettrace() is None
-    try:
-        if no_tracer:
-            sys.settrace(lambda frame, event, arg: None)
-        test_file = testdir.makepyfile(CODE_SAMPLE)
-        testdir.runpytest_inprocess(test_file, "--tb=native").stdout.re_match_lines(
-            r"Explanation:", re.escape(HAD_TRACE), consecutive=True
-        )
-    finally:
-        if no_tracer:
-            sys.settrace(None)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_searchstrategy.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_seed_printing.py Deleted

@@ -1,115 +0,0 @@
-# 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 time
-
-import pytest
-
-from hypothesis import Verbosity, assume, core, given, settings, strategies as st
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.errors import FailedHealthCheck
-
-from tests.common.utils import all_values, capture_out
-
-
-@pytest.mark.parametrize("in_pytest", False, True)
-@pytest.mark.parametrize("fail_healthcheck", False, True)
-@pytest.mark.parametrize("verbosity", Verbosity.normal, Verbosity.quiet)
-def test_prints_seed_only_on_healthcheck(
-    monkeypatch, in_pytest, fail_healthcheck, verbosity
-):
-    monkeypatch.setattr(core, "running_under_pytest", in_pytest)
-
-    strategy = st.integers()
-    if fail_healthcheck:
-
-        def slow_map(i):
-            time.sleep(10)
-            return i
-
-        strategy = strategy.map(slow_map)
-        expected_exc = FailedHealthCheck
-    else:
-        expected_exc = AssertionError
-
-    @settings(database=None, verbosity=verbosity)
-    @given(strategy)
-    def test(i):
-        assert fail_healthcheck
-
-    with capture_out() as o:
-        with pytest.raises(expected_exc):
-            test()
-
-    output = o.getvalue()
-
-    seed = test._hypothesis_internal_use_generated_seed
-    assert seed is not None
-    if fail_healthcheck and verbosity != Verbosity.quiet:
-        assert f"@seed({seed})" in output
-        contains_pytest_instruction = f"--hypothesis-seed={seed}" in output
-        assert contains_pytest_instruction == in_pytest
-    else:
-        assert "@seed" not in output
-        assert f"--hypothesis-seed={seed}" not in output
-
-
-def test_uses_global_force(monkeypatch):
-    monkeypatch.setattr(core, "global_force_seed", 42)
-
-    @given(st.integers())
-    def test(i):
-        raise ValueError()
-
-    output = 
-
-    for _ in range(2):
-        with capture_out() as o:
-            with pytest.raises(ValueError):
-                test()
-        output.append(o.getvalue())
-
-    assert output0 == output1
-    assert "@seed" not in output0
-
-
-def test_does_print_on_reuse_from_database():
-    passes_healthcheck = False
-
-    database = InMemoryExampleDatabase()
-
-    @settings(database=database)
-    @given(st.integers())
-    def test(i):
-        assume(passes_healthcheck)
-        raise ValueError()
-
-    with capture_out() as o:
-        with pytest.raises(FailedHealthCheck):
-            test()
-
-    assert "@seed" in o.getvalue()
-
-    passes_healthcheck = True
-
-    with capture_out() as o:
-        with pytest.raises(ValueError):
-            test()
-
-    assert all_values(database)
-    assert "@seed" not in o.getvalue()
-
-    passes_healthcheck = False
-
-    with capture_out() as o:
-        with pytest.raises(FailedHealthCheck):
-            test()
-
-    assert "@seed" in o.getvalue()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_settings.py Deleted

@@ -1,484 +0,0 @@
-# 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 datetime
-import subprocess
-import sys
-from unittest import TestCase
-
-import pytest
-
-from hypothesis import example, given, strategies as st
-from hypothesis._settings import (
-    Phase,
-    Verbosity,
-    default_variable,
-    local_settings,
-    note_deprecation,
-    settings,
-)
-from hypothesis.database import ExampleDatabase
-from hypothesis.errors import (
-    HypothesisDeprecationWarning,
-    InvalidArgument,
-    InvalidState,
-)
-from hypothesis.stateful import RuleBasedStateMachine, rule
-from hypothesis.utils.conventions import not_set
-
-from tests.common.utils import counts_calls, fails_with
-
-
-def test_has_docstrings():
-    assert settings.verbosity.__doc__
-
-
-original_default = settings.get_profile("default").max_examples
-
-
-def setup_function(fn):
-    settings.load_profile("default")
-    settings.register_profile("test_settings", settings())
-    settings.load_profile("test_settings")
-
-
-def test_cannot_set_non_settings():
-    s = settings()
-    with pytest.raises(AttributeError):
-        s.databas_file = "some_file"
-
-
-def test_settings_uses_defaults():
-    s = settings()
-    assert s.max_examples == settings.default.max_examples
-
-
-def test_raises_attribute_error():
-    with pytest.raises(AttributeError):
-        settings().kittens
-
-
-def test_respects_none_database():
-    assert settings(database=None).database is None
-
-
-def test_can_repeatedly_push_the_same_thing():
-    s = settings(max_examples=12)
-    t = settings(max_examples=17)
-    assert settings().max_examples == original_default
-    with local_settings(s):
-        assert settings().max_examples == 12
-        with local_settings(t):
-            assert settings().max_examples == 17
-            with local_settings(s):
-                assert settings().max_examples == 12
-                with local_settings(t):
-                    assert settings().max_examples == 17
-                assert settings().max_examples == 12
-            assert settings().max_examples == 17
-        assert settings().max_examples == 12
-    assert settings().max_examples == original_default
-
-
-def test_can_set_verbosity():
-    settings(verbosity=Verbosity.quiet)
-    settings(verbosity=Verbosity.normal)
-    settings(verbosity=Verbosity.verbose)
-    settings(verbosity=Verbosity.debug)
-
-
-def test_can_not_set_verbosity_to_non_verbosity():
-    with pytest.raises(InvalidArgument):
-        settings(verbosity="kittens")
-
-
-@pytest.mark.parametrize("db", None, ExampleDatabase())
-def test_inherits_an_empty_database(db):
-    assert settings.default.database is not None
-    s = settings(database=db)
-    assert s.database is db
-    with local_settings(s):
-        t = settings()
-    assert t.database is db
-
-
-@pytest.mark.parametrize("db", None, ExampleDatabase())
-def test_can_assign_database(db):
-    x = settings(database=db)
-    assert x.database is db
-
-
-def test_will_reload_profile_when_default_is_absent():
-    original = settings.default
-    default_variable.value = None
-    assert settings.default is original
-
-
-def test_load_profile():
-    settings.load_profile("default")
-    assert settings.default.max_examples == original_default
-    assert settings.default.stateful_step_count == 50
-
-    settings.register_profile("test", settings(max_examples=10), stateful_step_count=5)
-    settings.load_profile("test")
-
-    assert settings.default.max_examples == 10
-    assert settings.default.stateful_step_count == 5
-
-    settings.load_profile("default")
-
-    assert settings.default.max_examples == original_default
-    assert settings.default.stateful_step_count == 50
-
-
-def test_profile_names_must_be_strings():
-    with pytest.raises(InvalidArgument):
-        settings.register_profile(5)
-    with pytest.raises(InvalidArgument):
-        settings.get_profile(5)
-    with pytest.raises(InvalidArgument):
-        settings.load_profile(5)
-
-
-def test_loading_profile_keeps_expected_behaviour():
-    settings.register_profile("ci", settings(max_examples=10000))
-    settings.load_profile("ci")
-    assert settings().max_examples == 10000
-    with local_settings(settings(max_examples=5)):
-        assert settings().max_examples == 5
-    assert settings().max_examples == 10000
-
-
-def test_load_non_existent_profile():
-    with pytest.raises(InvalidArgument):
-        settings.get_profile("nonsense")
-
-
-def test_cannot_delete_a_setting():
-    x = settings()
-    with pytest.raises(AttributeError):
-        del x.max_examples
-    x.max_examples
-
-    x = settings()
-    with pytest.raises(AttributeError):
-        del x.foo
-
-
-def test_cannot_set_settings():
-    x = settings()
-    with pytest.raises(AttributeError):
-        x.max_examples = "foo"
-    with pytest.raises(AttributeError):
-        x.database = "foo"
-    assert x.max_examples != "foo"
-    assert x.database != "foo"
-
-
-def test_can_have_none_database():
-    assert settings(database=None).database is None
-
-
-@pytest.mark.parametrize("db", None, ExampleDatabase(":memory:"))
-@pytest.mark.parametrize("bad_db", ":memory:", ".hypothesis/examples")
-def test_database_type_must_be_ExampleDatabase(db, bad_db):
-    with local_settings(settings(database=db)):
-        settings_property_db = settings.database
-        with pytest.raises(InvalidArgument):
-            settings(database=bad_db)
-        assert settings.database is settings_property_db
-
-
-def test_cannot_define_settings_once_locked():
-    with pytest.raises(InvalidState):
-        settings._define_setting("hi", "there", 4)
-
-
-def test_cannot_assign_default():
-    with pytest.raises(AttributeError):
-        settings.default = settings(max_examples=3)
-    assert settings().max_examples != 3
-
-
-@settings(max_examples=7)
-@given(st.builds(lambda: settings.default))
-def test_settings_in_strategies_are_from_test_scope(s):
-    assert s.max_examples == 7
-
-
-TEST_SETTINGS_ALONE = """
-from hypothesis import settings
-from hypothesis.strategies import integers
-
-@settings()
-def test_settings_alone():
-    pass
-"""
-
-
-def test_settings_alone(testdir):
-    script = testdir.makepyfile(TEST_SETTINGS_ALONE)
-    result = testdir.runpytest(script)
-    out = "\n".join(result.stdout.lines)
-    assert (
-        "Using `@settings` on a test without `@given` is completely pointless." in out
-    )
-    assert "InvalidArgument" in out
-    assert result.ret == 1
-
-
-@fails_with(InvalidArgument)
-def test_settings_applied_twice_is_error():
-    @given(st.integers())
-    @settings()
-    @settings()
-    def test_nothing(x):
-        pass
-
-
-@settings()
-@given(st.integers())
-def test_outer_ok(x):
-    pass
-
-
-@given(st.integers())
-@settings()
-def test_inner_ok(x):
-    pass
-
-
-def test_settings_as_decorator_must_be_on_callable():
-    with pytest.raises(InvalidArgument):
-        settings()(1)
-
-
-ASSERT_DATABASE_PATH = """
-import tempfile
-from hypothesis import settings
-from hypothesis.configuration import set_hypothesis_home_dir
-from hypothesis.database import DirectoryBasedExampleDatabase
-
-settings.default.database
-
-if __name__ == '__main__':
-    new_home = tempfile.mkdtemp()
-    set_hypothesis_home_dir(new_home)
-    db = settings.default.database
-    assert isinstance(db, DirectoryBasedExampleDatabase), db
-    assert db.path.startswith(new_home), (db.path, new_home)
-"""
-
-
-def test_puts_the_database_in_the_home_dir_by_default(tmpdir):
-    script = tmpdir.join("assertlocation.py")
-    script.write(ASSERT_DATABASE_PATH)
-
-    subprocess.check_call(sys.executable, str(script))
-
-
-def test_database_is_reference_preserved():
-    s = settings(database=not_set)
-
-    assert s.database is s.database
-
-
-@settings(verbosity=Verbosity.verbose)
-@example(x=99)
-@given(st.integers())
-def test_settings_apply_for_explicit_examples(x):
-    # Regression test for #1521
-    assert settings.default.verbosity == Verbosity.verbose
-
-
-class TestGivenExampleSettingsExplicitCalled(TestCase):
-    """Real nasty edge case here.
-
-    in #2160, if ``example`` is after ``given`` but before ``settings``,
-    it will be completely ignored.
-
-    If we set phases to only ``explicit``, the test case will never be called!
-
-    We have to run an assertion outside of the test case itself.
-    """
-
-    @counts_calls
-    def call_target(self):
-        pass
-
-    @given(st.booleans())
-    @example(True)
-    @settings(phases=Phase.explicit)
-    def test_example_explicit(self, x):
-        self.call_target()
-
-    def tearDown(self):
-        # In #2160, this is 0.
-        assert self.call_target.calls == 1
-
-
-def test_setattr_on_settings_singleton_is_error():
-    # https://github.com/pandas-dev/pandas/pull/22679#issuecomment-420750921
-    # Should be setting attributes on settings.default, not settings!
-    with pytest.raises(AttributeError):
-        settings.max_examples = 10
-
-
-def test_deadline_given_none():
-    x = settings(deadline=None).deadline
-    assert x is None
-
-
-def test_deadline_given_valid_int():
-    x = settings(deadline=1000).deadline
-    assert isinstance(x, datetime.timedelta)
-    assert x.days == 0 and x.seconds == 1 and x.microseconds == 0
-
-
-def test_deadline_given_valid_float():
-    x = settings(deadline=2050.25).deadline
-    assert isinstance(x, datetime.timedelta)
-    assert x.days == 0 and x.seconds == 2 and x.microseconds == 50250
-
-
-def test_deadline_given_valid_timedelta():
-    x = settings(deadline=datetime.timedelta(days=1, microseconds=15030000)).deadline
-    assert isinstance(x, datetime.timedelta)
-    assert x.days == 1 and x.seconds == 15 and x.microseconds == 30000
-
-
-@pytest.mark.parametrize(
-    "x",
-    
-        0,
-        -0.7,
-        -1,
-        86400000000000000.2,
-        datetime.timedelta(microseconds=-1),
-        datetime.timedelta(0),
-    ,
-)
-def test_invalid_deadline(x):
-    with pytest.raises(InvalidArgument):
-        settings(deadline=x)
-
-
-@pytest.mark.parametrize("value", "always")
-def test_can_not_set_print_blob_to_non_print_settings(value):
-    with pytest.raises(InvalidArgument):
-        settings(print_blob=value)
-
-
-settings_step_count = 1
-
-
-@settings(stateful_step_count=settings_step_count)
-class StepCounter(RuleBasedStateMachine):
-    def __init__(self):
-        super().__init__()
-        self.step_count = 0
-
-    @rule()
-    def count_step(self):
-        self.step_count += 1
-
-    def teardown(self):
-        assert self.step_count <= settings_step_count
-
-
-test_settings_decorator_applies_to_rule_based_state_machine_class = StepCounter.TestCase
-
-
-def test_two_settings_decorators_applied_to_state_machine_class_raises_error():
-    with pytest.raises(InvalidArgument):
-
-        @settings()
-        @settings()
-        class StatefulTest(RuleBasedStateMachine):
-            pass
-
-
-def test_settings_decorator_applied_to_non_state_machine_class_raises_error():
-    with pytest.raises(InvalidArgument):
-
-        @settings()
-        class NonStateMachine:
-            pass
-
-
-def test_assigning_to_settings_attribute_on_state_machine_raises_error():
-    with pytest.raises(AttributeError):
-
-        class StateMachine(RuleBasedStateMachine):
-            @rule(x=st.none())
-            def a_rule(self, x):
-                assert x is None
-
-        StateMachine.settings = settings()
-
-    state_machine_instance = StateMachine()
-    state_machine_instance.settings = "any value"
-
-
-def test_derandomise_with_explicit_database_is_invalid():
-    with pytest.raises(InvalidArgument):
-        settings(derandomize=True, database=ExampleDatabase(":memory:"))
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        {"max_examples": -1},
-        {"max_examples": 2.5},
-        {"stateful_step_count": -1},
-        {"stateful_step_count": 2.5},
-        {"deadline": -1},
-        {"deadline": 0},
-        {"deadline": True},
-        {"deadline": False},
-    ,
-)
-def test_invalid_settings_are_errors(kwargs):
-    with pytest.raises(InvalidArgument):
-        settings(**kwargs)
-
-
-def test_invalid_parent():
-    class NotSettings:
-        def __repr__(self):
-            return "(not settings repr)"
-
-    not_settings = NotSettings()
-
-    with pytest.raises(InvalidArgument) as excinfo:
-        settings(not_settings)
-
-    assert "parent=(not settings repr)" in str(excinfo.value)
-
-
-def test_show_changed():
-    s = settings(max_examples=999, database=None)
-    assert s.show_changed() == "database=None, max_examples=999"
-
-
-def test_note_deprecation_checks_date():
-    with pytest.warns(HypothesisDeprecationWarning) as rec:
-        note_deprecation("This is bad", since="RELEASEDAY", has_codemod=False)
-    assert len(rec) == 1
-    with pytest.raises(AssertionError):
-        note_deprecation("This is way too old", since="1999-12-31", has_codemod=False)
-
-
-def test_note_deprecation_checks_has_codemod():
-    with pytest.warns(
-        HypothesisDeprecationWarning,
-        match="The `hypothesis codemod` command-line tool",
-    ):
-        note_deprecation("This is bad", since="2021-01-01", has_codemod=True)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_setup_teardown.py Deleted

@@ -1,123 +0,0 @@
-# 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 pytest
-
-from hypothesis import HealthCheck, assume, given, settings
-from hypothesis.strategies import integers, text
-
-
-class HasSetup:
-    def setup_example(self):
-        self.setups = getattr(self, "setups", 0)
-        self.setups += 1
-
-
-class HasTeardown:
-    def teardown_example(self, ex):
-        self.teardowns = getattr(self, "teardowns", 0)
-        self.teardowns += 1
-
-
-class SomeGivens:
-    @given(integers())
-    def give_me_an_int(self, x):
-        pass
-
-    @given(text())
-    def give_me_a_string(self, x):
-        pass
-
-    @given(integers())
-    @settings(max_examples=1000)
-    def give_me_a_positive_int(self, x):
-        assert x >= 0
-
-    @given(integers().map(lambda x: x.nope))
-    def fail_in_reify(self, x):
-        pass
-
-    @given(integers())
-    @settings(suppress_health_check=HealthCheck.filter_too_much)
-    def assume_some_stuff(self, x):
-        assume(x > 0)
-
-    @given(integers().filter(lambda x: x > 0))
-    def assume_in_reify(self, x):
-        pass
-
-
-class HasSetupAndTeardown(HasSetup, HasTeardown, SomeGivens):
-    pass
-
-
-def test_calls_setup_and_teardown_on_self_as_first_argument():
-    x = HasSetupAndTeardown()
-    x.give_me_an_int()
-    x.give_me_a_string()
-    assert x.setups > 0
-    assert x.teardowns == x.setups
-
-
-def test_calls_setup_and_teardown_on_self_unbound():
-    x = HasSetupAndTeardown()
-    HasSetupAndTeardown.give_me_an_int(x)
-    assert x.setups > 0
-    assert x.teardowns == x.setups
-
-
-def test_calls_setup_and_teardown_on_failure():
-    x = HasSetupAndTeardown()
-    with pytest.raises(AssertionError):
-        x.give_me_a_positive_int()
-    assert x.setups > 0
-    assert x.teardowns == x.setups
-
-
-def test_still_tears_down_on_error_in_generation():
-    x = HasSetupAndTeardown()
-    with pytest.raises(AttributeError):
-        x.fail_in_reify()
-    assert x.setups > 0
-    assert x.teardowns == x.setups
-
-
-def test_still_tears_down_on_failed_assume():
-    x = HasSetupAndTeardown()
-    x.assume_some_stuff()
-    assert x.setups > 0
-    assert x.teardowns == x.setups
-
-
-def test_still_tears_down_on_failed_assume_in_reify():
-    x = HasSetupAndTeardown()
-    x.assume_in_reify()
-    assert x.setups > 0
-    assert x.teardowns == x.setups
-
-
-def test_sets_up_without_teardown():
-    class Foo(HasSetup, SomeGivens):
-        pass
-
-    x = Foo()
-    x.give_me_an_int()
-    assert x.setups > 0
-    assert not hasattr(x, "teardowns")
-
-
-def test_tears_down_without_setup():
-    class Foo(HasTeardown, SomeGivens):
-        pass
-
-    x = Foo()
-    x.give_me_an_int()
-    assert x.teardowns > 0
-    assert not hasattr(x, "setups")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_shrink_budgeting.py Deleted

@@ -1,36 +0,0 @@
-# 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 math
-import sys
-from random import Random
-
-import pytest
-
-from hypothesis.internal.conjecture.shrinking import Integer, Lexical, Ordering
-
-
-def measure_baseline(cls, value, **kwargs):
-    shrinker = cls(value, lambda x: x == value, random=Random(0), **kwargs)
-    shrinker.run()
-    return shrinker.calls
-
-
-@pytest.mark.parametrize("cls", Lexical, Ordering)
-@pytest.mark.parametrize("example", 255 * 8)
-def test_meets_budgetary_requirements(cls, example):
-    # Somewhat arbitrary but not unreasonable budget.
-    n = len(example)
-    budget = n * math.ceil(math.log(n, 2)) + 5
-    assert measure_baseline(cls, example) <= budget
-
-
-def test_integer_shrinking_is_parsimonious():
-    assert measure_baseline(Integer, int(sys.float_info.max)) <= 10

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_simple_characters.py Deleted

@@ -1,145 +0,0 @@
-# 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 unicodedata
-
-import pytest
-
-from hypothesis.errors import InvalidArgument
-from hypothesis.strategies import characters
-
-from tests.common.debug import assert_no_examples, find_any, minimal
-from tests.common.utils import fails_with
-
-
-@fails_with(InvalidArgument)
-def test_nonexistent_category_argument():
-    characters(blacklist_categories="foo").example()
-
-
-def test_bad_codepoint_arguments():
-    with pytest.raises(InvalidArgument):
-        characters(min_codepoint=42, max_codepoint=24).example()
-
-
-def test_exclude_all_available_range():
-    with pytest.raises(InvalidArgument):
-        characters(
-            min_codepoint=ord("0"), max_codepoint=ord("0"), blacklist_characters="0"
-        ).example()
-
-
-def test_when_nothing_could_be_produced():
-    with pytest.raises(InvalidArgument):
-        characters(
-            whitelist_categories="Cc", min_codepoint=ord("0"), max_codepoint=ord("9")
-        ).example()
-
-
-def test_characters_of_specific_groups():
-    st = characters(whitelist_categories=("Lu", "Nd"))
-
-    find_any(st, lambda c: unicodedata.category(c) == "Lu")
-    find_any(st, lambda c: unicodedata.category(c) == "Nd")
-
-    assert_no_examples(st, lambda c: unicodedata.category(c) not in ("Lu", "Nd"))
-
-
-def test_characters_of_major_categories():
-    st = characters(whitelist_categories=("L", "N"))
-    find_any(st, lambda c: unicodedata.category(c).startswith("L"))
-    find_any(st, lambda c: unicodedata.category(c).startswith("N"))
-    assert_no_examples(st, lambda c: unicodedata.category(c)0 not in ("L", "N"))
-
-
-def test_exclude_characters_of_specific_groups():
-    st = characters(blacklist_categories=("Lu", "Nd"))
-
-    find_any(st, lambda c: unicodedata.category(c) != "Lu")
-    find_any(st, lambda c: unicodedata.category(c) != "Nd")
-
-    assert_no_examples(st, lambda c: unicodedata.category(c) in ("Lu", "Nd"))
-
-
-def test_exclude_characters_of_major_categories():
-    st = characters(blacklist_categories=("L", "N"))
-    find_any(st, lambda c: not unicodedata.category(c).startswith("L"))
-    find_any(st, lambda c: not unicodedata.category(c).startswith("N"))
-    assert_no_examples(st, lambda c: unicodedata.category(c)0 in ("L", "N"))
-
-
-def test_find_one():
-    char = minimal(characters(min_codepoint=48, max_codepoint=48), lambda _: True)
-    assert char == "0"
-
-
-def test_find_something_rare():
-    st = characters(whitelist_categories="Zs", min_codepoint=12288)
-
-    find_any(st, lambda c: unicodedata.category(c) == "Zs")
-
-    assert_no_examples(st, lambda c: unicodedata.category(c) != "Zs")
-
-
-def test_whitelisted_characters_alone():
-    with pytest.raises(InvalidArgument):
-        characters(whitelist_characters="te02тест49st").example()
-
-
-def test_whitelisted_characters_overlap_blacklisted_characters():
-    good_chars = "te02тест49st"
-    bad_chars = "ts94тсет"
-    with pytest.raises(InvalidArgument) as exc:
-        characters(
-            min_codepoint=ord("0"),
-            max_codepoint=ord("9"),
-            whitelist_characters=good_chars,
-            blacklist_characters=bad_chars,
-        ).example()
-        assert repr(good_chars) in str(exc)
-        assert repr(bad_chars) in str(exc)
-
-
-def test_whitelisted_characters_override():
-    good_characters = "teтестst"
-    st = characters(
-        min_codepoint=ord("0"),
-        max_codepoint=ord("9"),
-        whitelist_characters=good_characters,
-    )
-
-    find_any(st, lambda c: c in good_characters)
-    find_any(st, lambda c: c in "0123456789")
-
-    assert_no_examples(st, lambda c: c not in good_characters + "0123456789")
-
-
-def test_blacklisted_characters():
-    bad_chars = "te02тест49st"
-    st = characters(
-        min_codepoint=ord("0"), max_codepoint=ord("9"), blacklist_characters=bad_chars
-    )
-
-    assert "1" == minimal(st, lambda c: True)
-
-    assert_no_examples(st, lambda c: c in bad_chars)
-
-
-def test_whitelist_characters_disjoint_blacklist_characters():
-    good_chars = "123abc"
-    bad_chars = "456def"
-    st = characters(
-        min_codepoint=ord("0"),
-        max_codepoint=ord("9"),
-        blacklist_characters=bad_chars,
-        whitelist_characters=good_chars,
-    )
-
-    assert_no_examples(st, lambda c: c in bad_chars)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_simple_collections.py Deleted

@@ -1,184 +0,0 @@
-# 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/.
-
-from collections import OrderedDict
-from random import Random
-
-import pytest
-
-from hypothesis import given, settings
-from hypothesis.strategies import (
-    booleans,
-    dictionaries,
-    fixed_dictionaries,
-    frozensets,
-    integers,
-    lists,
-    none,
-    nothing,
-    sets,
-    text,
-    tuples,
-)
-
-from tests.common.debug import find_any, minimal
-from tests.common.utils import flaky
-
-
-@pytest.mark.parametrize(
-    ("col", "strat"),
-    
-        ((), tuples()),
-        (, lists(none(), max_size=0)),
-        (set(), sets(none(), max_size=0)),
-        (frozenset(), frozensets(none(), max_size=0)),
-        ({}, fixed_dictionaries({})),
-        ({}, fixed_dictionaries({}, optional={})),
-        (OrderedDict(), fixed_dictionaries(OrderedDict(), optional=OrderedDict())),
-        ({}, fixed_dictionaries({}, optional={1: booleans()})),
-        ({0: False}, fixed_dictionaries({0: booleans()}, optional={1: booleans()})),
-        ({}, fixed_dictionaries({}, optional={(): booleans(), 0: booleans()})),
-        (, lists(nothing())),
-        (, lists(nothing(), unique=True)),
-    ,
-)
-def test_find_empty_collection_gives_empty(col, strat):
-    assert minimal(strat, lambda x: True) == col
-
-
-@pytest.mark.parametrize(
-    ("coltype", "strat"), (list, lists), (set, sets), (frozenset, frozensets)
-)
-def test_find_non_empty_collection_gives_single_zero(coltype, strat):
-    assert minimal(strat(integers()), bool) == coltype((0,))
-
-
-@pytest.mark.parametrize(
-    ("coltype", "strat"), (list, lists), (set, sets), (frozenset, frozensets)
-)
-def test_minimizes_to_empty(coltype, strat):
-    assert minimal(strat(integers()), lambda x: True) == coltype()
-
-
-def test_minimizes_list_of_lists():
-    xs = minimal(lists(lists(booleans())), lambda x: any(x) and not all(x))
-    xs.sort()
-    assert xs == , False
-
-
-@given(sets(integers(0, 100), min_size=2, max_size=10))
-@settings(max_examples=100)
-def test_sets_are_size_bounded(xs):
-    assert 2 <= len(xs) <= 10
-
-
-def test_ordered_dictionaries_preserve_keys():
-    r = Random()
-    keys = list(range(100))
-    r.shuffle(keys)
-    x = fixed_dictionaries(OrderedDict((k, booleans()) for k in keys)).example()
-    assert list(x.keys()) == keys
-
-
-@given(fixed_dictionaries({}, optional={0: booleans(), 1: nothing(), 2: booleans()}))
-def test_fixed_dictionaries_with_optional_and_empty_keys(d):
-    assert 1 not in d
-
-
-@pytest.mark.parametrize("n", range(10))
-def test_lists_of_fixed_length(n):
-    assert minimal(lists(integers(), min_size=n, max_size=n), lambda x: True) == 0 * n
-
-
-@pytest.mark.parametrize("n", range(10))
-def test_sets_of_fixed_length(n):
-    x = minimal(sets(integers(), min_size=n, max_size=n), lambda x: True)
-    assert len(x) == n
-
-    if not n:
-        assert x == set()
-    else:
-        assert x == set(range(min(x), min(x) + n))
-
-
-@pytest.mark.parametrize("n", range(10))
-def test_dictionaries_of_fixed_length(n):
-    x = set(
-        minimal(
-            dictionaries(integers(), booleans(), min_size=n, max_size=n), lambda x: True
-        ).keys()
-    )
-
-    if not n:
-        assert x == set()
-    else:
-        assert x == set(range(min(x), min(x) + n))
-
-
-@pytest.mark.parametrize("n", range(10))
-def test_lists_of_lower_bounded_length(n):
-    x = minimal(lists(integers(), min_size=n), lambda x: sum(x) >= 2 * n)
-    assert n <= len(x) <= 2 * n
-    assert all(t >= 0 for t in x)
-    assert len(x) == n or all(t > 0 for t in x)
-    assert sum(x) == 2 * n
-
-
-@flaky(min_passes=1, max_runs=3)
-def test_can_find_unique_lists_of_non_set_order():
-    # This test checks that our strategy for unique lists doesn't accidentally
-    # depend on the iteration order of sets.
-    #
-    # Unfortunately, that means that *this* test has to rely on set iteration
-    # order. That makes it tricky to debug on CPython, because set iteration
-    # order changes every time the process is launched.
-    #
-    # To get around this, define the PYTHONHASHSEED environment variable to
-    # a consistent value. This could be 0, or it could be the PYTHONHASHSEED
-    # value listed in a failure log from CI.
-
-    ls = minimal(
-        lists(text(), min_size=2, unique=True),
-        lambda x: list(set(reversed(x))) != x,  # noqa: C414  # yes, reverse inside set
-    )
-    assert len(set(ls)) == len(ls)
-    assert len(ls) == 2
-
-
-def test_can_draw_empty_list_from_unsatisfiable_strategy():
-    assert find_any(lists(integers().filter(lambda s: False))) == 
-
-
-def test_can_draw_empty_set_from_unsatisfiable_strategy():
-    assert find_any(sets(integers().filter(lambda s: False))) == set()
-
-
-@given(lists(sets(none()), min_size=10))
-def test_small_sized_sets(x):
-    pass
-
-
-def test_minimize_dicts_with_incompatible_keys():
-    assert minimal(
-        fixed_dictionaries({1: booleans(), "hi": lists(booleans())}), lambda x: True
-    ) == {1: False, "hi": }
-
-
-@given(
-    lists(
-        tuples(integers(), integers()),
-        min_size=2,
-        unique_by=(lambda x: x0, lambda x: x1),
-    )
-)
-def test_lists_unique_by_tuple_funcs(ls):
-    firstitems, seconditems = zip(*ls)
-    assert len(set(firstitems)) == len(firstitems)
-    assert len(set(seconditems)) == len(seconditems)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_simple_strings.py Deleted

@@ -1,111 +0,0 @@
-# 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/.
-
-from hypothesis import given
-from hypothesis.strategies import binary, characters, text, tuples
-
-from tests.common.debug import minimal
-
-
-def test_can_minimize_up_to_zero():
-    s = minimal(text(), lambda x: any(lambda t: t <= "0" for t in x))
-    assert s == "0"
-
-
-def test_minimizes_towards_ascii_zero():
-    s = minimal(text(), lambda x: any(t < "0" for t in x))
-    assert s == chr(ord("0") - 1)
-
-
-def test_can_handle_large_codepoints():
-    s = minimal(text(), lambda x: x >= "☃")
-    assert s == "☃"
-
-
-def test_can_find_mixed_ascii_and_non_ascii_strings():
-    s = minimal(
-        text(), lambda x: (any(t >= "☃" for t in x) and any(ord(t) <= 127 for t in x))
-    )
-    assert len(s) == 2
-    assert sorted(s) == "0", "☃"
-
-
-def test_will_find_ascii_examples_given_the_chance():
-    s = minimal(
-        tuples(text(max_size=1), text(max_size=1)), lambda x: x0 and (x0 < x1)
-    )
-    assert ord(s1) == ord(s0) + 1
-    assert "0" in s
-
-
-def test_minimisation_consistent_with_characters():
-    s = minimal(text("FEDCBA", min_size=3))
-    assert s == "AAA"
-
-
-def test_finds_single_element_strings():
-    assert minimal(text(), bool) == "0"
-
-
-@given(binary(max_size=5))
-def test_binary_respects_max_size(x):
-    assert len(x) <= 5
-
-
-def test_does_not_simplify_into_surrogates():
-    f = minimal(text(), lambda x: x >= "\udfff")
-    assert f == "\ue000"
-
-    size = 5
-
-    f = minimal(text(min_size=size), lambda x: sum(t >= "\udfff" for t in x) >= size)
-    assert f == "\ue000" * size
-
-
-@given(text(alphabet="a", "b"))
-def test_respects_alphabet_if_list(xs):
-    assert set(xs).issubset(set("ab"))
-
-
-@given(text(alphabet="cdef"))
-def test_respects_alphabet_if_string(xs):
-    assert set(xs).issubset(set("cdef"))
-
-
-@given(text())
-def test_can_encode_as_utf8(s):
-    s.encode()
-
-
-@given(text(characters(blacklist_characters="\n")))
-def test_can_blacklist_newlines(s):
-    assert "\n" not in s
-
-
-@given(text(characters(blacklist_categories=("Cc", "Cs"))))
-def test_can_exclude_newlines_by_category(s):
-    assert "\n" not in s
-
-
-@given(text(characters(max_codepoint=127)))
-def test_can_restrict_to_ascii_only(s):
-    s.encode("ascii")
-
-
-def test_fixed_size_bytes_just_draw_bytes():
-    from hypothesis.internal.conjecture.data import ConjectureData
-
-    x = ConjectureData.for_buffer(b"foo")
-    assert x.draw(binary(min_size=3, max_size=3)) == b"foo"
-
-
-@given(text(max_size=10**6))
-def test_can_set_max_size_large(s):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_slices.py Deleted

@@ -1,106 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, settings, strategies as st
-
-from tests.common.debug import assert_all_examples, find_any, minimal
-
-use_several_sizes = pytest.mark.parametrize("size", 1, 2, 5, 10, 100, 1000)
-
-
-@use_several_sizes
-def test_stop_stays_within_bounds(size):
-    assert_all_examples(
-        st.slices(size),
-        lambda x: x.stop is None or (x.stop >= -size and x.stop <= size),
-    )
-
-
-@use_several_sizes
-def test_start_stay_within_bounds(size):
-    assert_all_examples(
-        st.slices(size).filter(lambda x: x.start is not None),
-        lambda x: range(size)x.start or True,  # no IndexError raised
-    )
-
-
-@use_several_sizes
-def test_step_stays_within_bounds(size):
-    # indices -> (start, stop, step)
-    # Stop is exclusive so we use -1 as the floor.
-    # This uses the indices that slice produces to make this test more readable
-    # due to how splice processes None being a little complex
-    assert_all_examples(
-        st.slices(size),
-        lambda x: (
-            x.indices(size)0 + x.indices(size)2 <= size
-            and x.indices(size)0 + x.indices(size)2 >= -size
-        )
-        or x.start % size == x.stop % size,
-    )
-
-
-@use_several_sizes
-def test_step_will_not_be_zero(size):
-    assert_all_examples(st.slices(size), lambda x: x.step != 0)
-
-
-@use_several_sizes
-def test_slices_will_shrink(size):
-    sliced = minimal(st.slices(size))
-    assert sliced.start == 0 or sliced.start is None
-    assert sliced.stop == 0 or sliced.stop is None
-    assert sliced.step is None
-
-
-@given(st.integers(1, 1000))
-@settings(deadline=None)
-def test_step_will_be_negative(size):
-    find_any(
-        st.slices(size), lambda x: (x.step or 1) < 0, settings(max_examples=10**6)
-    )
-
-
-@given(st.integers(1, 1000))
-@settings(deadline=None)
-def test_step_will_be_positive(size):
-    find_any(st.slices(size), lambda x: (x.step or 1) > 0)
-
-
-@pytest.mark.parametrize("size", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-def test_stop_will_equal_size(size):
-    find_any(st.slices(size), lambda x: x.stop == size, settings(max_examples=10**6))
-
-
-@pytest.mark.parametrize("size", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-def test_start_will_equal_size(size):
-    find_any(
-        st.slices(size), lambda x: x.start == size - 1, settings(max_examples=10**6)
-    )
-
-
-@given(st.integers(1, 1000))
-@settings(deadline=None)
-def test_start_will_equal_0(size):
-    find_any(st.slices(size), lambda x: x.start == 0)
-
-
-@given(st.integers(1, 1000))
-@settings(deadline=None)
-def test_start_will_equal_stop(size):
-    find_any(st.slices(size), lambda x: x.start == x.stop)
-
-
-def test_size_is_equal_0():
-    assert_all_examples(
-        st.slices(0), lambda x: x.step != 0 and x.start is None and x.stop is None
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_slippage.py Deleted

@@ -1,302 +0,0 @@
-# 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 pytest
-
-from hypothesis import Phase, assume, given, settings, strategies as st
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.errors import Flaky, MultipleFailures
-from hypothesis.internal.conjecture.engine import MIN_TEST_CALLS
-
-from tests.common.utils import (
-    assert_output_contains_failure,
-    capture_out,
-    non_covering_examples,
-)
-
-
-def test_raises_multiple_failures_with_varying_type():
-    target = None
-
-    @settings(database=None, max_examples=100)
-    @given(st.integers())
-    def test(i):
-        if abs(i) < 1000:
-            return
-        if target0 is None:
-            # Ensure that we have some space to shrink into, so we can't
-            # trigger an minimal example and mask the other exception type.
-            assume(1003 < abs(i))
-            target0 = i
-        exc_class = TypeError if target0 == i else ValueError
-        raise exc_class()
-
-    with capture_out() as o:
-        with pytest.raises(MultipleFailures):
-            test()
-
-    assert "TypeError" in o.getvalue()
-    assert "ValueError" in o.getvalue()
-
-
-def test_raises_multiple_failures_when_position_varies():
-    target = None
-
-    @settings(max_examples=100)
-    @given(st.integers())
-    def test(i):
-        if abs(i) < 1000:
-            return
-        if target0 is None:
-            target0 = i
-        if target0 == i:
-            raise ValueError("loc 1")
-        else:
-            raise ValueError("loc 2")
-
-    with capture_out() as o:
-        with pytest.raises(MultipleFailures):
-            test()
-    assert "loc 1" in o.getvalue()
-    assert "loc 2" in o.getvalue()
-
-
-def test_replays_both_failing_values():
-    target = None
-
-    @settings(database=InMemoryExampleDatabase(), max_examples=500)
-    @given(st.integers())
-    def test(i):
-        if abs(i) < 1000:
-            return
-        if target0 is None:
-            target0 = i
-        exc_class = TypeError if target0 == i else ValueError
-        raise exc_class()
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-
-@pytest.mark.parametrize("fix", TypeError, ValueError)
-def test_replays_slipped_examples_once_initial_bug_is_fixed(fix):
-    target = 
-    bug_fixed = False
-
-    @settings(database=InMemoryExampleDatabase(), max_examples=500)
-    @given(st.integers())
-    def test(i):
-        if abs(i) < 1000:
-            return
-        if not target:
-            target.append(i)
-        if i == target0:
-            if bug_fixed and fix == TypeError:
-                return
-            raise TypeError()
-        if len(target) == 1:
-            target.append(i)
-        if bug_fixed and fix == ValueError:
-            return
-        if i == target1:
-            raise ValueError()
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-    bug_fixed = True
-
-    with pytest.raises(ValueError if fix == TypeError else TypeError):
-        test()
-
-
-def test_garbage_collects_the_secondary_key():
-    target = 
-    bug_fixed = False
-
-    db = InMemoryExampleDatabase()
-
-    @settings(database=db, max_examples=500)
-    @given(st.integers())
-    def test(i):
-        if bug_fixed:
-            return
-        if abs(i) < 1000:
-            return
-        if not target:
-            target.append(i)
-        if i == target0:
-            raise TypeError()
-        if len(target) == 1:
-            target.append(i)
-        if i == target1:
-            raise ValueError()
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-    bug_fixed = True
-
-    def count():
-        return len(non_covering_examples(db))
-
-    prev = count()
-    while prev > 0:
-        test()
-        current = count()
-        assert current < prev
-        prev = current
-
-
-def test_shrinks_both_failures():
-    first_has_failed = False
-    duds = set()
-    second_target = None
-
-    @settings(database=None, max_examples=1000)
-    @given(st.integers(min_value=0).map(int))
-    def test(i):
-        if i >= 10000:
-            first_has_failed0 = True
-            raise AssertionError
-        assert i < 10000
-        if first_has_failed0:
-            if second_target0 is None:
-                for j in range(10000):
-                    if j not in duds:
-                        second_target0 = j
-                        break
-            assert i < second_target0
-        else:
-            duds.add(i)
-
-    with capture_out() as o:
-        with pytest.raises(MultipleFailures):
-            test()
-
-    output = o.getvalue()
-    assert_output_contains_failure(output, test, i=10000)
-    assert_output_contains_failure(output, test, i=second_target0)
-
-
-def test_handles_flaky_tests_where_only_one_is_flaky():
-    flaky_fixed = False
-
-    target = 
-    flaky_failed_once = False
-
-    @settings(database=InMemoryExampleDatabase(), max_examples=1000)
-    @given(st.integers())
-    def test(i):
-        if abs(i) < 1000:
-            return
-        if not target:
-            target.append(i)
-        if i == target0:
-            raise TypeError()
-        if flaky_failed_once0 and not flaky_fixed:
-            return
-        if len(target) == 1:
-            target.append(i)
-        if i == target1:
-            flaky_failed_once0 = True
-            raise ValueError()
-
-    with pytest.raises(Flaky):
-        test()
-
-    flaky_fixed = True
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-
-@pytest.mark.parametrize("allow_multi", True, False)
-def test_can_disable_multiple_error_reporting(allow_multi):
-    seen = set()
-
-    @settings(database=None, derandomize=True, report_multiple_bugs=allow_multi)
-    @given(st.integers(min_value=0))
-    def test(i):
-        # We will pass on the minimal i=0, then fail with a large i, and eventually
-        # slip to i=1 and a different error.  We check both seen and raised errors.
-        if i == 1:
-            seen.add(TypeError)
-            raise TypeError
-        elif i >= 2:
-            seen.add(ValueError)
-            raise ValueError
-
-    with pytest.raises(MultipleFailures if allow_multi else TypeError):
-        test()
-    assert seen == {TypeError, ValueError}
-
-
-def test_finds_multiple_failures_in_generation():
-    special = 
-    seen = set()
-
-    @settings(phases=Phase.generate, Phase.shrink, max_examples=100)
-    @given(st.integers(min_value=0))
-    def test(x):
-        """Constructs a test so the 10th largeish example we've seen is a
-        special failure, and anything new we see after that point that
-        is larger than it is a different failure. This demonstrates that we
-        can keep generating larger examples and still find new bugs after that
-        point."""
-        if not special:
-            if len(seen) >= 10 and x <= 1000:
-                special.append(x)
-            else:
-                seen.add(x)
-        if special:
-            assert x in seen or (x <= special0)
-        assert x not in special
-
-    with pytest.raises(MultipleFailures):
-        test()
-
-
-def test_stops_immediately_if_not_report_multiple_bugs():
-    seen = set()
-
-    @settings(phases=Phase.generate, report_multiple_bugs=False)
-    @given(st.integers())
-    def test(x):
-        seen.add(x)
-        raise AssertionError
-
-    with pytest.raises(AssertionError):
-        test()
-    assert len(seen) == 1
-
-
-def test_stops_immediately_on_replay():
-    seen = set()
-
-    @settings(database=InMemoryExampleDatabase())
-    @given(st.integers())
-    def test(x):
-        seen.add(x)
-        assert x
-
-    # On the first run, we look for up to ten examples:
-    with pytest.raises(AssertionError):
-        test()
-    assert 1 < len(seen) <= MIN_TEST_CALLS
-
-    # With failing examples in the database, we stop at one.
-    seen.clear()
-    with pytest.raises(AssertionError):
-        test()
-    assert len(seen) == 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_stateful.py Deleted

@@ -1,1201 +0,0 @@
-# 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 base64
-from collections import defaultdict
-
-import pytest
-from _pytest.outcomes import Failed, Skipped
-from pytest import raises
-
-from hypothesis import __version__, reproduce_failure, seed, settings as Settings
-from hypothesis.control import current_build_context
-from hypothesis.database import ExampleDatabase
-from hypothesis.errors import DidNotReproduce, Flaky, InvalidArgument, InvalidDefinition
-from hypothesis.internal.entropy import deterministic_PRNG
-from hypothesis.stateful import (
-    Bundle,
-    RuleBasedStateMachine,
-    consumes,
-    initialize,
-    invariant,
-    multiple,
-    precondition,
-    rule,
-    run_state_machine_as_test,
-)
-from hypothesis.strategies import binary, data, integers, just, lists
-
-from tests.common.utils import capture_out, validate_deprecation
-from tests.nocover.test_stateful import DepthMachine
-
-NO_BLOB_SETTINGS = Settings(print_blob=False)
-
-
-class MultipleRulesSameFuncMachine(RuleBasedStateMachine):
-    def myfunc(self, data):
-        print(data)
-
-    rule1 = rule(data=just("rule1data"))(myfunc)
-    rule2 = rule(data=just("rule2data"))(myfunc)
-
-
-class PreconditionMachine(RuleBasedStateMachine):
-    num = 0
-
-    @rule()
-    def add_one(self):
-        self.num += 1
-
-    @rule()
-    def set_to_zero(self):
-        self.num = 0
-
-    @rule(num=integers())
-    @precondition(lambda self: self.num != 0)
-    def div_by_precondition_after(self, num):
-        self.num = num / self.num
-
-    @precondition(lambda self: self.num != 0)
-    @rule(num=integers())
-    def div_by_precondition_before(self, num):
-        self.num = num / self.num
-
-
-TestPrecondition = PreconditionMachine.TestCase
-TestPrecondition.settings = Settings(TestPrecondition.settings, max_examples=10)
-
-
-def test_picks_up_settings_at_first_use_of_testcase():
-    assert TestPrecondition.settings.max_examples == 10
-
-
-def test_multiple_rules_same_func():
-    test_class = MultipleRulesSameFuncMachine.TestCase
-    with capture_out() as o:
-        test_class().runTest()
-    output = o.getvalue()
-    assert "rule1data" in output
-    assert "rule2data" in output
-
-
-def test_can_get_test_case_off_machine_instance():
-    assert DepthMachine().TestCase is DepthMachine().TestCase
-    assert DepthMachine().TestCase is not None
-
-
-class FlakyDrawLessMachine(RuleBasedStateMachine):
-    @rule(d=data())
-    def action(self, d):
-        if current_build_context().is_final:
-            d.draw(binary(min_size=1, max_size=1))
-        else:
-            buffer = binary(min_size=1024, max_size=1024)
-            assert 0 not in buffer
-
-
-def test_flaky_draw_less_raises_flaky():
-    with raises(Flaky):
-        FlakyDrawLessMachine.TestCase().runTest()
-
-
-class FlakyStateMachine(RuleBasedStateMachine):
-    @rule()
-    def action(self):
-        assert current_build_context().is_final
-
-
-def test_flaky_raises_flaky():
-    with raises(Flaky):
-        FlakyStateMachine.TestCase().runTest()
-
-
-class FlakyRatchettingMachine(RuleBasedStateMachine):
-    ratchet = 0
-
-    @rule(d=data())
-    def action(self, d):
-        FlakyRatchettingMachine.ratchet += 1
-        n = FlakyRatchettingMachine.ratchet
-        d.draw(lists(integers(), min_size=n, max_size=n))
-        raise AssertionError
-
-
-class MachineWithConsumingRule(RuleBasedStateMachine):
-    b1 = Bundle("b1")
-    b2 = Bundle("b2")
-
-    def __init__(self):
-        self.created_counter = 0
-        self.consumed_counter = 0
-        super().__init__()
-
-    @invariant()
-    def bundle_length(self):
-        assert len(self.bundle("b1")) == self.created_counter - self.consumed_counter
-
-    @rule(target=b1)
-    def populate_b1(self):
-        self.created_counter += 1
-        return self.created_counter
-
-    @rule(target=b2, consumed=consumes(b1))
-    def depopulate_b1(self, consumed):
-        self.consumed_counter += 1
-        return consumed
-
-    @rule(consumed=lists(consumes(b1)))
-    def depopulate_b1_multiple(self, consumed):
-        self.consumed_counter += len(consumed)
-
-    @rule(value1=b1, value2=b2)
-    def check(self, value1, value2):
-        assert value1 != value2
-
-
-TestMachineWithConsumingRule = MachineWithConsumingRule.TestCase
-
-
-def test_multiple():
-    none = multiple()
-    some = multiple(1, 2.01, "3", b"4", 5)
-    assert len(none.values) == 0 and len(some.values) == 5
-    assert set(some.values) == {1, 2.01, "3", b"4", 5}
-
-
-class MachineUsingMultiple(RuleBasedStateMachine):
-    b = Bundle("b")
-
-    def __init__(self):
-        self.expected_bundle_length = 0
-        super().__init__()
-
-    @invariant()
-    def bundle_length(self):
-        assert len(self.bundle("b")) == self.expected_bundle_length
-
-    @rule(target=b, items=lists(elements=integers(), max_size=10))
-    def populate_bundle(self, items):
-        self.expected_bundle_length += len(items)
-        return multiple(*items)
-
-    @rule(target=b)
-    def do_not_populate(self):
-        return multiple()
-
-
-TestMachineUsingMultiple = MachineUsingMultiple.TestCase
-
-
-def test_multiple_variables_printed():
-    class ProducesMultiple(RuleBasedStateMachine):
-        b = Bundle("b")
-
-        @initialize(target=b)
-        def populate_bundle(self):
-            return multiple(1, 2)
-
-        @rule()
-        def fail_fast(self):
-            raise AssertionError
-
-    with capture_out() as o:
-        # The state machine must raise an exception for the
-        # falsifying example to be printed.
-        with raises(AssertionError):
-            run_state_machine_as_test(ProducesMultiple)
-
-    # This is tightly coupled to the output format of the step printing.
-    # The first line is "Falsifying Example:..." the second is creating
-    # the state machine, the third is calling the "initialize" method.
-    assignment_line = o.getvalue().split("\n")2
-    # 'populate_bundle()' returns 2 values, so should be
-    # expanded to 2 variables.
-    assert assignment_line == "v1, v2 = state.populate_bundle()"
-
-    # Make sure MultipleResult is iterable so the printed code is valid.
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2311
-    state = ProducesMultiple()
-    v1, v2 = state.populate_bundle()
-    with raises(AssertionError):
-        state.fail_fast()
-
-
-def test_multiple_variables_printed_single_element():
-    # https://github.com/HypothesisWorks/hypothesis/issues/3236
-    class ProducesMultiple(RuleBasedStateMachine):
-        b = Bundle("b")
-
-        @initialize(target=b)
-        def populate_bundle(self):
-            return multiple(1)
-
-        @rule(b=b)
-        def fail_fast(self, b):
-            assert b != 1
-
-    with capture_out() as o, raises(AssertionError):
-        run_state_machine_as_test(ProducesMultiple)
-
-    assignment_line = o.getvalue().split("\n")2
-    assert assignment_line == "(v1,) = state.populate_bundle()"
-
-    state = ProducesMultiple()
-    (v1,) = state.populate_bundle()
-    state.fail_fast((v1,))  # passes if tuple not unpacked
-    with raises(AssertionError):
-        state.fail_fast(v1)
-
-
-def test_no_variables_printed():
-    class ProducesNoVariables(RuleBasedStateMachine):
-        b = Bundle("b")
-
-        @initialize(target=b)
-        def populate_bundle(self):
-            return multiple()
-
-        @rule()
-        def fail_fast(self):
-            raise AssertionError
-
-    with capture_out() as o:
-        # The state machine must raise an exception for the
-        # falsifying example to be printed.
-        with raises(AssertionError):
-            run_state_machine_as_test(ProducesNoVariables)
-
-    # This is tightly coupled to the output format of the step printing.
-    # The first line is "Falsifying Example:..." the second is creating
-    # the state machine, the third is calling the "initialize" method.
-    assignment_line = o.getvalue().split("\n")2
-    # 'populate_bundle()' returns 0 values, so there should be no
-    # variable assignment.
-    assert assignment_line == "state.populate_bundle()"
-
-
-def test_consumes_typecheck():
-    with pytest.raises(TypeError):
-        consumes(integers())
-
-
-def test_ratchetting_raises_flaky():
-    with raises(Flaky):
-        FlakyRatchettingMachine.TestCase().runTest()
-
-
-def test_empty_machine_is_invalid():
-    class EmptyMachine(RuleBasedStateMachine):
-        pass
-
-    with raises(InvalidDefinition):
-        EmptyMachine.TestCase().runTest()
-
-
-def test_machine_with_no_terminals_is_invalid():
-    class NonTerminalMachine(RuleBasedStateMachine):
-        @rule(value=Bundle("hi"))
-        def bye(self, hi):
-            pass
-
-    with raises(InvalidDefinition):
-        NonTerminalMachine.TestCase().runTest()
-
-
-def test_minimizes_errors_in_teardown():
-    counter = 0
-
-    class Foo(RuleBasedStateMachine):
-        @initialize()
-        def init(self):
-            counter0 = 0
-
-        @rule()
-        def increment(self):
-            counter0 += 1
-
-        def teardown(self):
-            assert not counter0
-
-    with raises(AssertionError):
-        run_state_machine_as_test(Foo)
-    assert counter0 == 1
-
-
-class RequiresInit(RuleBasedStateMachine):
-    def __init__(self, threshold):
-        super().__init__()
-        self.threshold = threshold
-
-    @rule(value=integers())
-    def action(self, value):
-        if value > self.threshold:
-            raise ValueError(f"{value} is too high")
-
-
-def test_can_use_factory_for_tests():
-    with raises(ValueError):
-        run_state_machine_as_test(
-            lambda: RequiresInit(42), settings=Settings(max_examples=100)
-        )
-
-
-class FailsEventually(RuleBasedStateMachine):
-    def __init__(self):
-        super().__init__()
-        self.counter = 0
-
-    @rule()
-    def increment(self):
-        self.counter += 1
-        assert self.counter < 10
-
-
-FailsEventually.TestCase.settings = Settings(stateful_step_count=5)
-
-
-def test_can_explicitly_pass_settings():
-    run_state_machine_as_test(FailsEventually)
-    try:
-        FailsEventually.TestCase.settings = Settings(
-            FailsEventually.TestCase.settings, stateful_step_count=15
-        )
-        run_state_machine_as_test(
-            FailsEventually, settings=Settings(stateful_step_count=2)
-        )
-    finally:
-        FailsEventually.TestCase.settings = Settings(
-            FailsEventually.TestCase.settings, stateful_step_count=5
-        )
-
-
-def test_settings_argument_is_validated():
-    with pytest.raises(InvalidArgument):
-        run_state_machine_as_test(FailsEventually, settings=object())
-
-
-def test_runner_that_checks_factory_produced_a_machine():
-    with pytest.raises(InvalidArgument):
-        run_state_machine_as_test(object)
-
-
-def test_settings_attribute_is_validated():
-    real_settings = FailsEventually.TestCase.settings
-    try:
-        FailsEventually.TestCase.settings = object()
-        with pytest.raises(InvalidArgument):
-            run_state_machine_as_test(FailsEventually)
-    finally:
-        FailsEventually.TestCase.settings = real_settings
-
-
-def test_saves_failing_example_in_database():
-    db = ExampleDatabase(":memory:")
-    with raises(AssertionError):
-        run_state_machine_as_test(
-            DepthMachine, settings=Settings(database=db, max_examples=100)
-        )
-    assert any(list(db.data.values()))
-
-
-def test_can_run_with_no_db():
-    with deterministic_PRNG(), raises(AssertionError):
-        run_state_machine_as_test(
-            DepthMachine, settings=Settings(database=None, max_examples=10_000)
-        )
-
-
-def test_stateful_double_rule_is_forbidden(recwarn):
-    with pytest.raises(InvalidDefinition):
-
-        class DoubleRuleMachine(RuleBasedStateMachine):
-            @rule(num=just(1))
-            @rule(num=just(2))
-            def whatevs(self, num):
-                pass
-
-
-def test_can_explicitly_call_functions_when_precondition_not_satisfied():
-    class BadPrecondition(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-
-        @precondition(lambda self: False)
-        @rule()
-        def test_blah(self):
-            raise ValueError()
-
-        @rule()
-        def test_foo(self):
-            self.test_blah()
-
-    with pytest.raises(ValueError):
-        run_state_machine_as_test(BadPrecondition)
-
-
-def test_invariant():
-    """If an invariant raise an exception, the exception is propagated."""
-
-    class Invariant(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-
-        @invariant()
-        def test_blah(self):
-            raise ValueError()
-
-        @rule()
-        def do_stuff(self):
-            pass
-
-    with pytest.raises(ValueError):
-        run_state_machine_as_test(Invariant)
-
-
-def test_no_double_invariant():
-    """The invariant decorator can't be applied multiple times to a single
-    function."""
-    with raises(InvalidDefinition):
-
-        class Invariant(RuleBasedStateMachine):
-            def __init__(self):
-                super().__init__()
-
-            @invariant()
-            @invariant()
-            def test_blah(self):
-                pass
-
-            @rule()
-            def do_stuff(self):
-                pass
-
-
-def test_invariant_precondition():
-    """If an invariant precodition isn't met, the invariant isn't run.
-
-    The precondition decorator can be applied in any order.
-    """
-
-    class Invariant(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-
-        @invariant()
-        @precondition(lambda _: False)
-        def an_invariant(self):
-            raise ValueError()
-
-        @precondition(lambda _: False)
-        @invariant()
-        def another_invariant(self):
-            raise ValueError()
-
-        @rule()
-        def do_stuff(self):
-            pass
-
-    run_state_machine_as_test(Invariant)
-
-
-@pytest.mark.parametrize(
-    "decorators",
-    
-        (invariant(), rule()),
-        (rule(), invariant()),
-        (invariant(), initialize()),
-        (initialize(), invariant()),
-        (invariant(), precondition(lambda self: True), rule()),
-        (rule(), precondition(lambda self: True), invariant()),
-        (precondition(lambda self: True), invariant(), rule()),
-        (precondition(lambda self: True), rule(), invariant()),
-    ,
-    ids=lambda x: "-".join(f.__qualname__.split(".")0 for f in x),
-)
-def test_invariant_and_rule_are_incompatible(decorators):
-    """It's an error to apply @invariant and @rule to the same method."""
-
-    def method(self):
-        pass
-
-    for d in decorators:-1:
-        method = d(method)
-    with pytest.raises(InvalidDefinition):
-        decorators-1(method)
-
-
-def test_invalid_rule_argument():
-    """Rule kwargs that are not a Strategy are expected to raise an InvalidArgument error."""
-    with pytest.raises(InvalidArgument):
-
-        class InvalidRuleMachine(RuleBasedStateMachine):
-            @rule(strategy=object())
-            def do_stuff(self):
-                pass
-
-
-def test_invalid_initialize_argument():
-    """Initialize kwargs that are not a Strategy are expected to raise an InvalidArgument error."""
-    with pytest.raises(InvalidArgument):
-
-        class InvalidInitialize(RuleBasedStateMachine):
-            @initialize(strategy=object())
-            def initialize(self):
-                pass
-
-
-def test_multiple_invariants():
-    """If multiple invariants are present, they all get run."""
-
-    class Invariant(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-            self.first_invariant_ran = False
-
-        @invariant()
-        def invariant_1(self):
-            self.first_invariant_ran = True
-
-        @precondition(lambda self: self.first_invariant_ran)
-        @invariant()
-        def invariant_2(self):
-            raise ValueError()
-
-        @rule()
-        def do_stuff(self):
-            pass
-
-    with pytest.raises(ValueError):
-        run_state_machine_as_test(Invariant)
-
-
-def test_explicit_invariant_call_with_precondition():
-    """Invariants can be called explicitly even if their precondition is not
-    satisfied."""
-
-    class BadPrecondition(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-
-        @precondition(lambda self: False)
-        @invariant()
-        def test_blah(self):
-            raise ValueError()
-
-        @rule()
-        def test_foo(self):
-            self.test_blah()
-
-    with pytest.raises(ValueError):
-        run_state_machine_as_test(BadPrecondition)
-
-
-def test_invariant_checks_initial_state_if_no_initialize_rules():
-    """Invariants are checked before any rules run."""
-
-    class BadPrecondition(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-            self.num = 0
-
-        @invariant()
-        def test_blah(self):
-            if self.num == 0:
-                raise ValueError()
-
-        @rule()
-        def test_foo(self):
-            self.num += 1
-
-    with pytest.raises(ValueError):
-        run_state_machine_as_test(BadPrecondition)
-
-
-def test_invariant_failling_present_in_falsifying_example():
-    @Settings(print_blob=False)
-    class BadInvariant(RuleBasedStateMachine):
-        @initialize()
-        def initialize_1(self):
-            pass
-
-        @invariant()
-        def invariant_1(self):
-            raise ValueError()
-
-        @rule()
-        def rule_1(self):
-            pass
-
-    with capture_out() as o:
-        with pytest.raises(ValueError):
-            run_state_machine_as_test(BadInvariant)
-
-    result = o.getvalue()
-    assert (
-        result
-        == """\
-Falsifying example:
-state = BadInvariant()
-state.initialize_1()
-state.invariant_1()
-state.teardown()
-"""
-    )
-
-
-def test_invariant_present_in_falsifying_example():
-    @Settings(print_blob=False)
-    class BadRuleWithGoodInvariants(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-            self.num = 0
-
-        @initialize()
-        def initialize_1(self):
-            pass
-
-        @invariant(check_during_init=True)
-        def invariant_1(self):
-            pass
-
-        @invariant(check_during_init=False)
-        def invariant_2(self):
-            pass
-
-        @precondition(lambda self: self.num > 0)
-        @invariant()
-        def invariant_3(self):
-            pass
-
-        @rule()
-        def rule_1(self):
-            self.num += 1
-            if self.num == 2:
-                raise ValueError()
-
-    with capture_out() as o:
-        with pytest.raises(ValueError):
-            run_state_machine_as_test(BadRuleWithGoodInvariants)
-
-    result = o.getvalue()
-    assert (
-        result
-        == """\
-Falsifying example:
-state = BadRuleWithGoodInvariants()
-state.invariant_1()
-state.initialize_1()
-state.invariant_1()
-state.invariant_2()
-state.rule_1()
-state.invariant_1()
-state.invariant_2()
-state.invariant_3()
-state.rule_1()
-state.teardown()
-"""
-    )
-
-
-def test_always_runs_at_least_one_step():
-    class CountSteps(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-            self.count = 0
-
-        @rule()
-        def do_something(self):
-            self.count += 1
-
-        def teardown(self):
-            assert self.count > 0
-
-    run_state_machine_as_test(CountSteps)
-
-
-def test_removes_needless_steps():
-    """Regression test from an example based on
-    tests/nocover/test_database_agreement.py, but without the expensive bits.
-    Comparing two database implementations in which deletion is broken, so as
-    soon as a key/value pair is successfully deleted the test will now fail if
-    you ever check that key.
-
-    The main interesting feature of this is that it has a lot of
-    opportunities to generate keys and values before it actually fails,
-    but will still fail with very high probability.
-    """
-
-    @Settings(derandomize=True, max_examples=1000, deadline=None)
-    class IncorrectDeletion(RuleBasedStateMachine):
-        def __init__(self):
-            super().__init__()
-            self.__saved = defaultdict(set)
-            self.__deleted = defaultdict(set)
-
-        keys = Bundle("keys")
-        values = Bundle("values")
-
-        @rule(target=keys, k=binary())
-        def k(self, k):
-            return k
-
-        @rule(target=values, v=binary())
-        def v(self, v):
-            return v
-
-        @rule(k=keys, v=values)
-        def save(self, k, v):
-            self.__savedk.add(v)
-
-        @rule(k=keys, v=values)
-        def delete(self, k, v):
-            if v in self.__savedk:
-                self.__deletedk.add(v)
-
-        @rule(k=keys)
-        def values_agree(self, k):
-            assert not self.__deletedk
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(IncorrectDeletion)
-
-    assert o.getvalue().count(" = state.k(") == 1
-    assert o.getvalue().count(" = state.v(") == 1
-
-
-def test_prints_equal_values_with_correct_variable_name():
-    @Settings(max_examples=100)
-    class MovesBetweenBundles(RuleBasedStateMachine):
-        b1 = Bundle("b1")
-        b2 = Bundle("b2")
-
-        @rule(target=b1)
-        def create(self):
-            return 
-
-        @rule(target=b2, source=b1)
-        def transfer(self, source):
-            return source
-
-        @rule(source=b2)
-        def fail(self, source):
-            raise AssertionError
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(MovesBetweenBundles)
-
-    result = o.getvalue()
-    for m in "create", "transfer", "fail":
-        assert result.count("state." + m) == 1
-    assert "v1 = state.create()" in result
-    assert "v2 = state.transfer(source=v1)" in result
-    assert "state.fail(source=v2)" in result
-
-
-def test_initialize_rule():
-    @Settings(max_examples=1000)
-    class WithInitializeRules(RuleBasedStateMachine):
-        initialized = 
-
-        @initialize()
-        def initialize_a(self):
-            self.initialized.append("a")
-
-        @initialize()
-        def initialize_b(self):
-            self.initialized.append("b")
-
-        @initialize()
-        def initialize_c(self):
-            self.initialized.append("c")
-
-        @rule()
-        def fail_fast(self):
-            raise AssertionError
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(WithInitializeRules)
-
-    assert set(WithInitializeRules.initialized-3:) == {"a", "b", "c"}
-    result = o.getvalue().splitlines()1:
-    assert result0 == "state = WithInitializeRules()"
-    # Initialize rules call order is shuffled
-    assert {result1, result2, result3} == {
-        "state.initialize_a()",
-        "state.initialize_b()",
-        "state.initialize_c()",
-    }
-    assert result4 == "state.fail_fast()"
-    assert result5 == "state.teardown()"
-
-
-def test_initialize_rule_populate_bundle():
-    class WithInitializeBundleRules(RuleBasedStateMachine):
-        a = Bundle("a")
-
-        @initialize(target=a, dep=just("dep"))
-        def initialize_a(self, dep):
-            return f"a v1 with ({dep})"
-
-        @rule(param=a)
-        def fail_fast(self, param):
-            raise AssertionError
-
-    WithInitializeBundleRules.TestCase.settings = NO_BLOB_SETTINGS
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(WithInitializeBundleRules)
-
-    result = o.getvalue()
-    assert (
-        result
-        == """\
-Falsifying example:
-state = WithInitializeBundleRules()
-v1 = state.initialize_a(dep='dep')
-state.fail_fast(param=v1)
-state.teardown()
-"""
-    )
-
-
-def test_initialize_rule_dont_mix_with_precondition():
-    with pytest.raises(InvalidDefinition) as exc:
-
-        class BadStateMachine(RuleBasedStateMachine):
-            @precondition(lambda self: True)
-            @initialize()
-            def initialize(self):
-                pass
-
-    assert "An initialization rule cannot have a precondition." in str(exc.value)
-
-    # Also test decorator application in reverse order
-
-    with pytest.raises(InvalidDefinition) as exc:
-
-        class BadStateMachineReverseOrder(RuleBasedStateMachine):
-            @initialize()
-            @precondition(lambda self: True)
-            def initialize(self):
-                pass
-
-    assert "An initialization rule cannot have a precondition." in str(exc.value)
-
-
-def test_initialize_rule_dont_mix_with_regular_rule():
-    with pytest.raises(InvalidDefinition) as exc:
-
-        class BadStateMachine(RuleBasedStateMachine):
-            @rule()
-            @initialize()
-            def initialize(self):
-                pass
-
-    assert "A function cannot be used for two distinct rules." in str(exc.value)
-
-
-def test_initialize_rule_cannot_be_double_applied():
-    with pytest.raises(InvalidDefinition) as exc:
-
-        class BadStateMachine(RuleBasedStateMachine):
-            @initialize()
-            @initialize()
-            def initialize(self):
-                pass
-
-    assert "A function cannot be used for two distinct rules." in str(exc.value)
-
-
-def test_initialize_rule_in_state_machine_with_inheritance():
-    class ParentStateMachine(RuleBasedStateMachine):
-        initialized = 
-
-        @initialize()
-        def initialize_a(self):
-            self.initialized.append("a")
-
-    class ChildStateMachine(ParentStateMachine):
-        @initialize()
-        def initialize_b(self):
-            self.initialized.append("b")
-
-        @rule()
-        def fail_fast(self):
-            raise AssertionError
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(ChildStateMachine)
-
-    assert set(ChildStateMachine.initialized-2:) == {"a", "b"}
-    result = o.getvalue().splitlines()1:
-    assert result0 == "state = ChildStateMachine()"
-    # Initialize rules call order is shuffled
-    assert {result1, result2} == {"state.initialize_a()", "state.initialize_b()"}
-    assert result3 == "state.fail_fast()"
-    assert result4 == "state.teardown()"
-
-
-def test_can_manually_call_initialize_rule():
-    class StateMachine(RuleBasedStateMachine):
-        initialize_called_counter = 0
-
-        @initialize()
-        def initialize(self):
-            self.initialize_called_counter += 1
-
-        @rule()
-        def fail_eventually(self):
-            self.initialize()
-            assert self.initialize_called_counter <= 2
-
-    StateMachine.TestCase.settings = NO_BLOB_SETTINGS
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(StateMachine)
-
-    result = o.getvalue()
-    assert (
-        result
-        == """\
-Falsifying example:
-state = StateMachine()
-state.initialize()
-state.fail_eventually()
-state.fail_eventually()
-state.teardown()
-"""
-    )
-
-
-def test_steps_printed_despite_pytest_fail(capsys):
-    # Test for https://github.com/HypothesisWorks/hypothesis/issues/1372
-    class RaisesProblem(RuleBasedStateMachine):
-        @rule()
-        def oops(self):
-            pytest.fail()
-
-    with pytest.raises(Failed):
-        run_state_machine_as_test(RaisesProblem)
-    out, _ = capsys.readouterr()
-    assert (
-        """\
-Falsifying example:
-state = RaisesProblem()
-state.oops()
-state.teardown()
-"""
-        in out
-    )
-
-
-def test_steps_not_printed_with_pytest_skip(capsys):
-    class RaisesProblem(RuleBasedStateMachine):
-        @rule()
-        def skip_whole_test(self):
-            pytest.skip()
-
-    with pytest.raises(Skipped):
-        run_state_machine_as_test(RaisesProblem)
-    out, _ = capsys.readouterr()
-    assert "state" not in out
-
-
-def test_rule_deprecation_targets_and_target():
-    k, v = Bundle("k"), Bundle("v")
-    with pytest.raises(InvalidArgument):
-        rule(targets=(k,), target=v)
-
-
-def test_rule_deprecation_bundle_by_name():
-    Bundle("k")
-    with pytest.raises(InvalidArgument):
-        rule(target="k")
-
-
-def test_rule_non_bundle_target():
-    with pytest.raises(InvalidArgument):
-        rule(target=integers())
-
-
-def test_rule_non_bundle_target_oneof():
-    k, v = Bundle("k"), Bundle("v")
-    pattern = r".+ `one_of(a, b)` or `a | b` .+"
-    with pytest.raises(InvalidArgument, match=pattern):
-        rule(target=k | v)
-
-
-def test_uses_seed(capsys):
-    @seed(0)
-    class TrivialMachine(RuleBasedStateMachine):
-        @rule()
-        def oops(self):
-            raise AssertionError
-
-    with pytest.raises(AssertionError):
-        run_state_machine_as_test(TrivialMachine)
-    out, _ = capsys.readouterr()
-    assert "@seed" not in out
-
-
-def test_reproduce_failure_works():
-    @reproduce_failure(__version__, base64.b64encode(b"\x00\x00\x01\x00\x00\x00"))
-    class TrivialMachine(RuleBasedStateMachine):
-        @rule()
-        def oops(self):
-            raise AssertionError
-
-    with pytest.raises(AssertionError):
-        run_state_machine_as_test(TrivialMachine, settings=Settings(print_blob=True))
-
-
-def test_reproduce_failure_fails_if_no_error():
-    @reproduce_failure(__version__, base64.b64encode(b"\x00\x00\x01\x00\x00\x00"))
-    class TrivialMachine(RuleBasedStateMachine):
-        @rule()
-        def ok(self):
-            pass
-
-    with pytest.raises(DidNotReproduce):
-        run_state_machine_as_test(TrivialMachine, settings=Settings(print_blob=True))
-
-
-def test_cannot_have_zero_steps():
-    with pytest.raises(InvalidArgument):
-        Settings(stateful_step_count=0)
-
-
-def test_arguments_do_not_use_names_of_return_values():
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2341
-    class TrickyPrintingMachine(RuleBasedStateMachine):
-        data = Bundle("data")
-
-        @initialize(target=data, value=integers())
-        def init_data(self, value):
-            return value
-
-        @rule(d=data)
-        def mostly_fails(self, d):
-            assert d == 42
-
-    with capture_out() as o:
-        with pytest.raises(AssertionError):
-            run_state_machine_as_test(TrickyPrintingMachine)
-    output = o.getvalue()
-    assert "v1 = state.init_data(value=0)" in output
-    assert "v1 = state.init_data(value=v1)" not in output
-
-
-def test_multiple_precondition_bug():
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2861
-    class MultiplePreconditionMachine(RuleBasedStateMachine):
-        @rule(x=integers())
-        def good_method(self, x):
-            pass
-
-        @precondition(lambda self: True)
-        @precondition(lambda self: False)
-        @rule(x=integers())
-        def bad_method_a(self, x):
-            raise AssertionError("This rule runs, even though it shouldn't.")
-
-        @precondition(lambda self: False)
-        @precondition(lambda self: True)
-        @rule(x=integers())
-        def bad_method_b(self, x):
-            raise AssertionError("This rule might be skipped for the wrong reason.")
-
-        @precondition(lambda self: True)
-        @rule(x=integers())
-        @precondition(lambda self: False)
-        def bad_method_c(self, x):
-            raise AssertionError("This rule runs, even though it shouldn't.")
-
-        @rule(x=integers())
-        @precondition(lambda self: True)
-        @precondition(lambda self: False)
-        def bad_method_d(self, x):
-            raise AssertionError("This rule runs, even though it shouldn't.")
-
-        @precondition(lambda self: True)
-        @precondition(lambda self: False)
-        @invariant()
-        def bad_invariant_a(self):
-            raise AssertionError("This invariant runs, even though it shouldn't.")
-
-        @precondition(lambda self: False)
-        @precondition(lambda self: True)
-        @invariant()
-        def bad_invariant_b(self):
-            raise AssertionError("This invariant runs, even though it shouldn't.")
-
-        @precondition(lambda self: True)
-        @invariant()
-        @precondition(lambda self: False)
-        def bad_invariant_c(self):
-            raise AssertionError("This invariant runs, even though it shouldn't.")
-
-        @invariant()
-        @precondition(lambda self: True)
-        @precondition(lambda self: False)
-        def bad_invariant_d(self):
-            raise AssertionError("This invariant runs, even though it shouldn't.")
-
-    run_state_machine_as_test(MultiplePreconditionMachine)
-
-
-class TrickyInitMachine(RuleBasedStateMachine):
-    @initialize()
-    def init_a(self):
-        self.a = 0
-
-    @rule()
-    def inc(self):
-        self.a += 1
-
-    @invariant()
-    def check_a_positive(self):
-        # This will fail if run before the init_a method, but without
-        # @invariant(check_during_init=True) it will only run afterwards.
-        assert self.a >= 0
-
-
-def test_invariants_are_checked_after_init_steps():
-    run_state_machine_as_test(TrickyInitMachine)
-
-
-def test_invariants_can_be_checked_during_init_steps():
-    class UndefinedMachine(TrickyInitMachine):
-        @invariant(check_during_init=True)
-        def check_a_defined(self):
-            # This will fail because `a` is undefined before the init rule.
-            self.a
-
-    with pytest.raises(AttributeError):
-        run_state_machine_as_test(UndefinedMachine)
-
-
-def test_check_during_init_must_be_boolean():
-    invariant(check_during_init=False)
-    invariant(check_during_init=True)
-    with pytest.raises(InvalidArgument):
-        invariant(check_during_init="not a bool")
-
-
-def test_deprecated_target_consumes_bundle():
-    # It would be nicer to raise this error at runtime, but the internals make
-    # this sadly impractical.  Most InvalidDefinition errors happen at, well,
-    # definition-time already anyway, so it's not *worse* than the status quo.
-    with validate_deprecation():
-        rule(target=consumes(Bundle("b")))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_statistical_events.py Deleted

@@ -1,256 +0,0 @@
-# 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 time
-import traceback
-
-import pytest
-
-from hypothesis import (
-    HealthCheck,
-    assume,
-    event,
-    example,
-    given,
-    settings,
-    stateful,
-    strategies as st,
-    target,
-)
-from hypothesis.statistics import collector, describe_statistics
-
-
-def call_for_statistics(test_function):
-    result = 
-    with collector.with_value(result.append):
-        try:
-            test_function()
-        except Exception:
-            traceback.print_exc()
-    assert len(result) == 1, result
-    return result0
-
-
-def unique_events(stats):
-    return set(sum((t"events" for t in stats"generate-phase""test-cases"), ))
-
-
-def test_notes_hard_to_satisfy():
-    @given(st.integers())
-    @settings(suppress_health_check=HealthCheck.all())
-    def test(i):
-        assume(i == 13)
-
-    stats = call_for_statistics(test)
-    assert "satisfied assumptions" in stats"stopped-because"
-
-
-def test_can_callback_with_a_string():
-    @given(st.integers())
-    def test(i):
-        event("hi")
-
-    stats = call_for_statistics(test)
-    assert any("hi" in s for s in unique_events(stats))
-
-
-counter = 0
-seen = 
-
-
-class Foo:
-    def __eq__(self, other):
-        return True
-
-    def __ne__(self, other):
-        return False
-
-    def __hash__(self):
-        return 0
-
-    def __str__(self):
-        seen.append(self)
-        global counter
-        counter += 1
-        return f"COUNTER {counter}"
-
-
-def test_formats_are_evaluated_only_once():
-    global counter
-    counter = 0
-
-    @given(st.integers())
-    def test(i):
-        event(Foo())
-
-    stats = call_for_statistics(test)
-    assert "COUNTER 1" in unique_events(stats)
-    assert "COUNTER 2" not in unique_events(stats)
-
-
-def test_does_not_report_on_examples():
-    @example("hi")
-    @given(st.integers())
-    def test(i):
-        if isinstance(i, str):
-            event("boo")
-
-    stats = call_for_statistics(test)
-    assert not unique_events(stats)
-
-
-def test_exact_timing():
-    @settings(suppress_health_check=HealthCheck.too_slow, deadline=None)
-    @given(st.integers())
-    def test(i):
-        time.sleep(0.5)
-
-    stats = describe_statistics(call_for_statistics(test))
-    assert "~ 529ms" in stats
-
-
-def test_apparently_instantaneous_tests():
-    time.freeze()
-
-    @given(st.integers())
-    def test(i):
-        pass
-
-    stats = describe_statistics(call_for_statistics(test))
-    assert "< 1ms" in stats
-
-
-def test_flaky_exit():
-    first = True
-
-    @settings(derandomize=True)
-    @given(st.integers())
-    def test(i):
-        if i > 1001:
-            if first0:
-                first0 = False
-                print("Hi")
-                raise AssertionError
-
-    stats = call_for_statistics(test)
-    assert stats"stopped-because" == "test was flaky"
-
-
-@pytest.mark.parametrize("draw_delay", False, True)
-@pytest.mark.parametrize("test_delay", False, True)
-def test_draw_time_percentage(draw_delay, test_delay):
-    time.freeze()
-
-    @st.composite
-    def s(draw):
-        if draw_delay:
-            time.sleep(0.05)
-
-    @given(s())
-    def test(_):
-        if test_delay:
-            time.sleep(0.05)
-
-    stats = describe_statistics(call_for_statistics(test))
-    if not draw_delay:
-        assert "~ 0%" in stats
-    elif test_delay:
-        assert "~ 50%" in stats
-    else:
-        assert "~ 100%" in stats
-
-
-def test_has_lambdas_in_output():
-    @settings(max_examples=100, database=None)
-    @given(st.integers().filter(lambda x: x % 2 == 0))
-    def test(i):
-        pass
-
-    stats = call_for_statistics(test)
-    assert any("lambda x: x % 2 == 0" in e for e in unique_events(stats))
-
-
-def test_stops_after_x_shrinks(monkeypatch):
-    # the max_shrinks argument is deprecated, but we still stop after some
-    # number - which we can reduce to zero to check that this works.
-    from hypothesis.internal.conjecture import engine
-
-    monkeypatch.setattr(engine, "MAX_SHRINKS", 0)
-
-    @given(st.integers(min_value=0))
-    def test(n):
-        assert n < 10
-
-    stats = call_for_statistics(test)
-    assert "shrunk example" in stats"stopped-because"
-
-
-def test_stateful_states_are_deduped():
-    class DemoStateMachine(stateful.RuleBasedStateMachine):
-        Stuff = stateful.Bundle("stuff")
-
-        @stateful.rule(target=Stuff, name=st.text())
-        def create_stuff(self, name):
-            return name
-
-        @stateful.rule(item=Stuff)
-        def do(self, item):
-            return
-
-    stats = call_for_statistics(DemoStateMachine.TestCase().runTest)
-    assert len(unique_events(stats)) <= 2
-
-
-def test_stateful_with_one_of_bundles_states_are_deduped():
-    class DemoStateMachine(stateful.RuleBasedStateMachine):
-        Things = stateful.Bundle("things")
-        Stuff = stateful.Bundle("stuff")
-        StuffAndThings = Things | Stuff
-
-        @stateful.rule(target=Things, name=st.text())
-        def create_thing(self, name):
-            return name
-
-        @stateful.rule(target=Stuff, name=st.text())
-        def create_stuff(self, name):
-            return name
-
-        @stateful.rule(item=StuffAndThings)
-        def do(self, item):
-            return
-
-    stats = call_for_statistics(DemoStateMachine.TestCase().runTest)
-    assert len(unique_events(stats)) <= 4
-
-
-def test_statistics_for_threshold_problem():
-    @settings(max_examples=100)
-    @given(st.floats(min_value=0, allow_infinity=False))
-    def threshold(error):
-        target(error, label="error")
-        assert error <= 10
-        target(0.0, label="never in failing example")
-
-    stats = call_for_statistics(threshold)
-    assert "  - Highest target scores:" in describe_statistics(stats)
-    assert "never in failing example" in describe_statistics(stats)
-    # Check that we report far-from-threshold failing examples
-    assert stats"targets""error" > 10
-
-
-def test_statistics_with_events_and_target():
-    @given(st.sampled_from("1234"))
-    def test(value):
-        event(value)
-        target(float(value), label="a target")
-
-    stats = describe_statistics(call_for_statistics(test))
-    assert "- Events:" in stats
-    assert "- Highest target score: " in stats

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_subnormal_floats.py Deleted

@@ -1,97 +0,0 @@
-# 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/.
-
-from sys import float_info
-
-import pytest
-
-from hypothesis.errors import InvalidArgument
-from hypothesis.internal.floats import next_down, next_up
-from hypothesis.strategies import floats
-from hypothesis.strategies._internal.numbers import next_down_normal, next_up_normal
-
-from tests.common.debug import assert_no_examples, find_any
-from tests.common.utils import PYTHON_FTZ
-
-pytestmark = pytest.mark.skipif(PYTHON_FTZ, reason="broken by unsafe compiler flags")
-
-
-def kw(marks=(), **kwargs):
-    id_ = ", ".join(f"{k}={v!r}" for k, v in kwargs.items())
-    return pytest.param(kwargs, id=id_, marks=marks)
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        kw(min_value=1),
-        kw(min_value=1),
-        kw(max_value=-1),
-        kw(min_value=float_info.min),
-        kw(min_value=next_down(float_info.min), exclude_min=True),
-        kw(max_value=-float_info.min),
-        kw(min_value=next_up(-float_info.min), exclude_max=True),
-    ,
-)
-def test_subnormal_validation(kwargs):
-    strat = floats(**kwargs, allow_subnormal=True)
-    with pytest.raises(InvalidArgument):
-        strat.example()
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        # min value
-        kw(allow_subnormal=False, min_value=1),
-        kw(allow_subnormal=False, min_value=float_info.min),
-        kw(allow_subnormal=True, min_value=-1),
-        kw(allow_subnormal=True, min_value=next_down(float_info.min)),
-        # max value
-        kw(allow_subnormal=False, max_value=-1),
-        kw(allow_subnormal=False, max_value=-float_info.min),
-        kw(allow_subnormal=True, max_value=1),
-        kw(allow_subnormal=True, max_value=next_up(-float_info.min)),
-        # min/max values
-        kw(allow_subnormal=True, min_value=-1, max_value=1),
-        kw(
-            allow_subnormal=True,
-            min_value=next_down(float_info.min),
-            max_value=float_info.min,
-        ),
-        kw(
-            allow_subnormal=True,
-            min_value=-float_info.min,
-            max_value=next_up(-float_info.min),
-        ),
-        kw(allow_subnormal=False, min_value=-1, max_value=-float_info.min),
-        kw(allow_subnormal=False, min_value=float_info.min, max_value=1),
-    ,
-)
-def test_allow_subnormal_defaults_correctly(kwargs):
-    allow_subnormal = kwargs.pop("allow_subnormal")
-    strat = floats(**kwargs).filter(lambda x: x != 0)
-    if allow_subnormal:
-        find_any(strat, lambda x: -float_info.min < x < float_info.min)
-    else:
-        assert_no_examples(strat, lambda x: -float_info.min < x < float_info.min)
-
-
-@pytest.mark.parametrize(
-    "func, val, expected",
-    
-        (next_up_normal, -float_info.min, -0.0),
-        (next_up_normal, +0.0, float_info.min),
-        (next_down_normal, float_info.min, +0.0),
-        (next_down_normal, -0.0, -float_info.min),
-    ,
-)
-def test_next_float_normal(func, val, expected):
-    assert func(value=val, width=64, allow_subnormal=False) == expected

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_targeting.py Deleted

@@ -1,122 +0,0 @@
-# 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/.
-
-from operator import itemgetter
-
-import pytest
-
-from hypothesis import example, given, strategies as st, target
-from hypothesis.errors import InvalidArgument
-
-
-@example(0.0, "this covers the branch where context.data is None")
-@given(
-    observation=st.integers() | st.floats(allow_nan=False, allow_infinity=False),
-    label=st.text(),
-)
-def test_allowed_inputs_to_target(observation, label):
-    target(observation, label=label)
-
-
-@given(
-    observation=st.integers(min_value=1)
-    | st.floats(min_value=1, allow_nan=False, allow_infinity=False),
-    label=st.sampled_from("a", "few", "labels"),
-)
-def test_allowed_inputs_to_target_fewer_labels(observation, label):
-    target(observation, label=label)
-
-
-@given(st.floats(min_value=1, max_value=10))
-def test_target_without_label(observation):
-    target(observation)
-
-
-@given(
-    st.lists(
-        st.tuples(st.floats(allow_nan=False, allow_infinity=False), st.text()),
-        min_size=1,
-        unique_by=itemgetter(1),
-    )
-)
-def test_multiple_target_calls(args):
-    for observation, label in args:
-        target(observation, label=label)
-
-
-@given(
-    st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=11, max_size=20)
-)
-def test_respects_max_pool_size(observations):
-    """Using many examples of several labels like this stresses the
-    pool-size logic and internal assertions in TargetSelector.
-    """
-    for i, obs in enumerate(observations):
-        target(obs, label=str(i))
-
-
-def everything_except(type_):
-    # Note: we would usually stick to faster traditional or parametrized
-    # tests to check that invalid inputs are rejected, but for `target()`
-    # we need to use `@given` (to validate arguments instead of context)
-    # so we might as well apply this neat recipe.
-    return (
-        st.from_type(type)
-        .flatmap(st.from_type)
-        .filter(lambda x: not isinstance(x, type_))
-    )
-
-
-@example(float("nan"), "")
-@example(float("inf"), "")
-@example(float("-inf"), "")
-@example("1", "Non-float observations are invalid")
-@example(0.0, "a list of strings is not a valid label")
-@given(observation=everything_except((float, int)), label=everything_except(str))
-def test_disallowed_inputs_to_target(observation, label):
-    with pytest.raises(InvalidArgument):
-        target(observation, label=label)
-
-
-def test_cannot_target_outside_test():
-    with pytest.raises(InvalidArgument):
-        target(1.0, label="example label")
-
-
-@given(st.none())
-def test_cannot_target_same_label_twice(_):
-    target(0.0, label="label")
-    with pytest.raises(InvalidArgument):
-        target(1.0, label="label")
-
-
-@given(st.none())
-def test_cannot_target_default_label_twice(_):
-    target(0.0)
-    with pytest.raises(InvalidArgument):
-        target(1.0)
-
-
-@given(st.lists(st.integers()), st.none())
-def test_targeting_with_following_empty(ls, n):
-    # This exercises some logic in the optimiser that prevents it from trying
-    # to mutate empty examples at the end of the test case.
-    target(float(len(ls)))
-
-
-@given(
-    st.tuples(
-        *(st.none() * 10 + st.integers() + st.none() * 10 + st.integers())
-    )
-)
-def test_targeting_with_many_empty(_):
-    # This exercises some logic in the optimiser that prevents it from trying
-    # to mutate empty examples in the middle of the test case.
-    target(1.0)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_testdecorators.py Deleted

@@ -1,485 +0,0 @@
-# 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 functools
-import threading
-from collections import namedtuple
-
-from hypothesis import HealthCheck, Verbosity, assume, given, note, reporting, settings
-from hypothesis.strategies import (
-    binary,
-    booleans,
-    builds,
-    data,
-    floats,
-    frozensets,
-    integers,
-    just,
-    lists,
-    one_of,
-    sampled_from,
-    sets,
-    text,
-)
-
-from tests.common.utils import (
-    assert_falsifying_output,
-    capture_out,
-    fails,
-    fails_with,
-    no_shrink,
-    raises,
-)
-
-# This particular test file is run under both pytest and nose, so it can't
-# rely on pytest-specific helpers like `pytest.raises` unless we define a
-# fallback in tests.common.utils.
-
-
-@given(integers(), integers())
-def test_int_addition_is_commutative(x, y):
-    assert x + y == y + x
-
-
-@fails
-@given(text(min_size=1), text(min_size=1))
-def test_str_addition_is_commutative(x, y):
-    assert x + y == y + x
-
-
-@fails
-@given(binary(min_size=1), binary(min_size=1))
-def test_bytes_addition_is_commutative(x, y):
-    # We enforce min_size=1 here to avoid a rare flakiness, where the
-    # test passes if x and/or y are b"" for every generated example.
-    # (the internal implementation makes this less rare for bytes)
-    assert x + y == y + x
-
-
-@given(integers(), integers(), integers())
-def test_int_addition_is_associative(x, y, z):
-    assert x + (y + z) == (x + y) + z
-
-
-@fails
-@given(floats(), floats(), floats())
-@settings(max_examples=2000)
-def test_float_addition_is_associative(x, y, z):
-    assert x + (y + z) == (x + y) + z
-
-
-@given(lists(integers()))
-def test_reversing_preserves_integer_addition(xs):
-    assert sum(xs) == sum(reversed(xs))
-
-
-def test_still_minimizes_on_non_assertion_failures():
-    @settings(max_examples=50)
-    @given(integers())
-    def is_not_too_large(x):
-        if x >= 10:
-            raise ValueError(f"No, {x} is just too large. Sorry")
-
-    with raises(ValueError, match=" 10 "):
-        is_not_too_large()
-
-
-@given(integers())
-def test_integer_division_shrinks_positive_integers(n):
-    assume(n > 0)
-    assert n / 2 < n
-
-
-class TestCases:
-    @given(integers())
-    def test_abs_non_negative(self, x):
-        assert abs(x) >= 0
-        assert isinstance(self, TestCases)
-
-    @given(x=integers())
-    def test_abs_non_negative_varargs(self, x, *args):
-        assert abs(x) >= 0
-        assert isinstance(self, TestCases)
-
-    @given(x=integers())
-    def test_abs_non_negative_varargs_kwargs(self, *args, **kw):
-        assert abs(kw"x") >= 0
-        assert isinstance(self, TestCases)
-
-    @given(x=integers())
-    def test_abs_non_negative_varargs_kwargs_only(*args, **kw):  # noqa: B902
-        assert abs(kw"x") >= 0
-        assert isinstance(args0, TestCases)
-
-    @fails
-    @given(integers())
-    def test_int_is_always_negative(self, x):
-        assert x < 0
-
-    @fails
-    @given(floats(), floats())
-    def test_float_addition_cancels(self, x, y):
-        assert x + (y - x) == y
-
-
-@fails
-@given(x=integers(min_value=0, max_value=3), name=text())
-def test_can_be_given_keyword_args(x, name):
-    assume(x > 0)
-    assert len(name) < x
-
-
-@fails
-@given(one_of(floats(), booleans()), one_of(floats(), booleans()))
-def test_one_of_produces_different_values(x, y):
-    assert type(x) == type(y)
-
-
-@given(just(42))
-def test_is_the_answer(x):
-    assert x == 42
-
-
-@given(integers(1, 10))
-def test_integers_are_in_range(x):
-    assert 1 <= x <= 10
-
-
-@given(integers(min_value=100))
-def test_integers_from_are_from(x):
-    assert x >= 100
-
-
-def test_does_not_catch_interrupt_during_falsify():
-    calls = 0
-
-    @given(integers())
-    def flaky_base_exception(x):
-        if not calls0:
-            calls0 = 1
-            raise KeyboardInterrupt()
-
-    with raises(KeyboardInterrupt):
-        flaky_base_exception()
-
-
-@given(lists(integers(), unique=True), integers())
-def test_removing_an_element_from_a_unique_list(xs, y):
-    assume(len(set(xs)) == len(xs))
-
-    try:
-        xs.remove(y)
-    except ValueError:
-        pass
-
-    assert y not in xs
-
-
-@fails
-@given(lists(integers(), min_size=2), data())
-def test_removing_an_element_from_a_non_unique_list(xs, data):
-    y = data.draw(sampled_from(xs))
-    xs.remove(y)
-    assert y not in xs
-
-
-@given(sets(sampled_from(list(range(10)))))
-def test_can_test_sets_sampled_from(xs):
-    assert all(isinstance(x, int) for x in xs)
-    assert all(0 <= x < 10 for x in xs)
-
-
-mix = one_of(sampled_from(1, 2, 3), text())
-
-
-@fails
-@given(mix, mix)
-def test_can_mix_sampling_with_generating(x, y):
-    assert type(x) == type(y)
-
-
-@fails
-@given(frozensets(integers()))
-def test_can_find_large_sum_frozenset(xs):
-    assert sum(xs) < 100
-
-
-def test_prints_on_failure_by_default():
-    @given(integers(), integers())
-    @settings(max_examples=100)
-    def test_ints_are_sorted(balthazar, evans):
-        assume(evans >= 0)
-        assert balthazar <= evans
-
-    assert_falsifying_output(test_ints_are_sorted, balthazar=1, evans=0)
-
-
-def test_does_not_print_on_success():
-    @settings(verbosity=Verbosity.normal)
-    @given(integers())
-    def test_is_an_int(x):
-        return
-
-    with capture_out() as out:
-        test_is_an_int()
-    out = out.getvalue()
-    lines = l.strip() for l in out.split("\n")
-    assert all(not l for l in lines), lines
-
-
-@given(sampled_from(1))
-def test_can_sample_from_single_element(x):
-    assert x == 1
-
-
-@fails
-@given(lists(integers()))
-def test_list_is_sorted(xs):
-    assert sorted(xs) == xs
-
-
-@fails
-@given(floats(1.0, 2.0))
-def test_is_an_endpoint(x):
-    assert x == 1.0 or x == 2.0
-
-
-def test_breaks_bounds():
-    @fails
-    @given(x=integers())
-    def test_is_bounded(t, x):
-        assert x < t
-
-    for t in 1, 10, 100, 1000:
-        test_is_bounded(t)
-
-
-@given(x=booleans())
-def test_can_test_kwargs_only_methods(**kwargs):
-    assert isinstance(kwargs"x", bool)
-
-
-@fails_with(UnicodeEncodeError)
-@given(text())
-@settings(max_examples=100)
-def test_is_ascii(x):
-    x.encode("ascii")
-
-
-@fails
-@given(text())
-def test_is_not_ascii(x):
-    try:
-        x.encode("ascii")
-        raise AssertionError
-    except UnicodeEncodeError:
-        pass
-
-
-@fails
-@given(text(min_size=2))
-@settings(max_examples=100, derandomize=True)
-def test_can_find_string_with_duplicates(s):
-    assert len(set(s)) == len(s)
-
-
-@fails
-@given(text(min_size=1))
-@settings(derandomize=True)
-def test_has_ascii(x):
-    if not x:
-        return
-    ascii_characters = (
-        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ \t\n"
-    )
-    assert any(c in ascii_characters for c in x)
-
-
-def test_can_derandomize():
-    values = 
-
-    @fails
-    @given(integers())
-    @settings(derandomize=True, database=None)
-    def test_blah(x):
-        values.append(x)
-        assert x > 0
-
-    test_blah()
-    assert values
-    v1 = values
-    values = 
-    test_blah()
-    assert v1 == values
-
-
-def test_can_run_without_database():
-    @given(integers())
-    @settings(database=None)
-    def test_blah(x):
-        raise AssertionError
-
-    with raises(AssertionError):
-        test_blah()
-
-
-def test_can_run_with_database_in_thread():
-    results = 
-
-    @given(integers())
-    def test_blah(x):
-        raise ValueError()
-
-    def run_test():
-        try:
-            test_blah()
-        except ValueError:
-            results.append("success")
-
-    # Run once in the main thread and once in another thread. Execution is
-    # strictly serial, so no need for locking.
-    run_test()
-    assert results == "success"
-    thread = threading.Thread(target=run_test)
-    thread.start()
-    thread.join()
-    assert results == "success", "success"
-
-
-@given(integers())
-def test_can_call_an_argument_f(f):
-    # See issue https://github.com/HypothesisWorks/hypothesis-python/issues/38
-    # for details
-    pass
-
-
-Litter = namedtuple("Litter", ("kitten1", "kitten2"))
-
-
-@given(builds(Litter, integers(), integers()))
-def test_named_tuples_are_of_right_type(litter):
-    assert isinstance(litter, Litter)
-
-
-@fails_with(AttributeError)
-@given(integers().map(lambda x: x.nope))
-@settings(suppress_health_check=HealthCheck.all())
-def test_fails_in_reify(x):
-    pass
-
-
-@given(text("a"))
-def test_a_text(x):
-    assert set(x).issubset(set("a"))
-
-
-@given(text(""))
-def test_empty_text(x):
-    assert not x
-
-
-@given(text("abcdefg"))
-def test_mixed_text(x):
-    assert set(x).issubset(set("abcdefg"))
-
-
-def test_when_set_to_no_simplifies_runs_failing_example_twice():
-    failing = 
-
-    @given(integers())
-    @settings(
-        phases=no_shrink,
-        max_examples=100,
-        verbosity=Verbosity.normal,
-        report_multiple_bugs=False,
-    )
-    def foo(x):
-        if x > 11:
-            note("Lo")
-            failing.append(x)
-            raise AssertionError
-
-    with raises(AssertionError):
-        with capture_out() as out:
-            foo()
-    assert len(failing) == 2
-    assert len(set(failing)) == 1
-    assert "Falsifying example" in out.getvalue()
-    assert "Lo" in out.getvalue()
-
-
-@given(integers().filter(lambda x: x % 4 == 0))
-def test_filtered_values_satisfy_condition(i):
-    assert i % 4 == 0
-
-
-def nameless_const(x):
-    def f(u, v):
-        return u
-
-    return functools.partial(f, x)
-
-
-@given(sets(booleans()).map(nameless_const(2)))
-def test_can_map_nameless(x):
-    assert x == 2
-
-
-@given(integers(0, 10).flatmap(nameless_const(just(3))))
-def test_can_flatmap_nameless(x):
-    assert x == 3
-
-
-def test_can_be_used_with_none_module():
-    def test_is_cool(i):
-        pass
-
-    test_is_cool.__module__ = None
-    test_is_cool = given(integers())(test_is_cool)
-    test_is_cool()
-
-
-def test_does_not_print_notes_if_all_succeed():
-    @given(integers())
-    @settings(verbosity=Verbosity.normal)
-    def test(i):
-        note("Hi there")
-
-    with capture_out() as out:
-        with reporting.with_reporter(reporting.default):
-            test()
-    assert not out.getvalue()
-
-
-def test_prints_notes_once_on_failure():
-    @given(lists(integers()))
-    @settings(database=None, verbosity=Verbosity.normal)
-    def test(xs):
-        note("Hi there")
-        if sum(xs) <= 100:
-            raise ValueError()
-
-    with capture_out() as out:
-        with reporting.with_reporter(reporting.default):
-            with raises(ValueError):
-                test()
-    lines = out.getvalue().strip().splitlines()
-    assert lines.count("Hi there") == 1
-
-
-@given(lists(integers(), max_size=0))
-def test_empty_lists(xs):
-    assert xs == 
-
-
-def test_given_usable_inline_on_lambdas():
-    xs = 
-    given(booleans())(lambda x: xs.append(x))()
-    assert len(xs) == 2 and set(xs) == {False, True}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_text.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_traceback_elision.py Deleted

@@ -1,34 +0,0 @@
-# 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 traceback
-
-import pytest
-
-from hypothesis import Verbosity, given, settings, strategies as st
-
-
-@pytest.mark.parametrize("verbosity", Verbosity.normal, Verbosity.debug)
-def test_tracebacks_omit_hypothesis_internals(verbosity):
-    @settings(verbosity=verbosity)
-    @given(st.just(False))
-    def simplest_failure(x):
-        raise ValueError()
-
-    try:
-        simplest_failure()
-    except ValueError as e:
-        tb = traceback.extract_tb(e.__traceback__)
-        # Unless in debug mode, Hypothesis adds 1 frame - the least possible!
-        # (4 frames: this one, simplest_failure, internal frame, assert False)
-        if verbosity < Verbosity.debug:
-            assert len(tb) == 4
-        else:
-            assert len(tb) >= 5

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_type_lookup.py Deleted

@@ -1,428 +0,0 @@
-# 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 abc
-import enum
-from inspect import Parameter as P, Signature
-from typing import Callable, Dict, Generic, List, Sequence, TypeVar, Union
-
-import pytest
-
-from hypothesis import given, infer, settings, strategies as st
-from hypothesis.errors import (
-    HypothesisDeprecationWarning,
-    InvalidArgument,
-    ResolutionFailed,
-)
-from hypothesis.internal.compat import get_type_hints
-from hypothesis.internal.reflection import get_pretty_function_description
-from hypothesis.strategies._internal import types
-from hypothesis.strategies._internal.core import _from_type
-from hypothesis.strategies._internal.types import _global_type_lookup
-from hypothesis.strategies._internal.utils import _strategies
-
-from tests.common.debug import assert_all_examples, find_any
-from tests.common.utils import fails_with, temp_registered
-
-# Build a set of all types output by core strategies
-blocklist = {
-    "builds",
-    "data",
-    "deferred",
-    "from_regex",
-    "from_type",
-    "ip_addresses",
-    "iterables",
-    "just",
-    "nothing",
-    "one_of",
-    "permutations",
-    "random_module",
-    "randoms",
-    "recursive",
-    "runner",
-    "sampled_from",
-    "shared",
-    "timezone_keys",
-    "timezones",
-}
-assert set(_strategies).issuperset(blocklist), blocklist.difference(_strategies)
-types_with_core_strat = set()
-for thing in (
-    getattr(st, name)
-    for name in sorted(_strategies)
-    if name in dir(st) and name not in blocklist
-):
-    for n in range(3):
-        try:
-            ex = thing(*(st.nothing() * n)).example()
-            types_with_core_strat.add(type(ex))
-            break
-        except (TypeError, InvalidArgument, HypothesisDeprecationWarning):
-            continue
-
-
-def test_generic_sequence_of_integers_may_be_lists_or_bytes():
-    strat = st.from_type(Sequenceint)
-    find_any(strat, lambda x: isinstance(x, bytes))
-    find_any(strat, lambda x: isinstance(x, list))
-
-
-@pytest.mark.parametrize("typ", sorted(types_with_core_strat, key=str))
-def test_resolve_core_strategies(typ):
-    @given(st.from_type(typ))
-    def inner(ex):
-        assert isinstance(ex, typ)
-
-    inner()
-
-
-def test_lookup_knows_about_all_core_strategies():
-    cannot_lookup = types_with_core_strat - set(types._global_type_lookup)
-    assert not cannot_lookup
-
-
-def test_lookup_keys_are_types():
-    with pytest.raises(InvalidArgument):
-        st.register_type_strategy("int", st.integers())
-    assert "int" not in types._global_type_lookup
-
-
-def test_lookup_values_are_strategies():
-    with pytest.raises(InvalidArgument):
-        st.register_type_strategy(int, 42)
-    assert 42 not in types._global_type_lookup.values()
-
-
-@pytest.mark.parametrize("typ", sorted(types_with_core_strat, key=str))
-def test_lookup_overrides_defaults(typ):
-    sentinel = object()
-    with temp_registered(typ, st.just(sentinel)):
-        assert st.from_type(typ).example() is sentinel
-    assert st.from_type(typ).example() is not sentinel
-
-
-class ParentUnknownType:
-    pass
-
-
-class UnknownType(ParentUnknownType):
-    def __init__(self, arg):
-        pass
-
-
-def test_custom_type_resolution_fails_without_registering():
-    fails = st.from_type(UnknownType)
-    with pytest.raises(ResolutionFailed):
-        fails.example()
-
-
-def test_custom_type_resolution():
-    sentinel = object()
-    with temp_registered(UnknownType, st.just(sentinel)):
-        assert st.from_type(UnknownType).example() is sentinel
-        # Also covered by registration of child class
-        assert st.from_type(ParentUnknownType).example() is sentinel
-
-
-def test_custom_type_resolution_with_function():
-    sentinel = object()
-    with temp_registered(UnknownType, lambda _: st.just(sentinel)):
-        assert st.from_type(UnknownType).example() is sentinel
-        assert st.from_type(ParentUnknownType).example() is sentinel
-
-
-def test_custom_type_resolution_with_function_non_strategy():
-    with temp_registered(UnknownType, lambda _: None):
-        with pytest.raises(ResolutionFailed):
-            st.from_type(UnknownType).example()
-        with pytest.raises(ResolutionFailed):
-            st.from_type(ParentUnknownType).example()
-
-
-def test_errors_if_generic_resolves_empty():
-    with temp_registered(UnknownType, lambda _: st.nothing()):
-        fails_1 = st.from_type(UnknownType)
-        with pytest.raises(ResolutionFailed):
-            fails_1.example()
-        fails_2 = st.from_type(ParentUnknownType)
-        with pytest.raises(ResolutionFailed):
-            fails_2.example()
-
-
-def test_cannot_register_empty():
-    # Cannot register and did not register
-    with pytest.raises(InvalidArgument):
-        st.register_type_strategy(UnknownType, st.nothing())
-    fails = st.from_type(UnknownType)
-    with pytest.raises(ResolutionFailed):
-        fails.example()
-    assert UnknownType not in types._global_type_lookup
-
-
-def test_pulic_interface_works():
-    st.from_type(int).example()
-    fails = st.from_type("not a type or annotated function")
-    with pytest.raises(InvalidArgument):
-        fails.example()
-
-
-@pytest.mark.parametrize("infer_token", infer, ...)
-def test_given_can_infer_from_manual_annotations(infer_token):
-    # Editing annotations before decorating is hilariously awkward, but works!
-    def inner(a):
-        assert isinstance(a, int)
-
-    inner.__annotations__ = {"a": int}
-    given(a=infer_token)(inner)()
-
-
-class EmptyEnum(enum.Enum):
-    pass
-
-
-@fails_with(InvalidArgument)
-@given(st.from_type(EmptyEnum))
-def test_error_if_enum_is_empty(x):
-    pass
-
-
-class BrokenClass:
-    __init__ = "Hello!"
-
-
-def test_uninspectable_builds():
-    with pytest.raises(TypeError, match="object is not callable"):
-        st.builds(BrokenClass).example()
-
-
-def test_uninspectable_from_type():
-    with pytest.raises(TypeError, match="object is not callable"):
-        st.from_type(BrokenClass).example()
-
-
-def _check_instances(t):
-    # See https://github.com/samuelcolvin/pydantic/discussions/2508
-    return t.__module__ != "typing" and not t.__module__.startswith("pydantic")
-
-
-@pytest.mark.parametrize(
-    "typ", sorted((x for x in _global_type_lookup if _check_instances(x)), key=str)
-)
-@given(data=st.data())
-def test_can_generate_from_all_registered_types(data, typ):
-    value = data.draw(st.from_type(typ), label="value")
-    assert isinstance(value, typ)
-
-
-T = TypeVar("T")
-
-
-class MyGeneric(GenericT):
-    def __init__(self, arg: T) -> None:
-        self.arg = arg
-
-
-class Lines(Sequencestr):
-    """Represent a sequence of text lines.
-
-    It turns out that resolving a class which inherits from a parametrised generic
-    type is... tricky.  See https://github.com/HypothesisWorks/hypothesis/issues/2951
-    """
-
-
-class SpecificDict(Dictint, int):
-    pass
-
-
-def using_generic(instance: MyGenericT) -> T:
-    return instance.arg
-
-
-def using_concrete_generic(instance: MyGenericint) -> int:
-    return instance.arg
-
-
-def test_generic_origin_empty():
-    with pytest.raises(ResolutionFailed):
-        find_any(st.builds(using_generic))
-
-
-def test_issue_2951_regression():
-    lines_strat = st.builds(Lines, lines=st.lists(st.text()))
-    with temp_registered(Lines, lines_strat):
-        assert st.from_type(Lines) == lines_strat
-        # Now let's test that the strategy for ``Sequenceint`` did not
-        # change just because we registered a strategy for ``Lines``:
-        expected = "one_of(binary(), lists(integers()))"
-        assert repr(st.from_type(Sequenceint)) == expected
-
-
-def test_issue_2951_regression_two_params():
-    map_strat = st.builds(SpecificDict, st.dictionaries(st.integers(), st.integers()))
-    expected = repr(st.from_type(Dictint, int))
-    with temp_registered(SpecificDict, map_strat):
-        assert st.from_type(SpecificDict) == map_strat
-        assert expected == repr(st.from_type(Dictint, int))
-
-
-@pytest.mark.parametrize(
-    "generic",
-    (
-        Unionstr, int,
-        SequenceSequenceint,
-        MyGenericstr,
-        Callable..., str,
-        Callableint, str,
-    ),
-    ids=repr,
-)
-@pytest.mark.parametrize("strategy", st.none(), lambda _: st.none())
-def test_generic_origin_with_type_args(generic, strategy):
-    with pytest.raises(InvalidArgument):
-        st.register_type_strategy(generic, strategy)
-    assert generic not in types._global_type_lookup
-
-
-@pytest.mark.parametrize(
-    "generic",
-    (
-        Callable,
-        List,
-        Sequence,
-        # you can register types with all generic parameters
-        ListT,
-        SequenceT,
-        # User-defined generics should also work
-        MyGeneric,
-        MyGenericT,
-    ),
-)
-def test_generic_origin_without_type_args(generic):
-    with temp_registered(generic, st.just("example")):
-        pass
-
-
-@pytest.mark.parametrize(
-    "strat, type_",
-    
-        (st.from_type, MyGenericT),
-        (st.from_type, MyGenericint),
-        (st.from_type, MyGeneric),
-        (st.builds, using_generic),
-        (st.builds, using_concrete_generic),
-    ,
-    ids=get_pretty_function_description,
-)
-def test_generic_origin_from_type(strat, type_):
-    with temp_registered(MyGeneric, st.builds(MyGeneric)):
-        find_any(strat(type_))
-
-
-def test_generic_origin_concrete_builds():
-    with temp_registered(MyGeneric, st.builds(MyGeneric, st.integers())):
-        assert_all_examples(
-            st.builds(using_generic), lambda example: isinstance(example, int)
-        )
-
-
-class AbstractFoo(abc.ABC):
-    def __init__(self, x):
-        pass
-
-    @abc.abstractmethod
-    def qux(self):
-        pass
-
-
-class ConcreteFoo1(AbstractFoo):
-    # Can't resolve this one due to unannotated `x` param
-    def qux(self):
-        pass
-
-
-class ConcreteFoo2(AbstractFoo):
-    def __init__(self, x: int):
-        pass
-
-    def qux(self):
-        pass
-
-
-@given(st.from_type(AbstractFoo))
-def test_gen_abstract(foo):
-    # This requires that we correctly checked which of the subclasses
-    # could be resolved, rather than unconditionally using all of them.
-    assert isinstance(foo, ConcreteFoo2)
-
-
-class AbstractBar(abc.ABC):
-    def __init__(self, x):
-        pass
-
-    @abc.abstractmethod
-    def qux(self):
-        pass
-
-
-class ConcreteBar(AbstractBar):
-    def qux(self):
-        pass
-
-
-def test_abstract_resolver_fallback():
-    # We create our distinct strategies for abstract and concrete types
-    gen_abstractbar = _from_type(AbstractBar)
-    gen_concretebar = st.builds(ConcreteBar, x=st.none())
-    assert gen_abstractbar != gen_concretebar
-
-    # And trying to generate an instance of the abstract type fails,
-    # UNLESS the concrete type is currently resolvable
-    with pytest.raises(ResolutionFailed):
-        gen_abstractbar.example()
-    with temp_registered(ConcreteBar, gen_concretebar):
-        gen = gen_abstractbar.example()
-    with pytest.raises(ResolutionFailed):
-        gen_abstractbar.example()
-
-    # which in turn means we resolve to the concrete subtype.
-    assert isinstance(gen, ConcreteBar)
-
-
-def _one_arg(x: int):
-    assert isinstance(x, int)
-
-
-def _multi_arg(x: int, y: str):
-    assert isinstance(x, int)
-    assert isinstance(y, str)
-
-
-def _kwd_only(*, y: str):
-    assert isinstance(y, str)
-
-
-def _pos_and_kwd_only(x: int, *, y: str):
-    assert isinstance(x, int)
-    assert isinstance(y, str)
-
-
-@pytest.mark.parametrize("func", _one_arg, _multi_arg, _kwd_only, _pos_and_kwd_only)
-def test_infer_all(func):
-    # tests @given(...) against various signatures
-    settings(max_examples=1)(given(...))(func)()
-
-
-def test_does_not_add_param_empty_to_type_hints():
-    def f(x):
-        pass
-
-    f.__signature__ = Signature(P("y", P.KEYWORD_ONLY), return_annotation=None)
-    assert get_type_hints(f) == {}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_type_lookup_forward_ref.py Deleted

@@ -1,141 +0,0 @@
-# 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/.
-
-"""
-We need these test to make sure ``TypeVar('X', bound='MyType')`` works correctly.
-
-There was a problem previously that ``bound='MyType'`` was resolved as ``ForwardRef('MyType')``
-which is not a real type. And ``hypothesis`` was not able to generate any meaningful values out of it.
-
-Right here we test different possible outcomes for different Python versions:
-- Regular case, when ``'MyType'`` can be imported
-- Alias case, when we use type aliases for ``'MyType'``
-- ``if TYPE_CHECKING:`` case, when ``'MyType'`` only exists during type checking and is not importable at all
-- Dot access case, like ``'module.MyType'``
-- Missing case, when there's no ``'MyType'`` at all
-"""
-
-from typing import TYPE_CHECKING, ForwardRef, TypeVar
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import ResolutionFailed
-
-from tests.common import utils
-
-if TYPE_CHECKING:
-    from tests.common.utils import ExcInfo  # we just need any type  # noqa: F401
-
-# Correct:
-
-_Correct = TypeVar("_Correct", bound="CustomType")
-
-
-def correct_fun(thing: _Correct) -> int:
-    return thing.arg
-
-
-class CustomType:
-    def __init__(self, arg: int) -> None:
-        self.arg = arg
-
-
-@given(st.builds(correct_fun))
-def test_bound_correct_forward_ref(built):
-    """Correct resolution of existing type codebase."""
-    assert isinstance(built, int)
-
-
-# Alises:
-
-_Alias = TypeVar("_Alias ", bound="OurAlias")
-
-
-def alias_fun(thing: _Alias) -> int:
-    return thing.arg
-
-
-OurAlias = CustomType
-
-
-@given(st.builds(alias_fun))
-def test_bound_alias_forward_ref(built):
-    """Correct resolution of type aliases."""
-    assert isinstance(built, int)
-
-
-# Dot access:
-
-_CorrectDotAccess = TypeVar("_CorrectDotAccess", bound="utils.ExcInfo")
-_WrongDotAccess = TypeVar("_WrongDotAccess", bound="wrong.ExcInfo")  # noqa
-_MissingDotAccess = TypeVar("_MissingDotAccess", bound="utils.MissingType")
-
-
-def correct_dot_access_fun(thing: _CorrectDotAccess) -> int:
-    return 1
-
-
-def wrong_dot_access_fun(thing: _WrongDotAccess) -> int:
-    return 1
-
-
-def missing_dot_access_fun(thing: _MissingDotAccess) -> int:
-    return 1
-
-
-@given(st.builds(correct_dot_access_fun))
-def test_bound_correct_dot_access_forward_ref(built):
-    """Correct resolution of dot access types."""
-    assert isinstance(built, int)
-
-
-@pytest.mark.parametrize("function", wrong_dot_access_fun, missing_dot_access_fun)
-def test_bound_missing_dot_access_forward_ref(function):
-    """Resolution of missing type in dot access."""
-    with pytest.raises(ResolutionFailed):
-        st.builds(function).example()
-
-
-# Missing:
-
-_Missing = TypeVar("_Missing", bound="MissingType")  # noqa
-
-
-def missing_fun(thing: _Missing) -> int:
-    return 1
-
-
-def test_bound_missing_forward_ref():
-    """We should raise proper errors on missing types."""
-    with pytest.raises(ResolutionFailed):
-        st.builds(missing_fun).example()
-
-
-# Type checking only:
-
-_TypeChecking = TypeVar("_TypeChecking", bound="ExcInfo")
-
-
-def typechecking_only_fun(thing: _TypeChecking) -> int:
-    return 1
-
-
-def test_bound_type_cheking_only_forward_ref():
-    """We should fallback to registering explicit ``ForwardRef`` when we have to."""
-    with utils.temp_registered(ForwardRef("ExcInfo"), st.just(1)):
-        st.builds(typechecking_only_fun).example()
-
-
-def test_bound_type_cheking_only_forward_ref_wrong_type():
-    """We should check ``ForwardRef`` parameter name correctly."""
-    with utils.temp_registered(ForwardRef("WrongType"), st.just(1)):
-        with pytest.raises(ResolutionFailed):
-            st.builds(typechecking_only_fun).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_unicode_identifiers.py Deleted

@@ -1,51 +0,0 @@
-# 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/.
-
-from hypothesis import given, strategies as st
-from hypothesis.internal.reflection import get_pretty_function_description, proxies
-
-
-def test_can_copy_argspec_of_unicode_args():
-    def foo(μ):
-        return μ
-
-    @proxies(foo)
-    def bar(μ):
-        return foo(μ)
-
-    assert bar(1) == 1
-
-
-def test_can_copy_argspec_of_unicode_name():
-    def ā():
-        return 1
-
-    @proxies(ā)
-    def bar():
-        return 2
-
-    assert bar() == 2
-
-
-is_approx_π = lambda x: x == 3.1415  # noqa: E731
-
-
-def test_can_handle_unicode_identifier_in_same_line_as_lambda_def():
-    assert get_pretty_function_description(is_approx_π) == "lambda x: x == 3.1415"
-
-
-def test_regression_issue_1700():
-    π = 3.1415
-
-    @given(st.floats(min_value=-π, max_value=π).filter(lambda x: abs(x) > 1e-5))
-    def test_nonzero(x):
-        assert x != 0
-
-    test_nonzero()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_unittest.py Deleted

@@ -1,74 +0,0 @@
-# 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 io
-import sys
-import unittest
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import FailedHealthCheck, HypothesisWarning
-
-from tests.common.utils import fails_with
-
-
-class Thing_with_a_subThing(unittest.TestCase):
-    """Example test case using subTest for the actual test below."""
-
-    @given(st.tuples(st.booleans(), st.booleans()))
-    def thing(self, lst):
-        for i, b in enumerate(lst):
-            with pytest.warns(HypothesisWarning):
-                with self.subTest((i, b)):
-                    self.assertTrue(b)
-
-
-def test_subTest():
-    suite = unittest.TestSuite()
-    suite.addTest(Thing_with_a_subThing("thing"))
-    stream = io.StringIO()
-    out = unittest.TextTestRunner(stream=stream).run(suite)
-    assert len(out.failures) <= out.testsRun, out
-
-
-class test_given_on_setUp_fails_health_check(unittest.TestCase):
-    @fails_with(FailedHealthCheck)
-    @given(st.integers())
-    def setUp(self, i):
-        pass
-
-    def test(self):
-        """Provide something to set up for, so the setUp method is called."""
-
-
-SUBTEST_SUITE = """
-import unittest
-from hypothesis import given, strategies as st
-
-class MyTest(unittest.TestCase):
-    @given(s=st.text())
-    def test_subtest(self, s):
-        with self.subTest(text=s):
-            self.assertIsInstance(s, str)
-
-if __name__ == "__main__":
-    unittest.main()
-"""
-
-
-@pytest.mark.parametrize("err", , "-Werror")
-def test_subTest_no_self(testdir, err):
-    # https://github.com/HypothesisWorks/hypothesis/issues/2462
-    # for some reason this issue happens only when running unittest from commandline
-    fname = testdir.makepyfile(tests=SUBTEST_SUITE)
-    result = testdir.run(sys.executable, *err, str(fname))
-    expected = pytest.ExitCode.TESTS_FAILED if err else pytest.ExitCode.OK
-    assert result.ret == expected, result.stderr.str()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_uuids.py Deleted

@@ -1,34 +0,0 @@
-# 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 uuid
-
-import pytest
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.debug import assert_no_examples, find_any
-
-
-def test_no_nil_uuid_by_default():
-    assert_no_examples(st.uuids(), lambda x: x == uuid.UUID(int=0))
-
-
-def test_can_generate_nil_uuid():
-    find_any(st.uuids(allow_nil=True), lambda x: x == uuid.UUID(int=0))
-
-
-def test_can_only_allow_nil_uuid_with_none_version():
-    st.uuids(version=None, allow_nil=True).example()
-    with pytest.raises(InvalidArgument):
-        st.uuids(version=4, allow_nil=True).example()
-    with pytest.raises(InvalidArgument):
-        st.uuids(version=None, allow_nil="not a bool").example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_validation.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/cover/test_verbosity.py Deleted

@@ -1,133 +0,0 @@
-# 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/.
-
-from contextlib import contextmanager
-
-from hypothesis import example, find, given
-from hypothesis._settings import Verbosity, settings
-from hypothesis.reporting import default as default_reporter, with_reporter
-from hypothesis.strategies import booleans, integers, lists
-
-from tests.common.debug import minimal
-from tests.common.utils import capture_out, fails
-
-
-@contextmanager
-def capture_verbosity():
-    with capture_out() as o:
-        with with_reporter(default_reporter):
-            yield o
-
-
-def test_prints_intermediate_in_success():
-    with capture_verbosity() as o:
-
-        @settings(verbosity=Verbosity.verbose)
-        @given(booleans())
-        def test_works(x):
-            pass
-
-        test_works()
-    assert "Trying example" in o.getvalue()
-
-
-def test_does_not_log_in_quiet_mode():
-    with capture_verbosity() as o:
-
-        @fails
-        @settings(verbosity=Verbosity.quiet, print_blob=False)
-        @given(integers())
-        def test_foo(x):
-            raise AssertionError
-
-        test_foo()
-    assert not o.getvalue()
-
-
-def test_includes_progress_in_verbose_mode():
-    with capture_verbosity() as o:
-        minimal(
-            lists(integers(), min_size=1),
-            lambda x: sum(x) >= 100,
-            settings(verbosity=Verbosity.verbose),
-        )
-    out = o.getvalue()
-    assert out
-    assert "Trying example: " in out
-    assert "Falsifying example: " in out
-
-
-def test_prints_initial_attempts_on_find():
-
-    with capture_verbosity() as o:
-
-        def foo():
-            seen = 
-
-            def not_first(x):
-                if not seen:
-                    seen.append(x)
-                    return False
-                return x not in seen
-
-            find(
-                integers(),
-                not_first,
-                settings=settings(verbosity=Verbosity.verbose, max_examples=1000),
-            )
-
-        foo()
-
-    assert "Trying example" in o.getvalue()
-
-
-def test_includes_intermediate_results_in_verbose_mode():
-    with capture_verbosity() as o:
-
-        @fails
-        @settings(
-            verbosity=Verbosity.verbose,
-            database=None,
-            derandomize=True,
-            max_examples=100,
-        )
-        @given(lists(integers(), min_size=1))
-        def test_foo(x):
-            assert sum(x) < 10000
-
-        test_foo()
-    lines = o.getvalue().splitlines()
-    assert len(l for l in lines if "example" in l) > 2
-    assert l for l in lines if "AssertionError" in l
-
-
-@example(0)
-@settings(verbosity=Verbosity.quiet)
-@given(integers())
-def test_no_indexerror_in_quiet_mode(x):
-    # Regression tests for https://github.com/HypothesisWorks/hypothesis/issues/2696
-    # where quiet mode -> no fragments to report -> IndexError accessing first report
-    pass
-
-
-@fails
-@example(0)
-@settings(verbosity=Verbosity.quiet, report_multiple_bugs=True)
-@given(integers())
-def test_no_indexerror_in_quiet_mode_report_multiple(x):
-    assert x
-
-
-@fails
-@example(0)
-@settings(verbosity=Verbosity.quiet, report_multiple_bugs=False)
-@given(integers())
-def test_no_indexerror_in_quiet_mode_report_one(x):
-    assert x

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/datetime Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/datetime/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/datetime/test_dateutil_timezones.py Deleted

@@ -1,125 +0,0 @@
-# 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 datetime as dt
-
-import pytest
-from dateutil import tz, zoneinfo
-
-from hypothesis import assume, given
-from hypothesis.errors import FailedHealthCheck, InvalidArgument
-from hypothesis.extra.dateutil import timezones
-from hypothesis.strategies import data, datetimes, just, sampled_from, times
-from hypothesis.strategies._internal.datetime import datetime_does_not_exist
-
-from tests.common.debug import assert_all_examples, find_any, minimal
-from tests.common.utils import fails_with
-
-
-def test_utc_is_minimal():
-    assert tz.UTC is minimal(timezones())
-
-
-def test_can_generate_non_naive_time():
-    assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == tz.UTC
-
-
-def test_can_generate_non_naive_datetime():
-    assert (
-        minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == tz.UTC
-    )
-
-
-@given(datetimes(timezones=timezones()))
-def test_timezone_aware_datetimes_are_timezone_aware(dt):
-    assert dt.tzinfo is not None
-
-
-@given(sampled_from("min_value", "max_value"), datetimes(timezones=timezones()))
-def test_datetime_bounds_must_be_naive(name, val):
-    with pytest.raises(InvalidArgument):
-        datetimes(**{name: val}).validate()
-
-
-def test_timezones_arg_to_datetimes_must_be_search_strategy():
-    all_timezones = zoneinfo.get_zonefile_instance().zones
-    with pytest.raises(InvalidArgument):
-        datetimes(timezones=all_timezones).validate()
-
-
-@given(times(timezones=timezones()))
-def test_timezone_aware_times_are_timezone_aware(dt):
-    assert dt.tzinfo is not None
-
-
-def test_can_generate_non_utc():
-    times(timezones=timezones()).filter(
-        lambda d: assume(d.tzinfo) and d.tzinfo.zone != "UTC"
-    ).validate()
-
-
-@given(sampled_from("min_value", "max_value"), times(timezones=timezones()))
-def test_time_bounds_must_be_naive(name, val):
-    with pytest.raises(InvalidArgument):
-        times(**{name: val}).validate()
-
-
-def test_should_have_correct_ordering():
-    def offset(timezone):
-        return abs(timezone.utcoffset(dt.datetime(2000, 1, 1)))
-
-    next_interesting_tz = minimal(timezones(), lambda tz: offset(tz) > dt.timedelta(0))
-    assert offset(next_interesting_tz) == dt.timedelta(seconds=3600)
-
-
-@given(data(), datetimes(), datetimes())
-def test_datetimes_stay_within_naive_bounds(data, lo, hi):
-    if lo > hi:
-        lo, hi = hi, lo
-    out = data.draw(datetimes(lo, hi, timezones=timezones()))
-    assert lo <= out.replace(tzinfo=None) <= hi
-
-
-DAY_WITH_IMAGINARY_HOUR_KWARGS = {
-    # The day of a spring-forward transition; 2am is imaginary
-    "min_value": dt.datetime(2020, 10, 4),
-    "max_value": dt.datetime(2020, 10, 5),
-    "timezones": just(tz.gettz("Australia/Sydney")),
-}
-
-
-@given(datetimes(timezones=timezones()) | datetimes(**DAY_WITH_IMAGINARY_HOUR_KWARGS))
-def test_dateutil_exists_our_not_exists_are_inverse(value):
-    assert datetime_does_not_exist(value) == (not tz.datetime_exists(value))
-
-
-def test_datetimes_can_exclude_imaginary():
-    find_any(
-        datetimes(**DAY_WITH_IMAGINARY_HOUR_KWARGS, allow_imaginary=True),
-        lambda x: not tz.datetime_exists(x),
-    )
-    assert_all_examples(
-        datetimes(**DAY_WITH_IMAGINARY_HOUR_KWARGS, allow_imaginary=False),
-        tz.datetime_exists,
-    )
-
-
-@fails_with(FailedHealthCheck)
-@given(
-    datetimes(
-        max_value=dt.datetime(1, 1, 1, 9),
-        timezones=just(tz.gettz("Australia/Sydney")),
-        allow_imaginary=False,
-    )
-)
-def test_non_imaginary_datetimes_at_boundary(val):
-    # This is expected to fail because Australia/Sydney is UTC+10,
-    # and the filter logic overflows when checking for round-trips.
-    raise AssertionError

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/datetime/test_pytz_timezones.py Deleted

@@ -1,156 +0,0 @@
-# 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 datetime as dt
-
-import pytest
-import pytz
-from dateutil.tz import datetime_exists
-
-from hypothesis import assume, given
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.pytz import timezones
-from hypothesis.strategies import data, datetimes, just, sampled_from, times
-from hypothesis.strategies._internal.datetime import datetime_does_not_exist
-
-from tests.common.debug import (
-    assert_all_examples,
-    assert_can_trigger_event,
-    find_any,
-    minimal,
-)
-
-
-def test_utc_is_minimal():
-    assert pytz.UTC is minimal(timezones())
-
-
-def test_can_generate_non_naive_time():
-    assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC
-
-
-def test_can_generate_non_naive_datetime():
-    assert (
-        minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC
-    )
-
-
-@given(datetimes(timezones=timezones()))
-def test_timezone_aware_datetimes_are_timezone_aware(dt):
-    assert dt.tzinfo is not None
-
-
-@given(sampled_from("min_value", "max_value"), datetimes(timezones=timezones()))
-def test_datetime_bounds_must_be_naive(name, val):
-    with pytest.raises(InvalidArgument):
-        datetimes(**{name: val}).validate()
-
-
-def test_underflow_in_simplify():
-    # we shouldn't trigger a pytz bug when we're simplifying
-    minimal(
-        datetimes(
-            max_value=dt.datetime.min + dt.timedelta(days=3), timezones=timezones()
-        ),
-        lambda x: x.tzinfo != pytz.UTC,
-    )
-
-
-def test_overflow_in_simplify():
-    # we shouldn't trigger a pytz bug when we're simplifying
-    minimal(
-        datetimes(
-            min_value=dt.datetime.max - dt.timedelta(days=3), timezones=timezones()
-        ),
-        lambda x: x.tzinfo != pytz.UTC,
-    )
-
-
-def test_timezones_arg_to_datetimes_must_be_search_strategy():
-    with pytest.raises(InvalidArgument):
-        datetimes(timezones=pytz.all_timezones).validate()
-    with pytest.raises(InvalidArgument):
-        tz = pytz.timezone(t) for t in pytz.all_timezones
-        datetimes(timezones=tz).validate()
-
-
-@given(times(timezones=timezones()))
-def test_timezone_aware_times_are_timezone_aware(dt):
-    assert dt.tzinfo is not None
-
-
-def test_can_generate_non_utc():
-    times(timezones=timezones()).filter(
-        lambda d: assume(d.tzinfo) and d.tzinfo.zone != "UTC"
-    ).validate()
-
-
-@given(sampled_from("min_value", "max_value"), times(timezones=timezones()))
-def test_time_bounds_must_be_naive(name, val):
-    with pytest.raises(InvalidArgument):
-        times(**{name: val}).validate()
-
-
-@pytest.mark.parametrize(
-    "bound",
-    
-        {"min_value": dt.datetime.max - dt.timedelta(days=3)},
-        {"max_value": dt.datetime.min + dt.timedelta(days=3)},
-    ,
-)
-def test_can_trigger_error_in_draw_near_boundary(bound):
-    assert_can_trigger_event(
-        datetimes(**bound, timezones=timezones()),
-        lambda event: "Failed to draw a datetime" in event,
-    )
-
-
-@given(data(), datetimes(), datetimes())
-def test_datetimes_stay_within_naive_bounds(data, lo, hi):
-    if lo > hi:
-        lo, hi = hi, lo
-    out = data.draw(datetimes(lo, hi, timezones=timezones()))
-    assert lo <= out.replace(tzinfo=None) <= hi
-
-
-@pytest.mark.parametrize(
-    "kw",
-    
-        # Ireland uses  *negative* offset DST, which means that our sloppy interpretation
-        # of "is_dst=not fold" bypasses the filter for imaginary times.  This is basically
-        # unfixable without redesigning pytz per PEP-495, and it's much more likely to be
-        # replaced by dateutil or PEP-615 zoneinfo in the standard library instead.
-        {
-            "min_value": dt.datetime(2019, 3, 31),
-            "max_value": dt.datetime(2019, 4, 1),
-            "timezones": just(pytz.timezone("Europe/Dublin")),
-        },
-        # The day of a spring-forward transition in Australia; 2am is imaginary
-        # (the common case so an optimistic `is_dst=bool(fold)` also fails the test)
-        {
-            "min_value": dt.datetime(2020, 10, 4),
-            "max_value": dt.datetime(2020, 10, 5),
-            "timezones": just(pytz.timezone("Australia/Sydney")),
-        },
-    ,
-)
-def test_datetimes_can_exclude_imaginary(kw):
-    # Sanity check: fail unless those days contain an imaginary hour to filter out
-    find_any(datetimes(**kw, allow_imaginary=True), lambda x: not datetime_exists(x))
-
-    # Assert that with allow_imaginary=False we only generate existing datetimes.
-    assert_all_examples(datetimes(**kw, allow_imaginary=False), datetime_exists)
-
-
-def test_really_weird_tzinfo_case():
-    x = dt.datetime(2019, 3, 31, 2, 30, tzinfo=pytz.timezone("Europe/Dublin"))
-    assert x.tzinfo is not x.astimezone(dt.timezone.utc).astimezone(x.tzinfo)
-    # And that weird case exercises the rare branch in our helper:
-    assert datetime_does_not_exist(x)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/datetime/test_zoneinfo_timezones.py Deleted

@@ -1,81 +0,0 @@
-# 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 platform
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.strategies._internal.datetime import zoneinfo
-
-from tests.common.debug import assert_no_examples, find_any, minimal
-
-
-def test_utc_is_minimal():
-    assert minimal(st.timezones()) is zoneinfo.ZoneInfo("UTC")
-
-
-def test_can_generate_non_utc():
-    find_any(
-        st.datetimes(timezones=st.timezones()).filter(lambda d: d.tzinfo.key != "UTC")
-    )
-
-
-@given(st.data(), st.datetimes(), st.datetimes())
-def test_datetimes_stay_within_naive_bounds(data, lo, hi):
-    if lo > hi:
-        lo, hi = hi, lo
-    out = data.draw(st.datetimes(lo, hi, timezones=st.timezones()))
-    assert lo <= out.replace(tzinfo=None) <= hi
-
-
-@pytest.mark.parametrize("kwargs", {"no_cache": 1})
-def test_timezones_argument_validation(kwargs):
-    with pytest.raises(InvalidArgument):
-        st.timezones(**kwargs).validate()
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    
-        # {"allow_alias": 1},
-        # {"allow_deprecated": 1},
-        {"allow_prefix": 1},
-    ,
-)
-def test_timezone_keys_argument_validation(kwargs):
-    with pytest.raises(InvalidArgument):
-        st.timezone_keys(**kwargs).validate()
-
-
-@pytest.mark.skipif(platform.system() != "Linux", reason="platform-specific")
-def test_can_generate_prefixes_if_allowed_and_available():
-    """
-    This is actually kinda fiddly: we may generate timezone keys with the
-    "posix/" or "right/" prefix if-and-only-if they are present on the filesystem.
-
-    This immediately rules out Windows (which uses the tzdata package instead),
-    along with OSX (which doesn't seem to have prefixed keys).  We believe that
-    they are present on at least most Linux distros, but have not done exhaustive
-    testing.
-
-    It's fine to just patch this test out if it fails - passing in the
-    Hypothesis CI demonstrates that the feature works on *some* systems.
-    """
-    find_any(st.timezone_keys(), lambda s: s.startswith("posix/"))
-    find_any(st.timezone_keys(), lambda s: s.startswith("right/"))
-
-
-def test_can_disallow_prefixes():
-    assert_no_examples(
-        st.timezone_keys(allow_prefix=False),
-        lambda s: s.startswith(("posix/", "right/")),
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/manage.py Deleted

@@ -1,43 +0,0 @@
-# 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 os
-import sys
-import warnings
-
-from hypothesis import HealthCheck, settings
-
-from tests.common.setup import run
-
-if __name__ == "__main__":
-    run()
-
-    settings.register_profile(
-        "default", settings(suppress_health_check=HealthCheck.too_slow)
-    )
-
-    settings.load_profile(os.getenv("HYPOTHESIS_PROFILE", "default"))
-
-    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tests.django.toys.settings")
-
-    # This triggers a deprecation warning on some older versions of Django
-    # because of its use of the imp module.
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=DeprecationWarning)
-        from django.core.management import execute_from_command_line
-
-    try:
-        from django.utils.deprecation import RemovedInDjango50Warning
-    except ImportError:
-        RemovedInDjango50Warning = ()
-
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=RemovedInDjango50Warning)
-        execute_from_command_line(sys.argv)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toys Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toys/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toys/settings.py Deleted

@@ -1,121 +0,0 @@
-# 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/.
-
-"""Django settings for toys project.
-
-For more information on this file, see
-https://docs.djangoproject.com/en/1.7/topics/settings/
-
-For the full list of settings and their values, see
-https://docs.djangoproject.com/en/1.7/ref/settings/
-"""
-
-import os
-
-# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
-BASE_DIR = os.path.dirname(os.path.dirname(__file__))
-
-
-# Quick-start development settings - unsuitable for production
-# See https://docs.djangoproject.com/en/1.7/howto/deployment/checklist/
-
-# SECURITY WARNING: keep the secret key used in production secret!
-SECRET_KEY = "o0zlv@74u4e3s+o0^h$+tlalh&$r(7hbx01g4^h5-3gizj%hub"
-
-# SECURITY WARNING: don't run with debug turned on in production!
-DEBUG = True
-
-TEMPLATE_DEBUG = True
-
-ALLOWED_HOSTS = 
-
-
-# Application definition
-
-INSTALLED_APPS = (
-    "django.contrib.admin",
-    "django.contrib.auth",
-    "django.contrib.contenttypes",
-    "django.contrib.sessions",
-    "django.contrib.messages",
-    "django.contrib.staticfiles",
-    "tests.django.toystore",
-)
-
-MIDDLEWARE_CLASSES = (
-    "django.contrib.sessions.middleware.SessionMiddleware",
-    "django.middleware.common.CommonMiddleware",
-    "django.middleware.csrf.CsrfViewMiddleware",
-    "django.contrib.auth.middleware.AuthenticationMiddleware",
-    "django.contrib.auth.middleware.SessionAuthenticationMiddleware",
-    "django.contrib.messages.middleware.MessageMiddleware",
-    "django.middleware.clickjacking.XFrameOptionsMiddleware",
-)
-
-ROOT_URLCONF = "tests.django.toys.urls"
-
-WSGI_APPLICATION = "tests.django.toys.wsgi.application"
-
-
-# Database
-# https://docs.djangoproject.com/en/1.7/ref/settings/#databases
-
-DATABASES = {
-    "default": {
-        "ENGINE": "django.db.backends.sqlite3",
-        "NAME": os.path.join(BASE_DIR, "db.sqlite3"),
-    }
-}
-
-# Internationalization
-# https://docs.djangoproject.com/en/1.7/topics/i18n/
-
-LANGUAGE_CODE = "en-us"
-
-TIME_ZONE = "UTC"
-
-USE_I18N = True
-
-USE_L10N = True
-
-USE_TZ = os.environ.get("HYPOTHESIS_DJANGO_USETZ", "TRUE") == "TRUE"
-
-
-# Static files (CSS, JavaScript, Images)
-# https://docs.djangoproject.com/en/1.7/howto/static-files/
-
-STATIC_URL = "/static/"
-
-
-# Added these bits to avoid warnings on Django 2.2
-
-TEMPLATES = 
-    {
-        "BACKEND": "django.template.backends.django.DjangoTemplates",
-        "OPTIONS": {
-            "context_processors": 
-                "django.template.context_processors.debug",
-                "django.template.context_processors.request",
-                "django.contrib.auth.context_processors.auth",
-                "django.contrib.messages.context_processors.messages",
-            
-        },
-    }
-
-
-MIDDLEWARE = 
-    "django.middleware.security.SecurityMiddleware",
-    "django.contrib.sessions.middleware.SessionMiddleware",
-    "django.middleware.common.CommonMiddleware",
-    "django.middleware.csrf.CsrfViewMiddleware",
-    "django.contrib.auth.middleware.AuthenticationMiddleware",
-    "django.contrib.messages.middleware.MessageMiddleware",
-    "django.middleware.clickjacking.XFrameOptionsMiddleware",
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toys/urls.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toys/wsgi.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/admin.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/forms.py Deleted

@@ -1,214 +0,0 @@
-# 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/.
-
-from django import forms
-from django.core.validators import (
-    MaxLengthValidator,
-    MaxValueValidator,
-    MinLengthValidator,
-    MinValueValidator,
-)
-from django.forms import widgets
-
-from tests.django.toystore.models import (
-    CouldBeCharming,
-    Customer,
-    ManyNumerics,
-    ManyTimes,
-    OddFields,
-)
-
-
-class ReprModelForm(forms.ModelForm):
-    def __repr__(self):
-        """I recommend putting this in your form to show the failed cases."""
-        return f"{self.data!r}\n{self.errors!r}"
-
-
-class ReprForm(forms.Form):
-    def __repr__(self):
-        return f"{self.data!r}\n{self.errors!r}"
-
-
-class CouldBeCharmingForm(ReprModelForm):
-    class Meta:
-        model = CouldBeCharming
-        fields = "__all__"
-
-
-class CustomerForm(ReprModelForm):
-    class Meta:
-        model = Customer
-        fields = "__all__"
-
-
-class ManyNumericsForm(ReprModelForm):
-    class Meta:
-        model = ManyNumerics
-        fields = "__all__"
-
-
-class ManyTimesForm(ReprModelForm):
-    class Meta:
-        model = ManyTimes
-        fields = "__all__"
-
-
-class OddFieldsForm(ReprModelForm):
-    class Meta:
-        model = OddFields
-        fields = "__all__"
-
-
-class DynamicForm(ReprForm):
-    def __init__(self, field_count=5, **kwargs):
-        super().__init__(**kwargs)
-        for i in range(field_count):
-            field_name = f"field-{i}"
-            self.fieldsfield_name = forms.CharField(required=False)
-
-
-class BasicFieldForm(ReprForm):
-    _boolean_required = forms.BooleanField()
-    _boolean = forms.BooleanField(required=False)
-    # This took me too long to figure out... The BooleanField will actually
-    # raise a ValidationError when it receives a value of False. Why they
-    # didn't call it a TrueOnlyField escapes me, but *if* you actually want
-    # to accept both True and False in your BooleanField, make sure you set
-    # `required=False`. This behavior has been hotly contested in the bug
-    # tracker (e.g. https://code.djangoproject.com/ticket/23547), but it
-    # seems that since the tests and documentation are already written
-    # this behavior is Truth.
-    # see the note in the documentation
-    # https://docs.djangoproject.com/en/dev/ref/forms/fields/#booleanfield
-
-    _char_required = forms.CharField(required=True)
-    _char = forms.CharField(required=False)
-    _decimal = forms.DecimalField(max_digits=8, decimal_places=3)
-    _float = forms.FloatField()
-    _integer = forms.IntegerField()
-    _null_boolean = forms.NullBooleanField()
-
-
-class TemporalFieldForm(ReprForm):
-    _date = forms.DateField()
-    _date_time = forms.DateTimeField()
-    _duration = forms.DurationField()
-    _time = forms.TimeField()
-    _split_date_time = forms.SplitDateTimeField()
-
-
-class WithValidatorsForm(ReprForm):
-    num_validators = MinValueValidator(1), MaxValueValidator(5)
-    _int_one_to_five = forms.IntegerField(validators=num_validators)
-    _decimal_one_to_five = forms.FloatField(validators=num_validators)
-    _float_one_to_five = forms.FloatField(validators=num_validators)
-    len_validators = MinLengthValidator(5), MaxLengthValidator(10)
-    _string_five_to_ten = forms.CharField(validators=len_validators)
-
-
-class EmailFieldForm(ReprForm):
-    _email = forms.EmailField()
-
-
-class SlugFieldForm(ReprForm):
-    _slug = forms.SlugField()
-
-
-class URLFieldForm(ReprForm):
-    _url = forms.URLField()
-
-
-class RegexFieldForm(ReprForm):
-    _regex = forms.RegexField(regex="A-Z{3}\\.a-z{4}")
-
-
-class UUIDFieldForm(ReprForm):
-    _uuid = forms.UUIDField()
-
-
-class ChoiceFieldForm(ReprForm):
-    _choice = forms.ChoiceField(
-        choices=(("cola", "Cola"), ("tea", "Tea"), ("water", "Water"))
-    )
-    _multiple = forms.MultipleChoiceField(
-        choices=(("cola", "Cola"), ("tea", "Tea"), ("water", "Water"))
-    )
-    _typed = forms.TypedChoiceField(
-        choices=(("1", "one"), ("2", "two"), ("3", "three"), ("4", "four")),
-        coerce=int,
-        empty_value=0,
-    )
-    _typed_multiple = forms.TypedMultipleChoiceField(
-        choices=(("1", "one"), ("2", "two"), ("3", "three"), ("4", "four")),
-        coerce=int,
-        empty_value=0,
-    )
-
-
-class InternetProtocolForm(ReprForm):
-    _ip_both = forms.GenericIPAddressField()
-    _ip_v4 = forms.GenericIPAddressField(protocol="IPv4")
-    _ip_v6 = forms.GenericIPAddressField(protocol="IPv6")
-
-
-class BroadBooleanInput(widgets.CheckboxInput):
-    """Basically pulled directly from the Django CheckboxInput. I added
-    some stuff to ``values``
-    """
-
-    def value_from_datadict(self, data, files, name):
-        if name not in data:
-            return False
-        value = data.get(name)
-        # Translate true and false strings to boolean values.
-        values = {"true": True, "false": False, "0": False, "1": True}
-        if isinstance(value, str):
-            value = values.get(value.lower(), value)
-        return bool(value)
-
-
-class MultiCheckboxWidget(widgets.MultiWidget):
-    def __init__(self, subfield_count=12, **kwargs):
-        _widgets = BroadBooleanInput() * subfield_count
-        super().__init__(_widgets, **kwargs)
-
-    def decompress(self, value):
-        values = 
-        for _value in value.split("::"):
-            if _value in ("0", "", "False", 0, None, False):
-                values.append(False)
-            else:
-                values.append(True)
-        return values
-
-
-class BroadBooleanField(forms.BooleanField):
-    pass
-
-
-class MultiBooleanField(forms.MultiValueField):
-    def __init__(self, subfield_count=12, **kwargs):
-        subfields = BroadBooleanField() * subfield_count
-        widget = MultiCheckboxWidget(subfield_count=subfield_count)
-        super().__init__(fields=subfields, widget=widget)
-
-    def compress(self, values):
-        return "::".join(str(x) for x in values)
-
-
-class ManyMultiValueForm(ReprForm):
-    def __init__(self, subfield_count=12, **kwargs):
-        super().__init__(**kwargs)
-        self.fields"mv_field" = MultiBooleanField(subfield_count=subfield_count)
-
-
-class ShortStringForm(ReprForm):
-    _not_too_long = forms.CharField(max_length=20, required=False)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/models.py Deleted

@@ -1,147 +0,0 @@
-# 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/.
-
-from django.core.exceptions import ValidationError
-from django.db import models
-
-
-class Company(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-
-
-class Store(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    company = models.ForeignKey(Company, null=False, on_delete=models.CASCADE)
-
-
-class Car(models.Model):
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2369
-    model = models.CharField(max_length=100, unique=True)
-
-
-class CharmField(models.Field):
-    def db_type(self, connection):
-        return "char(1)"
-
-
-class CustomishField(models.Field):
-    def db_type(self, connection):
-        return "char(1)"
-
-
-class Customish(models.Model):
-    customish = CustomishField()
-
-
-class Customer(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    email = models.EmailField(max_length=100, unique=True)
-    gender = models.CharField(max_length=50, null=True)
-    age = models.IntegerField()
-    birthday = models.DateTimeField()
-
-
-class Charming(models.Model):
-    charm = CharmField()
-
-
-class CouldBeCharming(models.Model):
-    charm = CharmField(null=True)
-
-
-class SelfLoop(models.Model):
-    me = models.ForeignKey("self", null=True, on_delete=models.SET_NULL)
-
-
-class LoopA(models.Model):
-    b = models.ForeignKey("LoopB", null=False, on_delete=models.CASCADE)
-
-
-class LoopB(models.Model):
-    a = models.ForeignKey("LoopA", null=True, on_delete=models.SET_NULL)
-
-
-class ManyNumerics(models.Model):
-    i1 = models.IntegerField()
-    i2 = models.SmallIntegerField()
-    i3 = models.BigIntegerField()
-
-    p1 = models.PositiveIntegerField()
-    p2 = models.PositiveSmallIntegerField()
-
-    d = models.DecimalField(decimal_places=2, max_digits=5)
-
-
-class ManyTimes(models.Model):
-    time = models.TimeField()
-    date = models.DateField()
-    duration = models.DurationField()
-
-
-class OddFields(models.Model):
-    uuid = models.UUIDField()
-    slug = models.SlugField()
-    url = models.URLField()
-    ipv4 = models.GenericIPAddressField(protocol="IPv4")
-    ipv6 = models.GenericIPAddressField(protocol="IPv6")
-
-
-class CustomishDefault(models.Model):
-    customish = CustomishField(default="b")
-
-
-class MandatoryComputed(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    company = models.ForeignKey(Company, null=False, on_delete=models.CASCADE)
-
-    def __init__(self, **kw):
-        if "company" in kw:
-            raise RuntimeError()
-        cname = kw"name" + "_company"
-        kw"company" = Company.objects.create(name=cname)
-        super().__init__(**kw)
-
-
-def validate_even(value):
-    if value % 2 != 0:
-        raise ValidationError("")
-
-
-class RestrictedFields(models.Model):
-    text_field_4 = models.TextField(max_length=4, blank=True)
-    char_field_4 = models.CharField(max_length=4, blank=True)
-    choice_field_text = models.TextField(choices=(("foo", "Foo"), ("bar", "Bar")))
-    choice_field_int = models.IntegerField(choices=((1, "First"), (2, "Second")))
-    null_choice_field_int = models.IntegerField(
-        choices=((1, "First"), (2, "Second")), null=True, blank=True
-    )
-    choice_field_grouped = models.TextField(
-        choices=(
-            ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))),
-            ("Video", (("vhs", "VHS Tape"), ("dvd", "DVD"))),
-            ("unknown", "Unknown"),
-        )
-    )
-    even_number_field = models.IntegerField(validators=validate_even)
-    non_blank_text_field = models.TextField(blank=False)
-
-
-class SelfModifyingField(models.IntegerField):
-    def pre_save(self, model_instance, add):
-        value = getattr(model_instance, self.attname)
-        value += 1
-        setattr(model_instance, self.attname, value)
-        return value
-
-
-class CompanyExtension(models.Model):
-    company = models.OneToOneField(Company, primary_key=True, on_delete=models.CASCADE)
-
-    self_modifying = SelfModifyingField()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/test_basic_configuration.py Deleted

@@ -1,82 +0,0 @@
-# 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/.
-
-from unittest import TestCase as VanillaTestCase
-
-import pytest
-from django.db import IntegrityError
-from django.test import TestCase as DjangoTestCase
-
-from hypothesis import HealthCheck, Verbosity, given, settings
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.django import TestCase, TransactionTestCase
-from hypothesis.internal.compat import PYPY
-from hypothesis.strategies import integers
-
-from tests.django.toystore.models import Company
-
-
-class SomeStuff:
-    @settings(suppress_health_check=HealthCheck.too_slow)
-    @given(integers())
-    def test_is_blank_slate(self, unused):
-        Company.objects.create(name="MickeyCo")
-
-    def test_normal_test_1(self):
-        Company.objects.create(name="MickeyCo")
-
-    def test_normal_test_2(self):
-        Company.objects.create(name="MickeyCo")
-
-
-class TestConstraintsWithTransactions(SomeStuff, TestCase):
-    pass
-
-
-if not PYPY:
-    # xfail
-    # This is excessively slow in general, but particularly on pypy. We just
-    # disable it altogether there as it's a niche case.
-    class TestConstraintsWithoutTransactions(SomeStuff, TransactionTestCase):
-        pass
-
-
-class TestWorkflow(VanillaTestCase):
-    def test_does_not_break_later_tests(self):
-        def break_the_db(i):
-            Company.objects.create(name="MickeyCo")
-            Company.objects.create(name="MickeyCo")
-
-        class LocalTest(TestCase):
-            @given(integers().map(break_the_db))
-            @settings(
-                suppress_health_check=HealthCheck.all(), verbosity=Verbosity.quiet
-            )
-            def test_does_not_break_other_things(self, unused):
-                pass
-
-            def test_normal_test_1(self):
-                Company.objects.create(name="MickeyCo")
-
-        t = LocalTest("test_normal_test_1")
-        try:
-            t.test_does_not_break_other_things()
-        except IntegrityError:
-            pass
-        t.test_normal_test_1()
-
-    def test_given_needs_hypothesis_test_case(self):
-        class LocalTest(DjangoTestCase):
-            @given(integers())
-            def tst(self, i):
-                raise AssertionError("InvalidArgument should be raised in @given")
-
-        with pytest.raises(InvalidArgument):
-            LocalTest("tst").tst()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/test_given_forms.py Deleted

@@ -1,120 +0,0 @@
-# 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/.
-
-from hypothesis import given
-from hypothesis.extra.django import TestCase, from_form, register_field_strategy
-from hypothesis.strategies import booleans, sampled_from
-
-from tests.django.toystore.forms import (
-    BasicFieldForm,
-    BroadBooleanField,
-    ChoiceFieldForm,
-    CustomerForm,
-    DynamicForm,
-    EmailFieldForm,
-    InternetProtocolForm,
-    ManyMultiValueForm,
-    ManyNumericsForm,
-    ManyTimesForm,
-    OddFieldsForm,
-    RegexFieldForm,
-    ShortStringForm,
-    SlugFieldForm,
-    TemporalFieldForm,
-    URLFieldForm,
-    UUIDFieldForm,
-    WithValidatorsForm,
-)
-
-register_field_strategy(
-    BroadBooleanField, booleans() | sampled_from("1", "0", "True", "False")
-)
-
-
-class TestGetsBasicForms(TestCase):
-    @given(from_form(CustomerForm))
-    def test_valid_customer(self, customer_form):
-        self.assertTrue(customer_form.is_valid())
-
-    @given(from_form(ManyNumericsForm))
-    def test_valid_numerics(self, numerics_form):
-        self.assertTrue(numerics_form.is_valid())
-
-    @given(from_form(ManyTimesForm))
-    def test_valid_times(self, times_form):
-        self.assertTrue(times_form.is_valid())
-
-    @given(from_form(OddFieldsForm))
-    def test_valid_odd_fields(self, odd_form):
-        self.assertTrue(odd_form.is_valid())
-
-    def test_dynamic_form(self):
-        for field_count in range(2, 7):
-
-            @given(from_form(DynamicForm, form_kwargs={"field_count": field_count}))
-            def _test(dynamic_form):
-                self.assertTrue(dynamic_form.is_valid())
-
-            _test()
-
-    @given(from_form(BasicFieldForm))
-    def test_basic_fields_form(self, basic_field_form):
-        self.assertTrue(basic_field_form.is_valid())
-
-    @given(from_form(TemporalFieldForm))
-    def test_temporal_fields_form(self, time_field_form):
-        self.assertTrue(time_field_form.is_valid())
-
-    @given(from_form(EmailFieldForm))
-    def test_email_field_form(self, email_field_form):
-        self.assertTrue(email_field_form.is_valid())
-
-    @given(from_form(SlugFieldForm))
-    def test_slug_field_form(self, slug_field_form):
-        self.assertTrue(slug_field_form.is_valid())
-
-    @given(from_form(URLFieldForm))
-    def test_url_field_form(self, url_field_form):
-        self.assertTrue(url_field_form.is_valid())
-
-    @given(from_form(RegexFieldForm))
-    def test_regex_field_form(self, regex_field_form):
-        self.assertTrue(regex_field_form.is_valid())
-
-    @given(from_form(UUIDFieldForm))
-    def test_uuid_field_form(self, uuid_field_form):
-        self.assertTrue(uuid_field_form.is_valid())
-
-    @given(from_form(ChoiceFieldForm))
-    def test_choice_fields_form(self, choice_field_form):
-        self.assertTrue(choice_field_form.is_valid())
-
-    @given(from_form(InternetProtocolForm))
-    def test_ip_fields_form(self, ip_field_form):
-        self.assertTrue(ip_field_form.is_valid())
-
-    @given(from_form(ManyMultiValueForm, form_kwargs={"subfield_count": 2}))
-    def test_many_values_in_multi_value_field(self, many_multi_value_form):
-        self.assertTrue(many_multi_value_form.is_valid())
-
-    @given(from_form(ManyMultiValueForm, form_kwargs={"subfield_count": 105}))
-    def test_excessive_values_in_multi_value_field(self, excessive_form):
-        self.assertTrue(excessive_form.is_valid())
-
-    @given(from_form(ShortStringForm))
-    def test_short_string_form(self, short_string_form):
-        self.assertTrue(short_string_form.is_valid())
-
-    @given(from_form(WithValidatorsForm))
-    def test_tight_validators_form(self, x):
-        self.assertTrue(1 <= x.data"_int_one_to_five" <= 5)
-        self.assertTrue(1 <= x.data"_decimal_one_to_five" <= 5)
-        self.assertTrue(1 <= x.data"_float_one_to_five" <= 5)
-        self.assertTrue(5 <= len(x.data"_string_five_to_ten") <= 10)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/test_given_models.py Deleted

@@ -1,203 +0,0 @@
-# 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 datetime as dt
-import sys
-from uuid import UUID
-
-from django.conf import settings as django_settings
-from django.contrib.auth.models import User
-
-from hypothesis import HealthCheck, assume, given, settings
-from hypothesis.control import reject
-from hypothesis.errors import HypothesisException, InvalidArgument
-from hypothesis.extra.django import (
-    TestCase,
-    TransactionTestCase,
-    from_model,
-    register_field_strategy,
-)
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.strategies import binary, just, lists
-
-from tests.django.toystore.models import (
-    Car,
-    Company,
-    CompanyExtension,
-    CouldBeCharming,
-    Customer,
-    Customish,
-    CustomishDefault,
-    CustomishField,
-    MandatoryComputed,
-    ManyNumerics,
-    ManyTimes,
-    OddFields,
-    RestrictedFields,
-    SelfLoop,
-    Store,
-)
-
-register_field_strategy(CustomishField, just("a"))
-
-
-class TestGetsBasicModels(TestCase):
-    @given(from_model(Company))
-    def test_is_company(self, company):
-        self.assertIsInstance(company, Company)
-        self.assertIsNotNone(company.pk)
-
-    @given(from_model(Store, company=from_model(Company)))
-    def test_can_get_a_store(self, store):
-        assert store.company.pk
-
-    @given(lists(from_model(Company)))
-    def test_can_get_multiple_models_with_unique_field(self, companies):
-        assume(len(companies) > 1)
-        for c in companies:
-            self.assertIsNotNone(c.pk)
-        self.assertEqual(
-            len({c.pk for c in companies}), len({c.name for c in companies})
-        )
-
-    @settings(suppress_health_check=HealthCheck.too_slow)
-    @given(from_model(Customer))
-    def test_is_customer(self, customer):
-        self.assertIsInstance(customer, Customer)
-        self.assertIsNotNone(customer.pk)
-        self.assertIsNotNone(customer.email)
-
-    @settings(suppress_health_check=HealthCheck.too_slow)
-    @given(from_model(Customer))
-    def test_tz_presence(self, customer):
-        if django_settings.USE_TZ:
-            self.assertIsNotNone(customer.birthday.tzinfo)
-        else:
-            self.assertIsNone(customer.birthday.tzinfo)
-
-    @given(from_model(CouldBeCharming))
-    def test_is_not_charming(self, not_charming):
-        self.assertIsInstance(not_charming, CouldBeCharming)
-        self.assertIsNotNone(not_charming.pk)
-        self.assertIsNone(not_charming.charm)
-
-    @given(from_model(SelfLoop))
-    def test_sl(self, sl):
-        self.assertIsNone(sl.me)
-
-    @given(lists(from_model(ManyNumerics)))
-    def test_no_overflow_in_integer(self, manyints):
-        pass
-
-    @given(from_model(Customish))
-    def test_custom_field(self, x):
-        assert x.customish == "a"
-
-    def test_mandatory_fields_are_mandatory(self):
-        self.assertRaises(InvalidArgument, from_model(Store).example)
-
-    def test_mandatory_computed_fields_are_mandatory(self):
-        with self.assertRaises(InvalidArgument):
-            from_model(MandatoryComputed).example()
-
-    def test_mandatory_computed_fields_may_not_be_provided(self):
-        mc = from_model(MandatoryComputed, company=from_model(Company))
-        self.assertRaises(RuntimeError, mc.example)
-
-    @given(from_model(CustomishDefault, customish=...))
-    def test_customish_default_overridden_by_infer(self, x):
-        assert x.customish == "a"
-
-    @given(from_model(CustomishDefault, customish=...))
-    def test_customish_infer_uses_registered_instead_of_default(self, x):
-        assert x.customish == "a"
-
-    @given(from_model(OddFields))
-    def test_odd_fields(self, x):
-        assert isinstance(x.uuid, UUID)
-        assert isinstance(x.slug, str)
-        assert " " not in x.slug
-        assert isinstance(x.ipv4, str)
-        assert len(x.ipv4.split(".")) == 4
-        assert all(int(i) in range(256) for i in x.ipv4.split("."))
-        assert isinstance(x.ipv6, str)
-        assert set(x.ipv6).issubset(set("0123456789abcdefABCDEF:."))
-
-    @given(from_model(ManyTimes))
-    def test_time_fields(self, x):
-        assert isinstance(x.time, dt.time)
-        assert isinstance(x.date, dt.date)
-        assert isinstance(x.duration, dt.timedelta)
-
-    @given(from_model(Company))
-    def test_no_null_in_charfield(self, x):
-        # regression test for #1045.  Company just has a convenient CharField.
-        assert "\x00" not in x.name
-
-    @given(binary(min_size=10))
-    def test_foreign_key_primary(self, buf):
-        # Regression test for #1307
-        company_strategy = from_model(Company, name=just("test"))
-        strategy = from_model(
-            CompanyExtension, company=company_strategy, self_modifying=just(2)
-        )
-        try:
-            ConjectureData.for_buffer(buf).draw(strategy)
-        except HypothesisException:
-            reject()
-        # Draw again with the same buffer. This will cause a duplicate
-        # primary key.
-        ConjectureData.for_buffer(buf).draw(strategy)
-        assert CompanyExtension.objects.all().count() == 1
-
-
-class TestsNeedingRollback(TransactionTestCase):
-    def test_can_get_examples(self):
-        for _ in range(200):
-            from_model(Company).example()
-
-
-class TestRestrictedFields(TestCase):
-    @given(from_model(RestrictedFields))
-    def test_constructs_valid_instance(self, instance):
-        self.assertIsInstance(instance, RestrictedFields)
-        instance.full_clean()
-        self.assertLessEqual(len(instance.text_field_4), 4)
-        self.assertLessEqual(len(instance.char_field_4), 4)
-        self.assertIn(instance.choice_field_text, ("foo", "bar"))
-        self.assertIn(instance.choice_field_int, (1, 2))
-        self.assertIn(instance.null_choice_field_int, (1, 2, None))
-        self.assertEqual(
-            instance.choice_field_grouped, instance.choice_field_grouped.lower()
-        )
-        self.assertEqual(instance.even_number_field % 2, 0)
-        self.assertTrue(instance.non_blank_text_field)
-
-
-class TestValidatorInference(TestCase):
-    @given(from_model(User))
-    def test_user_issue_1112_regression(self, user):
-        assert user.username
-
-
-class TestPosOnlyArg(TestCase):
-    @given(from_model(Car))
-    def test_user_issue_2369_regression(self, val):
-        pass
-
-    def test_from_model_argspec(self):
-        if sys.version_info:2 <= (3, 7):
-            self.assertRaises(TypeError, from_model().example)
-            self.assertRaises(TypeError, from_model(Car, None).example)
-            self.assertRaises(TypeError, from_model(model=Customer).example)
-        else:
-            self.assertRaises(TypeError, from_model)
-            self.assertRaises(TypeError, from_model, Car, None)
-            self.assertRaises(TypeError, from_model, model=Customer)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/django/toystore/views.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/dpcontracts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/dpcontracts/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/dpcontracts/test_contracts.py Deleted

@@ -1,42 +0,0 @@
-# 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 pytest
-from dpcontracts import require
-
-from hypothesis import given
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.dpcontracts import fulfill
-from hypothesis.strategies import builds, integers
-
-
-def identity(x):
-    return x
-
-
-@require("division is undefined for zero", lambda args: args.n != 0)
-def invert(n):
-    return 1 / n
-
-
-@given(builds(fulfill(invert), integers()))
-def test_contract_filter_builds(x):
-    assert -1 <= x <= 1
-
-
-@given(integers())
-def test_contract_filter_inline(n):
-    assert -1 <= fulfill(invert)(n) <= 1
-
-
-@pytest.mark.parametrize("f", int, identity, lambda x: None)
-def test_no_vacuous_fulfill(f):
-    with pytest.raises(InvalidArgument):
-        fulfill(f)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/addition_op_magic.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/addition_op_multimagic.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/base64_magic.txt Deleted

@@ -1,81 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-import base64
-from hypothesis import given, strategies as st
-
-# TODO: replace st.nothing() with appropriate strategies
-
-
-@given(
-    adobe=st.booleans(),
-    b=st.nothing(),
-    foldspaces=st.booleans(),
-    ignorechars=st.just(b" \t\n\r\x0b"),
-    pad=st.booleans(),
-    wrapcol=st.just(0),
-)
-def test_roundtrip_a85encode_a85decode(adobe, b, foldspaces, ignorechars, pad, wrapcol):
-    value0 = base64.a85encode(
-        b=b, foldspaces=foldspaces, wrapcol=wrapcol, pad=pad, adobe=adobe
-    )
-    value1 = base64.a85decode(
-        b=value0, foldspaces=foldspaces, adobe=adobe, ignorechars=ignorechars
-    )
-    assert b == value1, (b, value1)
-
-
-@given(casefold=st.booleans(), s=st.nothing())
-def test_roundtrip_b16encode_b16decode(casefold, s):
-    value0 = base64.b16encode(s=s)
-    value1 = base64.b16decode(s=value0, casefold=casefold)
-    assert s == value1, (s, value1)
-
-
-@given(casefold=st.booleans(), map01=st.none(), s=st.nothing())
-def test_roundtrip_b32encode_b32decode(casefold, map01, s):
-    value0 = base64.b32encode(s=s)
-    value1 = base64.b32decode(s=value0, casefold=casefold, map01=map01)
-    assert s == value1, (s, value1)
-
-
-@given(altchars=st.none(), s=st.nothing(), validate=st.booleans())
-def test_roundtrip_b64encode_b64decode(altchars, s, validate):
-    value0 = base64.b64encode(s=s, altchars=altchars)
-    value1 = base64.b64decode(s=value0, altchars=altchars, validate=validate)
-    assert s == value1, (s, value1)
-
-
-@given(b=st.nothing(), pad=st.booleans())
-def test_roundtrip_b85encode_b85decode(b, pad):
-    value0 = base64.b85encode(b=b, pad=pad)
-    value1 = base64.b85decode(b=value0)
-    assert b == value1, (b, value1)
-
-
-@given(input=st.nothing(), output=st.nothing())
-def test_roundtrip_encode_decode(input, output):
-    value0 = base64.encode(input=input, output=output)
-    value1 = base64.decode(input=value0, output=output)
-    assert input == value1, (input, value1)
-
-
-@given(s=st.nothing())
-def test_roundtrip_encodebytes_decodebytes(s):
-    value0 = base64.encodebytes(s=s)
-    value1 = base64.decodebytes(s=value0)
-    assert s == value1, (s, value1)
-
-
-@given(s=st.nothing())
-def test_roundtrip_standard_b64encode_standard_b64decode(s):
-    value0 = base64.standard_b64encode(s=s)
-    value1 = base64.standard_b64decode(s=value0)
-    assert s == value1, (s, value1)
-
-
-@given(s=st.nothing())
-def test_roundtrip_urlsafe_b64encode_urlsafe_b64decode(s):
-    value0 = base64.urlsafe_b64encode(s=s)
-    value1 = base64.urlsafe_b64decode(s=value0)
-    assert s == value1, (s, value1)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/division_binop_error_handler.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/division_fuzz_error_handler.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/division_operator.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/division_roundtrip_arithmeticerror_handler.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/division_roundtrip_error_handler.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/division_roundtrip_typeerror_handler.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/eval_equivalent.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/fuzz_classmethod.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/fuzz_sorted.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/fuzz_staticmethod.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/fuzz_ufunc.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/fuzz_with_docstring.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/hypothesis_module_magic.txt Deleted

@@ -1,116 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-import hypothesis
-import typing
-from hypothesis import given, settings, strategies as st
-from hypothesis.strategies._internal.strategies import Ex
-from random import Random
-
-
-@given(condition=st.from_type(object))
-def test_fuzz_assume(condition):
-    hypothesis.assume(condition=condition)
-
-
-@given(value=st.text())
-def test_fuzz_event(value):
-    hypothesis.event(value=value)
-
-
-@given(
-    specifier=st.from_type(hypothesis.strategies.SearchStrategy),
-    condition=st.functions(like=lambda *a, **k: None, returns=st.booleans()),
-    settings=st.one_of(st.none(), st.builds(settings)),
-    random=st.one_of(st.none(), st.builds(Random)),
-    database_key=st.one_of(st.none(), st.binary()),
-)
-def test_fuzz_find(specifier, condition, settings, random, database_key):
-    hypothesis.find(
-        specifier=specifier,
-        condition=condition,
-        settings=settings,
-        random=random,
-        database_key=database_key,
-    )
-
-
-@given(value=st.text())
-def test_fuzz_note(value):
-    hypothesis.note(value=value)
-
-
-@given(r=st.builds(Random))
-def test_fuzz_register_random(r):
-    hypothesis.register_random(r=r)
-
-
-@given(version=st.text(), blob=st.binary())
-def test_fuzz_reproduce_failure(version, blob):
-    hypothesis.reproduce_failure(version=version, blob=blob)
-
-
-@given(seed=st.from_type(typing.Hashable))
-def test_fuzz_seed(seed):
-    hypothesis.seed(seed=seed)
-
-
-@given(
-    parent=st.none(),
-    max_examples=st.just(not_set),
-    derandomize=st.just(not_set),
-    database=st.just(not_set),
-    verbosity=st.just(not_set),
-    phases=st.just(not_set),
-    stateful_step_count=st.just(not_set),
-    report_multiple_bugs=st.just(not_set),
-    suppress_health_check=st.just(not_set),
-    deadline=st.just(not_set),
-    print_blob=st.just(not_set),
-)
-def test_fuzz_settings(
-    parent,
-    max_examples,
-    derandomize,
-    database,
-    verbosity,
-    phases,
-    stateful_step_count,
-    report_multiple_bugs,
-    suppress_health_check,
-    deadline,
-    print_blob,
-):
-    hypothesis.settings(
-        parent=parent,
-        max_examples=max_examples,
-        derandomize=derandomize,
-        database=database,
-        verbosity=verbosity,
-        phases=phases,
-        stateful_step_count=stateful_step_count,
-        report_multiple_bugs=report_multiple_bugs,
-        suppress_health_check=suppress_health_check,
-        deadline=deadline,
-        print_blob=print_blob,
-    )
-
-
-@given(name=st.text())
-def test_fuzz_settings_get_profile(name):
-    hypothesis.settings.get_profile(name=name)
-
-
-@given(name=st.text())
-def test_fuzz_settings_load_profile(name):
-    hypothesis.settings.load_profile(name=name)
-
-
-@given(name=st.text(), parent=st.one_of(st.none(), st.builds(settings)))
-def test_fuzz_settings_register_profile(name, parent):
-    hypothesis.settings.register_profile(name=name, parent=parent)
-
-
-@given(observation=st.one_of(st.floats(), st.integers()), label=st.text())
-def test_fuzz_target(observation, label):
-    hypothesis.target(observation=observation, label=label)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/magic_base64_roundtrip.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/magic_builtins.txt Deleted

@@ -1,306 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-from hypothesis import given, strategies as st
-
-# TODO: replace st.nothing() with appropriate strategies
-
-
-@given(x=st.nothing())
-def test_fuzz_abs(x):
-    abs(x)
-
-
-@given(iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())))
-def test_fuzz_all(iterable):
-    all(iterable)
-
-
-@given(iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())))
-def test_fuzz_any(iterable):
-    any(iterable)
-
-
-@given(obj=st.nothing())
-def test_fuzz_ascii(obj):
-    ascii(obj)
-
-
-@given(number=st.one_of(st.integers(), st.floats()))
-def test_fuzz_bin(number):
-    bin(number)
-
-
-@given(frm=st.nothing(), to=st.nothing())
-def test_fuzz_bytearray_maketrans(frm, to):
-    bytearray.maketrans(frm, to)
-
-
-@given(frm=st.nothing(), to=st.nothing())
-def test_fuzz_bytes_maketrans(frm, to):
-    bytes.maketrans(frm, to)
-
-
-@given(obj=st.nothing())
-def test_fuzz_callable(obj):
-    callable(obj)
-
-
-@given(i=st.nothing())
-def test_fuzz_chr(i):
-    chr(i)
-
-
-@given(
-    source=st.nothing(),
-    filename=st.nothing(),
-    mode=st.nothing(),
-    flags=st.just(0),
-    dont_inherit=st.booleans(),
-    optimize=st.just(-1),
-    _feature_version=st.just(-1),
-)
-def test_fuzz_compile(
-    source, filename, mode, flags, dont_inherit, optimize, _feature_version
-):
-    compile(
-        source=source,
-        filename=filename,
-        mode=mode,
-        flags=flags,
-        dont_inherit=dont_inherit,
-        optimize=optimize,
-        _feature_version=_feature_version,
-    )
-
-
-@given(real=st.just(0), imag=st.just(0))
-def test_fuzz_complex(real, imag):
-    complex(real=real, imag=imag)
-
-
-@given(obj=st.nothing(), name=st.text())
-def test_fuzz_delattr(obj, name):
-    delattr(obj, name)
-
-
-@given(object=st.builds(object))
-def test_fuzz_dir(object):
-    dir(object)
-
-
-@given(x=st.nothing(), y=st.nothing())
-def test_fuzz_divmod(x, y):
-    divmod(x, y)
-
-
-@given(
-    iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-    start=st.just(0),
-)
-def test_fuzz_enumerate(iterable, start):
-    enumerate(iterable=iterable, start=start)
-
-
-@given(source=st.nothing(), globals=st.none(), locals=st.none())
-def test_fuzz_eval(source, globals, locals):
-    eval(source, globals, locals)
-
-
-@given(source=st.nothing(), globals=st.none(), locals=st.none())
-def test_fuzz_exec(source, globals, locals):
-    exec(source, globals, locals)
-
-
-@given(x=st.just(0))
-def test_fuzz_float(x):
-    float(x)
-
-
-@given(value=st.nothing(), format_spec=st.just(""))
-def test_fuzz_format(value, format_spec):
-    format(value, format_spec)
-
-
-@given(object=st.builds(object), name=st.text(), default=st.nothing())
-def test_fuzz_getattr(object, name, default):
-    getattr(object, name, default)
-
-
-@given(obj=st.nothing(), name=st.text())
-def test_fuzz_hasattr(obj, name):
-    hasattr(obj, name)
-
-
-@given(obj=st.nothing())
-def test_fuzz_hash(obj):
-    hash(obj)
-
-
-@given(number=st.one_of(st.integers(), st.floats()))
-def test_fuzz_hex(number):
-    hex(number)
-
-
-@given(obj=st.nothing())
-def test_fuzz_id(obj):
-    id(obj)
-
-
-@given(prompt=st.none())
-def test_fuzz_input(prompt):
-    input(prompt)
-
-
-@given(obj=st.nothing(), class_or_tuple=st.nothing())
-def test_fuzz_isinstance(obj, class_or_tuple):
-    isinstance(obj, class_or_tuple)
-
-
-@given(cls=st.nothing(), class_or_tuple=st.nothing())
-def test_fuzz_issubclass(cls, class_or_tuple):
-    issubclass(cls, class_or_tuple)
-
-
-@given(iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())))
-def test_fuzz_iter(iterable):
-    iter(iterable)
-
-
-@given(obj=st.nothing())
-def test_fuzz_len(obj):
-    len(obj)
-
-
-@given(iterable=st.just(()))
-def test_fuzz_list(iterable):
-    list(iterable)
-
-
-@given(
-    iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-    default=st.nothing(),
-    key=st.nothing(),
-)
-def test_fuzz_max(iterable, default, key):
-    max(iterable, default=default, key=key)
-
-
-@given(object=st.builds(object))
-def test_fuzz_memoryview(object):
-    memoryview(object=object)
-
-
-@given(
-    iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-    default=st.nothing(),
-    key=st.nothing(),
-)
-def test_fuzz_min(iterable, default, key):
-    min(iterable, default=default, key=key)
-
-
-@given(iterator=st.nothing(), default=st.nothing())
-def test_fuzz_next(iterator, default):
-    next(iterator, default)
-
-
-@given(number=st.one_of(st.integers(), st.floats()))
-def test_fuzz_oct(number):
-    oct(number)
-
-
-@given(
-    file=st.nothing(),
-    mode=st.just("r"),
-    buffering=st.just(-1),
-    encoding=st.none(),
-    errors=st.none(),
-    newline=st.none(),
-    closefd=st.booleans(),
-    opener=st.none(),
-)
-def test_fuzz_open(file, mode, buffering, encoding, errors, newline, closefd, opener):
-    open(
-        file=file,
-        mode=mode,
-        buffering=buffering,
-        encoding=encoding,
-        errors=errors,
-        newline=newline,
-        closefd=closefd,
-        opener=opener,
-    )
-
-
-@given(c=st.nothing())
-def test_fuzz_ord(c):
-    ord(c)
-
-
-@given(base=st.nothing(), exp=st.nothing(), mod=st.none())
-def test_fuzz_pow(base, exp, mod):
-    pow(base=base, exp=exp, mod=mod)
-
-
-@given(
-    value=st.nothing(),
-    sep=st.text(),
-    end=st.nothing(),
-    file=st.nothing(),
-    flush=st.nothing(),
-)
-def test_fuzz_print(value, sep, end, file, flush):
-    print(value, sep=sep, end=end, file=file, flush=flush)
-
-
-@given(fget=st.none(), fset=st.none(), fdel=st.none(), doc=st.none())
-def test_fuzz_property(fget, fset, fdel, doc):
-    property(fget=fget, fset=fset, fdel=fdel, doc=doc)
-
-
-@given(obj=st.nothing())
-def test_fuzz_repr(obj):
-    repr(obj)
-
-
-@given(sequence=st.nothing())
-def test_fuzz_reversed(sequence):
-    reversed(sequence)
-
-
-@given(number=st.one_of(st.integers(), st.floats()), ndigits=st.none())
-def test_fuzz_round(number, ndigits):
-    round(number=number, ndigits=ndigits)
-
-
-@given(obj=st.nothing(), name=st.text(), value=st.nothing())
-def test_fuzz_setattr(obj, name, value):
-    setattr(obj, name, value)
-
-
-@given(
-    iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-    key=st.none(),
-    reverse=st.booleans(),
-)
-def test_fuzz_sorted(iterable, key, reverse):
-    sorted(iterable, key=key, reverse=reverse)
-
-
-@given(
-    iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-    start=st.just(0),
-)
-def test_fuzz_sum(iterable, start):
-    sum(iterable, start=start)
-
-
-@given(iterable=st.just(()))
-def test_fuzz_tuple(iterable):
-    tuple(iterable)
-
-
-@given(object=st.builds(object))
-def test_fuzz_vars(object):
-    vars(object)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/magic_class.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/magic_gufunc.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/multiplication_operator.txt Deleted

@@ -1,35 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-import _operator
-from hypothesis import given, strategies as st
-
-# TODO: replace st.nothing() with an appropriate strategy
-
-mul_operands = st.nothing()
-
-
-@given(a=mul_operands, b=mul_operands, c=mul_operands)
-def test_associative_binary_operation_mul(a, b, c):
-    left = _operator.mul(a, _operator.mul(b, c))
-    right = _operator.mul(_operator.mul(a, b), c)
-    assert left == right, (left, right)
-
-
-@given(a=mul_operands, b=mul_operands)
-def test_commutative_binary_operation_mul(a, b):
-    left = _operator.mul(a, b)
-    right = _operator.mul(b, a)
-    assert left == right, (left, right)
-
-
-@given(a=mul_operands)
-def test_identity_binary_operation_mul(a):
-    assert a == _operator.mul(a, 1)
-
-
-@given(a=mul_operands, b=mul_operands, c=mul_operands)
-def test_add_distributes_over_binary_operation_mul(a, b, c):
-    left = _operator.add(_operator.mul(a, b), _operator.mul(a, c))
-    right = _operator.mul(a, _operator.add(b, c))
-    assert left == right, (left, right)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/multiplication_operator_unittest.txt Deleted

@@ -1,34 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-import _operator
-import unittest
-from hypothesis import given, strategies as st
-
-# TODO: replace st.nothing() with an appropriate strategy
-
-
-class TestBinaryOperationmul(unittest.TestCase):
-    mul_operands = st.nothing()
-
-    @given(a=mul_operands, b=mul_operands, c=mul_operands)
-    def test_associative_binary_operation_mul(self, a, b, c):
-        left = _operator.mul(a, _operator.mul(b, c))
-        right = _operator.mul(_operator.mul(a, b), c)
-        self.assertEqual(left, right)
-
-    @given(a=mul_operands, b=mul_operands)
-    def test_commutative_binary_operation_mul(self, a, b):
-        left = _operator.mul(a, b)
-        right = _operator.mul(b, a)
-        self.assertEqual(left, right)
-
-    @given(a=mul_operands)
-    def test_identity_binary_operation_mul(self, a):
-        self.assertEqual(a, _operator.mul(a, 1))
-
-    @given(a=mul_operands, b=mul_operands, c=mul_operands)
-    def test_add_distributes_over_binary_operation_mul(self, a, b, c):
-        left = _operator.add(_operator.mul(a, b), _operator.mul(a, c))
-        right = _operator.mul(a, _operator.add(b, c))
-        self.assertEqual(left, right)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/re_compile.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/re_compile_except.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/re_compile_unittest.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/sorted_idempotent.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/sorted_self_equivalent.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/sorted_self_error_equivalent_1error.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/sorted_self_error_equivalent_2error_unittest.txt Deleted

@@ -1,29 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-import unittest
-from hypothesis import given, reject, strategies as st, target
-
-
-class TestEquivalentSortedSorted(unittest.TestCase):
-    @given(
-        iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-        key=st.none(),
-        reverse=st.booleans(),
-    )
-    def test_equivalent_sorted_sorted(self, iterable, key, reverse):
-        try:
-            result_0_sorted = sorted(iterable, key=key, reverse=reverse)
-            exc_type = None
-            target(1, label="input was valid")
-        except (TypeError, ValueError):
-            reject()
-        except Exception as exc:
-            exc_type = type(exc)
-
-        if exc_type:
-            with self.assertRaises(exc_type):
-                sorted(iterable, key=key, reverse=reverse)
-        else:
-            result_1_sorted = sorted(iterable, key=key, reverse=reverse)
-            self.assertEqual(result_0_sorted, result_1_sorted)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/sorted_self_error_equivalent_simple.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/sorted_self_error_equivalent_threefuncs.txt Deleted

@@ -1,33 +0,0 @@
-# This test code was written by the `hypothesis.extra.ghostwriter` module
-# and is provided under the Creative Commons Zero public domain dedication.
-
-import pytest
-from hypothesis import given, strategies as st, target
-
-
-@given(
-    iterable=st.one_of(st.iterables(st.integers()), st.iterables(st.text())),
-    key=st.none(),
-    reverse=st.booleans(),
-)
-def test_equivalent_sorted_sorted_sorted(iterable, key, reverse):
-    try:
-        result_0_sorted = sorted(iterable, key=key, reverse=reverse)
-        exc_type = None
-        target(1, label="input was valid")
-    except Exception as exc:
-        exc_type = type(exc)
-
-    if exc_type:
-        with pytest.raises(exc_type):
-            sorted(iterable, key=key, reverse=reverse)
-    else:
-        result_1_sorted = sorted(iterable, key=key, reverse=reverse)
-        assert result_0_sorted == result_1_sorted, (result_0_sorted, result_1_sorted)
-
-    if exc_type:
-        with pytest.raises(exc_type):
-            sorted(iterable, key=key, reverse=reverse)
-    else:
-        result_2_sorted = sorted(iterable, key=key, reverse=reverse)
-        assert result_0_sorted == result_2_sorted, (result_0_sorted, result_2_sorted)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/timsort_idempotent.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/recorded/timsort_idempotent_asserts.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/test_expected_output.py Deleted

@@ -1,209 +0,0 @@
-# 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/.
-
-"""
-'Golden master' tests for the ghostwriter.
-
-To update the recorded outputs, run `pytest --hypothesis-update-outputs ...`.
-"""
-
-import ast
-import base64
-import builtins
-import operator
-import pathlib
-import re
-import sys
-from typing import Sequence
-
-import numpy
-import pytest
-
-import hypothesis
-from hypothesis.extra import ghostwriter
-from hypothesis.utils.conventions import not_set
-
-
-@pytest.fixture
-def update_recorded_outputs(request):
-    return request.config.getoption("--hypothesis-update-outputs")
-
-
-def get_recorded(name, actual=""):
-    file_ = pathlib.Path(__file__).parent / "recorded" / f"{name}.txt"
-    if actual:
-        file_.write_text(actual)
-    return file_.read_text()
-
-
-def timsort(seq: Sequenceint) -> Sequenceint:
-    return sorted(seq)
-
-
-def with_docstring(a, b, c, d=int, e=lambda x: f"xx{x}xx") -> None:
-    """Demonstrates parsing params from the docstring
-
-    :param a: sphinx docstring style
-    :type a: sequence of integers
-
-    b (list, tuple, or None): Google docstring style
-
-    c : {"foo", "bar", or None}
-        Numpy docstring style
-    """
-
-
-class A_Class:
-    @classmethod
-    def a_classmethod(cls, arg: int):
-        pass
-
-    @staticmethod
-    def a_staticmethod(arg: int):
-        pass
-
-
-def add(a: float, b: float) -> float:
-    return a + b
-
-
-def divide(a: int, b: int) -> float:
-    """This is a RST-style docstring for `divide`.
-
-    :raises ZeroDivisionError: if b == 0
-    """
-    return a / b
-
-
-# Note: for some of the `expected` outputs, we replace away some small
-#       parts which vary between minor versions of Python.
-@pytest.mark.parametrize(
-    "data",
-    
-        ("fuzz_sorted", ghostwriter.fuzz(sorted)),
-        ("fuzz_with_docstring", ghostwriter.fuzz(with_docstring)),
-        ("fuzz_classmethod", ghostwriter.fuzz(A_Class.a_classmethod)),
-        ("fuzz_staticmethod", ghostwriter.fuzz(A_Class.a_staticmethod)),
-        ("fuzz_ufunc", ghostwriter.fuzz(numpy.add)),
-        ("magic_gufunc", ghostwriter.magic(numpy.matmul)),
-        ("magic_base64_roundtrip", ghostwriter.magic(base64.b64encode)),
-        ("re_compile", ghostwriter.fuzz(re.compile)),
-        (
-            "re_compile_except",
-            ghostwriter.fuzz(re.compile, except_=re.error)
-            # re.error fixed it's __module__ in Python 3.7
-            .replace("import sre_constants\n", "").replace("sre_constants.", "re."),
-        ),
-        ("re_compile_unittest", ghostwriter.fuzz(re.compile, style="unittest")),
-        pytest.param(
-            ("base64_magic", ghostwriter.magic(base64)),
-            marks=pytest.mark.skipif("sys.version_info:2 >= (3, 10)"),
-        ),
-        ("sorted_idempotent", ghostwriter.idempotent(sorted)),
-        ("timsort_idempotent", ghostwriter.idempotent(timsort)),
-        (
-            "timsort_idempotent_asserts",
-            ghostwriter.idempotent(timsort, except_=AssertionError),
-        ),
-        ("eval_equivalent", ghostwriter.equivalent(eval, ast.literal_eval)),
-        ("sorted_self_equivalent", ghostwriter.equivalent(sorted, sorted, sorted)),
-        ("addition_op_magic", ghostwriter.magic(add)),
-        ("addition_op_multimagic", ghostwriter.magic(add, operator.add, numpy.add)),
-        ("division_fuzz_error_handler", ghostwriter.fuzz(divide)),
-        (
-            "division_binop_error_handler",
-            ghostwriter.binary_operation(divide, identity=1),
-        ),
-        (
-            "division_roundtrip_error_handler",
-            ghostwriter.roundtrip(divide, operator.mul),
-        ),
-        (
-            "division_roundtrip_arithmeticerror_handler",
-            ghostwriter.roundtrip(divide, operator.mul, except_=ArithmeticError),
-        ),
-        (
-            "division_roundtrip_typeerror_handler",
-            ghostwriter.roundtrip(divide, operator.mul, except_=TypeError),
-        ),
-        (
-            "division_operator",
-            ghostwriter.binary_operation(
-                operator.truediv, associative=False, commutative=False
-            ),
-        ),
-        (
-            "multiplication_operator",
-            ghostwriter.binary_operation(
-                operator.mul, identity=1, distributes_over=operator.add
-            ),
-        ),
-        (
-            "multiplication_operator_unittest",
-            ghostwriter.binary_operation(
-                operator.mul,
-                identity=1,
-                distributes_over=operator.add,
-                style="unittest",
-            ),
-        ),
-        (
-            "sorted_self_error_equivalent_simple",
-            ghostwriter.equivalent(sorted, sorted, allow_same_errors=True),
-        ),
-        (
-            "sorted_self_error_equivalent_threefuncs",
-            ghostwriter.equivalent(sorted, sorted, sorted, allow_same_errors=True),
-        ),
-        (
-            "sorted_self_error_equivalent_1error",
-            ghostwriter.equivalent(
-                sorted,
-                sorted,
-                allow_same_errors=True,
-                except_=ValueError,
-            ),
-        ),
-        (
-            "sorted_self_error_equivalent_2error_unittest",
-            ghostwriter.equivalent(
-                sorted,
-                sorted,
-                allow_same_errors=True,
-                except_=(TypeError, ValueError),
-                style="unittest",
-            ),
-        ),
-        ("magic_class", ghostwriter.magic(A_Class)),
-        pytest.param(
-            ("magic_builtins", ghostwriter.magic(builtins)),
-            marks=
-                pytest.mark.skipif(
-                    sys.version_info:2 not in (3, 8), (3, 9),
-                    reason="compile arg new in 3.8, aiter and anext new in 3.10",
-                )
-            ,
-        ),
-    ,
-    ids=lambda x: x0,
-)
-def test_ghostwriter_example_outputs(update_recorded_outputs, data):
-    name, actual = data
-    expected = get_recorded(name, actual * update_recorded_outputs)
-    assert actual == expected  # We got the expected source code
-    exec(expected, {})  # and there are no SyntaxError or NameErrors
-
-
-def test_ghostwriter_on_hypothesis(update_recorded_outputs):
-    actual = ghostwriter.magic(hypothesis).replace("Strategy+Ex", "Strategy")
-    expected = get_recorded("hypothesis_module_magic", actual * update_recorded_outputs)
-    if sys.version_info:2 < (3, 10):
-        assert actual == expected
-    exec(expected, {"not_set": not_set})

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/test_ghostwriter.py Deleted

@@ -1,427 +0,0 @@
-# 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 ast
-import enum
-import json
-import re
-import socket
-import unittest
-import unittest.mock
-from decimal import Decimal
-from types import ModuleType
-from typing import (
-    Any,
-    FrozenSet,
-    KeysView,
-    List,
-    Match,
-    Pattern,
-    Sequence,
-    Set,
-    Sized,
-    Union,
-    ValuesView,
-)
-
-import attr
-import pytest
-
-from hypothesis.errors import InvalidArgument, MultipleFailures, Unsatisfiable
-from hypothesis.extra import ghostwriter
-from hypothesis.strategies import builds, from_type, just, lists
-from hypothesis.strategies._internal.lazy import LazyStrategy
-
-varied_excepts = pytest.mark.parametrize("ex", (), ValueError, (TypeError, re.error))
-
-
-def get_test_function(source_code):
-    # A helper function to get the dynamically-defined test function.
-    # Note that this also tests that the module is syntatically-valid,
-    # AND free from undefined names, import problems, and so on.
-    namespace = {}
-    try:
-        exec(source_code, namespace)
-    except Exception:
-        print(f"************\n{source_code}\n************")
-        raise
-    tests = 
-        v
-        for k, v in namespace.items()
-        if k.startswith(("test_", "Test")) and not isinstance(v, ModuleType)
-    
-    assert len(tests) == 1, tests
-    return tests0
-
-
-@pytest.mark.parametrize(
-    "badness", "not an exception", BaseException, ValueError, (Exception, "bad")
-)
-def test_invalid_exceptions(badness):
-    with pytest.raises(InvalidArgument):
-        ghostwriter._check_except(badness)
-
-
-def test_style_validation():
-    ghostwriter._check_style("pytest")
-    ghostwriter._check_style("unittest")
-    with pytest.raises(InvalidArgument):
-        ghostwriter._check_style("not a valid style")
-
-
-def test_strategies_with_invalid_syntax_repr_as_nothing():
-    msg = "$$ this repr is not Python syntax $$"
-
-    class NoRepr:
-        def __repr__(self):
-            return msg
-
-    s = just(NoRepr())
-    assert repr(s) == f"just({msg})"
-    assert ghostwriter._valid_syntax_repr(s)1 == "nothing()"
-
-
-class AnEnum(enum.Enum):
-    a = "value of AnEnum.a"
-    b = "value of AnEnum.b"
-
-
-def takes_enum(foo=AnEnum.a):
-    # This can only fail if we use the default argument to guess
-    # that any instance of that enum type should be allowed.
-    assert foo != AnEnum.b
-
-
-def test_ghostwriter_exploits_arguments_with_enum_defaults():
-    source_code = ghostwriter.fuzz(takes_enum)
-    test = get_test_function(source_code)
-    with pytest.raises(AssertionError):
-        test()
-
-
-def timsort(seq: Sequenceint) -> Listint:
-    return sorted(seq)
-
-
-def non_type_annotation(x: 3):  # type: ignore
-    pass
-
-
-def annotated_any(x: Any):
-    pass
-
-
-space_in_name = type("a name", (type,), {"__init__": lambda self: None})
-
-
-class NotResolvable:
-    def __init__(self, unannotated_required):
-        pass
-
-
-def non_resolvable_arg(x: NotResolvable):
-    pass
-
-
-def test_flattens_one_of_repr():
-    strat = from_type(Unionint, Sequenceint)
-    assert repr(strat).count("one_of(") > 1
-    assert ghostwriter._valid_syntax_repr(strat)1.count("one_of(") == 1
-
-
-def takes_keys(x: KeysViewint) -> None:
-    pass
-
-
-def takes_values(x: ValuesViewint) -> None:
-    pass
-
-
-def takes_match(x: Matchbytes) -> None:
-    pass
-
-
-def takes_pattern(x: Patternstr) -> None:
-    pass
-
-
-def takes_sized(x: Sized) -> None:
-    pass
-
-
-def takes_frozensets(a: FrozenSetint, b: FrozenSetint) -> None:
-    pass
-
-
-@attr.s()
-class Foo:
-    foo: str = attr.ib()
-
-
-def takes_attrs_class(x: Foo) -> None:
-    pass
-
-
-@varied_excepts
-@pytest.mark.parametrize(
-    "func",
-    
-        re.compile,
-        json.loads,
-        json.dump,
-        timsort,
-        ast.literal_eval,
-        non_type_annotation,
-        annotated_any,
-        space_in_name,
-        non_resolvable_arg,
-        takes_keys,
-        takes_values,
-        takes_match,
-        takes_pattern,
-        takes_sized,
-        takes_frozensets,
-        takes_attrs_class,
-    ,
-)
-def test_ghostwriter_fuzz(func, ex):
-    source_code = ghostwriter.fuzz(func, except_=ex)
-    get_test_function(source_code)
-
-
-def test_socket_module():
-    source_code = ghostwriter.magic(socket)
-    exec(source_code, {})
-
-
-def test_binary_op_also_handles_frozensets():
-    # Using str.replace in a loop would convert `frozensets()` into
-    # `st.frozenst.sets()` instead of `st.frozensets()`; fixed with re.sub.
-    source_code = ghostwriter.binary_operation(takes_frozensets)
-    exec(source_code, {})
-
-
-@varied_excepts
-@pytest.mark.parametrize(
-    "func", re.compile, json.loads, json.dump, timsort, ast.literal_eval
-)
-def test_ghostwriter_unittest_style(func, ex):
-    source_code = ghostwriter.fuzz(func, except_=ex, style="unittest")
-    assert issubclass(get_test_function(source_code), unittest.TestCase)
-
-
-def no_annotations(foo=None, bar=False):
-    pass
-
-
-def test_inference_from_defaults_and_none_booleans_reprs_not_just_and_sampled_from():
-    source_code = ghostwriter.fuzz(no_annotations)
-    assert "@given(foo=st.none(), bar=st.booleans())" in source_code
-
-
-def hopefully_hashable(foo: SetDecimal):
-    pass
-
-
-def test_no_hashability_filter():
-    # In from_type, we ordinarily protect users from really weird cases like
-    # `Decimal('snan')` - a unhashable value of a hashable type - but in the
-    # ghostwriter we instead want to present this to the user for an explicit
-    # decision.  They can pass `allow_nan=False`, fix their custom type's
-    # hashing logic, or whatever else; simply doing nothing will usually work.
-    source_code = ghostwriter.fuzz(hopefully_hashable)
-    assert "@given(foo=st.sets(st.decimals()))" in source_code
-    assert "_can_hash" not in source_code
-
-
-@pytest.mark.parametrize(
-    "gw,args",
-    
-        (ghostwriter.fuzz, "not callable"),
-        (ghostwriter.idempotent, "not callable"),
-        (ghostwriter.roundtrip, ),
-        (ghostwriter.roundtrip, "not callable"),
-        (ghostwriter.equivalent, sorted),
-        (ghostwriter.equivalent, sorted, "not callable"),
-    ,
-)
-def test_invalid_func_inputs(gw, args):
-    with pytest.raises(InvalidArgument):
-        gw(*args)
-
-
-class A:
-    @classmethod
-    def to_json(cls, obj: Uniondict, list) -> str:
-        return json.dumps(obj)
-
-    @classmethod
-    def from_json(cls, obj: str) -> Uniondict, list:
-        return json.loads(obj)
-
-    @staticmethod
-    def static_sorter(seq: Sequenceint) -> Listint:
-        return sorted(seq)
-
-
-@pytest.mark.parametrize(
-    "gw,args",
-    
-        (ghostwriter.fuzz, A.static_sorter),
-        (ghostwriter.idempotent, A.static_sorter),
-        (ghostwriter.roundtrip, A.to_json, A.from_json),
-        (ghostwriter.equivalent, A.to_json, json.dumps),
-    ,
-)
-def test_class_methods_inputs(gw, args):
-    source_code = gw(*args)
-    get_test_function(source_code)()
-
-
-def test_run_ghostwriter_fuzz():
-    # Our strategy-guessing code works for all the arguments to sorted,
-    # and we handle positional-only arguments in calls correctly too.
-    source_code = ghostwriter.fuzz(sorted)
-    assert "st.nothing()" not in source_code
-    get_test_function(source_code)()
-
-
-class MyError(UnicodeDecodeError):
-    pass
-
-
-@pytest.mark.parametrize(
-    "exceptions,output",
-    
-        # Discard subclasses of other exceptions to catch, including non-builtins,
-        # and replace OSError aliases with OSError.
-        ((Exception, UnicodeError), "Exception"),
-        ((UnicodeError, MyError), "UnicodeError"),
-        ((IOError,), "OSError"),
-        ((IOError, UnicodeError), "(OSError, UnicodeError)"),
-    ,
-)
-def test_exception_deduplication(exceptions, output):
-    _, body = ghostwriter._make_test_body(
-        lambda: None, ghost="", test_body="pass", except_=exceptions, style="pytest"
-    )
-    assert f"except {output}:" in body
-
-
-def test_run_ghostwriter_roundtrip():
-    # This test covers the whole lifecycle: first, we get the default code.
-    # The first argument is unknown, so we fail to draw from st.nothing()
-    source_code = ghostwriter.roundtrip(json.dumps, json.loads)
-    with pytest.raises(Unsatisfiable):
-        get_test_function(source_code)()
-
-    # Replacing that nothing() with a strategy for JSON allows us to discover
-    # two possible failures: `nan` is not equal to itself, and if dumps is
-    # passed allow_nan=False it is a ValueError to pass a non-finite float.
-    source_code = source_code.replace(
-        "st.nothing()",
-        "st.recursive(st.one_of(st.none(), st.booleans(), st.floats(), st.text()), "
-        "lambda v: st.lists(v, max_size=2) | st.dictionaries(st.text(), v, max_size=2)"
-        ", max_leaves=2)",
-    )
-    try:
-        get_test_function(source_code)()
-    except (AssertionError, ValueError, MultipleFailures):
-        pass
-
-    # Finally, restricting ourselves to finite floats makes the test pass!
-    source_code = source_code.replace(
-        "st.floats()", "st.floats(allow_nan=False, allow_infinity=False)"
-    )
-    get_test_function(source_code)()
-
-
-@varied_excepts
-@pytest.mark.parametrize("func", sorted, timsort)
-def test_ghostwriter_idempotent(func, ex):
-    source_code = ghostwriter.idempotent(func, except_=ex)
-    test = get_test_function(source_code)
-    if "=st.nothing()" in source_code:
-        with pytest.raises(Unsatisfiable):
-            test()
-    else:
-        test()
-
-
-def test_overlapping_args_use_union_of_strategies():
-    def f(arg: int) -> None:
-        pass
-
-    def g(arg: float) -> None:
-        pass
-
-    source_code = ghostwriter.equivalent(f, g)
-    assert "arg=st.one_of(st.integers(), st.floats())" in source_code
-
-
-def test_module_with_mock_does_not_break():
-    # Before we added an explicit check for unspec'd mocks, they would pass
-    # through the initial validation and then fail when used in more detailed
-    # logic in the ghostwriter machinery.
-    ghostwriter.magic(unittest.mock)
-
-
-def compose_types(x: type, y: type):
-    pass
-
-
-def test_unrepr_identity_elem():
-    # Works with inferred identity element
-    source_code = ghostwriter.binary_operation(compose_types)
-    exec(source_code, {})
-    # and also works with explicit identity element
-    source_code = ghostwriter.binary_operation(compose_types, identity=type)
-    exec(source_code, {})
-
-
-@pytest.mark.parametrize(
-    "strategy, imports",
-    # The specifics don't matter much here; we're just demonstrating that
-    # we can walk the strategy and collect all the objects to import.
-    
-        # Lazy from_type() is handled without being unwrapped
-        (LazyStrategy(from_type, (enum.Enum,), {}), {("enum", "Enum")}),
-        # Mapped, filtered, and flatmapped check both sides of the method
-        (
-            builds(enum.Enum).map(Decimal),
-            {("enum", "Enum"), ("decimal", "Decimal")},
-        ),
-        (
-            builds(enum.Enum).flatmap(Decimal),
-            {("enum", "Enum"), ("decimal", "Decimal")},
-        ),
-        (
-            builds(enum.Enum).filter(Decimal).filter(re.compile),
-            {("enum", "Enum"), ("decimal", "Decimal"), ("re", "compile")},
-        ),
-        # one_of() strategies recurse into all the branches
-        (
-            builds(enum.Enum) | builds(Decimal) | builds(re.compile),
-            {("enum", "Enum"), ("decimal", "Decimal"), ("re", "compile")},
-        ),
-        # and builds() checks the arguments as well as the target
-        (
-            builds(enum.Enum, builds(Decimal), kw=builds(re.compile)),
-            {("enum", "Enum"), ("decimal", "Decimal"), ("re", "compile")},
-        ),
-        # lists recurse on imports
-        (
-            lists(builds(Decimal)),
-            {("decimal", "Decimal")},
-        ),
-    ,
-)
-def test_get_imports_for_strategy(strategy, imports):
-    assert ghostwriter._imports_for_strategy(strategy) == imports

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/test_ghostwriter_cli.py Deleted

@@ -1,255 +0,0 @@
-# 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 ast
-import itertools
-import json
-import operator
-import re
-import subprocess
-
-import pytest
-
-from hypothesis.errors import StopTest
-from hypothesis.extra.ghostwriter import (
-    binary_operation,
-    equivalent,
-    fuzz,
-    idempotent,
-    roundtrip,
-)
-
-
-@pytest.mark.parametrize(
-    "cli,code",
-    
-        # Passing one argument falls back to one-argument tests
-        ("--equivalent re.compile", lambda: fuzz(re.compile)),
-        ("--roundtrip sorted", lambda: idempotent(sorted)),
-        # For multiple arguments, they're equivalent to the function call
-        (
-            "--equivalent eval ast.literal_eval",
-            lambda: equivalent(eval, ast.literal_eval),
-        ),
-        (
-            "--roundtrip json.loads json.dumps --except ValueError",
-            lambda: roundtrip(json.loads, json.dumps, except_=ValueError),
-        ),
-        # Imports submodule (importlib.import_module passes; __import__ fails)
-        ("hypothesis.errors.StopTest", lambda: fuzz(StopTest)),
-        # We can write tests for classes even without classmethods or staticmethods
-        ("hypothesis.errors.StopTest", lambda: fuzz(StopTest)),
-        # Search for identity element does not print e.g. "You can use @seed ..."
-        ("--binary-op operator.add", lambda: binary_operation(operator.add)),
-    ,
-)
-def test_cli_python_equivalence(cli, code):
-    result = subprocess.run(
-        "hypothesis write " + cli,
-        capture_output=True,
-        shell=True,
-        text=True,
-    )
-    result.check_returncode()
-    cli_output = result.stdout.strip()
-    assert not result.stderr
-    code_output = code().strip()
-    assert code_output == cli_output
-
-
-@pytest.mark.parametrize(
-    "cli,err_msg",
-    
-        ("--idempotent sorted sorted", "Test functions for idempotence one at a time."),
-        (
-            "xxxx",
-            "Found the 'builtins' module, but it doesn't have a 'xxxx' attribute.",
-        ),
-        (
-            "re.srch",
-            "Found the 're' module, but it doesn't have a 'srch' attribute.  "
-            "Closest matches: 'search'",
-        ),
-        (
-            "re.fmatch",
-            "Found the 're' module, but it doesn't have a 'fmatch' attribute.  "
-            "Closest matches: 'match', 'fullmatch'",
-            # Python >= 3.7 has 'Match' objects too
-        ),
-    ,
-)
-def test_cli_too_many_functions(cli, err_msg):
-    # Supplying multiple functions to writers that only cope with one
-    result = subprocess.run(
-        "hypothesis write " + cli,
-        capture_output=True,
-        shell=True,
-        text=True,
-    )
-    assert result.returncode == 2
-    assert "Error: " + err_msg in result.stderr
-    assert ("Closest matches" in err_msg) == ("Closest matches" in result.stderr)
-
-
-CODE_TO_TEST = """
-from typing import Sequence, List
-
-def sorter(seq: Sequenceint) -> Listint:
-    return sorted(seq)
-"""
-
-
-def test_can_import_from_scripts_in_working_dir(tmpdir):
-    (tmpdir / "mycode.py").write(CODE_TO_TEST)
-    result = subprocess.run(
-        "hypothesis write mycode.sorter",
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-    assert result.returncode == 0
-    assert "Error: " not in result.stderr
-
-
-CLASS_CODE_TO_TEST = """
-from typing import Sequence, List
-
-def my_func(seq: Sequenceint) -> Listint:
-    return sorted(seq)
-
-class MyClass:
-
-    @staticmethod
-    def my_staticmethod(seq: Sequenceint) -> Listint:
-        return sorted(seq)
-
-    @classmethod
-    def my_classmethod(cls, seq: Sequenceint) -> Listint:
-        return sorted(seq)
-"""
-
-
-@pytest.mark.parametrize("func", "my_staticmethod", "my_classmethod")
-def test_can_import_from_class(tmpdir, func):
-    (tmpdir / "mycode.py").write(CLASS_CODE_TO_TEST)
-    result = subprocess.run(
-        f"hypothesis write mycode.MyClass.{func}",
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-    assert result.returncode == 0
-    assert "Error: " not in result.stderr
-
-
-@pytest.mark.parametrize(
-    "classname,thing,kind",
-    
-        ("XX", "", "class"),
-        ("MyClass", " and 'MyClass' class", "attribute"),
-        ("my_func", " and 'my_func' attribute", "attribute"),
-    ,
-)
-def test_error_import_from_class(tmpdir, classname, thing, kind):
-    (tmpdir / "mycode.py").write(CLASS_CODE_TO_TEST)
-    result = subprocess.run(
-        f"hypothesis write mycode.{classname}.XX",
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-    msg = f"Error: Found the 'mycode' module{thing}, but it doesn't have a 'XX' {kind}."
-    assert result.returncode == 2
-    assert msg in result.stderr
-
-
-def test_magic_discovery_from_module(tmpdir):
-    (tmpdir / "mycode.py").write(CLASS_CODE_TO_TEST)
-    result = subprocess.run(
-        f"hypothesis write mycode",
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-    assert result.returncode == 0
-    assert "my_func" in result.stdout
-    assert "MyClass.my_staticmethod" in result.stdout
-    assert "MyClass.my_classmethod" in result.stdout
-
-
-ROUNDTRIP_CODE_TO_TEST = """
-from typing import Union
-import json
-
-def to_json(json: Uniondict,list) -> str:
-    return json.dumps(json)
-
-def from_json(json: str) -> Uniondict,list:
-    return json.loads(json)
-
-class MyClass:
-
-    @staticmethod
-    def to_json(json: Uniondict,list) -> str:
-        return json.dumps(json)
-
-    @staticmethod
-    def from_json(json: str) -> Uniondict,list:
-        return json.loads(json)
-
-class OtherClass:
-
-    @classmethod
-    def to_json(cls, json: Uniondict,list) -> str:
-        return json.dumps(json)
-
-    @classmethod
-    def from_json(cls, json: str) -> Uniondict,list:
-        return json.loads(json)
-"""
-
-
-def test_roundtrip_correct_pairs(tmpdir):
-    (tmpdir / "mycode.py").write(ROUNDTRIP_CODE_TO_TEST)
-    result = subprocess.run(
-        f"hypothesis write mycode",
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-    assert result.returncode == 0
-    for scope1, scope2 in itertools.product(
-        "mycode.MyClass", "mycode.OtherClass", "mycode", repeat=2
-    ):
-        round_trip_code = f"""value0 = {scope1}.to_json(json=json)
-    value1 = {scope2}.from_json(json=value0)"""
-        if scope1 == scope2:
-            assert round_trip_code in result.stdout
-        else:
-            assert round_trip_code not in result.stdout
-
-
-def test_empty_module_is_not_error(tmpdir):
-    (tmpdir / "mycode.py").write("# Nothing to see here\n")
-    result = subprocess.run(
-        "hypothesis write mycode",
-        capture_output=True,
-        shell=True,
-        text=True,
-        cwd=tmpdir,
-    )
-    assert result.returncode == 0
-    assert "Error: " not in result.stderr
-    assert "# Found no testable functions" in result.stdout

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/ghostwriter/try-writing-for-installed.py Deleted

@@ -1,71 +0,0 @@
-# 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/.
-
-"""Try running `hypothesis write ...` on all available modules.
-
-Prints a list of module names which caused some kind of internal error.
-
-The idea here is to check that we at least don't crash on anything that
-people actually ship, or at least only on the cases we know and don't
-really care about - there are a lot of strange things in a python install.
-Some have import-time side effects or errors so we skip them; others
-just have such weird semantics that we don't _want_ to support them.
-"""
-
-import distutils.sysconfig as sysconfig
-import multiprocessing
-import os
-import subprocess
-
-skip = (
-    "idlelib curses antigravity pip prompt_toolkit IPython .popen_ django. .test. "
-    "execnet.script lib2to3.pgen2.conv tests. Cython. ~ - ._ libcst.codemod. "
-    "modernize flask. sphinx. pyasn1 dbm.ndbm doctest"
-).split()
-
-
-def getmodules():
-    std_lib = sysconfig.get_python_lib(standard_lib=True)
-    for top, _, files in os.walk(std_lib):
-        for nm in files:
-            if nm.endswith(".py") and nm not in ("__init__.py", "__main__.py"):
-                modname = (
-                    os.path.join(top, nm)len(std_lib) + 1 : -3
-                    .replace(os.sep, ".")
-                    .replace("site-packages.", "")
-                )
-                if not any(bad in modname for bad in skip):
-                    yield modname
-
-
-def write_for(mod):
-    try:
-        subprocess.run(
-            "hypothesis", "write", mod,
-            check=True,
-            capture_output=True,
-            timeout=10,
-            text=True,
-        )
-    except subprocess.SubprocessError as e:
-        # Only report the error if we could load _but not process_ the module
-        if (
-            "Error: Found the '" not in e.stderr
-            and "Error: Failed to import" not in e.stderr
-        ):
-            return mod
-
-
-if __name__ == "__main__":
-    print("# prints the names of modules for which `hypothesis write` errors out")
-    with multiprocessing.Pool() as pool:
-        for name in pool.imap(write_for, getmodules()):
-            if name is not None:
-                print(name, flush=True)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/lark Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/lark/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/lark/test_grammar.py Deleted

@@ -1,133 +0,0 @@
-# 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 pytest
-from lark.lark import Lark
-
-from hypothesis import given
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.lark import from_lark
-from hypothesis.strategies import data, just
-
-from tests.common.debug import find_any
-
-# Adapted from the official Lark tutorial, with modifications to ensure
-# that the generated JSON is valid.  i.e. no numbers starting with ".",
-# \f is not ignorable whitespace, and restricted strings only.  Source:
-# https://github.com/lark-parser/lark/blob/master/docs/json_tutorial.md
-EBNF_GRAMMAR = r"""
-    value: dict
-         | list
-         | STRING
-         | NUMBER
-         | "true"  -> true
-         | "false" -> false
-         | "null"  -> null
-    list : "" value ("," value)* ""
-    dict : "{" STRING ":" value ("," STRING ":" value)* "}"
-
-    STRING : /"a-z*"/
-    NUMBER : /-?1-90-9*(\.0-9+)?(eE+-?0-9+)?/
-
-    WS : / \t\r\n+/
-    %ignore WS
-"""
-
-LIST_GRAMMAR = r"""
-list : "" NUMBER ("," NUMBER)* ""
-NUMBER: /0-9+/
-"""
-
-
-@given(from_lark(Lark(EBNF_GRAMMAR, start="value")))
-def test_generates_valid_json(string):
-    json.loads(string)
-
-
-@pytest.mark.parametrize(
-    "start, type_",
-    
-        ("dict", dict),
-        ("list", list),
-        ("STRING", str),
-        ("NUMBER", (int, float)),
-        ("TRUE", bool),
-        ("FALSE", bool),
-        ("NULL", type(None)),
-    ,
-)
-@given(data=data())
-def test_can_specify_start_rule(data, start, type_):
-    string = data.draw(from_lark(Lark(EBNF_GRAMMAR, start="value"), start=start))
-    value = json.loads(string)
-    assert isinstance(value, type_)
-
-
-def test_can_generate_ignored_tokens():
-    list_grammar = r"""
-    list : "" STRING ("," STRING)* ""
-    STRING : /"a-z*"/
-    WS : / \t\r\n+/
-    %ignore WS
-    """
-    strategy = from_lark(Lark(list_grammar, start="list"))
-    # A JSON list of strings in canonical form which does not round-trip,
-    # must contain ignorable whitespace in the initial string.
-    find_any(strategy, lambda s: "\t" in s)
-
-
-def test_generation_without_whitespace():
-    find_any(from_lark(Lark(LIST_GRAMMAR, start="list")), lambda g: " " not in g)
-
-
-def test_cannot_convert_EBNF_to_strategy_directly():
-    with pytest.raises(InvalidArgument):
-        # Not a Lark object
-        from_lark(EBNF_GRAMMAR).example()
-    with pytest.raises(TypeError):
-        # Not even the right number of arguments
-        from_lark(EBNF_GRAMMAR, start="value").example()
-    with pytest.raises(InvalidArgument):
-        # Wrong type for explicit_strategies
-        from_lark(Lark(LIST_GRAMMAR, start="list"), explicit=).example()
-
-
-def test_undefined_terminals_require_explicit_strategies():
-    elem_grammar = r"""
-    list : "" ELEMENT ("," ELEMENT)* ""
-    %declare ELEMENT
-    """
-    with pytest.raises(InvalidArgument):
-        from_lark(Lark(elem_grammar, start="list")).example()
-    strategy = {"ELEMENT": just("200")}
-    from_lark(Lark(elem_grammar, start="list"), explicit=strategy).example()
-
-
-def test_cannot_use_explicit_strategies_for_unknown_terminals():
-    with pytest.raises(InvalidArgument):
-        from_lark(
-            Lark(LIST_GRAMMAR, start="list"), explicit={"unused_name": just("")}
-        ).example()
-
-
-def test_non_string_explicit_strategies_are_invalid():
-    with pytest.raises(InvalidArgument):
-        from_lark(
-            Lark(LIST_GRAMMAR, start="list"), explicit={"NUMBER": just(0)}
-        ).example()
-
-
-@given(
-    string=from_lark(Lark(LIST_GRAMMAR, start="list"), explicit={"NUMBER": just("0")})
-)
-def test_can_override_defined_terminal(string):
-    assert sum(json.loads(string)) == 0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_argument_validation.py Deleted

@@ -1,59 +0,0 @@
-# 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/.
-
-from inspect import Parameter
-
-import pytest
-
-from hypothesis import strategies as st
-from hypothesis.strategies._internal.utils import _strategies
-
-from tests.common.arguments import argument_validation_test, e
-
-BAD_ARGS = 
-
-
-def adjust(ex, **kwargs):
-    f, a, b = ex
-    b = dict(b)
-    b.update(kwargs)
-    BAD_ARGS.append((f, a, b))
-
-
-for ex in 
-    e(st.lists, st.integers()),
-    e(st.sets, st.integers()),
-    e(st.frozensets, st.integers()),
-    e(st.dictionaries, st.integers(), st.integers()),
-    e(st.text),
-    e(st.binary),
-:
-    adjust(ex, min_size=-1)
-    adjust(ex, max_size=-1)
-    adjust(ex, min_size="no")
-    adjust(ex, max_size="no")
-
-
-BAD_ARGS.extend(e(st.lists, st.nothing(), unique=True, min_size=1))
-
-test_raise_invalid_argument = argument_validation_test(BAD_ARGS)
-
-
-@pytest.mark.parametrize("name", sorted(_strategies))
-def test_consistent_with_api_guide_on_kwonly_args(name):
-    # Enforce our style-guide: if it has a default value, it should be
-    # keyword-only with a very few exceptions.
-    for arg in _strategiesname.parameters.values():
-        assert (
-            arg.default == Parameter.empty
-            or arg.kind != Parameter.POSITIONAL_OR_KEYWORD
-            or arg.name in ("min_value", "max_value", "subtype_strategy", "columns")
-            or name in ("text", "range_indexes", "badly_draw_lists", "write_pattern")
-        ), f"need kwonly args in {name}"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_bad_repr.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_baseexception.py Deleted

@@ -1,123 +0,0 @@
-# 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 pytest
-
-from hypothesis import given
-from hypothesis.errors import Flaky
-from hypothesis.strategies import composite, integers
-
-
-@pytest.mark.parametrize(
-    "e", KeyboardInterrupt, SystemExit, GeneratorExit, ValueError
-)
-def test_exception_propagates_fine(e):
-    @given(integers())
-    def test_raise(x):
-        raise e
-
-    with pytest.raises(e):
-        test_raise()
-
-
-@pytest.mark.parametrize(
-    "e", KeyboardInterrupt, SystemExit, GeneratorExit, ValueError
-)
-def test_exception_propagates_fine_from_strategy(e):
-    @composite
-    def interrupt_eventually(draw):
-        raise e
-
-    @given(interrupt_eventually())
-    def test_do_nothing(x):
-        pass
-
-    with pytest.raises(e):
-        test_do_nothing()
-
-
-@pytest.mark.parametrize("e", KeyboardInterrupt, ValueError)
-def test_baseexception_no_rerun_no_flaky(e):
-    runs = 0
-    interrupt = 3
-
-    @given(integers())
-    def test_raise_baseexception(x):
-        runs0 += 1
-        if runs0 == interrupt:
-            raise e
-
-    if issubclass(e, (KeyboardInterrupt, SystemExit, GeneratorExit)):
-        # Here SystemExit and GeneratorExit are passed through
-        with pytest.raises(e):
-            test_raise_baseexception()
-
-        assert runs0 == interrupt
-    else:
-        with pytest.raises(Flaky):
-            test_raise_baseexception()
-
-
-@pytest.mark.parametrize(
-    "e", KeyboardInterrupt, SystemExit, GeneratorExit, ValueError
-)
-def test_baseexception_in_strategy_no_rerun_no_flaky(e):
-    runs = 0
-    interrupt = 3
-
-    @composite
-    def interrupt_eventually(draw):
-        runs0 += 1
-        if runs0 == interrupt:
-            raise e
-        return draw(integers())
-
-    @given(interrupt_eventually())
-    def test_do_nothing(x):
-        pass
-
-    if issubclass(e, KeyboardInterrupt):
-        with pytest.raises(e):
-            test_do_nothing()
-
-        assert runs0 == interrupt
-
-    else:
-        # Now SystemExit and GeneratorExit are caught like other exceptions
-        with pytest.raises(Flaky):
-            test_do_nothing()
-
-
-TEMPLATE = """
-from hypothesis import given, note, strategies as st
-
-@st.composite
-def things(draw):
-    raise {exception}
-
-
-@given(st.data(), st.integers())
-def test(data, x):
-    if x > 100:
-        data.draw({strategy})
-        raise {exception}
-"""
-
-
-@pytest.mark.parametrize("exc_name", "SystemExit", "GeneratorExit")
-@pytest.mark.parametrize("use_composite", True, False)
-def test_explanations(testdir, exc_name, use_composite):
-    code = TEMPLATE.format(
-        exception=exc_name, strategy="things()" if use_composite else "st.none()"
-    )
-    test_file = str(testdir.makepyfile(code))
-    pytest_stdout = str(testdir.runpytest_inprocess(test_file, "--tb=native").stdout)
-    assert "x=101" in pytest_stdout
-    assert exc_name in pytest_stdout

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_boundary_exploration.py Deleted

@@ -1,41 +0,0 @@
-# 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 pytest
-
-from hypothesis import HealthCheck, Verbosity, given, reject, settings, strategies as st
-from hypothesis.errors import Unsatisfiable
-
-from tests.common.debug import minimal
-from tests.common.utils import no_shrink
-
-
-@pytest.mark.parametrize("strat", st.text(min_size=5))
-@settings(phases=no_shrink, deadline=None, suppress_health_check=HealthCheck.all())
-@given(st.data())
-def test_explore_arbitrary_function(strat, data):
-    cache = {}
-
-    def predicate(x):
-        try:
-            return cachex
-        except KeyError:
-            return cache.setdefault(x, data.draw(st.booleans(), label=repr(x)))
-
-    try:
-        minimal(
-            strat,
-            predicate,
-            settings=settings(
-                max_examples=10, database=None, verbosity=Verbosity.quiet
-            ),
-        )
-    except Unsatisfiable:
-        reject()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_build_signature.py Deleted

@@ -1,115 +0,0 @@
-# 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/.
-
-from inspect import signature
-from typing import List, get_type_hints
-
-from hypothesis import given, strategies as st
-
-from tests.common.debug import find_any
-
-
-def use_this_signature(self, a: int, b: bool = None, *, x: float, y: str):
-    pass
-
-
-class Model:
-    # Emulates the implementation of Pydantic models.  See e.g.
-    # https://github.com/timothycrosley/hypothesis-auto/issues/10
-    __annotations__ = get_type_hints(use_this_signature)
-    __signature__ = signature(use_this_signature)
-
-    def __init__(self, **kwargs):
-        # Check that we're being called with the expected arguments
-        assert set(kwargs) == {"a", "x", "y"}
-        assert isinstance(kwargs"a", int)
-        assert isinstance(kwargs"x", float)
-        assert isinstance(kwargs"y", str)
-
-
-@given(st.builds(Model))
-def test_builds_uses_signature_attribute(val):
-    assert isinstance(val, Model)
-
-
-class ModelForFromType(Model):
-    def __init__(self, **kwargs):
-        assert set(kwargs) == {"a", "b", "x", "y"}
-        self.b = kwargs"b"
-        assert self.b is None or isinstance(self.b, bool)
-
-
-@given(st.from_type(ModelForFromType))
-def test_from_type_uses_signature_attribute(val):
-    assert isinstance(val, ModelForFromType)
-
-
-def test_from_type_can_be_default_or_annotation():
-    find_any(st.from_type(ModelForFromType), lambda m: m.b is None)
-    find_any(st.from_type(ModelForFromType), lambda m: isinstance(m.b, bool))
-
-
-def use_annotations(
-    self, test_a: int, test_b: str = None, *, test_x: float, test_y: str
-):
-    pass
-
-
-def use_signature(
-    self, testA: int, testB: str = None, *, testX: float, testY: Liststr
-):
-    pass
-
-
-class ModelWithAlias:
-    __annotations__ = get_type_hints(use_annotations)
-    __signature__ = signature(use_signature)
-
-    def __init__(self, **kwargs):
-        # Check that we're being called with the expected arguments
-        assert set(kwargs) == {"testA", "testX", "testY"}
-        assert isinstance(kwargs"testA", int)
-        assert isinstance(kwargs"testX", float)
-        assert isinstance(kwargs"testY", list)
-        assert all(isinstance(elem, str) for elem in kwargs"testY")
-
-
-@given(st.builds(ModelWithAlias))
-def test_build_using_different_signature_and_annotations(val):
-    assert isinstance(val, ModelWithAlias)
-
-
-def use_bad_signature(self, testA: 1, *, testX: float):
-    pass
-
-
-class ModelWithBadAliasSignature:
-    __annotations__ = get_type_hints(use_annotations)
-    __signature__ = signature(use_bad_signature)
-
-    def __init__(self, **kwargs):
-        assert set(kwargs) == {"testX"}
-        assert isinstance(kwargs"testX", float)
-
-
-@given(st.builds(ModelWithBadAliasSignature))
-def test_build_with_non_types_in_signature(val):
-    assert isinstance(val, ModelWithBadAliasSignature)
-
-
-class UnconventionalSignature:
-    def __init__(x: int = 0, self: bool = True):  # noqa: B902
-        assert not isinstance(x, int)
-        x.self = self
-
-
-def test_build_in_from_type_with_self_named_something_else():
-    find_any(st.from_type(UnconventionalSignature), lambda x: x.self is True)
-    find_any(st.from_type(UnconventionalSignature), lambda x: x.self is False)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_cache_implementation.py Deleted

@@ -1,97 +0,0 @@
-# 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/.
-
-from collections import Counter
-
-from hypothesis import strategies as st
-from hypothesis.internal.cache import GenericCache
-from hypothesis.stateful import (
-    Bundle,
-    RuleBasedStateMachine,
-    initialize,
-    invariant,
-    rule,
-)
-
-
-class CacheWithScores(GenericCache):
-    def __init__(self, max_size):
-        super().__init__(max_size)
-        self.scores = {}
-
-    def new_entry(self, key, value):
-        return self.scoreskey
-
-
-class CacheRules(RuleBasedStateMachine):
-    keys = Bundle("keys")
-
-    @initialize(max_size=st.integers(1, 8))
-    def create_cache(self, max_size):
-        self.cache = CacheWithScores(max_size)
-        self.__values = {}
-
-        self.__total_pins = 0
-        self.__pins = Counter()
-        self.__live = set()
-        self.__next_value = 0
-        self.__last_key = None
-
-        def on_evict(evicted_key, value, score):
-            assert self.__pinsevicted_key == 0
-            assert score == self.cache.scoresevicted_key
-            assert value == self.__valuesevicted_key
-            for k in self.cache:
-                assert (
-                    self.__pinsk > 0
-                    or self.cache.scoresk >= score
-                    or k == self.__last_key
-                )
-
-        self.cache.on_evict = on_evict
-
-    @rule(key=st.integers(), score=st.integers(0, 100), target=keys)
-    def new_key(self, key, score):
-        if key not in self.cache.scores:
-            self.cache.scoreskey = score
-        return key
-
-    @rule(key=keys)
-    def set_key(self, key):
-        if self.__total_pins < self.cache.max_size or key in self.cache:
-            self.__last_key = key
-            self.cachekey = self.__next_value
-            self.__valueskey = self.__next_value
-            self.__next_value += 1
-
-    @invariant()
-    def check_values(self):
-        for k in getattr(self, "cache", ()):
-            assert self.__valuesk == self.cachek
-
-    @rule(key=keys)
-    def pin_key(self, key):
-        if key in self.cache:
-            self.cache.pin(key)
-            if self.__pinskey == 0:
-                self.__total_pins += 1
-            self.__pinskey += 1
-
-    @rule(key=keys)
-    def unpin_key(self, key):
-        if self.__pinskey > 0:
-            self.cache.unpin(key)
-            self.__pinskey -= 1
-            if self.__pinskey == 0:
-                self.__total_pins -= 1
-                assert self.__total_pins >= 0
-
-
-TestCache = CacheRules.TestCase

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_cacheable.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_characters.py Deleted

@@ -1,34 +0,0 @@
-# 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 string
-
-from hypothesis import given, strategies as st
-
-IDENTIFIER_CHARS = string.ascii_letters + string.digits + "_"
-
-
-@given(st.characters(blacklist_characters=IDENTIFIER_CHARS))
-def test_large_blacklist(c):
-    assert c not in IDENTIFIER_CHARS
-
-
-@given(st.data())
-def test_arbitrary_blacklist(data):
-    blacklist = data.draw(st.text(st.characters(max_codepoint=1000), min_size=1))
-    ords = list(map(ord, blacklist))
-    c = data.draw(
-        st.characters(
-            blacklist_characters=blacklist,
-            min_codepoint=max(0, min(ords) - 1),
-            max_codepoint=max(0, max(ords) + 1),
-        )
-    )
-    assert c not in blacklist

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_collective_minimization.py Deleted

@@ -1,39 +0,0 @@
-# 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 pytest
-
-from hypothesis import settings
-from hypothesis.errors import Unsatisfiable
-from hypothesis.strategies import lists
-
-from tests.common import standard_types
-from tests.common.debug import minimal
-from tests.common.utils import flaky
-
-
-@pytest.mark.parametrize("spec", standard_types, ids=list(map(repr, standard_types)))
-@flaky(min_passes=1, max_runs=2)
-def test_can_collectively_minimize(spec):
-    """This should generally exercise strategies' strictly_simpler heuristic by
-    putting us in a state where example cloning is required to get to the
-    answer fast enough."""
-    n = 10
-
-    try:
-        xs = minimal(
-            lists(spec, min_size=n, max_size=n),
-            lambda x: len(set(map(repr, x))) >= 2,
-            settings(max_examples=2000),
-        )
-        assert len(xs) == n
-        assert 2 <= len(set(map(repr, xs))) <= 3
-    except Unsatisfiable:
-        pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_compat.py Deleted

@@ -1,52 +0,0 @@
-# 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 math
-
-from hypothesis import given, strategies as st
-from hypothesis.internal.compat import ceil, floor, int_from_bytes, int_to_bytes
-
-
-@given(st.binary())
-def test_convert_back(bs):
-    bs = bytearray(bs)
-    assert int_to_bytes(int_from_bytes(bs), len(bs)) == bs
-
-
-bytes8 = st.builds(bytearray, st.binary(min_size=8, max_size=8))
-
-
-@given(bytes8, bytes8)
-def test_to_int_in_big_endian_order(x, y):
-    x, y = sorted((x, y))
-    assert 0 <= int_from_bytes(x) <= int_from_bytes(y)
-
-
-ints8 = st.integers(min_value=0, max_value=2**63 - 1)
-
-
-@given(ints8, ints8)
-def test_to_bytes_in_big_endian_order(x, y):
-    x, y = sorted((x, y))
-    assert int_to_bytes(x, 8) <= int_to_bytes(y, 8)
-
-
-@given(st.fractions())
-def test_ceil(x):
-    assert isinstance(ceil(x), int)
-    assert x <= ceil(x) < x + 1
-    assert ceil(x) == math.ceil(x)
-
-
-@given(st.fractions())
-def test_floor(x):
-    assert isinstance(floor(x), int)
-    assert x - 1 < floor(x) <= x
-    assert floor(x) == math.floor(x)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_completion.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_conjecture_engine.py Deleted

@@ -1,148 +0,0 @@
-# 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/.
-
-from hypothesis import given, settings, strategies as st
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.internal.compat import int_from_bytes
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.conjecture.shrinker import Shrinker, block_program
-
-from tests.common.utils import counts_calls, non_covering_examples
-from tests.conjecture.common import run_to_buffer, shrinking_from
-
-
-def test_lot_of_dead_nodes():
-    @run_to_buffer
-    def x(data):
-        for i in range(4):
-            if data.draw_bytes(1)0 != i:
-                data.mark_invalid()
-        data.mark_interesting()
-
-    assert x == bytes(0, 1, 2, 3)
-
-
-def test_saves_data_while_shrinking(monkeypatch):
-    key = b"hi there"
-    n = 5
-    db = InMemoryExampleDatabase()
-    assert list(db.fetch(key)) == 
-    seen = set()
-
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function(255 * 10),
-    )
-
-    def f(data):
-        x = data.draw_bytes(10)
-        if sum(x) >= 2000 and len(seen) < n:
-            seen.add(x)
-        if x in seen:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(f, settings=settings(database=db), database_key=key)
-    runner.run()
-    assert runner.interesting_examples
-    assert len(seen) == n
-    in_db = non_covering_examples(db)
-    assert in_db.issubset(seen)
-    assert in_db == seen
-
-
-def test_can_discard(monkeypatch):
-    n = 8
-
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function(
-            v for i in range(n) for v in i, i
-        ),
-    )
-
-    @run_to_buffer
-    def x(data):
-        seen = set()
-        while len(seen) < n:
-            seen.add(bytes(data.draw_bytes(1)))
-        data.mark_interesting()
-
-    assert len(x) == n
-
-
-def test_regression_1():
-    # This is a really hard to reproduce bug that previously triggered a very
-    # specific exception inside one of the shrink passes. It's unclear how
-    # useful this regression test really is, but nothing else caught the
-    # problem.
-    @run_to_buffer
-    def x(data):
-        data.write(b"\x01\x02")
-        data.write(b"\x01\x00")
-        v = data.draw_bits(41)
-        if v >= 512 or v == 254:
-            data.mark_interesting()
-
-    assert list(x):-2 == 1, 2, 1, 0, 0, 0, 0, 0
-
-    assert int_from_bytes(x-2:) in (254, 512)
-
-
-@given(st.integers(0, 255), st.integers(0, 255))
-def test_cached_with_masked_byte_agrees_with_results(byte_a, byte_b):
-    def f(data):
-        data.draw_bits(2)
-
-    runner = ConjectureRunner(f)
-
-    cached_a = runner.cached_test_function(bytes(byte_a))
-    cached_b = runner.cached_test_function(bytes(byte_b))
-
-    data_b = ConjectureData.for_buffer(
-        bytes(byte_b), observer=runner.tree.new_observer()
-    )
-    runner.test_function(data_b)
-
-    # If the cache found an old result, then it should match the real result.
-    # If it did not, then it must be because A and B were different.
-    assert (cached_a is cached_b) == (cached_a.buffer == data_b.buffer)
-
-
-def test_block_programs_fail_efficiently(monkeypatch):
-    # Create 256 byte-sized blocks. None of the blocks can be deleted, and
-    # every deletion attempt produces a different buffer.
-    @shrinking_from(bytes(range(256)))
-    def shrinker(data):
-        values = set()
-        for _ in range(256):
-            v = data.draw_bits(8)
-            values.add(v)
-        if len(values) == 256:
-            data.mark_interesting()
-
-    monkeypatch.setattr(
-        Shrinker, "run_block_program", counts_calls(Shrinker.run_block_program)
-    )
-
-    shrinker.max_stall = 500
-
-    shrinker.fixate_shrink_passes(block_program("XX"))
-
-    assert shrinker.shrinks == 0
-    assert 250 <= shrinker.calls <= 260
-
-    # The block program should have been run roughly 255 times, with a little
-    # bit of wiggle room for implementation details.
-    #   - Too many calls mean that failing steps are doing too much work.
-    #   - Too few calls mean that this test is probably miscounting and buggy.
-    assert 250 <= Shrinker.run_block_program.calls <= 260

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_conjecture_int_list.py Deleted

@@ -1,70 +0,0 @@
-# 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/.
-
-from hypothesis import strategies as st
-from hypothesis.internal.conjecture.junkdrawer import IntList
-from hypothesis.stateful import RuleBasedStateMachine, initialize, invariant, rule
-
-INTEGERS = st.integers(0, 2**68)
-
-
-@st.composite
-def valid_index(draw):
-    machine = draw(st.runner())
-    if not machine.model:
-        return draw(st.nothing())
-    return draw(st.integers(0, len(machine.model) - 1))
-
-
-@st.composite
-def valid_slice(draw):
-    machine = draw(st.runner())
-    result = 
-        draw(st.integers(0, max(3, len(machine.model) * 2 - 1))) for _ in range(2)
-    
-    result.sort()
-    return slice(*result)
-
-
-class IntListRules(RuleBasedStateMachine):
-    @initialize(ls=st.lists(INTEGERS))
-    def starting_lists(self, ls):
-        self.model = list(ls)
-        self.target = IntList(ls)
-
-    @invariant()
-    def lists_are_equivalent(self):
-        if hasattr(self, "model"):
-            assert isinstance(self.model, list)
-            assert isinstance(self.target, IntList)
-            assert len(self.model) == len(self.target)
-            assert list(self.target) == self.model
-
-    @rule(n=INTEGERS)
-    def append(self, n):
-        self.model.append(n)
-        self.target.append(n)
-
-    @rule(i=valid_index() | valid_slice())
-    def delete(self, i):
-        del self.modeli
-        del self.targeti
-
-    @rule(sl=valid_slice())
-    def slice(self, sl):
-        self.model = self.modelsl
-        self.target = self.targetsl
-
-    @rule(i=valid_index())
-    def agree_on_values(self, i):
-        assert self.modeli == self.targeti
-
-
-TestIntList = IntListRules.TestCase

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_conjecture_utils.py Deleted

@@ -1,72 +0,0 @@
-# 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 sys
-from fractions import Fraction
-
-from hypothesis import assume, example, given, strategies as st, target
-from hypothesis.internal.compat import int_to_bytes
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.conjecture.data import ConjectureData, StopTest
-from hypothesis.internal.conjecture.engine import BUFFER_SIZE
-
-
-def test_gives_the_correct_probabilities():
-    weights = Fraction(1), Fraction(9)
-    total = sum(weights)
-    probabilities = w / total for w in weights
-
-    sampler = cu.Sampler(probabilities)
-
-    assert cu.Sampler(weights).table == sampler.table
-
-    counts = 0 * len(weights)
-
-    i = 0
-    while i < 2**16:
-        data = ConjectureData.for_buffer(int_to_bytes(i, 2))
-        try:
-            c = sampler.sample(data)
-            countsc += 1
-            assert probabilitiesc >= Fraction(countsc, 2**16)
-        except StopTest:
-            pass
-        if 1 in data.forced_indices:
-            i += 256
-        else:
-            i += 1
-
-
-@example(0, 1)
-@example(0, float("inf"))
-@example(cu.SMALLEST_POSITIVE_FLOAT, 2 * cu.SMALLEST_POSITIVE_FLOAT)
-@example(cu.SMALLEST_POSITIVE_FLOAT, 1)
-@example(cu.SMALLEST_POSITIVE_FLOAT, float("inf"))
-@example(sys.float_info.min, 1)
-@example(sys.float_info.min, float("inf"))
-@example(10, 10)
-@example(10, float("inf"))
-# BUFFER_SIZE divided by (2bytes coin + 0byte element) gives the
-# maximum number of elements that we would ever be able to generate.
-@given(st.floats(0, BUFFER_SIZE // 2), st.integers(0, BUFFER_SIZE // 2))
-def test_p_continue(average_size, max_size):
-    assume(average_size <= max_size)
-    p = cu._calc_p_continue(average_size, max_size)
-    assert 0 <= target(p, label="p") <= 1
-    assert 0 < target(p, label="-p") or average_size < 1e-5
-    abs_err = abs(average_size - cu._p_continue_to_avg(p, max_size))
-    assert target(abs_err, label="abs_err") < 0.01
-
-
-@example(1.1, 10)
-@given(st.floats(0, 1), st.integers(0, BUFFER_SIZE // 2))
-def test_p_continue_to_average(p_continue, max_size):
-    average = cu._p_continue_to_avg(p_continue, max_size)
-    assert 0 <= average <= max_size

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_conventions.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_database_agreement.py Deleted

@@ -1,73 +0,0 @@
-# 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 os
-import shutil
-import tempfile
-
-from hypothesis import strategies as st
-from hypothesis.database import DirectoryBasedExampleDatabase, InMemoryExampleDatabase
-from hypothesis.stateful import Bundle, RuleBasedStateMachine, rule
-
-
-class DatabaseComparison(RuleBasedStateMachine):
-    def __init__(self):
-        super().__init__()
-        self.tempd = tempfile.mkdtemp()
-        exampledir = os.path.join(self.tempd, "examples")
-
-        self.dbs = 
-            DirectoryBasedExampleDatabase(exampledir),
-            InMemoryExampleDatabase(),
-            DirectoryBasedExampleDatabase(exampledir),
-        
-
-    keys = Bundle("keys")
-    values = Bundle("values")
-
-    @rule(target=keys, k=st.binary())
-    def k(self, k):
-        return k
-
-    @rule(target=values, v=st.binary())
-    def v(self, v):
-        return v
-
-    @rule(k=keys, v=values)
-    def save(self, k, v):
-        for db in self.dbs:
-            db.save(k, v)
-
-    @rule(k=keys, v=values)
-    def delete(self, k, v):
-        for db in self.dbs:
-            db.delete(k, v)
-
-    @rule(k1=keys, k2=keys, v=values)
-    def move(self, k1, k2, v):
-        for db in self.dbs:
-            db.move(k1, k2, v)
-
-    @rule(k=keys)
-    def values_agree(self, k):
-        last = None
-        last_db = None
-        for db in self.dbs:
-            keys = set(db.fetch(k))
-            if last is not None:
-                assert last == keys, (last_db, db)
-            last = keys
-            last_db = db
-
-    def teardown(self):
-        shutil.rmtree(self.tempd)
-
-
-TestDBs = DatabaseComparison.TestCase

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_database_usage.py Deleted

@@ -1,156 +0,0 @@
-# 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 os.path
-
-from hypothesis import assume, core, find, given, settings, strategies as st
-from hypothesis.database import ExampleDatabase, InMemoryExampleDatabase
-from hypothesis.errors import NoSuchExample, Unsatisfiable
-from hypothesis.internal.entropy import deterministic_PRNG
-
-from tests.common.utils import all_values, non_covering_examples
-
-
-def has_a_non_zero_byte(x):
-    return any(bytes(x))
-
-
-def test_saves_incremental_steps_in_database():
-    key = b"a database key"
-    database = InMemoryExampleDatabase()
-    find(
-        st.binary(min_size=10),
-        lambda x: has_a_non_zero_byte(x),
-        settings=settings(database=database),
-        database_key=key,
-    )
-    assert len(all_values(database)) > 1
-
-
-def test_clears_out_database_as_things_get_boring():
-    key = b"a database key"
-    database = InMemoryExampleDatabase()
-    do_we_care = True
-
-    def stuff():
-        try:
-            find(
-                st.binary(min_size=50),
-                lambda x: do_we_care and has_a_non_zero_byte(x),
-                settings=settings(database=database, max_examples=10),
-                database_key=key,
-            )
-        except NoSuchExample:
-            pass
-
-    stuff()
-    assert len(non_covering_examples(database)) > 1
-    do_we_care = False
-    stuff()
-    initial = len(non_covering_examples(database))
-    assert initial > 0
-
-    for _ in range(initial):
-        stuff()
-        keys = len(non_covering_examples(database))
-        if not keys:
-            break
-    else:
-        raise AssertionError
-
-
-def test_trashes_invalid_examples():
-    key = b"a database key"
-    database = InMemoryExampleDatabase()
-
-    invalid = set()
-
-    def stuff():
-        try:
-
-            def condition(x):
-                assume(x not in invalid)
-                return not invalid and has_a_non_zero_byte(x)
-
-            return find(
-                st.binary(min_size=5),
-                condition,
-                settings=settings(database=database),
-                database_key=key,
-            )
-        except (Unsatisfiable, NoSuchExample):
-            pass
-
-    with deterministic_PRNG():
-        value = stuff()
-
-    original = len(all_values(database))
-    assert original > 1
-
-    invalid.add(value)
-    with deterministic_PRNG():
-        stuff()
-
-    assert len(all_values(database)) < original
-
-
-def test_respects_max_examples_in_database_usage():
-    key = b"a database key"
-    database = InMemoryExampleDatabase()
-    do_we_care = True
-    counter = 0
-
-    def check(x):
-        counter0 += 1
-        return do_we_care and has_a_non_zero_byte(x)
-
-    def stuff():
-        try:
-            find(
-                st.binary(min_size=100),
-                check,
-                settings=settings(database=database, max_examples=10),
-                database_key=key,
-            )
-        except NoSuchExample:
-            pass
-
-    with deterministic_PRNG():
-        stuff()
-    assert len(all_values(database)) > 10
-    do_we_care = False
-    counter0 = 0
-    stuff()
-    assert counter == 10
-
-
-def test_does_not_use_database_when_seed_is_forced(monkeypatch):
-    monkeypatch.setattr(core, "global_force_seed", 42)
-    database = InMemoryExampleDatabase()
-    database.fetch = None
-
-    @settings(database=database)
-    @given(st.integers())
-    def test(i):
-        pass
-
-    test()
-
-
-@given(st.binary(), st.binary())
-def test_database_not_created_when_not_used(tmp_path_factory, key, value):
-    path = tmp_path_factory.mktemp("hypothesis") / "examples"
-    assert not os.path.exists(str(path))
-    database = ExampleDatabase(path)
-    assert not list(database.fetch(key))
-    assert not os.path.exists(str(path))
-    database.save(key, value)
-    assert os.path.exists(str(path))
-    assert list(database.fetch(key)) == value

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_deferred_errors.py Deleted

@@ -1,67 +0,0 @@
-# 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 pytest
-
-from hypothesis import find, given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.strategies._internal.core import defines_strategy
-
-
-def test_does_not_error_on_initial_calculation():
-    st.floats(max_value=float("nan"))
-    st.sampled_from()
-    st.lists(st.integers(), min_size=5, max_size=2)
-    st.floats(min_value=2.0, max_value=1.0)
-
-
-def test_errors_each_time():
-    s = st.integers(max_value=1, min_value=3)
-    with pytest.raises(InvalidArgument):
-        s.example()
-    with pytest.raises(InvalidArgument):
-        s.example()
-
-
-def test_errors_on_test_invocation():
-    @given(st.integers(max_value=1, min_value=3))
-    def test(x):
-        pass
-
-    with pytest.raises(InvalidArgument):
-        test()
-
-
-def test_errors_on_find():
-    s = st.lists(st.integers(), min_size=5, max_size=2)
-    with pytest.raises(InvalidArgument):
-        find(s, lambda x: True)
-
-
-def test_errors_on_example():
-    s = st.floats(min_value=2.0, max_value=1.0)
-    with pytest.raises(InvalidArgument):
-        s.example()
-
-
-def test_does_not_recalculate_the_strategy():
-    calls = 0
-
-    @defines_strategy()
-    def foo():
-        calls0 += 1
-        return st.just(1)
-
-    f = foo()
-    assert calls == 0
-    f.example()
-    assert calls == 1
-    f.example()
-    assert calls == 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_drypython_returns.py Deleted

@@ -1,202 +0,0 @@
-# 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/.
-
-from typing import Generic, TypeVar
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import ResolutionFailed
-
-from tests.common.debug import find_any
-from tests.common.utils import temp_registered
-
-# Primitives:
-# ===========
-
-_InstanceType = TypeVar("_InstanceType", covariant=True)
-_TypeArgType1 = TypeVar("_TypeArgType1", covariant=True)
-_FirstType = TypeVar("_FirstType")
-_LawType = TypeVar("_LawType")
-
-
-class KindN(Generic_InstanceType, _TypeArgType1):
-    pass
-
-
-class Lawful(Generic_LawType):
-    """This type defines law-related operations."""
-
-
-class MappableN(Generic_FirstType, Lawful"MappableN_FirstType"):
-    """Behaves like a functor."""
-
-
-# End definition:
-# ===============
-
-_ValueType = TypeVar("_ValueType")
-
-
-class MyFunctor(KindN"MyFunctor", _ValueType, MappableN_ValueType):
-    def __init__(self, inner_value: _ValueType) -> None:
-        self.inner_value = inner_value
-
-
-# Testing part:
-# =============
-
-
-def target_func(mappable: "MappableN_FirstType") -> bool:
-    return isinstance(mappable, MappableN)
-
-
-@given(st.data())
-def test_my_mappable(source: st.DataObject) -> None:
-    """
-    Checks that complex types with multiple inheritance levels and strings are fine.
-
-    Regression test for https://github.com/HypothesisWorks/hypothesis/issues/3060
-    """
-    # In `returns` we register all types in `__mro__`
-    # to be this exact type at the moment. But here, we only need `Mappable`.
-    # Current `__mro__` is `MyFunctor / Kind / Mappable`:
-    assert MyFunctor.__mro__2 is MappableN
-    with temp_registered(
-        MyFunctor.__mro__2,
-        st.builds(MyFunctor),
-    ):
-        assert source.draw(st.builds(target_func)) is True
-
-
-A = TypeVar("A")
-B = TypeVar("B")
-C = TypeVar("C")
-D = TypeVar("D")
-
-
-class _FirstBase(GenericA, B):
-    pass
-
-
-class _SecondBase(GenericC, D):
-    pass
-
-
-# To be tested:
-
-
-class TwoGenericBases1(_FirstBaseA, B, _SecondBaseC, D):
-    pass
-
-
-class TwoGenericBases2(_FirstBaseC, D, _SecondBaseA, B):
-    pass
-
-
-class OneGenericOneConrete1(_FirstBaseint, str, _SecondBaseA, B):
-    pass
-
-
-class OneGenericOneConrete2(_FirstBaseA, B, _SecondBasefloat, bool):
-    pass
-
-
-class MixedGenerics1(_FirstBaseint, B, _SecondBaseC, bool):
-    pass
-
-
-class MixedGenerics2(_FirstBaseA, str, _SecondBasefloat, D):
-    pass
-
-
-class AllConcrete(_FirstBaseint, str, _SecondBasefloat, bool):
-    pass
-
-
-_generic_test_types = (
-    TwoGenericBases1,
-    TwoGenericBases2,
-    OneGenericOneConrete1,
-    OneGenericOneConrete2,
-    MixedGenerics1,
-    MixedGenerics2,
-    AllConcrete,
-)
-
-
-@pytest.mark.parametrize("type_", _generic_test_types)
-def test_several_generic_bases(type_):
-    with temp_registered(_FirstBase, st.builds(type_)):
-        find_any(st.builds(_FirstBase))
-
-    with temp_registered(_SecondBase, st.builds(type_)):
-        find_any(st.builds(_SecondBase))
-
-
-def var_generic_func1(obj: _FirstBaseA, B):
-    pass
-
-
-def var_generic_func2(obj: _SecondBaseA, B):
-    pass
-
-
-def concrete_generic_func1(obj: _FirstBaseint, str):
-    pass
-
-
-def concrete_generic_func2(obj: _SecondBasefloat, bool):
-    pass
-
-
-def mixed_generic_func1(obj: _FirstBaseA, str):
-    pass
-
-
-def mixed_generic_func2(obj: _SecondBasefloat, D):
-    pass
-
-
-@pytest.mark.parametrize("type_", _generic_test_types)
-@pytest.mark.parametrize(
-    "func",
-    
-        var_generic_func1,
-        var_generic_func2,
-        concrete_generic_func1,
-        concrete_generic_func2,
-        mixed_generic_func1,
-        mixed_generic_func2,
-    ,
-)
-def test_several_generic_bases_functions(type_, func):
-    with temp_registered(_FirstBase, st.builds(type_)), temp_registered(
-        _SecondBase, st.builds(type_)
-    ):
-        find_any(st.builds(func))
-
-    with temp_registered(type_, st.builds(type_)):
-        find_any(st.builds(func))
-
-
-def wrong_generic_func1(obj: _FirstBaseA, None):
-    pass
-
-
-def wrong_generic_func2(obj: _SecondBaseNone, bool):
-    pass
-
-
-@pytest.mark.parametrize("func", wrong_generic_func1, wrong_generic_func2)
-def test_several_generic_bases_wrong_functions(func):
-    with temp_registered(AllConcrete, st.builds(AllConcrete)):
-        with pytest.raises(ResolutionFailed):
-            st.builds(func).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_duplication.py Deleted

@@ -1,63 +0,0 @@
-# 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/.
-
-from collections import Counter
-
-import pytest
-
-from hypothesis import given, settings
-from hypothesis.strategies._internal import SearchStrategy
-
-
-class Blocks(SearchStrategy):
-    def __init__(self, n):
-        self.n = n
-
-    def do_draw(self, data):
-        return data.draw_bytes(self.n)
-
-
-@pytest.mark.parametrize("n", range(1, 5))
-def test_does_not_duplicate_blocks(n):
-    counts = Counter()
-
-    @given(Blocks(n))
-    @settings(database=None)
-    def test(b):
-        countsb += 1
-
-    test()
-    assert set(counts.values()) == {1}
-
-
-@pytest.mark.parametrize("n", range(1, 5))
-def test_mostly_does_not_duplicate_blocks_even_when_failing(n):
-    counts = Counter()
-
-    @settings(database=None)
-    @given(Blocks(n))
-    def test(b):
-        countsb += 1
-        if len(counts) > 3:
-            raise ValueError()
-
-    try:
-        test()
-    except ValueError:
-        pass
-    # There are two circumstances in which a duplicate is allowed: We replay
-    # the failing test once to check for flakiness, and then we replay the
-    # fully minimized failing test at the end to display the error. The
-    # complication comes from the fact that these may or may not be the same
-    # test case, so we can see either two test cases each run twice or one
-    # test case which has been run three times.
-    seen_counts = set(counts.values())
-    assert seen_counts in ({1, 2}, {1, 3})
-    assert len(k for k, v in counts.items() if v > 1) <= 2

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_dynamic_variable.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_emails.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_eval_as_source.py Deleted

@@ -1,34 +0,0 @@
-# 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/.
-
-from hypothesis.internal.reflection import source_exec_as_module
-
-
-def test_can_eval_as_source():
-    assert source_exec_as_module("foo=1").foo == 1
-
-
-def test_caches():
-    x = source_exec_as_module("foo=2")
-    y = source_exec_as_module("foo=2")
-    assert x is y
-
-
-RECURSIVE = """
-from hypothesis.internal.reflection import source_exec_as_module
-
-def test_recurse():
-    assert not (
-        source_exec_as_module("too_much_recursion = False").too_much_recursion)
-"""
-
-
-def test_can_call_self_recursively():
-    source_exec_as_module(RECURSIVE).test_recurse()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_explore_arbitrary_languages.py Deleted

@@ -1,147 +0,0 @@
-# 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 random
-
-import attr
-import pytest
-
-from hypothesis import (
-    HealthCheck,
-    Phase,
-    Verbosity,
-    assume,
-    given,
-    note,
-    settings,
-    strategies as st,
-)
-from hypothesis.internal import escalation as esc
-from hypothesis.internal.conjecture.data import Status
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-
-
-def setup_module(module):
-    esc.PREVENT_ESCALATION = True
-
-
-def teardown_module(module):
-    esc.PREVENT_ESCALATION = False
-
-
-@attr.s()
-class Write:
-    value = attr.ib()
-    child = attr.ib()
-
-
-@attr.s()
-class Branch:
-    bits = attr.ib()
-    children = attr.ib(default=attr.Factory(dict))
-
-
-@attr.s()
-class Terminal:
-    status = attr.ib()
-    payload = attr.ib(default=None)
-
-
-nodes = st.deferred(lambda: terminals | writes | branches)
-
-
-# Does not include Status.OVERFLOW by design: That happens because of the size
-# of the string, not the input language.
-terminals = st.one_of(
-    st.just(Terminal(Status.VALID)),
-    st.just(Terminal(Status.INVALID)),
-    st.builds(Terminal, status=st.just(Status.INTERESTING), payload=st.integers(0, 10)),
-)
-
-branches = st.builds(Branch, bits=st.integers(1, 64))
-
-writes = st.builds(Write, value=st.binary(min_size=1), child=nodes)
-
-
-# Remember what the default phases are with no test running, so that we can
-# run an outer test with non-default phases and then restore the defaults for
-# the inner test.
-_default_phases = settings.default.phases
-
-
-def run_language_test_for(root, data, seed):
-    random.seed(seed)
-
-    def test(local_data):
-        node = root
-        while not isinstance(node, Terminal):
-            if isinstance(node, Write):
-                local_data.write(node.value)
-                node = node.child
-            else:
-                assert isinstance(node, Branch)
-                c = local_data.draw_bits(node.bits)
-                try:
-                    node = node.childrenc
-                except KeyError:
-                    if data is None:
-                        return
-                    node = node.children.setdefault(c, data.draw(nodes))
-        assert isinstance(node, Terminal)
-        if node.status == Status.INTERESTING:
-            local_data.mark_interesting(node.payload)
-        elif node.status == Status.INVALID:
-            local_data.mark_invalid()
-
-    runner = ConjectureRunner(
-        test,
-        settings=settings(
-            max_examples=1,
-            database=None,
-            suppress_health_check=HealthCheck.all(),
-            verbosity=Verbosity.quiet,
-            # Restore the global default phases, so that we don't inherit the
-            # phases setting from the outer test.
-            phases=_default_phases,
-        ),
-    )
-    try:
-        runner.run()
-    finally:
-        if data is not None:
-            note(root)
-    assume(runner.interesting_examples)
-
-
-@settings(
-    suppress_health_check=HealthCheck.all(),
-    deadline=None,
-    phases=set(settings.default.phases) - {Phase.shrink},
-)
-@given(st.data())
-def test_explore_an_arbitrary_language(data):
-    root = data.draw(writes | branches)
-    seed = data.draw(st.integers(0, 2**64 - 1))
-    run_language_test_for(root, data, seed)
-
-
-@pytest.mark.parametrize("seed, language", )
-def test_run_specific_example(seed, language):
-    """This test recreates individual languages generated with the main test.
-
-    These are typically manually pruned down a bit - e.g. it's
-    OK to remove VALID nodes because KeyError is treated as if it lead to one
-    in this test (but not in the @given test).
-
-    These tests are likely to be fairly fragile with respect to changes in the
-    underlying engine. Feel free to delete examples if they start failing after
-    a change.
-    """
-    run_language_test_for(language, None, seed)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_fancy_repr.py Deleted

@@ -1,49 +0,0 @@
-# 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/.
-
-from hypothesis import strategies as st
-
-
-def test_floats_is_floats():
-    assert repr(st.floats()) == "floats()"
-
-
-def test_includes_non_default_values():
-    assert repr(st.floats(max_value=1.0)) == "floats(max_value=1.0)"
-
-
-def foo(*args, **kwargs):
-    pass
-
-
-# fmt: off
-# The linebreaks here can force our lambda repr code into specific paths,
-# so we tell Black to leave them as-is.
-
-
-def test_builds_repr():
-    assert repr(st.builds(foo, st.just(1), x=st.just(10))) == \
-        'builds(foo, just(1), x=just(10))'
-
-
-def test_map_repr():
-    assert repr(st.integers().map(abs)) == 'integers().map(abs)'
-    assert repr(st.integers().map(lambda x: x * 2)) == \
-        'integers().map(lambda x: x * 2)'
-
-
-def test_filter_repr():
-    assert repr(st.integers().filter(lambda x: x != 3)) == \
-        'integers().filter(lambda x: x != 3)'
-
-
-def test_flatmap_repr():
-    assert repr(st.integers().flatmap(lambda x: st.booleans())) == \
-        'integers().flatmap(lambda x: st.booleans())'

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_filtering.py Deleted

@@ -1,69 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.strategies import integers, lists
-
-
-@pytest.mark.parametrize(
-    ("specifier", "condition"),
-    (integers(), lambda x: x > 1), (lists(integers()), bool),
-)
-def test_filter_correctly(specifier, condition):
-    @given(specifier.filter(condition))
-    def test_is_filtered(x):
-        assert condition(x)
-
-    test_is_filtered()
-
-
-# A variety of strategies that generate the integers 1-20 inclusive, but might
-# differ in their support for special-case filtering.
-one_to_twenty_strategies = 
-    st.integers(1, 20),
-    st.integers(0, 19).map(lambda x: x + 1),
-    st.sampled_from(range(1, 21)),
-    st.sampled_from(range(0, 20)).map(lambda x: x + 1),
-
-
-
-@pytest.mark.parametrize("base", one_to_twenty_strategies)
-@given(
-    data=st.data(),
-    forbidden_values=st.lists(st.integers(1, 20), max_size=19, unique=True),
-)
-def test_chained_filters_agree(data, forbidden_values, base):
-    def forbid(s, forbidden):
-        """Helper function to avoid Python variable scoping issues."""
-        return s.filter(lambda x: x != forbidden)
-
-    s = base
-    for forbidden in forbidden_values:
-        s = forbid(s, forbidden)
-
-    x = data.draw(s)
-    assert 1 <= x <= 20
-    assert x not in forbidden_values
-
-
-@pytest.mark.parametrize("base", one_to_twenty_strategies)
-def test_chained_filters_repr(base):
-    def foo(x):
-        return x != 0
-
-    def bar(x):
-        return x != 2
-
-    filtered = base.filter(foo)
-    chained = filtered.filter(bar)
-    assert repr(chained) == f"{base!r}.filter(foo).filter(bar)"
-    assert repr(filtered) == f"{base!r}.filter(foo)"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_find.py Deleted

@@ -1,67 +0,0 @@
-# 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 math
-
-import pytest
-
-from hypothesis import find, settings as Settings
-from hypothesis.errors import NoSuchExample
-from hypothesis.strategies import booleans, dictionaries, floats, integers, lists
-
-from tests.common.debug import minimal
-
-
-def test_can_find_an_int():
-    assert minimal(integers(), lambda x: True) == 0
-    assert minimal(integers(), lambda x: x >= 13) == 13
-
-
-def test_can_find_list():
-    x = minimal(lists(integers()), lambda x: sum(x) >= 10)
-    assert sum(x) == 10
-
-
-def test_can_find_nan():
-    minimal(floats(), math.isnan)
-
-
-def test_can_find_nans():
-    x = minimal(lists(floats()), lambda x: math.isnan(sum(x)))
-    if len(x) == 1:
-        assert math.isnan(x0)
-    else:
-        assert 2 <= len(x) <= 3
-
-
-def test_condition_is_name():
-    settings = Settings(max_examples=20)
-    with pytest.raises(NoSuchExample) as e:
-        find(booleans(), lambda x: False, settings=settings)
-    assert "lambda x:" in e.value.args0
-
-    with pytest.raises(NoSuchExample) as e:
-        find(integers(), lambda x: "☃" in str(x), settings=settings)
-    assert "lambda x:" in e.value.args0
-
-    def bad(x):
-        return False
-
-    with pytest.raises(NoSuchExample) as e:
-        find(integers(), bad, settings=settings)
-    assert "bad" in e.value.args0
-
-
-def test_find_dictionary():
-    smallest = minimal(
-        dictionaries(keys=integers(), values=integers()),
-        lambda xs: any(kv0 > kv1 for kv in xs.items()),
-    )
-    assert len(smallest) == 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_fixtures.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_flatmap.py Deleted

@@ -1,114 +0,0 @@
-# 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/.
-
-from collections import Counter
-
-import pytest
-
-from hypothesis import HealthCheck, assume, given, settings
-from hypothesis.database import ExampleDatabase
-from hypothesis.strategies import (
-    booleans,
-    builds,
-    floats,
-    integers,
-    just,
-    lists,
-    text,
-    tuples,
-)
-
-from tests.common.debug import minimal
-
-ConstantLists = integers().flatmap(lambda i: lists(just(i)))
-
-OrderedPairs = integers(1, 200).flatmap(lambda e: tuples(integers(0, e - 1), just(e)))
-
-
-# This health check fails very very occasionally - rarely enough to not be worth
-# investigation
-@settings(max_examples=100, suppress_health_check=HealthCheck.filter_too_much)
-@given(ConstantLists)
-def test_constant_lists_are_constant(x):
-    assume(len(x) >= 3)
-    assert len(set(x)) == 1
-
-
-@settings(max_examples=100)
-@given(OrderedPairs)
-def test_in_order(x):
-    assert x0 < x1
-
-
-def test_flatmap_retrieve_from_db():
-    constant_float_lists = floats(0, 1).flatmap(lambda x: lists(just(x)))
-
-    track = 
-
-    db = ExampleDatabase()
-
-    @given(constant_float_lists)
-    @settings(database=db)
-    def record_and_test_size(xs):
-        if sum(xs) >= 1:
-            track.append(xs)
-            raise AssertionError
-
-    with pytest.raises(AssertionError):
-        record_and_test_size()
-
-    assert track
-    example = track-1
-    track = 
-
-    with pytest.raises(AssertionError):
-        record_and_test_size()
-
-    assert track0 == example
-
-
-def test_flatmap_does_not_reuse_strategies():
-    s = builds(list).flatmap(just)
-    assert s.example() is not s.example()
-
-
-def test_flatmap_has_original_strategy_repr():
-    ints = integers()
-    ints_up = ints.flatmap(lambda n: integers(min_value=n))
-    assert repr(ints) in repr(ints_up)
-
-
-def test_mixed_list_flatmap():
-    s = lists(booleans().flatmap(lambda b: booleans() if b else text()))
-
-    def criterion(ls):
-        c = Counter(type(l) for l in ls)
-        return len(c) >= 2 and min(c.values()) >= 3
-
-    result = minimal(s, criterion)
-    assert len(result) == 6
-    assert set(result) == {False, ""}
-
-
-@pytest.mark.parametrize("n", range(1, 10))
-def test_can_shrink_through_a_binding(n):
-    bool_lists = integers(0, 100).flatmap(
-        lambda k: lists(booleans(), min_size=k, max_size=k)
-    )
-    assert minimal(bool_lists, lambda x: x.count(True) >= n) == True * n
-
-
-@pytest.mark.parametrize("n", range(1, 10))
-def test_can_delete_in_middle_of_a_binding(n):
-    bool_lists = integers(1, 100).flatmap(
-        lambda k: lists(booleans(), min_size=k, max_size=k)
-    )
-    result = minimal(bool_lists, lambda x: x0 and x-1 and x.count(False) >= n)
-    assert result == True + False * n + True

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_floating.py Deleted

@@ -1,141 +0,0 @@
-# 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/.
-
-"""Tests for being able to generate weird and wonderful floating point numbers."""
-
-import math
-import sys
-
-import pytest
-
-from hypothesis import HealthCheck, assume, given, settings
-from hypothesis.internal.floats import float_to_int
-from hypothesis.strategies import data, floats, lists
-
-from tests.common.debug import find_any
-from tests.common.utils import fails
-
-TRY_HARDER = settings(
-    max_examples=1000, suppress_health_check=HealthCheck.filter_too_much
-)
-
-
-@given(floats())
-@TRY_HARDER
-def test_is_float(x):
-    assert isinstance(x, float)
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_inversion_is_imperfect(x):
-    assume(x != 0.0)
-    y = 1.0 / x
-    assert x * y == 1.0
-
-
-@given(floats(-sys.float_info.max, sys.float_info.max))
-def test_largest_range(x):
-    assert not math.isinf(x)
-
-
-@given(floats())
-@TRY_HARDER
-def test_negation_is_self_inverse(x):
-    assume(not math.isnan(x))
-    y = -x
-    assert -y == x
-
-
-@fails
-@given(lists(floats()))
-def test_is_not_nan(xs):
-    assert not any(math.isnan(x) for x in xs)
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_is_not_positive_infinite(x):
-    assume(x > 0)
-    assert not math.isinf(x)
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_is_not_negative_infinite(x):
-    assume(x < 0)
-    assert not math.isinf(x)
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_is_int(x):
-    assume(math.isfinite(x))
-    assert x == int(x)
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_is_not_int(x):
-    assume(math.isfinite(x))
-    assert x != int(x)
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_is_in_exact_int_range(x):
-    assume(math.isfinite(x))
-    assert x + 1 != x
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_can_find_floats_that_do_not_round_trip_through_strings(x):
-    assert float(str(x)) == x
-
-
-@fails
-@given(floats())
-@TRY_HARDER
-def test_can_find_floats_that_do_not_round_trip_through_reprs(x):
-    assert float(repr(x)) == x
-
-
-finite_floats = floats(allow_infinity=False, allow_nan=False)
-
-
-@settings(deadline=None)
-@given(finite_floats, finite_floats, data())
-def test_floats_are_in_range(x, y, data):
-    x, y = sorted((x, y))
-    assume(x < y)
-
-    t = data.draw(floats(x, y))
-    assert x <= t <= y
-
-
-@pytest.mark.parametrize("neg", False, True)
-@pytest.mark.parametrize("snan", False, True)
-def test_can_find_negative_and_signaling_nans(neg, snan):
-    find_any(
-        floats().filter(math.isnan),
-        lambda x: (
-            snan is (float_to_int(abs(x)) != float_to_int(float("nan")))
-            and neg is (math.copysign(1, x) == -1)
-        ),
-        settings=TRY_HARDER,
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_from_type_recipe.py Deleted

@@ -1,34 +0,0 @@
-# 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/.
-
-from hypothesis import given, strategies as st
-from hypothesis.strategies._internal.types import _global_type_lookup
-
-TYPES = sorted((x for x in _global_type_lookup if x.__module__ != "typing"), key=str)
-
-
-def everything_except(excluded_types):
-    """Recipe copied from the docstring of ``from_type``"""
-    return (
-        st.from_type(type)
-        .flatmap(st.from_type)
-        .filter(lambda x: not isinstance(x, excluded_types))
-    )
-
-
-@given(
-    excluded_types=st.lists(
-        st.sampled_from(TYPES), min_size=1, max_size=3, unique=True
-    ).map(tuple),
-    data=st.data(),
-)
-def test_recipe_for_everything_except(excluded_types, data):
-    value = data.draw(everything_except(excluded_types))
-    assert not isinstance(value, excluded_types)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_given_error_conditions.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_given_reuse.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_imports.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_integer_ranges.py Deleted

@@ -1,60 +0,0 @@
-# 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 pytest
-
-from hypothesis import given
-from hypothesis.internal.conjecture.utils import integer_range
-from hypothesis.strategies import integers
-from hypothesis.strategies._internal.strategies import SearchStrategy
-
-from tests.common.debug import minimal
-
-
-class interval(SearchStrategy):
-    def __init__(self, lower, upper, center=None):
-        self.lower = lower
-        self.upper = upper
-        self.center = center
-
-    def do_draw(self, data):
-        return integer_range(data, self.lower, self.upper, center=self.center)
-
-
-@pytest.mark.parametrize(
-    "lower_center_upper",
-    (0, 5, 10), (-10, 10, 10), (0, 1, 1), (1, 1, 2), (-10, 0, 10), (-10, 5, 10),
-    ids=repr,
-)
-def test_intervals_shrink_to_center(lower_center_upper):
-    lower, center, upper = lower_center_upper
-    s = interval(lower, upper, center)
-    assert minimal(s, lambda x: True) == center
-    if lower < center:
-        assert minimal(s, lambda x: x < center) == center - 1
-    if center < upper:
-        assert minimal(s, lambda x: x > center) == center + 1
-        assert minimal(s, lambda x: x != center) == center + 1
-
-
-def test_bounded_integers_distribution_of_bit_width_issue_1387_regression():
-    values = 
-
-    @given(integers(0, 1e100))
-    def test(x):
-        values.append(x)
-
-    test()
-
-    # We draw from a shaped distribution up to 128bit ~7/8 of the time, and
-    # uniformly the rest.  So we should get some very large but not too many.
-    huge = sum(x > 1e97 for x in values)
-    assert huge != 0
-    assert huge <= 0.3 * len(values)  # expected ~1/8

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_interesting_origin.py Deleted

@@ -1,66 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, settings, strategies as st
-from hypothesis.errors import MultipleFailures
-
-from tests.common.utils import flaky
-
-
-def go_wrong_naive(a, b):
-    try:
-        assert a + b < 100
-        a / b
-    except Exception:
-        # Hiding the actual problem is terrible, but this pattern can make sense
-        # if you're raising a library-specific or semantically meaningful error.
-        raise ValueError("Something went wrong") from None
-
-
-def go_wrong_with_cause(a, b):
-    try:
-        assert a + b < 100
-        a / b
-    except Exception as err:
-        # Explicit chaining is the *right way* to change exception type.
-        raise ValueError("Something went wrong") from err
-
-
-def go_wrong_coverup(a, b):
-    try:
-        assert a + b < 100
-        a / b
-    except Exception:
-        # This pattern SHOULD be local enough that it never distinguishes
-        # errors in practice... but if it does, we're ready.
-        raise ValueError("Something went wrong") from None
-
-
-@pytest.mark.parametrize(
-    "function",
-    go_wrong_naive, go_wrong_with_cause, go_wrong_coverup,
-    ids=lambda f: f.__name__,
-)
-@flaky(max_runs=3, min_passes=1)
-def test_can_generate_specified_version(function):
-    @given(st.integers(), st.integers())
-    @settings(database=None)
-    def test_fn(x, y):
-        # Indirection to fix https://github.com/HypothesisWorks/hypothesis/issues/2888
-        return function(x, y)
-
-    try:
-        test_fn()
-    except MultipleFailures:
-        pass
-    else:
-        raise AssertionError("Expected MultipleFailures")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_labels.py Deleted

@@ -1,49 +0,0 @@
-# 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/.
-
-from hypothesis import strategies as st
-
-
-def test_labels_are_cached():
-    x = st.integers()
-    assert x.label is x.label
-
-
-def test_labels_are_distinct():
-    assert st.integers().label != st.text().label
-
-
-@st.composite
-def foo(draw):
-    pass
-
-
-@st.composite
-def bar(draw):
-    pass
-
-
-def test_different_composites_have_different_labels():
-    assert foo().label != bar().label
-
-
-def test_one_of_label_is_distinct():
-    a = st.integers()
-    b = st.booleans()
-    assert st.one_of(a, b).label != st.one_of(b, a).label
-
-
-def test_lists_label_by_element():
-    assert st.lists(st.integers()).label != st.lists(st.booleans()).label
-
-
-def test_label_of_deferred_strategy_is_well_defined():
-    recursive = st.deferred(lambda: st.lists(recursive))
-    recursive.label

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_large_examples.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_limits.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_lstar.py Deleted

@@ -1,35 +0,0 @@
-# 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 hypothesis.strategies as st
-from hypothesis import Phase, example, given, settings
-from hypothesis.internal.conjecture.dfa.lstar import LStar
-
-
-@st.composite
-def byte_order(draw):
-    ls = draw(st.permutations(range(256)))
-    n = draw(st.integers(0, len(ls)))
-    return ls:n
-
-
-@example({0}, 1)
-@given(st.sets(st.integers(0, 255)), byte_order())
-# This test doesn't even use targeting at all, but for some reason the
-# pareto optimizer makes it much slower.
-@settings(phases=set(settings.default.phases) - {Phase.target})
-def test_learning_always_changes_generation(chars, order):
-    learner = LStar(lambda s: len(s) == 1 and s0 in chars)
-    for c in order:
-        prev = learner.generation
-        s = bytes(c)
-        if learner.dfa.matches(s) != learner.member(s):
-            learner.learn(s)
-            assert learner.generation > prev

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_modify_inner_test.py Deleted

@@ -1,104 +0,0 @@
-# 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/.
-
-from functools import wraps
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-
-def always_passes(*args, **kwargs):
-    """Stand-in for a fixed version of an inner test.
-
-    For example, pytest-trio would take the inner test, wrap it in an
-    async-to-sync converter, and use the new func (not always_passes).
-    """
-
-
-@given(st.integers())
-def test_can_replace_inner_test(x):
-    raise AssertionError("This should be replaced")
-
-
-test_can_replace_inner_test.hypothesis.inner_test = always_passes
-
-
-def decorator(func):
-    """An example of a common decorator pattern."""
-
-    @wraps(func)
-    def inner(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    return inner
-
-
-@decorator
-@given(st.integers())
-def test_can_replace_when_decorated(x):
-    raise AssertionError("This should be replaced")
-
-
-test_can_replace_when_decorated.hypothesis.inner_test = always_passes
-
-
-@pytest.mark.parametrize("x", 1, 2)
-@given(y=st.integers())
-def test_can_replace_when_parametrized(x, y):
-    raise AssertionError("This should be replaced")
-
-
-test_can_replace_when_parametrized.hypothesis.inner_test = always_passes
-
-
-def test_can_replace_when_original_is_invalid():
-    # Invalid: @given with too many positional arguments
-    @given(st.integers(), st.integers())
-    def invalid_test(x):
-        raise AssertionError
-
-    invalid_test.hypothesis.inner_test = always_passes
-
-    # Even after replacing the inner test, calling the wrapper should still
-    # fail.
-    with pytest.raises(InvalidArgument, match="Too many positional arguments"):
-        invalid_test()
-
-
-def test_inner_is_original_even_when_invalid():
-    def invalid_test(x):
-        raise AssertionError
-
-    original = invalid_test
-
-    # Invalid: @given with no arguments
-    invalid_test = given()(invalid_test)
-
-    # Verify that the test is actually invalid
-    with pytest.raises(
-        InvalidArgument,
-        match="given must be called with at least one argument",
-    ):
-        invalid_test()
-
-    assert invalid_test.hypothesis.inner_test == original
-
-
-def test_invokes_inner_function_with_args_by_name():
-    # Regression test for https://github.com/HypothesisWorks/hypothesis/issues/3245
-    @given(st.integers())
-    def test(x):
-        pass
-
-    f = test.hypothesis.inner_test
-    test.hypothesis.inner_test = wraps(f)(lambda **kw: f(**kw))
-    test()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_nesting.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_pretty_repr.py Deleted

@@ -1,116 +0,0 @@
-# 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/.
-
-from collections import OrderedDict
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.control import reject
-from hypothesis.errors import HypothesisDeprecationWarning, InvalidArgument
-
-
-def foo(x):
-    pass
-
-
-def bar(x):
-    pass
-
-
-def baz(x):
-    pass
-
-
-fns = foo, bar, baz
-
-
-def builds_ignoring_invalid(target, *args, **kwargs):
-    def splat(value):
-        try:
-            result = target(*value0, **value1)
-            result.validate()
-            return result
-        except (HypothesisDeprecationWarning, InvalidArgument):
-            reject()
-
-    return st.tuples(st.tuples(*args), st.fixed_dictionaries(kwargs)).map(splat)
-
-
-size_strategies = {
-    "min_size": st.integers(min_value=0, max_value=100),
-    "max_size": st.integers(min_value=0, max_value=100) | st.none(),
-}
-
-values = st.integers() | st.text()
-
-
-Strategies = st.recursive(
-    st.one_of(
-        st.sampled_from(
-            
-                st.none(),
-                st.booleans(),
-                st.randoms(use_true_random=True),
-                st.complex_numbers(),
-                st.randoms(use_true_random=True),
-                st.fractions(),
-                st.decimals(),
-            
-        ),
-        st.builds(st.just, values),
-        st.builds(st.sampled_from, st.lists(values, min_size=1)),
-        builds_ignoring_invalid(st.floats, st.floats(), st.floats()),
-    ),
-    lambda x: st.one_of(
-        builds_ignoring_invalid(st.lists, x, **size_strategies),
-        builds_ignoring_invalid(st.sets, x, **size_strategies),
-        builds_ignoring_invalid(lambda v: st.tuples(*v), st.lists(x)),
-        builds_ignoring_invalid(lambda v: st.one_of(*v), st.lists(x, min_size=1)),
-        builds_ignoring_invalid(
-            st.dictionaries,
-            x,
-            x,
-            dict_class=st.sampled_from(dict, OrderedDict),
-            **size_strategies,
-        ),
-        st.builds(lambda s, f: s.map(f), x, st.sampled_from(fns)),
-    ),
-)
-
-
-strategy_globals = {k: getattr(st, k) for k in dir(st)}
-
-strategy_globals"OrderedDict" = OrderedDict
-strategy_globals"inf" = float("inf")
-strategy_globals"nan" = float("nan")
-strategy_globals"foo" = foo
-strategy_globals"bar" = bar
-strategy_globals"baz" = baz
-
-
-@given(Strategies)
-def test_repr_evals_to_thing_with_same_repr(strategy):
-    r = repr(strategy)
-    via_eval = eval(r, strategy_globals)
-    r2 = repr(via_eval)
-    assert r == r2
-
-
-@pytest.mark.parametrize(
-    "r",
-    
-        "none().filter(foo).map(bar)",
-        "just(1).filter(foo).map(bar)",
-        "sampled_from(1, 2, 3).filter(foo).map(bar)",
-    ,
-)
-def test_sampled_transform_reprs(r):
-    assert repr(eval(r, strategy_globals)) == r

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_randomization.py Deleted

@@ -1,41 +0,0 @@
-# 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/.
-
-from pytest import raises
-
-from hypothesis import Verbosity, core, find, given, settings, strategies as st
-
-from tests.common.utils import no_shrink
-
-
-def test_seeds_off_internal_random():
-    s = settings(phases=no_shrink, database=None)
-    r = core._hypothesis_global_random.getstate()
-    x = find(st.integers(), lambda x: True, settings=s)
-    core._hypothesis_global_random.setstate(r)
-    y = find(st.integers(), lambda x: True, settings=s)
-    assert x == y
-
-
-def test_nesting_with_control_passes_health_check():
-    @given(st.integers(0, 100), st.random_module())
-    @settings(max_examples=5, database=None, deadline=None)
-    def test_blah(x, rnd):
-        @given(st.integers())
-        @settings(
-            max_examples=100, phases=no_shrink, database=None, verbosity=Verbosity.quiet
-        )
-        def test_nest(y):
-            assert y < x
-
-        with raises(AssertionError):
-            test_nest()
-
-    test_blah()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_recursive.py Deleted

@@ -1,170 +0,0 @@
-# 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 threading
-
-from hypothesis import HealthCheck, given, settings, strategies as st
-
-from tests.common.debug import find_any, minimal
-from tests.common.utils import flaky
-
-
-def test_can_generate_with_large_branching():
-    def flatten(x):
-        if isinstance(x, list):
-            return sum(map(flatten, x), )
-        else:
-            return x
-
-    size = 20
-
-    xs = minimal(
-        st.recursive(
-            st.integers(),
-            lambda x: st.lists(x, min_size=size // 2),
-            max_leaves=size * 2,
-        ),
-        lambda x: isinstance(x, list) and len(flatten(x)) >= size,
-        timeout_after=None,
-    )
-    assert flatten(xs) == 0 * size
-
-
-def test_can_generate_some_depth_with_large_branching():
-    def depth(x):
-        if x and isinstance(x, list):
-            return 1 + max(map(depth, x))
-        else:
-            return 1
-
-    xs = minimal(
-        st.recursive(st.integers(), st.lists),
-        lambda x: depth(x) > 1,
-        timeout_after=None,
-    )
-    assert xs in (0, )
-
-
-def test_can_find_quite_broad_lists():
-    def breadth(x):
-        if isinstance(x, list):
-            return sum(map(breadth, x))
-        else:
-            return 1
-
-    target = 10
-
-    broad = minimal(
-        st.recursive(st.booleans(), lambda x: st.lists(x, max_size=target // 2)),
-        lambda x: breadth(x) >= target,
-        settings=settings(max_examples=10000),
-        timeout_after=None,
-    )
-    assert breadth(broad) == target
-
-
-def test_drawing_many_near_boundary():
-    target = 4
-
-    ls = minimal(
-        st.lists(
-            st.recursive(
-                st.booleans(),
-                lambda x: st.lists(
-                    x, min_size=2 * (target - 1), max_size=2 * target
-                ).map(tuple),
-                max_leaves=2 * target - 1,
-            )
-        ),
-        lambda x: len(set(x)) >= target,
-        timeout_after=None,
-    )
-    assert len(ls) == target
-
-
-def test_can_use_recursive_data_in_sets():
-    nested_sets = st.recursive(st.booleans(), st.frozensets, max_leaves=3)
-    find_any(nested_sets, settings=settings(deadline=None))
-
-    def flatten(x):
-        if isinstance(x, bool):
-            return frozenset((x,))
-        else:
-            result = frozenset()
-            for t in x:
-                result |= flatten(t)
-                if len(result) == 2:
-                    break
-            return result
-
-    x = minimal(nested_sets, lambda x: len(flatten(x)) == 2, settings(deadline=None))
-    assert x in (
-        frozenset((False, True)),
-        frozenset((False, frozenset((True,)))),
-        frozenset((frozenset((False, True)),)),
-    )
-
-
-@flaky(max_runs=2, min_passes=1)
-def test_can_form_sets_of_recursive_data():
-    size = 3
-
-    trees = st.sets(
-        st.recursive(
-            st.booleans(),
-            lambda x: st.lists(x, min_size=size).map(tuple),
-            max_leaves=20,
-        )
-    )
-    xs = minimal(trees, lambda x: len(x) >= size, timeout_after=None)
-    assert len(xs) == size
-
-
-def test_drawing_from_recursive_strategy_is_thread_safe():
-    shared_strategy = st.recursive(
-        st.integers(), lambda s: st.lists(s, max_size=2), max_leaves=20
-    )
-
-    errors = 
-
-    @settings(
-        database=None, deadline=None, suppress_health_check=HealthCheck.too_slow
-    )
-    @given(data=st.data())
-    def test(data):
-        try:
-            data.draw(shared_strategy)
-        except Exception as exc:
-            errors.append(exc)
-
-    threads = 
-
-    for _ in range(4):
-        threads.append(threading.Thread(target=test))
-
-    for thread in threads:
-        thread.start()
-
-    for thread in threads:
-        thread.join()
-
-    assert not errors
-
-
-SELF_REF = st.recursive(
-    st.deferred(lambda: st.booleans() | SELF_REF),
-    lambda s: st.lists(s, min_size=1),
-)
-
-
-@given(SELF_REF)
-def test_self_ref_regression(_):
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2794
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_regex.py Deleted

@@ -1,108 +0,0 @@
-# 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 re
-import string
-from functools import reduce
-
-from hypothesis import assume, given, reject, strategies as st
-from hypothesis.strategies._internal.regex import base_regex_strategy
-
-
-@st.composite
-def charset(draw):
-    negated = draw(st.booleans())
-    chars = draw(st.text(string.ascii_letters + string.digits, min_size=1))
-    if negated:
-        return f"^{chars}"
-    else:
-        return f"{chars}"
-
-
-COMBINED_MATCHER = re.compile("?+*{2}")
-
-
-@st.composite
-def conservative_regex(draw):
-    result = draw(
-        st.one_of(
-            st.just("."),
-            st.sampled_from(re.escape(c) for c in string.printable),
-            charset(),
-            CONSERVATIVE_REGEX.map(lambda s: f"({s})"),
-            CONSERVATIVE_REGEX.map(lambda s: s + "+"),
-            CONSERVATIVE_REGEX.map(lambda s: s + "?"),
-            CONSERVATIVE_REGEX.map(lambda s: s + "*"),
-            st.lists(CONSERVATIVE_REGEX, min_size=1, max_size=3).map("|".join),
-            st.lists(CONSERVATIVE_REGEX, min_size=1, max_size=3).map("".join),
-        )
-    )
-    assume(COMBINED_MATCHER.search(result) is None)
-    control = sum(result.count(c) for c in "?+*")
-    assume(control <= 3)
-    return result
-
-
-CONSERVATIVE_REGEX = conservative_regex()
-FLAGS = st.sets(
-    st.sampled_from(re.ASCII, re.IGNORECASE, re.MULTILINE, re.DOTALL)
-).map(lambda flag_set: reduce(int.__or__, flag_set, 0))
-
-
-@given(st.data())
-def test_conservative_regex_are_correct_by_construction(data):
-    pattern = re.compile(data.draw(CONSERVATIVE_REGEX), flags=data.draw(FLAGS))
-    result = data.draw(base_regex_strategy(pattern))
-    assert pattern.search(result) is not None
-
-
-@given(st.data())
-def test_fuzz_stuff(data):
-    pattern = data.draw(
-        st.text(min_size=1, max_size=5)
-        | st.binary(min_size=1, max_size=5)
-        | CONSERVATIVE_REGEX.filter(bool)
-    )
-    flags = data.draw(FLAGS)
-
-    try:
-        regex = re.compile(pattern, flags=flags)
-    except (re.error, FutureWarning):
-        # Possible nested sets, e.g. "", trigger a FutureWarning
-        reject()
-
-    ex = data.draw(st.from_regex(regex))
-    assert regex.search(ex)
-
-
-# Some preliminaries, to establish what's happening:
-I_WITH_DOT = "\u0130"
-assert I_WITH_DOT.swapcase() == "i\u0307"  # note: string of length two!
-assert re.compile(I_WITH_DOT, flags=re.IGNORECASE).match(I_WITH_DOT.swapcase())
-
-
-@given(st.data())
-def test_case_insensitive_not_literal_never_constructs_multichar_match(data):
-    # So our goal is to confirm that we can never accidentally create a non-matching
-    # string by assembling individually allowed characters.
-    pattern = re.compile(f"^{I_WITH_DOT}+", flags=re.IGNORECASE)
-    strategy = st.from_regex(pattern, fullmatch=True)
-    for _ in range(5):
-        s = data.draw(strategy)
-        assert pattern.fullmatch(s) is not None
-        # And to be on the safe side, we implement this stronger property:
-        assert set(s).isdisjoint(I_WITH_DOT.swapcase())
-
-
-@given(st.from_regex(re.compile(f"^{I_WITH_DOT}_", re.IGNORECASE), fullmatch=True))
-def test_no_error_converting_negated_sets_to_strategy(s):
-    # CharactersBuilder no longer triggers an internal error converting sets
-    # or negated sets to a strategy when multi-char strings are whitelisted.
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_regressions.py Deleted

@@ -1,46 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-from hypothesis._settings import note_deprecation
-from hypothesis.errors import HypothesisDeprecationWarning
-
-
-def test_note_deprecation_blames_right_code_issue_652():
-    msg = "this is an arbitrary deprecation warning message"
-
-    @st.composite
-    def deprecated_strategy(draw):
-        draw(st.none())
-        note_deprecation(msg, since="RELEASEDAY", has_codemod=False)
-
-    @given(deprecated_strategy())
-    def f(x):
-        pass
-
-    with pytest.warns(HypothesisDeprecationWarning) as log:
-        f()
-
-    assert len(log) == 1
-    (record,) = log
-    # We got the warning we expected, from the right file
-    assert isinstance(record.message, HypothesisDeprecationWarning)
-    assert record.message.args == (msg,)
-    assert record.filename == __file__
-
-
-@given(
-    x=st.one_of(st.just(0) | st.just(1)),
-    y=st.one_of(st.just(0) | st.just(1) | st.just(2)),
-)
-def test_performance_issue_2027(x, y):
-    pass

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_reusable_values.py Deleted

@@ -1,162 +0,0 @@
-# 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 pytest
-
-from hypothesis import example, given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-# Be aware that tests in this file pass strategies as arguments to @example.
-# That's normally a mistake, but for these tests it's intended.
-# If one of these tests fails, Hypothesis will complain about the
-# @example/strategy interaction, but it should be safe to ignore that
-# error message and focus on the underlying failure instead.
-
-base_reusable_strategies = (
-    st.text(),
-    st.binary(),
-    st.dates(),
-    st.times(),
-    st.timedeltas(),
-    st.booleans(),
-    st.complex_numbers(),
-    st.floats(),
-    st.floats(-1.0, 1.0),
-    st.integers(),
-    st.integers(1, 10),
-    st.integers(1),
-    # Note that `just` and `sampled_from` count as "reusable" even if their
-    # values are mutable, because the user has implicitly promised that they
-    # don't care about the same mutable value being returned by separate draws.
-    st.just(),
-    st.sampled_from(),
-    st.tuples(st.integers()),
-)
-
-
-@st.deferred
-def reusable():
-    """Meta-strategy that produces strategies that should have
-    ``.has_reusable_values == True``."""
-    return st.one_of(
-        # This looks like it should be `one_of`, but `sampled_from` is correct
-        # because we want this meta-strategy to yield strategies as its values.
-        st.sampled_from(base_reusable_strategies),
-        # This sometimes produces invalid combinations of arguments, which
-        # we filter out further down with an explicit validation check.
-        st.builds(
-            st.floats,
-            min_value=st.none() | st.floats(allow_nan=False),
-            max_value=st.none() | st.floats(allow_nan=False),
-            allow_infinity=st.booleans(),
-            allow_nan=st.booleans(),
-        ),
-        st.builds(st.just, st.builds(list)),
-        st.builds(st.sampled_from, st.lists(st.builds(list), min_size=1)),
-        st.lists(reusable).map(st.one_of),
-        st.lists(reusable).map(lambda ls: st.tuples(*ls)),
-    )
-
-
-def is_valid(s):
-    try:
-        s.validate()
-        return True
-    except InvalidArgument:
-        return False
-
-
-reusable = reusable.filter(is_valid)
-
-assert not reusable.is_empty
-
-
-def many_examples(examples):
-    """Helper decorator to apply the ``@example`` decorator multiple times,
-    once for each given example."""
-
-    def accept(f):
-        for e in examples:
-            f = example(e)(f)
-        return f
-
-    return accept
-
-
-@many_examples(base_reusable_strategies)
-@many_examples(st.tuples(s) for s in base_reusable_strategies)
-@given(reusable)
-def test_reusable_strategies_are_all_reusable(s):
-    assert s.has_reusable_values
-
-
-@many_examples(base_reusable_strategies)
-@given(reusable)
-def test_filter_breaks_reusability(s):
-    cond = True
-
-    def nontrivial_filter(x):
-        """Non-trivial filtering function, intended to remain opaque even if
-        some strategies introspect their filters."""
-        return cond
-
-    assert s.has_reusable_values
-    assert not s.filter(nontrivial_filter).has_reusable_values
-
-
-@many_examples(base_reusable_strategies)
-@given(reusable)
-def test_map_breaks_reusability(s):
-    cond = True
-
-    def nontrivial_map(x):
-        """Non-trivial mapping function, intended to remain opaque even if
-        some strategies introspect their mappings."""
-        if cond:
-            return x
-        else:
-            return None
-
-    assert s.has_reusable_values
-    assert not s.map(nontrivial_map).has_reusable_values
-
-
-@many_examples(base_reusable_strategies)
-@given(reusable)
-def test_flatmap_breaks_reusability(s):
-    cond = True
-
-    def nontrivial_flatmap(x):
-        """Non-trivial flat-mapping function, intended to remain opaque even
-        if some strategies introspect their flat-mappings."""
-        if cond:
-            return st.just(x)
-        else:
-            return st.none()
-
-    assert s.has_reusable_values
-    assert not s.flatmap(nontrivial_flatmap).has_reusable_values
-
-
-@pytest.mark.parametrize(
-    "strat",
-    
-        st.lists(st.booleans()),
-        st.sets(st.booleans()),
-        st.dictionaries(st.booleans(), st.booleans()),
-    ,
-)
-def test_mutable_collections_do_not_have_reusable_values(strat):
-    assert not strat.has_reusable_values
-
-
-def test_recursion_does_not_break_reusability():
-    x = st.deferred(lambda: st.none() | st.tuples(x))
-    assert x.has_reusable_values

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_sampled_from.py Deleted

@@ -1,89 +0,0 @@
-# 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 enum
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import InvalidArgument
-
-from tests.common.utils import counts_calls, fails_with
-
-
-@pytest.mark.parametrize("n", 100, 10**5, 10**6, 2**25)
-def test_filter_large_lists(n):
-    filter_limit = 100 * 10000
-
-    @counts_calls
-    def cond(x):
-        assert cond.calls < filter_limit
-        return x % 2 != 0
-
-    s = st.sampled_from(range(n)).filter(cond)
-
-    @given(s)
-    def run(x):
-        assert x % 2 != 0
-
-    run()
-
-    assert cond.calls < filter_limit
-
-
-def rare_value_strategy(n, target):
-    def forbid(s, forbidden):
-        """Helper function to avoid Python variable scoping issues."""
-        return s.filter(lambda x: x != forbidden)
-
-    s = st.sampled_from(range(n))
-    for i in range(n):
-        if i != target:
-            s = forbid(s, i)
-
-    return s
-
-
-@given(rare_value_strategy(n=128, target=80))
-def test_chained_filters_find_rare_value(x):
-    assert x == 80
-
-
-@fails_with(InvalidArgument)
-@given(st.sets(st.sampled_from(range(10)), min_size=11))
-def test_unsat_sets_of_samples(x):
-    raise AssertionError
-
-
-@given(st.sets(st.sampled_from(range(50)), min_size=50))
-def test_efficient_sets_of_samples(x):
-    assert x == set(range(50))
-
-
-class AnEnum(enum.Enum):
-    a = enum.auto()
-    b = enum.auto()
-
-
-def test_enum_repr_uses_class_not_a_list():
-    # The repr should have enough detail to find the class again
-    # (which is very useful for the ghostwriter logic we're working on)
-    lazy_repr = repr(st.sampled_from(AnEnum))
-    assert lazy_repr == "sampled_from(tests.nocover.test_sampled_from.AnEnum)"
-
-
-class AFlag(enum.Flag):
-    a = enum.auto()
-    b = enum.auto()
-
-
-def test_flag_enum_repr_uses_class_not_a_list():
-    lazy_repr = repr(st.sampled_from(AFlag))
-    assert lazy_repr == "sampled_from(tests.nocover.test_sampled_from.AFlag)"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_scrutineer.py Deleted

@@ -1,78 +0,0 @@
-# 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 sys
-
-import pytest
-
-from hypothesis.internal.compat import PYPY
-from hypothesis.internal.scrutineer import make_report
-
-# We skip tracing for explanations under PyPy, where it has a large performance
-# impact, or if there is already a trace function (e.g. coverage or a debugger)
-pytestmark = pytest.mark.skipif(PYPY or sys.gettrace(), reason="See comment")
-
-BUG_MARKER = "# BUG"
-DEADLINE_PRELUDE = """
-from datetime import timedelta
-from hypothesis.errors import DeadlineExceeded
-"""
-PRELUDE = """
-from hypothesis import Phase, given, settings, strategies as st
-
-@settings(phases=tuple(Phase), derandomize=True)
-"""
-TRIVIAL = """
-@given(st.integers())
-def test_reports_branch_in_test(x):
-    if x > 10:
-        raise AssertionError  # BUG
-"""
-MULTIPLE_BUGS = """
-@given(st.integers(), st.integers())
-def test_reports_branch_in_test(x, y):
-    if x > 10:
-        raise (AssertionError if x % 2 else Exception)  # BUG
-"""
-FRAGMENTS = (
-    pytest.param(TRIVIAL, id="trivial"),
-    pytest.param(MULTIPLE_BUGS, id="multiple-bugs"),
-)
-
-
-def get_reports(file_contents, *, testdir):
-    # Takes the source code string with "# BUG" comments, and returns a list of
-    # multi-line report strings which we expect to see in explain-mode output.
-    # The list length is the number of explainable bugs, usually one.
-    test_file = str(testdir.makepyfile(file_contents))
-    pytest_stdout = str(testdir.runpytest_inprocess(test_file, "--tb=native").stdout)
-
-    explanations = {
-        i: {(test_file, i)}
-        for i, line in enumerate(file_contents.splitlines())
-        if line.endswith(BUG_MARKER)
-    }
-    expected = "\n".join(r) for k, r in make_report(explanations).items()
-    return pytest_stdout, expected
-
-
-@pytest.mark.parametrize("code", FRAGMENTS)
-def test_explanations(code, testdir):
-    pytest_stdout, expected = get_reports(PRELUDE + code, testdir=testdir)
-    assert len(expected) == code.count(BUG_MARKER)
-    for report in expected:
-        assert report in pytest_stdout
-
-
-@pytest.mark.parametrize("code", FRAGMENTS)
-def test_no_explanations_if_deadline_exceeded(code, testdir):
-    code = code.replace("AssertionError", "DeadlineExceeded(timedelta(), timedelta())")
-    pytest_stdout, _ = get_reports(DEADLINE_PRELUDE + PRELUDE + code, testdir=testdir)
-    assert "Explanation:" not in pytest_stdout

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_sets.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_sharing.py Deleted

@@ -1,59 +0,0 @@
-# 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/.
-
-from hypothesis import given, strategies as st
-
-from tests.common.debug import find_any, minimal
-
-x = st.shared(st.integers())
-
-
-@given(x, x)
-def test_sharing_is_by_instance_by_default(a, b):
-    assert a == b
-
-
-@given(st.shared(st.integers(), key="hi"), st.shared(st.integers(), key="hi"))
-def test_different_instances_with_the_same_key_are_shared(a, b):
-    assert a == b
-
-
-def test_different_instances_are_not_shared():
-    find_any(
-        st.tuples(st.shared(st.integers()), st.shared(st.integers())),
-        lambda x: x0 != x1,
-    )
-
-
-def test_different_keys_are_not_shared():
-    find_any(
-        st.tuples(st.shared(st.integers(), key=1), st.shared(st.integers(), key=2)),
-        lambda x: x0 != x1,
-    )
-
-
-def test_keys_and_default_are_not_shared():
-    find_any(
-        st.tuples(st.shared(st.integers(), key=1), st.shared(st.integers())),
-        lambda x: x0 != x1,
-    )
-
-
-def test_can_simplify_shared_lists():
-    xs = minimal(
-        st.lists(st.shared(st.integers())), lambda x: len(x) >= 10 and x0 != 0
-    )
-    assert xs == 1 * 10
-
-
-def test_simplify_shared_linked_to_size():
-    xs = minimal(st.lists(st.shared(st.integers())), lambda t: sum(t) >= 1000)
-    assert sum(xs:-1) < 1000
-    assert (xs0 - 1) * len(xs) < 1000

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_simple_numbers.py Deleted

@@ -1,220 +0,0 @@
-# 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 math
-import sys
-
-import pytest
-
-from hypothesis import given
-from hypothesis.strategies import floats, integers, lists
-
-from tests.common.debug import minimal
-
-
-def test_minimize_negative_int():
-    assert minimal(integers(), lambda x: x < 0) == -1
-    assert minimal(integers(), lambda x: x < -1) == -2
-
-
-def test_positive_negative_int():
-    assert minimal(integers(), lambda x: x > 0) == 1
-    assert minimal(integers(), lambda x: x > 1) == 2
-
-
-boundaries = pytest.mark.parametrize(
-    "boundary",
-    sorted(
-        2**i for i in range(10)
-        + 2**i - 1 for i in range(10)
-        + 2**i + 1 for i in range(10)
-        + 10**i for i in range(6)
-    ),
-)
-
-
-@boundaries
-def test_minimizes_int_down_to_boundary(boundary):
-    assert minimal(integers(), lambda x: x >= boundary) == boundary
-
-
-@boundaries
-def test_minimizes_int_up_to_boundary(boundary):
-    assert minimal(integers(), lambda x: x <= -boundary) == -boundary
-
-
-@boundaries
-def test_minimizes_ints_from_down_to_boundary(boundary):
-    def is_good(x):
-        assert x >= boundary - 10
-        return x >= boundary
-
-    assert minimal(integers(min_value=boundary - 10), is_good) == boundary
-
-    assert minimal(integers(min_value=boundary), lambda x: True) == boundary
-
-
-def test_minimizes_negative_integer_range_upwards():
-    assert minimal(integers(min_value=-10, max_value=-1)) == -1
-
-
-@boundaries
-def test_minimizes_integer_range_to_boundary(boundary):
-    assert minimal(integers(boundary, boundary + 100), lambda x: True) == boundary
-
-
-def test_single_integer_range_is_range():
-    assert minimal(integers(1, 1), lambda x: True) == 1
-
-
-def test_minimal_small_number_in_large_range():
-    assert minimal(integers((-(2**32)), 2**32), lambda x: x >= 101) == 101
-
-
-def test_minimal_small_sum_float_list():
-    xs = minimal(lists(floats(), min_size=5), lambda x: sum(x) >= 1.0)
-    assert xs == 0.0, 0.0, 0.0, 0.0, 1.0
-
-
-def test_minimals_boundary_floats():
-    def f(x):
-        print(x)
-        return True
-
-    assert minimal(floats(min_value=-1, max_value=1), f) == 0
-
-
-def test_minimal_non_boundary_float():
-    x = minimal(floats(min_value=1, max_value=9), lambda x: x > 2)
-    assert x == 3  # (the smallest integer > 2)
-
-
-def test_minimal_float_is_zero():
-    assert minimal(floats(), lambda x: True) == 0.0
-
-
-def test_minimal_asymetric_bounded_float():
-    assert minimal(floats(min_value=1.1, max_value=1.9), lambda x: True) == 1.5
-
-
-def test_negative_floats_simplify_to_zero():
-    assert minimal(floats(), lambda x: x <= -1.0) == -1.0
-
-
-def test_minimal_infinite_float_is_positive():
-    assert minimal(floats(), math.isinf) == math.inf
-
-
-def test_can_minimal_infinite_negative_float():
-    assert minimal(floats(), lambda x: x < -sys.float_info.max)
-
-
-def test_can_minimal_float_on_boundary_of_representable():
-    minimal(floats(), lambda x: x + 1 == x and not math.isinf(x))
-
-
-def test_minimize_nan():
-    assert math.isnan(minimal(floats(), math.isnan))
-
-
-def test_minimize_very_large_float():
-    t = sys.float_info.max / 2
-    assert minimal(floats(), lambda x: x >= t) == t
-
-
-def is_integral(value):
-    try:
-        return int(value) == value
-    except (OverflowError, ValueError):
-        return False
-
-
-def test_can_minimal_float_far_from_integral():
-    minimal(floats(), lambda x: math.isfinite(x) and not is_integral(x * (2**32)))
-
-
-def test_list_of_fractional_float():
-    assert set(
-        minimal(
-            lists(floats(), min_size=5),
-            lambda x: len(t for t in x if t >= 1.5) >= 5,
-            timeout_after=60,
-        )
-    ) == {2}
-
-
-def test_minimal_fractional_float():
-    assert minimal(floats(), lambda x: x >= 1.5) == 2
-
-
-def test_minimizes_lists_of_negative_ints_up_to_boundary():
-    result = minimal(
-        lists(integers(), min_size=10),
-        lambda x: len(t for t in x if t <= -1) >= 10,
-        timeout_after=60,
-    )
-    assert result == -1 * 10
-
-
-@pytest.mark.parametrize(
-    ("left", "right"),
-    (0.0, 5e-324), (-5e-324, 0.0), (-5e-324, 5e-324), (5e-324, 1e-323),
-)
-def test_floats_in_constrained_range(left, right):
-    @given(floats(left, right))
-    def test_in_range(r):
-        assert left <= r <= right
-
-    test_in_range()
-
-
-def test_bounds_are_respected():
-    assert minimal(floats(min_value=1.0), lambda x: True) == 1.0
-    assert minimal(floats(max_value=-1.0), lambda x: True) == -1.0
-
-
-@pytest.mark.parametrize("k", range(10))
-def test_floats_from_zero_have_reasonable_range(k):
-    n = 10**k
-    assert minimal(floats(min_value=0.0), lambda x: x >= n) == float(n)
-    assert minimal(floats(max_value=0.0), lambda x: x <= -n) == float(-n)
-
-
-def test_explicit_allow_nan():
-    minimal(floats(allow_nan=True), math.isnan)
-
-
-def test_one_sided_contains_infinity():
-    minimal(floats(min_value=1.0), math.isinf)
-    minimal(floats(max_value=1.0), math.isinf)
-
-
-@given(floats(min_value=0.0, allow_infinity=False))
-def test_no_allow_infinity_upper(x):
-    assert not math.isinf(x)
-
-
-@given(floats(max_value=0.0, allow_infinity=False))
-def test_no_allow_infinity_lower(x):
-    assert not math.isinf(x)
-
-
-class TestFloatsAreFloats:
-    @given(floats())
-    def test_unbounded(self, arg):
-        assert isinstance(arg, float)
-
-    @given(floats(min_value=0, max_value=float(2**64 - 1)))
-    def test_int_float(self, arg):
-        assert isinstance(arg, float)
-
-    @given(floats(min_value=float(0), max_value=float(2**64 - 1)))
-    def test_float_float(self, arg):
-        assert isinstance(arg, float)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_simple_strings.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_skipping.py Deleted

@@ -1,40 +0,0 @@
-# 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 unittest
-
-import pytest
-
-from hypothesis import given
-from hypothesis.core import skip_exceptions_to_reraise
-from hypothesis.strategies import integers
-
-from tests.common.utils import capture_out
-
-
-@pytest.mark.parametrize("skip_exception", skip_exceptions_to_reraise())
-def test_no_falsifying_example_if_unittest_skip(skip_exception):
-    """If a ``SkipTest`` exception is raised during a test, Hypothesis should
-    not continue running the test and shrink process, nor should it print
-    anything about falsifying examples."""
-
-    class DemoTest(unittest.TestCase):
-        @given(xs=integers())
-        def test_to_be_skipped(self, xs):
-            if xs == 0:
-                raise skip_exception
-            else:
-                assert xs == 0
-
-    with capture_out() as o:
-        suite = unittest.defaultTestLoader.loadTestsFromTestCase(DemoTest)
-        unittest.TextTestRunner().run(suite)
-
-    assert "Falsifying example" not in o.getvalue()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_stateful.py Deleted

@@ -1,195 +0,0 @@
-# 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/.
-
-from collections import namedtuple
-
-import pytest
-from pytest import raises
-
-from hypothesis import settings as Settings
-from hypothesis.stateful import Bundle, RuleBasedStateMachine, precondition, rule
-from hypothesis.strategies import booleans, integers, lists
-
-from tests.common.utils import capture_out
-
-Leaf = namedtuple("Leaf", ("label",))
-Split = namedtuple("Split", ("left", "right"))
-
-
-class BalancedTrees(RuleBasedStateMachine):
-    trees = Bundle("BinaryTree")
-
-    @rule(target=trees, x=booleans())
-    def leaf(self, x):
-        return Leaf(x)
-
-    @rule(target=trees, left=trees, right=trees)
-    def split(self, left, right):
-        return Split(left, right)
-
-    @rule(tree=trees)
-    def test_is_balanced(self, tree):
-        if isinstance(tree, Leaf):
-            return
-        else:
-            assert abs(self.size(tree.left) - self.size(tree.right)) <= 1
-            self.test_is_balanced(tree.left)
-            self.test_is_balanced(tree.right)
-
-    def size(self, tree):
-        if isinstance(tree, Leaf):
-            return 1
-        else:
-            return 1 + self.size(tree.left) + self.size(tree.right)
-
-
-class DepthCharge:
-    def __init__(self, value):
-        if value is None:
-            self.depth = 0
-        else:
-            self.depth = value.depth + 1
-
-
-class DepthMachine(RuleBasedStateMachine):
-    charges = Bundle("charges")
-
-    @rule(targets=(charges,), child=charges)
-    def charge(self, child):
-        return DepthCharge(child)
-
-    @rule(targets=(charges,))
-    def none_charge(self):
-        return DepthCharge(None)
-
-    @rule(check=charges)
-    def is_not_too_deep(self, check):
-        assert check.depth < 3
-
-
-class RoseTreeStateMachine(RuleBasedStateMachine):
-    nodes = Bundle("nodes")
-
-    @rule(target=nodes, source=lists(nodes))
-    def bunch(self, source):
-        return source
-
-    @rule(source=nodes)
-    def shallow(self, source):
-        def d(ls):
-            if not ls:
-                return 0
-            else:
-                return 1 + max(map(d, ls))
-
-        assert d(source) <= 5
-
-
-class NotTheLastMachine(RuleBasedStateMachine):
-    stuff = Bundle("stuff")
-
-    def __init__(self):
-        super().__init__()
-        self.last = None
-        self.bye_called = False
-
-    @rule(target=stuff)
-    def hi(self):
-        result = object()
-        self.last = result
-        return result
-
-    @precondition(lambda self: not self.bye_called)
-    @rule(v=stuff)
-    def bye(self, v):
-        assert v == self.last
-        self.bye_called = True
-
-
-class PopulateMultipleTargets(RuleBasedStateMachine):
-    b1 = Bundle("b1")
-    b2 = Bundle("b2")
-
-    @rule(targets=(b1, b2))
-    def populate(self):
-        return 1
-
-    @rule(x=b1, y=b2)
-    def fail(self, x, y):
-        raise AssertionError
-
-
-class CanSwarm(RuleBasedStateMachine):
-    """This test will essentially never pass if you choose rules uniformly at
-    random, because every time the snake rule fires we return to the beginning,
-    so we will tend to undo progress well before we make enough progress for
-    the test to fail.
-
-    This tests our swarm testing functionality in stateful testing by ensuring
-    that we can sometimes generate long runs of steps which exclude a
-    particular rule.
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.seen = set()
-
-    # The reason this rule takes a parameter is that it ensures that we do not
-    # achieve "swarming" by by just restricting the alphabet for single byte
-    # decisions, which is a thing the underlying conjecture engine  will
-    # happily do on its own without knowledge of the rule structure.
-    @rule(move=integers(0, 255))
-    def ladder(self, move):
-        self.seen.add(move)
-        assert len(self.seen) <= 15
-
-    @rule()
-    def snake(self):
-        self.seen.clear()
-
-
-bad_machines = (
-    BalancedTrees,
-    DepthMachine,
-    RoseTreeStateMachine,
-    NotTheLastMachine,
-    PopulateMultipleTargets,
-    CanSwarm,
-)
-
-for m in bad_machines:
-    m.TestCase.settings = Settings(m.TestCase.settings, max_examples=1000)
-
-
-cheap_bad_machines = list(bad_machines)
-cheap_bad_machines.remove(BalancedTrees)
-
-
-with_cheap_bad_machines = pytest.mark.parametrize(
-    "machine", cheap_bad_machines, ids=t.__name__ for t in cheap_bad_machines
-)
-
-
-@pytest.mark.parametrize(
-    "machine", bad_machines, ids=t.__name__ for t in bad_machines
-)
-def test_bad_machines_fail(machine):
-    test_class = machine.TestCase
-    try:
-        with capture_out() as o:
-            with raises(AssertionError):
-                test_class().runTest()
-    except Exception:
-        print(o.getvalue())
-        raise
-    v = o.getvalue()
-    print(v)
-    steps = l for l in v.splitlines() if "Step " in l or "state." in l
-    assert 1 <= len(steps) <= 50

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_strategy_state.py Deleted

@@ -1,196 +0,0 @@
-# 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 hashlib
-import math
-from random import Random
-
-from hypothesis import Verbosity, assume, settings
-from hypothesis.database import ExampleDatabase
-from hypothesis.internal.compat import PYPY
-from hypothesis.internal.floats import float_to_int, int_to_float, is_negative
-from hypothesis.stateful import Bundle, RuleBasedStateMachine, rule
-from hypothesis.strategies import (
-    binary,
-    booleans,
-    complex_numbers,
-    data,
-    decimals,
-    floats,
-    fractions,
-    integers,
-    just,
-    lists,
-    none,
-    sampled_from,
-    text,
-    tuples,
-)
-
-AVERAGE_LIST_LENGTH = 2
-
-
-def clamp(lower, value, upper):
-    """Given a value and optional lower/upper bounds, 'clamp' the value so that
-    it satisfies lower <= value <= upper."""
-    if (lower is not None) and (upper is not None) and (lower > upper):
-        raise ValueError(f"Cannot clamp with lower > upper: {lower!r} > {upper!r}")
-    if lower is not None:
-        value = max(lower, value)
-    if upper is not None:
-        value = min(value, upper)
-    return value
-
-
-class HypothesisSpec(RuleBasedStateMachine):
-    def __init__(self):
-        super().__init__()
-        self.database = None
-
-    strategies = Bundle("strategy")
-    strategy_tuples = Bundle("tuples")
-    objects = Bundle("objects")
-    basic_data = Bundle("basic")
-    varied_floats = Bundle("varied_floats")
-
-    def teardown(self):
-        self.clear_database()
-
-    @rule()
-    def clear_database(self):
-        if self.database is not None:
-            self.database = None
-
-    @rule()
-    def set_database(self):
-        self.teardown()
-        self.database = ExampleDatabase()
-
-    @rule(
-        target=strategies,
-        spec=sampled_from(
-            (
-                integers(),
-                booleans(),
-                floats(),
-                complex_numbers(),
-                fractions(),
-                decimals(),
-                text(),
-                binary(),
-                none(),
-                tuples(),
-            )
-        ),
-    )
-    def strategy(self, spec):
-        return spec
-
-    @rule(target=strategies, values=lists(integers() | text(), min_size=1))
-    def sampled_from_strategy(self, values):
-        return sampled_from(values)
-
-    @rule(target=strategies, spec=strategy_tuples)
-    def strategy_for_tupes(self, spec):
-        return tuples(*spec)
-
-    @rule(target=strategies, source=strategies, level=integers(1, 10), mixer=text())
-    def filtered_strategy(self, source, level, mixer):
-        def is_good(x):
-            seed = hashlib.sha384((mixer + repr(x)).encode()).digest()
-            return bool(Random(seed).randint(0, level))
-
-        return source.filter(is_good)
-
-    @rule(target=strategies, elements=strategies)
-    def list_strategy(self, elements):
-        return lists(elements)
-
-    @rule(target=strategies, left=strategies, right=strategies)
-    def or_strategy(self, left, right):
-        return left | right
-
-    @rule(target=varied_floats, source=floats())
-    def float(self, source):
-        return source
-
-    @rule(target=varied_floats, source=varied_floats, offset=integers(-100, 100))
-    def adjust_float(self, source, offset):
-        return int_to_float(clamp(0, float_to_int(source) + offset, 2**64 - 1))
-
-    @rule(target=strategies, left=varied_floats, right=varied_floats)
-    def float_range(self, left, right):
-        assume(math.isfinite(left) and math.isfinite(right))
-        left, right = sorted((left, right))
-        assert left <= right
-        # exclude deprecated case where left = 0.0 and right = -0.0
-        assume(left or right or not (is_negative(right) and not is_negative(left)))
-        return floats(left, right)
-
-    @rule(
-        target=strategies,
-        source=strategies,
-        result1=strategies,
-        result2=strategies,
-        mixer=text(),
-        p=floats(0, 1),
-    )
-    def flatmapped_strategy(self, source, result1, result2, mixer, p):
-        assume(result1 is not result2)
-
-        def do_map(value):
-            rep = repr(value)
-            random = Random(hashlib.sha384((mixer + rep).encode()).digest())
-            if random.random() <= p:
-                return result1
-            else:
-                return result2
-
-        return source.flatmap(do_map)
-
-    @rule(target=strategies, value=objects)
-    def just_strategy(self, value):
-        return just(value)
-
-    @rule(target=strategy_tuples, source=strategies)
-    def single_tuple(self, source):
-        return (source,)
-
-    @rule(target=strategy_tuples, left=strategy_tuples, right=strategy_tuples)
-    def cat_tuples(self, left, right):
-        return left + right
-
-    @rule(target=objects, strat=strategies, data=data())
-    def get_example(self, strat, data):
-        data.draw(strat)
-
-    @rule(target=strategies, left=integers(), right=integers())
-    def integer_range(self, left, right):
-        left, right = sorted((left, right))
-        return integers(left, right)
-
-    @rule(strat=strategies)
-    def repr_is_good(self, strat):
-        assert " at 0x" not in repr(strat)
-
-
-MAIN = __name__ == "__main__"
-
-TestHypothesis = HypothesisSpec.TestCase
-
-TestHypothesis.settings = settings(
-    TestHypothesis.settings,
-    stateful_step_count=10 if PYPY else 50,
-    verbosity=max(TestHypothesis.settings.verbosity, Verbosity.verbose),
-    max_examples=10000 if MAIN else 200,
-)
-
-if MAIN:
-    TestHypothesis().runTest()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_subnormal_floats.py Deleted

@@ -1,56 +0,0 @@
-# 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 math
-from sys import float_info
-
-import pytest
-
-from hypothesis.internal.floats import width_smallest_normals
-from hypothesis.strategies import floats
-
-from tests.common.debug import assert_all_examples, find_any
-from tests.common.utils import PYTHON_FTZ
-
-
-def test_python_compiled_with_sane_math_options():
-    """Python does not flush-to-zero, which violates IEEE-754
-
-    The other tests that rely on subnormals are skipped when Python is FTZ
-    (otherwise pytest will be very noisy), so this meta test ensures CI jobs
-    still fail as we currently don't care to support such builds of Python.
-    """
-    assert not PYTHON_FTZ
-
-
-skipif_ftz = pytest.mark.skipif(PYTHON_FTZ, reason="broken by unsafe compiler flags")
-
-
-@skipif_ftz
-def test_can_generate_subnormals():
-    find_any(floats().filter(lambda x: x > 0), lambda x: x < float_info.min)
-    find_any(floats().filter(lambda x: x < 0), lambda x: x > -float_info.min)
-
-
-@skipif_ftz
-@pytest.mark.parametrize(
-    "min_value, max_value", (None, None), (-1, 0), (0, 1), (-1, 1)
-)
-@pytest.mark.parametrize("width", 16, 32, 64)
-def test_does_not_generate_subnormals_when_disallowed(width, min_value, max_value):
-    strat = floats(
-        min_value=min_value,
-        max_value=max_value,
-        allow_subnormal=False,
-        width=width,
-    )
-    strat = strat.filter(lambda x: x != 0.0 and math.isfinite(x))
-    smallest_normal = width_smallest_normalswidth
-    assert_all_examples(strat, lambda x: x <= -smallest_normal or x >= smallest_normal)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_targeting.py Deleted

@@ -1,91 +0,0 @@
-# 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 pytest
-
-from hypothesis import Phase, given, seed, settings, strategies as st, target
-
-pytest_plugins = "pytester"
-
-TESTSUITE = """
-from hypothesis import given, strategies as st, target
-
-@given(st.integers(min_value=0))
-def test_threshold_problem(x):
-    target(float(x))
-    {0}target(float(x * 2), label="double")
-    {0}assert x <= 100000
-    assert x <= 100
-"""
-
-
-@pytest.mark.parametrize("multiple", False, True)
-def test_reports_target_results(testdir, multiple):
-    script = testdir.makepyfile(TESTSUITE.format("" if multiple else "# "))
-    result = testdir.runpytest(script)
-    out = "\n".join(result.stdout.lines)
-    assert "Falsifying example" in out
-    assert "x=101" in out
-    assert out.count("Highest target score") == 1
-    assert out.index("Highest target score") < out.index("Falsifying example")
-    assert result.ret != 0
-
-
-def test_targeting_increases_max_length():
-    strat = st.lists(st.booleans())
-
-    @settings(database=None, max_examples=200, phases=Phase.generate, Phase.target)
-    @given(strat)
-    def test_with_targeting(ls):
-        target(float(len(ls)))
-        assert len(ls) <= 80
-
-    with pytest.raises(AssertionError):
-        test_with_targeting()
-
-
-@given(st.integers(), st.integers())
-def test_target_returns_value(a, b):
-    difference = target(abs(a - b))
-    assert difference == abs(a - b)
-    assert isinstance(difference, int)
-
-
-def test_targeting_can_be_disabled():
-    strat = st.lists(st.integers(0, 255))
-
-    def score(enabled):
-        result = 0
-        phases = Phase.generate
-        if enabled:
-            phases.append(Phase.target)
-
-        @seed(0)
-        @settings(database=None, max_examples=200, phases=phases)
-        @given(strat)
-        def test(ls):
-            score = float(sum(ls))
-            result0 = max(result0, score)
-            target(score)
-
-        test()
-        return result0
-
-    assert score(enabled=True) > score(enabled=False)
-
-
-def test_issue_2395_regression():
-    @given(d=st.floats().filter(lambda x: abs(x) < 1000))
-    @settings(max_examples=1000, database=None)
-    @seed(93962505385993024185959759429298090872)
-    def test_targeting_square_loss(d):
-        target(-((d - 42.5) ** 2.0))
-
-    test_targeting_square_loss()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_testdecorators.py Deleted

@@ -1,65 +0,0 @@
-# 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 re
-
-import pytest
-
-from hypothesis import HealthCheck, given, reject, settings, strategies as st
-from hypothesis.errors import InvalidArgument, Unsatisfiable
-
-
-def test_contains_the_test_function_name_in_the_exception_string():
-    look_for_one = settings(max_examples=1, suppress_health_check=HealthCheck.all())
-
-    @given(st.integers())
-    @look_for_one
-    def this_has_a_totally_unique_name(x):
-        reject()
-
-    with pytest.raises(
-        Unsatisfiable, match=re.escape(this_has_a_totally_unique_name.__name__)
-    ):
-        this_has_a_totally_unique_name()
-
-    class Foo:
-        @given(st.integers())
-        @look_for_one
-        def this_has_a_unique_name_and_lives_on_a_class(self, x):
-            reject()
-
-    with pytest.raises(
-        Unsatisfiable,
-        match=re.escape(Foo.this_has_a_unique_name_and_lives_on_a_class.__name__),
-    ):
-        Foo().this_has_a_unique_name_and_lives_on_a_class()
-
-
-def test_signature_mismatch_error_message():
-    # Regression test for issue #1978
-
-    @settings(max_examples=2)
-    @given(x=st.integers())
-    def bad_test():
-        pass
-
-    try:
-        bad_test()
-    except InvalidArgument as e:
-        assert (
-            str(e) == "bad_test() got an unexpected keyword argument 'x', "
-            "from `x=integers()` in @given"
-        )
-
-
-@given(data=st.data(), keys=st.lists(st.integers(), unique=True))
-def test_fixed_dict_preserves_iteration_order(data, keys):
-    d = data.draw(st.fixed_dictionaries({k: st.none() for k in keys}))
-    assert all(a == b for a, b in zip(keys, d)), f"keys={keys}, d.keys()={d.keys()}"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_threading.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_type_lookup.py Deleted

@@ -1,85 +0,0 @@
-# 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/.
-
-from typing import Callable
-
-import pytest
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.strategies._internal.types import NON_RUNTIME_TYPES
-
-try:
-    from typing import Concatenate, ParamSpec, TypeGuard  # new in 3.10
-except ImportError:
-    Concatenate = ParamSpec = TypeGuard = None
-
-# See also typing_extensions/test_backported_types.py
-
-
-@pytest.mark.parametrize("non_runtime_type", NON_RUNTIME_TYPES)
-def test_non_runtime_type_cannot_be_resolved(non_runtime_type):
-    strategy = st.from_type(non_runtime_type)
-    with pytest.raises(
-        InvalidArgument, match="there is no such thing as a runtime instance"
-    ):
-        strategy.example()
-
-
-@pytest.mark.parametrize("non_runtime_type", NON_RUNTIME_TYPES)
-def test_non_runtime_type_cannot_be_registered(non_runtime_type):
-    with pytest.raises(
-        InvalidArgument, match="there is no such thing as a runtime instance"
-    ):
-        st.register_type_strategy(non_runtime_type, st.none())
-
-
-@pytest.mark.skipif(Concatenate is None, reason="requires python3.10 or higher")
-def test_callable_with_concatenate():
-    P = ParamSpec("P")
-    func_type = CallableConcatenateint, P, None
-    strategy = st.from_type(func_type)
-    with pytest.raises(
-        InvalidArgument,
-        match="Hypothesis can't yet construct a strategy for instances of a Callable type",
-    ):
-        strategy.example()
-
-    with pytest.raises(InvalidArgument, match="Cannot register generic type"):
-        st.register_type_strategy(func_type, st.none())
-
-
-@pytest.mark.skipif(ParamSpec is None, reason="requires python3.10 or higher")
-def test_callable_with_paramspec():
-    P = ParamSpec("P")
-    func_type = CallableP, None
-    strategy = st.from_type(func_type)
-    with pytest.raises(
-        InvalidArgument,
-        match="Hypothesis can't yet construct a strategy for instances of a Callable type",
-    ):
-        strategy.example()
-
-    with pytest.raises(InvalidArgument, match="Cannot register generic type"):
-        st.register_type_strategy(func_type, st.none())
-
-
-@pytest.mark.skipif(TypeGuard is None, reason="requires python3.10 or higher")
-def test_callable_return_typegard_type():
-    strategy = st.from_type(Callable, TypeGuardint)
-    with pytest.raises(
-        InvalidArgument,
-        match="Hypothesis cannot yet construct a strategy for callables "
-        "which are PEP-647 TypeGuards",
-    ):
-        strategy.example()
-
-    with pytest.raises(InvalidArgument, match="Cannot register generic type"):
-        st.register_type_strategy(Callable, TypeGuardint, st.none())

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_type_lookup_forward_ref.py Deleted

@@ -1,60 +0,0 @@
-# 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/.
-
-from typing import Dict, ForwardRef, List, Union
-
-import pytest
-
-from hypothesis import given, strategies as st
-from hypothesis.errors import ResolutionFailed
-
-from tests.common import utils
-
-# Mutually-recursive types
-# See https://github.com/HypothesisWorks/hypothesis/issues/2722
-
-
-@given(st.data())
-def test_mutually_recursive_types_with_typevar(data):
-    # The previously-failing example from the issue
-    A = Dictbool, "B"  # noqa: F821 - an undefined name is the whole point!
-    B = UnionListbool, A
-
-    with pytest.raises(ResolutionFailed, match=r"Could not resolve ForwardRef$'B'$"):
-        data.draw(st.from_type(A))
-
-    with utils.temp_registered(
-        ForwardRef("B"),
-        lambda _: st.deferred(lambda: b_strategy),
-    ):
-        b_strategy = st.from_type(B)
-        data.draw(b_strategy)
-        data.draw(st.from_type(A))
-        data.draw(st.from_type(B))
-
-
-@given(st.data())
-def test_mutually_recursive_types_with_typevar_alternate(data):
-    # It's not particularly clear why this version passed when the previous
-    # test failed, but different behaviour means we add both to the suite.
-    C = UnionListbool, "D"  # noqa: F821 - an undefined name is the whole point!
-    D = Dictbool, C
-
-    with pytest.raises(ResolutionFailed, match=r"Could not resolve ForwardRef$'D'$"):
-        data.draw(st.from_type(C))
-
-    with utils.temp_registered(
-        ForwardRef("D"),
-        lambda _: st.deferred(lambda: d_strategy),
-    ):
-        d_strategy = st.from_type(D)
-        data.draw(d_strategy)
-        data.draw(st.from_type(C))
-        data.draw(st.from_type(D))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_type_lookup_future_annotations.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_unusual_settings_configs.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/nocover/test_uuids.py Deleted

@@ -1,34 +0,0 @@
-# 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 pytest
-
-from hypothesis import given, strategies as st
-
-from tests.common.debug import minimal
-
-
-@given(st.lists(st.uuids()))
-def test_are_unique(ls):
-    assert len(set(ls)) == len(ls)
-
-
-def test_retains_uniqueness_in_simplify():
-    ts = minimal(st.lists(st.uuids()), lambda x: len(x) >= 5)
-    assert len(ts) == len(set(ts)) == 5
-
-
-@pytest.mark.parametrize("version", (1, 2, 3, 4, 5))
-def test_can_generate_specified_version(version):
-    @given(st.uuids(version=version))
-    def inner(uuid):
-        assert version == uuid.version
-
-    inner()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_argument_validation.py Deleted

@@ -1,290 +0,0 @@
-# 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 numpy
-import pytest
-
-from hypothesis import strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra import numpy as nps
-
-from tests.common.utils import checks_deprecated_behaviour
-
-
-def e(a, **kwargs):
-    kw = ", ".join(f"{k}={v!r}" for k, v in kwargs.items())
-    return pytest.param(a, kwargs, id=f"{a.__name__}({kw})")
-
-
-@pytest.mark.parametrize(
-    ("function", "kwargs"),
-    
-        e(nps.array_dtypes, min_size=2, max_size=1),
-        e(nps.array_dtypes, min_size=-1),
-        e(nps.array_shapes, min_side=2, max_side=1),
-        e(nps.array_shapes, min_dims=3, max_dims=2),
-        e(nps.array_shapes, min_dims=-1),
-        e(nps.array_shapes, min_side=-1),
-        e(nps.array_shapes, min_side="not an int"),
-        e(nps.array_shapes, max_side="not an int"),
-        e(nps.array_shapes, min_dims="not an int"),
-        e(nps.array_shapes, max_dims="not an int"),
-        e(nps.array_shapes, min_dims=33),
-        e(nps.array_shapes, max_dims=33),
-        e(nps.arrays, dtype=float, shape=(0.5,)),
-        e(nps.arrays, dtype=object, shape=1),
-        e(nps.arrays, dtype=float, shape=1, fill=3),
-        e(nps.arrays, dtype="U", shape=1, elements=st.just("abc\0\0")),
-        e(nps.arrays, dtype=int, shape=1, elements="not a strategy"),
-        e(nps.byte_string_dtypes, min_len=-1),
-        e(nps.byte_string_dtypes, min_len=2, max_len=1),
-        e(nps.byte_string_dtypes, min_len=0, max_len=0),
-        e(nps.datetime64_dtypes, max_period=11),
-        e(nps.datetime64_dtypes, min_period=11),
-        e(nps.datetime64_dtypes, min_period="Y", max_period="M"),
-        e(nps.timedelta64_dtypes, max_period=11),
-        e(nps.timedelta64_dtypes, min_period=11),
-        e(nps.timedelta64_dtypes, min_period="Y", max_period="M"),
-        e(nps.unicode_string_dtypes, min_len=-1),
-        e(nps.unicode_string_dtypes, min_len=2, max_len=1),
-        e(nps.unicode_string_dtypes, min_len=0, max_len=0),
-        e(nps.unsigned_integer_dtypes, endianness=3),
-        e(nps.unsigned_integer_dtypes, sizes=()),
-        e(nps.unsigned_integer_dtypes, sizes=(3,)),
-        e(nps.from_dtype, dtype="float64"),
-        e(nps.from_dtype, dtype=float),
-        e(nps.from_dtype, dtype=numpy.int8),
-        e(nps.from_dtype, dtype=1),
-        e(nps.from_dtype, dtype=numpy.dtype("uint8"), min_value=-999),
-        e(nps.from_dtype, dtype=numpy.dtype("uint8"), max_value=999),
-        e(nps.from_dtype, dtype=numpy.dtype("int8"), min_value=-999),
-        e(nps.from_dtype, dtype=numpy.dtype("int8"), max_value=999),
-        e(nps.from_dtype, dtype=numpy.dtype("S4"), max_size=5),
-        e(nps.from_dtype, dtype=numpy.dtype("U4"), max_size=5),
-        e(nps.valid_tuple_axes, ndim=-1),
-        e(nps.valid_tuple_axes, ndim=2, min_size=-1),
-        e(nps.valid_tuple_axes, ndim=2, min_size=3, max_size=10),
-        e(nps.valid_tuple_axes, ndim=2, min_size=2, max_size=1),
-        e(nps.valid_tuple_axes, ndim=2.0, min_size=2, max_size=1),
-        e(nps.valid_tuple_axes, ndim=2, min_size=1.0, max_size=2),
-        e(nps.valid_tuple_axes, ndim=2, min_size=1, max_size=2.0),
-        e(nps.valid_tuple_axes, ndim=2, min_size=1, max_size=3),
-        e(nps.broadcastable_shapes, shape="a"),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_side="a"),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_dims="a"),
-        e(nps.broadcastable_shapes, shape=(2, 2), max_side="a"),
-        e(nps.broadcastable_shapes, shape=(2, 2), max_dims="a"),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_side=-1),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_dims=-1),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_dims=33, max_dims=None),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_dims=1, max_dims=33),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_side=1, max_side=0),
-        e(nps.broadcastable_shapes, shape=(2, 2), min_dims=1, max_dims=0),
-        e(
-            nps.broadcastable_shapes,  # max_side too small
-            shape=(5, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.broadcastable_shapes,  # min_side too large
-            shape=(0, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.broadcastable_shapes,  # default max_dims unsatisfiable
-            shape=(5, 3, 2, 1),
-            min_dims=3,
-            max_dims=None,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.broadcastable_shapes,  # default max_dims unsatisfiable
-            shape=(0, 3, 2, 1),
-            min_dims=3,
-            max_dims=None,
-            min_side=2,
-            max_side=3,
-        ),
-        e(nps.mutually_broadcastable_shapes),
-        e(nps.mutually_broadcastable_shapes, num_shapes=0),
-        e(nps.mutually_broadcastable_shapes, num_shapes="a"),
-        e(nps.mutually_broadcastable_shapes, num_shapes=2, base_shape="a"),
-        e(
-            nps.mutually_broadcastable_shapes,  # min_side is invalid type
-            num_shapes=2,
-            min_side="a",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # min_dims is invalid type
-            num_shapes=2,
-            min_dims="a",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_side is invalid type
-            num_shapes=2,
-            max_side="a",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_side is invalid type
-            num_shapes=2,
-            max_dims="a",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # min_side is out of domain
-            num_shapes=2,
-            min_side=-1,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # min_dims is out of domain
-            num_shapes=2,
-            min_dims=-1,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # min_dims is out of domain
-            num_shapes=2,
-            min_dims=33,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_dims is out of domain
-            num_shapes=2,
-            max_dims=33,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_side < min_side
-            num_shapes=2,
-            min_side=1,
-            max_side=0,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_dims < min_dims
-            num_shapes=2,
-            min_dims=1,
-            max_dims=0,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_side too small
-            num_shapes=2,
-            base_shape=(5, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # min_side too large
-            num_shapes=2,
-            base_shape=(0, 1),
-            min_dims=2,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # user-specified max_dims unsatisfiable
-            num_shapes=1,
-            base_shape=(5, 3, 2, 1),
-            min_dims=3,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # user-specified max_dims unsatisfiable
-            num_shapes=2,
-            base_shape=(0, 3, 2, 1),
-            min_dims=3,
-            max_dims=4,
-            min_side=2,
-            max_side=3,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # valid to pass num_shapes xor gufunc
-            num_shapes=2,
-            signature="()->()",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # element-wise ufunc has signature=None
-            signature=numpy.add.signature,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # multiple outputs not yet supported
-            signature="()->(),()",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # output has dimension not in inputs
-            signature="()->(i)",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # frozen-optional is ambiguous & banned
-            signature="(2?)->()",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # signature must be in string format
-            signature=((), (), ()),
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # string must match signature regex
-            signature="this string isn't a valid signature",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # shape with too many dimensions
-            signature="(" + ",".join(f"d{n}" for n in range(33)) + ")->()",
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # max_dims too large given ufunc
-            signature=numpy.matmul.signature,
-            max_dims=32,
-        ),
-        e(
-            nps.mutually_broadcastable_shapes,  # least valid max_dims is < min_dims
-            signature=numpy.matmul.signature,
-            min_dims=32,
-        ),
-        e(nps.basic_indices, shape=0),
-        e(nps.basic_indices, shape=("1", "2")),
-        e(nps.basic_indices, shape=(0, -1)),
-        e(nps.basic_indices, shape=(0, 0), allow_newaxis=None),
-        e(nps.basic_indices, shape=(0, 0), allow_ellipsis=None),
-        e(nps.basic_indices, shape=(0, 0), min_dims=-1),
-        e(nps.basic_indices, shape=(0, 0), min_dims=1.0),
-        e(nps.basic_indices, shape=(0, 0), max_dims=-1),
-        e(nps.basic_indices, shape=(0, 0), max_dims=1.0),
-        e(nps.basic_indices, shape=(0, 0), min_dims=2, max_dims=1),
-        e(nps.basic_indices, shape=(3, 3, 3), max_dims="not an int"),
-        e(nps.integer_array_indices, shape=()),
-        e(nps.integer_array_indices, shape=(2, 0)),
-        e(nps.integer_array_indices, shape="a"),
-        e(nps.integer_array_indices, shape=(2,), result_shape=(2, 2)),
-        e(nps.integer_array_indices, shape=(2,), dtype=float),
-    ,
-)
-def test_raise_invalid_argument(function, kwargs):
-    with pytest.raises(InvalidArgument):
-        function(**kwargs).example()
-
-
-@pytest.mark.parametrize(
-    ("function", "kwargs"),
-    
-        e(nps.basic_indices, shape=(0, 0), min_dims=50),
-        e(nps.basic_indices, shape=(0, 0), max_dims=50),
-    ,
-)
-@checks_deprecated_behaviour
-def test_raise_invalid_argument_deprecated(function, kwargs):
-    with pytest.raises(InvalidArgument):
-        function(**kwargs).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_deprecation.py Deleted

@@ -1,34 +0,0 @@
-# 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/.
-
-from warnings import catch_warnings
-
-import pytest
-
-from hypothesis.errors import HypothesisDeprecationWarning, InvalidArgument
-from hypothesis.extra import numpy as nps
-
-
-def test_basic_indices_bad_min_dims_warns():
-    with pytest.warns(HypothesisDeprecationWarning):
-        with pytest.raises(InvalidArgument):
-            nps.basic_indices((3, 3, 3), min_dims=4).example()
-
-
-def test_basic_indices_bad_max_dims_warns():
-    with pytest.warns(HypothesisDeprecationWarning):
-        nps.basic_indices((3, 3, 3), max_dims=4).example()
-
-
-def test_basic_indices_default_max_dims_does_not_warn():
-    with catch_warnings(record=True) as record:
-        nps.basic_indices((3, 3, 3)).example()
-        nps.basic_indices((3, 3, 3), allow_newaxis=True).example()
-        assert len(record) == 0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_fill_values.py Deleted

@@ -1,56 +0,0 @@
-# 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/.
-
-from hypothesis import given, strategies as st
-from hypothesis.extra.numpy import arrays
-
-from tests.common.debug import find_any, minimal
-
-
-@given(arrays(object, 100, elements=st.builds(list)))
-def test_generated_lists_are_distinct(ls):
-    assert len(set(map(id, ls))) == len(ls)
-
-
-@st.composite
-def distinct_integers(draw):
-    used = draw(st.shared(st.builds(set), key="distinct_integers.used"))
-    i = draw(st.integers(0, 2**64 - 1).filter(lambda x: x not in used))
-    used.add(i)
-    return i
-
-
-@given(arrays("uint64", 10, elements=distinct_integers()))
-def test_does_not_reuse_distinct_integers(arr):
-    assert len(set(arr)) == len(arr)
-
-
-def test_may_reuse_distinct_integers_if_asked():
-    find_any(
-        arrays("uint64", 10, elements=distinct_integers(), fill=distinct_integers()),
-        lambda x: len(set(x)) < len(x),
-    )
-
-
-def test_minimizes_to_fill():
-    result = minimal(arrays(float, 10, fill=st.just(3.0)))
-    assert (result == 3.0).all()
-
-
-@given(
-    arrays(
-        dtype=float,
-        elements=st.floats(allow_nan=False).filter(bool),
-        shape=(3, 3, 3),
-        fill=st.just(1.0),
-    )
-)
-def test_fills_everything(x):
-    assert x.all()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_floor_ceil.py Deleted

@@ -1,48 +0,0 @@
-# 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 math
-
-import numpy as np
-import pytest
-
-from hypothesis.internal.compat import ceil, floor
-
-
-@pytest.mark.parametrize(
-    "value",
-    
-        # These are strings so that the test names are easier to read.
-        "2**64+1",
-        "2**64-1",
-        "2**63+1",
-        "2**53+1",
-        "-2**53-1",
-        "-2**63+1",
-        "-2**63-1",
-        "-2**64+1",
-        "-2**64-1",
-    ,
-)
-def test_our_floor_and_ceil_avoid_numpy_rounding(value):
-    a = np.array(eval(value))
-
-    f = floor(a)
-    c = ceil(a)
-
-    assert type(f) == int
-    assert type(c) == int
-
-    # Using math.floor or math.ceil for these values would give an incorrect
-    # result.
-    assert (math.floor(a) > a) or (math.ceil(a) < a)
-
-    assert f <= a <= c
-    assert f + 1 > a > c - 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_from_dtype.py Deleted

@@ -1,224 +0,0 @@
-# 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 numpy as np
-import pytest
-
-from hypothesis import assume, given, settings, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra import numpy as nps
-from hypothesis.strategies._internal import SearchStrategy
-
-from tests.common.debug import find_any
-
-STANDARD_TYPES = 
-    np.dtype(t)
-    for t in (
-        "int8",
-        "int16",
-        "int32",
-        "int64",
-        "uint8",
-        "uint16",
-        "uint32",
-        "uint64",
-        "float",
-        "float16",
-        "float32",
-        "float64",
-        "complex64",
-        "complex128",
-        "datetime64",
-        "timedelta64",
-        bool,
-        str,
-        bytes,
-    )
-
-for nonstandard_typecode in "g", "G", "S1", "q", "Q":
-    try:
-        STANDARD_TYPES.append(np.dtype(nonstandard_typecode))
-    except Exception:
-        pass
-
-
-@given(nps.nested_dtypes())
-def test_strategies_for_standard_dtypes_have_reusable_values(dtype):
-    assert nps.from_dtype(dtype).has_reusable_values
-
-
-@pytest.mark.parametrize("t", STANDARD_TYPES)
-def test_produces_instances(t):
-    @given(nps.from_dtype(t))
-    def test_is_t(x):
-        assert isinstance(x, t.type)
-        assert x.dtype.kind == t.kind
-
-    test_is_t()
-
-
-@settings(max_examples=100)
-@given(nps.nested_dtypes(max_itemsize=400), st.data())
-def test_infer_strategy_from_dtype(dtype, data):
-    # Given a dtype
-    assert isinstance(dtype, np.dtype)
-    # We can infer a strategy
-    strat = nps.from_dtype(dtype)
-    assert isinstance(strat, SearchStrategy)
-    # And use it to fill an array of that dtype
-    data.draw(nps.arrays(dtype, 10, elements=strat))
-
-
-@given(st.data())
-def test_can_cast_for_scalars(data):
-    # Note: this only passes with castable datatypes, certain dtype
-    # combinations will result in an error if numpy is not able to cast them.
-    dt_elements = np.dtype(data.draw(st.sampled_from("bool", "<i2", ">i2")))
-    dt_desired = np.dtype(
-        data.draw(st.sampled_from("<i2", ">i2", "float32", "float64"))
-    )
-    result = data.draw(
-        nps.arrays(dtype=dt_desired, elements=nps.from_dtype(dt_elements), shape=())
-    )
-    assert isinstance(result, np.ndarray)
-    assert result.dtype == dt_desired
-
-
-@given(st.data())
-def test_unicode_string_dtypes_generate_unicode_strings(data):
-    dt = data.draw(nps.unicode_string_dtypes())
-    result = data.draw(nps.from_dtype(dt))
-    assert isinstance(result, str)
-
-
-@given(nps.arrays(dtype="U99", shape=(10,)))
-def test_can_unicode_strings_without_decode_error(arr):
-    # See https://github.com/numpy/numpy/issues/15363
-    pass
-
-
-@pytest.mark.xfail(strict=False, reason="mitigation for issue above")
-def test_unicode_string_dtypes_need_not_be_utf8():
-    def cannot_encode(string):
-        try:
-            string.encode()
-            return False
-        except UnicodeEncodeError:
-            return True
-
-    find_any(nps.from_dtype(np.dtype("U")), cannot_encode)
-
-
-@given(st.data())
-def test_byte_string_dtypes_generate_unicode_strings(data):
-    dt = data.draw(nps.byte_string_dtypes())
-    result = data.draw(nps.from_dtype(dt))
-    assert isinstance(result, bytes)
-
-
-@pytest.mark.parametrize("dtype", "U", "S", "a")
-def test_unsized_strings_length_gt_one(dtype):
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2229
-    find_any(nps.arrays(dtype=dtype, shape=1), lambda arr: len(arr0) >= 2)
-
-
-@given(
-    st.data(),
-    st.builds(
-        "{}{}".format,
-        st.sampled_from(("datetime64", "timedelta64")),
-        st.sampled_from(nps.TIME_RESOLUTIONS),
-    ).map(np.dtype),
-)
-def test_inferring_from_time_dtypes_gives_same_dtype(data, dtype):
-    ex = data.draw(nps.from_dtype(dtype))
-    assert dtype == ex.dtype
-
-
-@given(st.data(), nps.byte_string_dtypes() | nps.unicode_string_dtypes())
-def test_inferred_string_strategies_roundtrip(data, dtype):
-    # Check that we never generate too-long or nul-terminated strings, which
-    # cannot be read back out of an array.
-    arr = np.zeros(shape=1, dtype=dtype)
-    ex = data.draw(nps.from_dtype(arr.dtype))
-    arr0 = ex
-    assert arr0 == ex
-
-
-@given(st.data(), nps.scalar_dtypes())
-def test_all_inferred_scalar_strategies_roundtrip(data, dtype):
-    # We only check scalars here, because record/compound/nested dtypes always
-    # give an array of np.void objects.  We're interested in whether scalar
-    # values are safe, not known type coercion.
-    arr = np.zeros(shape=1, dtype=dtype)
-    ex = data.draw(nps.from_dtype(arr.dtype))
-    assume(ex == ex)  # If not, the roundtrip test *should* fail!  (eg NaN)
-    arr0 = ex
-    assert arr0 == ex
-
-
-@pytest.mark.parametrize("dtype_str", "m8", "M8")
-@given(data=st.data())
-def test_from_dtype_works_without_time_unit(data, dtype_str):
-    arr = data.draw(nps.from_dtype(np.dtype(dtype_str)))
-    assert (dtype_str + "") in arr.dtype.str
-
-
-@pytest.mark.parametrize("dtype_str", "m8", "M8")
-@given(data=st.data())
-def test_arrays_selects_consistent_time_unit(data, dtype_str):
-    arr = data.draw(nps.arrays(dtype_str, 10))
-    assert (dtype_str + "") in arr.dtype.str
-
-
-def test_arrays_gives_useful_error_on_inconsistent_time_unit():
-    with pytest.raises(InvalidArgument, match="mismatch of time units in dtypes"):
-        nps.arrays("m8Y", 10, elements=nps.from_dtype(np.dtype("m8D"))).example()
-
-
-@pytest.mark.parametrize(
-    "dtype, kwargs, pred",
-    
-        # Floating point: bounds, exclusive bounds, and excluding nonfinites
-        (float, {"min_value": 1, "max_value": 2}, lambda x: 1 <= x <= 2),
-        (
-            float,
-            {"min_value": 1, "max_value": 2, "exclude_min": True, "exclude_max": True},
-            lambda x: 1 < x < 2,
-        ),
-        (float, {"allow_nan": False}, lambda x: not np.isnan(x)),
-        (float, {"allow_infinity": False}, lambda x: not np.isinf(x)),
-        (float, {"allow_nan": False, "allow_infinity": False}, np.isfinite),
-        (complex, {"allow_nan": False}, lambda x: not np.isnan(x)),
-        (complex, {"allow_infinity": False}, lambda x: not np.isinf(x)),
-        (complex, {"allow_nan": False, "allow_infinity": False}, np.isfinite),
-        # Integer bounds, limited to the representable range
-        ("int8", {"min_value": -1, "max_value": 1}, lambda x: -1 <= x <= 1),
-        ("uint8", {"min_value": 1, "max_value": 2}, lambda x: 1 <= x <= 2),
-        # String arguments, bounding size and unicode alphabet
-        ("S", {"min_size": 1, "max_size": 2}, lambda x: 1 <= len(x) <= 2),
-        ("S4", {"min_size": 1, "max_size": 2}, lambda x: 1 <= len(x) <= 2),
-        ("U", {"min_size": 1, "max_size": 2}, lambda x: 1 <= len(x) <= 2),
-        ("U4", {"min_size": 1, "max_size": 2}, lambda x: 1 <= len(x) <= 2),
-        ("U", {"alphabet": "abc"}, lambda x: set(x).issubset("abc")),
-    ,
-)
-@given(data=st.data())
-def test_from_dtype_with_kwargs(data, dtype, kwargs, pred):
-    value = data.draw(nps.from_dtype(np.dtype(dtype), **kwargs))
-    assert pred(value)
-
-
-@given(nps.from_dtype(np.dtype("U20,uint8,float32"), min_size=1, allow_nan=False))
-def test_customize_structured_dtypes(x):
-    name, age, score = x
-    assert len(name) >= 1
-    assert 0 <= age <= 255
-    assert not np.isnan(score)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_gen_data.py Deleted

@@ -1,1201 +0,0 @@
-# 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 sys
-from functools import reduce
-from itertools import zip_longest
-
-import numpy as np
-import pytest
-
-from hypothesis import HealthCheck, assume, given, note, settings, strategies as st
-from hypothesis.errors import InvalidArgument, UnsatisfiedAssumption
-from hypothesis.extra import numpy as nps
-
-from tests.common.debug import find_any, minimal
-from tests.common.utils import fails_with, flaky
-
-ANY_SHAPE = nps.array_shapes(min_dims=0, max_dims=32, min_side=0, max_side=32)
-ANY_NONZERO_SHAPE = nps.array_shapes(min_dims=0, max_dims=32, min_side=1, max_side=32)
-
-
-@given(nps.arrays(float, ()))
-def test_empty_dimensions_are_arrays(x):
-    assert isinstance(x, np.ndarray)
-    assert x.dtype.kind == "f"
-
-
-@given(nps.arrays(float, (1, 0, 1)))
-def test_can_handle_zero_dimensions(x):
-    assert x.shape == (1, 0, 1)
-
-
-@given(nps.arrays("uint32", (5, 5)))
-def test_generates_unsigned_ints(x):
-    assert (x >= 0).all()
-
-
-@given(nps.arrays(int, (1,)))
-def test_assert_fits_in_machine_size(x):
-    pass
-
-
-def test_generates_and_minimizes():
-    assert (minimal(nps.arrays(float, (2, 2))) == np.zeros(shape=(2, 2))).all()
-
-
-def test_can_minimize_large_arrays():
-    x = minimal(
-        nps.arrays("uint32", 100),
-        lambda x: np.any(x) and not np.all(x),
-        timeout_after=60,
-    )
-    assert np.logical_or(x == 0, x == 1).all()
-    assert np.count_nonzero(x) in (1, len(x) - 1)
-
-
-@flaky(max_runs=50, min_passes=1)
-@np.errstate(over="ignore", invalid="ignore")
-def test_can_minimize_float_arrays():
-    x = minimal(nps.arrays(float, 50), lambda t: np.nansum(t) >= 1.0)
-    assert x.sum() in (1, 50)
-
-
-class Foo:
-    pass
-
-
-foos = st.tuples().map(lambda _: Foo())
-
-
-def test_can_create_arrays_of_composite_types():
-    arr = minimal(nps.arrays(object, 100, elements=foos))
-    for x in arr:
-        assert isinstance(x, Foo)
-
-
-@given(st.lists(st.integers()), st.data())
-def test_can_create_zero_dim_arrays_of_lists(x, data):
-    arr = data.draw(nps.arrays(object, (), elements=st.just(x)))
-    assert arr.shape == ()
-    assert arr.dtype == np.dtype(object)
-    assert arr.item() == x
-
-
-def test_can_create_arrays_of_tuples():
-    arr = minimal(
-        nps.arrays(object, 10, elements=st.tuples(st.integers(), st.integers())),
-        lambda x: all(t0 != t1 for t0, t1 in x),
-    )
-    assert all(a in ((1, 0), (0, 1)) for a in arr)
-
-
-@given(nps.arrays(object, (2, 2), elements=st.tuples(st.integers())))
-def test_does_not_flatten_arrays_of_tuples(arr):
-    assert isinstance(arr00, tuple)
-
-
-@given(
-    nps.arrays(object, (2, 2), elements=st.lists(st.integers(), min_size=1, max_size=1))
-)
-def test_does_not_flatten_arrays_of_lists(arr):
-    assert isinstance(arr00, list)
-
-
-@given(nps.array_shapes())
-def test_can_generate_array_shapes(shape):
-    assert isinstance(shape, tuple)
-    assert all(isinstance(i, int) for i in shape)
-
-
-@settings(deadline=None, max_examples=10)
-@given(st.integers(0, 10), st.integers(0, 9), st.integers(0), st.integers(0))
-def test_minimise_array_shapes(min_dims, dim_range, min_side, side_range):
-    smallest = minimal(
-        nps.array_shapes(
-            min_dims=min_dims,
-            max_dims=min_dims + dim_range,
-            min_side=min_side,
-            max_side=min_side + side_range,
-        )
-    )
-    assert len(smallest) == min_dims and all(k == min_side for k in smallest)
-
-
-@pytest.mark.parametrize(
-    "kwargs", {"min_side": 100}, {"min_dims": 15}, {"min_dims": 32}
-)
-def test_interesting_array_shapes_argument(kwargs):
-    nps.array_shapes(**kwargs).example()
-
-
-@given(nps.scalar_dtypes())
-def test_can_generate_scalar_dtypes(dtype):
-    assert isinstance(dtype, np.dtype)
-
-
-@settings(max_examples=100)
-@given(
-    nps.nested_dtypes(
-        subtype_strategy=st.one_of(
-            nps.scalar_dtypes(), nps.byte_string_dtypes(), nps.unicode_string_dtypes()
-        )
-    )
-)
-def test_can_generate_compound_dtypes(dtype):
-    assert isinstance(dtype, np.dtype)
-
-
-@settings(max_examples=100)
-@given(
-    nps.nested_dtypes(
-        subtype_strategy=st.one_of(
-            nps.scalar_dtypes(), nps.byte_string_dtypes(), nps.unicode_string_dtypes()
-        )
-    ).flatmap(lambda dt: nps.arrays(dtype=dt, shape=1))
-)
-def test_can_generate_data_compound_dtypes(arr):
-    # This is meant to catch the class of errors which prompted PR #2085
-    assert isinstance(arr, np.ndarray)
-
-
-@given(nps.nested_dtypes())
-def test_np_dtype_is_idempotent(dtype):
-    assert dtype == np.dtype(dtype)
-
-
-def test_minimise_scalar_dtypes():
-    assert minimal(nps.scalar_dtypes()) == np.dtype("bool")
-
-
-def test_minimise_nested_types():
-    assert minimal(nps.nested_dtypes()) == np.dtype("bool")
-
-
-def test_minimise_array_strategy():
-    smallest = minimal(
-        nps.arrays(
-            nps.nested_dtypes(max_itemsize=200),
-            nps.array_shapes(max_dims=3, max_side=3),
-        )
-    )
-    assert smallest.dtype == np.dtype("bool") and not smallest.any()
-
-
-@given(nps.array_dtypes(allow_subarrays=False))
-def test_can_turn_off_subarrays(dt):
-    for name in dt.names:
-        assert dt.fieldsname0.shape == ()
-
-
-def test_array_dtypes_may_have_field_titles():
-    find_any(nps.array_dtypes(), lambda dt: len(dt.fields) > len(dt.names))
-
-
-@pytest.mark.parametrize("byteorder", "<", ">")
-@given(data=st.data())
-def test_can_restrict_endianness(data, byteorder):
-    dtype = data.draw(nps.integer_dtypes(endianness=byteorder, sizes=(16, 32, 64)))
-    if byteorder == ("<" if sys.byteorder == "little" else ">"):
-        assert dtype.byteorder == "="
-    else:
-        assert dtype.byteorder == byteorder
-
-
-@given(nps.integer_dtypes(sizes=8))
-def test_can_specify_size_as_an_int(dt):
-    assert dt.itemsize == 1
-
-
-@given(st.data())
-def test_can_draw_arrays_from_scalars(data):
-    dt = data.draw(nps.scalar_dtypes())
-    result = data.draw(nps.arrays(dtype=dt, shape=()))
-    assert isinstance(result, np.ndarray)
-    assert result.dtype == dt
-
-
-@given(st.data())
-def test_can_cast_for_arrays(data):
-    # Note: this only passes with castable datatypes, certain dtype
-    # combinations will result in an error if numpy is not able to cast them.
-    dt_elements = np.dtype(data.draw(st.sampled_from("bool", "<i2", ">i2")))
-    dt_desired = np.dtype(
-        data.draw(st.sampled_from("<i2", ">i2", "float32", "float64"))
-    )
-    result = data.draw(
-        nps.arrays(
-            dtype=dt_desired, elements=nps.from_dtype(dt_elements), shape=(1, 2, 3)
-        )
-    )
-    assert isinstance(result, np.ndarray)
-    assert result.dtype == dt_desired
-
-
-@given(nps.arrays(dtype="int8", shape=st.integers(0, 20), unique=True))
-def test_array_values_are_unique(arr):
-    assert len(set(arr)) == len(arr)
-
-
-def test_cannot_generate_unique_array_of_too_many_elements():
-    strat = nps.arrays(dtype=int, elements=st.integers(0, 5), shape=10, unique=True)
-    with pytest.raises(InvalidArgument):
-        strat.example()
-
-
-@given(
-    nps.arrays(
-        elements=st.just(0.0),
-        dtype=float,
-        fill=st.just(np.nan),
-        shape=st.integers(0, 20),
-        unique=True,
-    )
-)
-def test_array_values_are_unique_high_collision(arr):
-    assert (arr == 0.0).sum() <= 1
-
-
-@given(nps.arrays(dtype="int8", shape=(4,), elements=st.integers(0, 3), unique=True))
-def test_generates_all_values_for_unique_array(arr):
-    # Ensures that the "reject already-seen element" branch is covered
-    assert len(set(arr)) == len(arr)
-
-
-@given(nps.arrays(dtype="int8", shape=255, unique=True))
-def test_efficiently_generates_all_unique_array(arr):
-    # Avoids the birthday paradox with UniqueSampledListStrategy
-    assert len(set(arr)) == len(arr)
-
-
-@given(st.data(), st.integers(-100, 100), st.integers(1, 100))
-def test_array_element_rewriting(data, start, size):
-    arr = nps.arrays(
-        dtype=np.dtype("int64"),
-        shape=size,
-        elements=st.integers(start, start + size - 1),
-        unique=True,
-    )
-    assert set(data.draw(arr)) == set(range(start, start + size))
-
-
-def test_may_fill_with_nan_when_unique_is_set():
-    find_any(
-        nps.arrays(
-            dtype=float,
-            elements=st.floats(allow_nan=False),
-            shape=10,
-            unique=True,
-            fill=st.just(np.nan),
-        ),
-        lambda x: np.isnan(x).any(),
-    )
-
-
-@given(
-    nps.arrays(
-        dtype=float,
-        elements=st.floats(allow_nan=False),
-        shape=10,
-        unique=True,
-        fill=st.just(np.nan),
-    )
-)
-def test_is_still_unique_with_nan_fill(xs):
-    assert len(set(xs)) == len(xs)
-
-
-@fails_with(InvalidArgument)
-@given(
-    nps.arrays(
-        dtype=float,
-        elements=st.floats(allow_nan=False),
-        shape=10,
-        unique=True,
-        fill=st.just(0.0),
-    )
-)
-def test_may_not_fill_with_non_nan_when_unique_is_set(arr):
-    pass
-
-
-@fails_with(InvalidArgument)
-@given(nps.arrays(dtype="U", shape=10, unique=True, fill=st.just("")))
-def test_may_not_fill_with_non_nan_when_unique_is_set_and_type_is_not_number(arr):
-    pass
-
-
-@pytest.mark.parametrize("fill", False, True)
-@fails_with(InvalidArgument)
-@given(st.data())
-def test_overflowing_integers_are_deprecated(fill, data):
-    kw = {"elements": st.just(300)}
-    if fill:
-        kw = {"elements": st.nothing(), "fill": kw"elements"}
-    arr = data.draw(nps.arrays(dtype="int8", shape=(1,), **kw))
-    assert arr0 == (300 % 256)
-
-
-@pytest.mark.parametrize("fill", False, True)
-@pytest.mark.parametrize(
-    "dtype,strat",
-    
-        ("float16", st.floats(min_value=65520, allow_infinity=False)),
-        ("float32", st.floats(min_value=10**40, allow_infinity=False)),
-        (
-            "complex64",
-            st.complex_numbers(min_magnitude=10**300, allow_infinity=False),
-        ),
-        ("U1", st.text(min_size=2, max_size=2)),
-        ("S1", st.binary(min_size=2, max_size=2)),
-    ,
-)
-@fails_with(InvalidArgument)
-@given(data=st.data())
-def test_unrepresentable_elements_are_deprecated(fill, dtype, strat, data):
-    if fill:
-        kw = {"elements": st.nothing(), "fill": strat}
-    else:
-        kw = {"elements": strat}
-    arr = data.draw(nps.arrays(dtype=dtype, shape=(1,), **kw))
-    try:
-        # This is a float or complex number, and has overflowed to infinity,
-        # triggering our deprecation for overflow.
-        assert np.isinf(arr0)
-    except TypeError:
-        # We tried to call isinf on a string.  The string was generated at
-        # length two, then truncated by the dtype of size 1 - deprecation
-        # again.  If the first character was \0 it is now the empty string.
-        assert len(arr0) <= 1
-
-
-@given(nps.arrays(dtype="float16", shape=(1,)))
-def test_inferred_floats_do_not_overflow(arr):
-    pass
-
-
-@given(nps.arrays(dtype="float16", shape=10, elements={"min_value": 0, "max_value": 1}))
-def test_inferred_floats_can_be_constrained_at_low_width(arr):
-    assert (arr >= 0).all()
-    assert (arr <= 1).all()
-
-
-@given(
-    nps.arrays(
-        dtype="float16",
-        shape=10,
-        elements={
-            "min_value": 0,
-            "max_value": 1,
-            "exclude_min": True,
-            "exclude_max": True,
-        },
-    )
-)
-def test_inferred_floats_can_be_constrained_at_low_width_excluding_endpoints(arr):
-    assert (arr > 0).all()
-    assert (arr < 1).all()
-
-
-@given(
-    nps.arrays(
-        dtype="float16",
-        shape=10,
-        unique=True,
-        elements=st.integers(1, 9),
-        fill=st.just(np.nan),
-    )
-)
-def test_unique_array_with_fill_can_use_all_elements(arr):
-    assume(len(set(arr)) == arr.size)
-
-
-@given(nps.arrays(dtype="uint8", shape=25, unique=True, fill=st.nothing()))
-def test_unique_array_without_fill(arr):
-    # This test covers the collision-related branches for fully dense unique arrays.
-    # Choosing 25 of 256 possible elements means we're almost certain to see colisions
-    # thanks to the 'birthday paradox', but finding unique elemennts is still easy.
-    assume(len(set(arr)) == arr.size)
-
-
-@given(ndim=st.integers(0, 5), data=st.data())
-def test_mapped_positive_axes_are_unique(ndim, data):
-    min_size = data.draw(st.integers(0, ndim), label="min_size")
-    max_size = data.draw(st.integers(min_size, ndim), label="max_size")
-    axes = data.draw(
-        nps.valid_tuple_axes(ndim, min_size=min_size, max_size=max_size), label="axes"
-    )
-    assert len(set(axes)) == len({i if 0 < i else ndim + i for i in axes})
-
-
-@given(ndim=st.integers(0, 5), data=st.data())
-def test_length_bounds_are_satisfied(ndim, data):
-    min_size = data.draw(st.integers(0, ndim), label="min_size")
-    max_size = data.draw(st.integers(min_size, ndim), label="max_size")
-    axes = data.draw(
-        nps.valid_tuple_axes(ndim, min_size=min_size, max_size=max_size), label="axes"
-    )
-    assert min_size <= len(axes) <= max_size
-
-
-@given(shape=nps.array_shapes(), data=st.data())
-def test_axes_are_valid_inputs_to_sum(shape, data):
-    x = np.zeros(shape, dtype="uint8")
-    axes = data.draw(nps.valid_tuple_axes(ndim=len(shape)), label="axes")
-    np.sum(x, axes)
-
-
-@settings(deadline=None, max_examples=10)
-@given(ndim=st.integers(0, 3), data=st.data())
-def test_minimize_tuple_axes(ndim, data):
-    min_size = data.draw(st.integers(0, ndim), label="min_size")
-    max_size = data.draw(st.integers(min_size, ndim), label="max_size")
-    smallest = minimal(nps.valid_tuple_axes(ndim, min_size=min_size, max_size=max_size))
-    assert len(smallest) == min_size and all(k > -1 for k in smallest)
-
-
-@settings(deadline=None, max_examples=10)
-@given(ndim=st.integers(0, 3), data=st.data())
-def test_minimize_negative_tuple_axes(ndim, data):
-    min_size = data.draw(st.integers(0, ndim), label="min_size")
-    max_size = data.draw(st.integers(min_size, ndim), label="max_size")
-    smallest = minimal(
-        nps.valid_tuple_axes(ndim, min_size=min_size, max_size=max_size),
-        lambda x: all(i < 0 for i in x),
-    )
-    assert len(smallest) == min_size
-
-
-@given(nps.broadcastable_shapes((), min_side=0, max_side=0, min_dims=0, max_dims=0))
-def test_broadcastable_empty_shape(shape):
-    assert shape == ()
-
-
-@settings(deadline=None, suppress_health_check=HealthCheck.too_slow)
-@given(shape=ANY_SHAPE, data=st.data())
-def test_broadcastable_shape_bounds_are_satisfied(shape, data):
-    min_dims = data.draw(st.integers(0, 32), label="min_dims")
-    max_dims = data.draw(st.none() | st.integers(min_dims, 32), label="max_dims")
-    min_side = data.draw(st.integers(0, 3), label="min_side")
-    max_side = data.draw(st.none() | st.integers(min_side, 6), label="max_side")
-    try:
-        bshape = data.draw(
-            nps.broadcastable_shapes(
-                shape,
-                min_side=min_side,
-                max_side=max_side,
-                min_dims=min_dims,
-                max_dims=max_dims,
-            ),
-            label="bshape",
-        )
-    except InvalidArgument:
-        raise UnsatisfiedAssumption from None
-
-    if max_dims is None:
-        max_dims = max(len(shape), min_dims) + 2
-
-    if max_side is None:
-        max_side = max(tuple(shape::-1:max_dims) + (min_side,)) + 2
-
-    assert isinstance(bshape, tuple) and all(isinstance(s, int) for s in bshape)
-    assert min_dims <= len(bshape) <= max_dims
-    assert all(min_side <= s <= max_side for s in bshape)
-
-
-@settings(deadline=None)
-@given(num_shapes=st.integers(1, 4), base_shape=ANY_SHAPE, data=st.data())
-def test_mutually_broadcastable_shape_bounds_are_satisfied(
-    num_shapes, base_shape, data
-):
-    min_dims = data.draw(st.integers(0, 32), label="min_dims")
-    max_dims = data.draw(
-        st.one_of(st.none(), st.integers(min_dims, 32)), label="max_dims"
-    )
-    min_side = data.draw(st.integers(0, 3), label="min_side")
-    max_side = data.draw(
-        st.one_of(st.none(), st.integers(min_side, 6)), label="max_side"
-    )
-    try:
-        shapes, result = data.draw(
-            nps.mutually_broadcastable_shapes(
-                num_shapes=num_shapes,
-                base_shape=base_shape,
-                min_side=min_side,
-                max_side=max_side,
-                min_dims=min_dims,
-                max_dims=max_dims,
-            ),
-            label="shapes, result",
-        )
-    except InvalidArgument:
-        raise UnsatisfiedAssumption from None
-
-    if max_dims is None:
-        max_dims = max(len(base_shape), min_dims) + 2
-
-    if max_side is None:
-        max_side = max(tuple(base_shape::-1:max_dims) + (min_side,)) + 2
-
-    assert isinstance(shapes, tuple)
-    assert isinstance(result, tuple)
-    assert all(isinstance(s, int) for s in result)
-
-    for bshape in shapes:
-        assert isinstance(bshape, tuple) and all(isinstance(s, int) for s in bshape)
-        assert min_dims <= len(bshape) <= max_dims
-        assert all(min_side <= s <= max_side for s in bshape)
-
-
-def _draw_valid_bounds(data, shape, max_dims, permit_none=True):
-    if max_dims == 0 or not shape:
-        return 0, None
-
-    smallest_side = min(shape::-1:max_dims)
-    min_strat = (
-        st.sampled_from(1, smallest_side)
-        if smallest_side > 1
-        else st.just(smallest_side)
-    )
-    min_side = data.draw(min_strat, label="min_side")
-    largest_side = max(max(shape::-1:max_dims), min_side)
-    if permit_none:
-        max_strat = st.one_of(st.none(), st.integers(largest_side, largest_side + 2))
-    else:
-        max_strat = st.integers(largest_side, largest_side + 2)
-    max_side = data.draw(max_strat, label="max_side")
-    return min_side, max_side
-
-
-def _broadcast_two_shapes(shape_a: nps.Shape, shape_b: nps.Shape) -> nps.Shape:
-    result = 
-    for a, b in zip_longest(reversed(shape_a), reversed(shape_b), fillvalue=1):
-        if a != b and (a != 1) and (b != 1):
-            raise ValueError(
-                f"shapes {shape_a!r} and {shape_b!r} are not broadcast-compatible"
-            )
-        result.append(a if a != 1 else b)
-    return tuple(reversed(result))
-
-
-def _broadcast_shapes(*shapes):
-    """Returns the shape resulting from broadcasting the
-    input shapes together.
-
-    Raises ValueError if the shapes are not broadcast-compatible"""
-    assert shapes, "Must pass >=1 shapes to broadcast"
-    return reduce(_broadcast_two_shapes, shapes, ())
-
-
-@settings(deadline=None, max_examples=500)
-@given(
-    shapes=st.lists(
-        nps.array_shapes(min_dims=0, min_side=0, max_dims=4, max_side=4), min_size=1
-    )
-)
-def test_broadcastable_shape_util(shapes):
-    """Ensures that `_broadcast_shapes` raises when fed incompatible shapes,
-    and ensures that it produces the true broadcasted shape"""
-    if len(shapes) == 1:
-        assert _broadcast_shapes(*shapes) == shapes0
-        return
-
-    arrs = np.zeros(s, dtype=np.uint8) for s in shapes
-
-    try:
-        broadcast_out = np.broadcast_arrays(*arrs)
-    except ValueError:
-        with pytest.raises(ValueError):
-            _broadcast_shapes(*shapes)
-        return
-    broadcasted_shape = _broadcast_shapes(*shapes)
-
-    assert broadcast_out0.shape == broadcasted_shape
-
-
-@settings(deadline=None, max_examples=200)
-@given(shape=ANY_NONZERO_SHAPE, data=st.data())
-def test_broadcastable_shape_has_good_default_values(shape, data):
-    # This test ensures that default parameters can always produce broadcast-compatible shapes
-    broadcastable_shape = data.draw(
-        nps.broadcastable_shapes(shape), label="broadcastable_shapes"
-    )
-    # error if drawn shape for b is not broadcast-compatible
-    _broadcast_shapes(shape, broadcastable_shape)
-
-
-@settings(deadline=None, max_examples=200)
-@given(base_shape=ANY_SHAPE, num_shapes=st.integers(1, 10), data=st.data())
-def test_mutually_broadcastableshapes_has_good_default_values(
-    num_shapes, base_shape, data
-):
-    # This test ensures that default parameters can always produce broadcast-compatible shapes
-    shapes, result = data.draw(
-        nps.mutually_broadcastable_shapes(num_shapes=num_shapes, base_shape=base_shape),
-        label="shapes, result",
-    )
-    assert len(shapes) == num_shapes
-    # raises if shapes are not mutually-compatible
-    assert result == _broadcast_shapes(base_shape, *shapes)
-
-
-@settings(deadline=None)
-@given(min_dims=st.integers(0, 32), shape=ANY_SHAPE, data=st.data())
-def test_broadcastable_shape_can_broadcast(min_dims, shape, data):
-    max_dims = data.draw(st.none() | st.integers(min_dims, 32), label="max_dims")
-    min_side, max_side = _draw_valid_bounds(data, shape, max_dims)
-    broadcastable_shape = data.draw(
-        nps.broadcastable_shapes(
-            shape,
-            min_side=min_side,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        ),
-        label="broadcastable_shapes",
-    )
-    # error if drawn shape for b is not broadcast-compatible
-    _broadcast_shapes(shape, broadcastable_shape)
-
-
-@settings(deadline=None)
-@given(
-    num_shapes=st.integers(1, 10),
-    min_dims=st.integers(0, 32),
-    base_shape=ANY_SHAPE,
-    data=st.data(),
-)
-def test_mutually_broadcastable_shape_can_broadcast(
-    num_shapes, min_dims, base_shape, data
-):
-    max_dims = data.draw(st.none() | st.integers(min_dims, 32), label="max_dims")
-    min_side, max_side = _draw_valid_bounds(data, base_shape, max_dims)
-    shapes, result = data.draw(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=num_shapes,
-            base_shape=base_shape,
-            min_side=min_side,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        ),
-        label="shapes, result",
-    )
-
-    # error if drawn shapes are not mutually broadcast-compatible
-    assert result == _broadcast_shapes(base_shape, *shapes)
-
-
-@settings(deadline=None, max_examples=50)
-@given(
-    num_shapes=st.integers(1, 3),
-    min_dims=st.integers(0, 5),
-    base_shape=nps.array_shapes(min_dims=0, max_dims=3, min_side=0, max_side=5),
-    data=st.data(),
-)
-def test_minimize_mutually_broadcastable_shape(num_shapes, min_dims, base_shape, data):
-    # Ensure aligned dimensions of broadcastable shape minimizes to `(1,) * min_dims`
-    max_dims = data.draw(st.none() | st.integers(min_dims, 5), label="max_dims")
-    min_side, max_side = _draw_valid_bounds(
-        data, base_shape, max_dims, permit_none=False
-    )
-
-    if num_shapes > 1:
-        # shrinking gets a little bit hairy when we have empty axes
-        # and multiple num_shapes
-        assume(min_side > 0)
-
-    smallest_shapes, result = minimal(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=num_shapes,
-            base_shape=base_shape,
-            min_side=min_side,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        )
-    )
-    note(f"smallest_shapes: {smallest_shapes}")
-    note(f"result: {result}")
-    assert len(smallest_shapes) == num_shapes
-    assert result == _broadcast_shapes(base_shape, *smallest_shapes)
-    for smallest in smallest_shapes:
-        n_leading = max(len(smallest) - len(base_shape), 0)
-        n_aligned = max(len(smallest) - n_leading, 0)
-        note(f"n_leading: {n_leading}")
-        note(f"n_aligned: {n_aligned} {base_shape-n_aligned:}")
-        expected = min_side * n_leading + 
-            (min(1, i) if i != 1 else min_side) if min_side <= 1 <= max_side else i
-            for i in (base_shape-n_aligned: if n_aligned else ())
-        
-        assert tuple(expected) == smallest
-
-
-@settings(deadline=None)
-@given(max_dims=st.integers(4, 6), data=st.data())
-def test_broadcastable_shape_adjusts_max_dim_with_explicit_bounds(max_dims, data):
-    # Ensures that `broadcastable_shapes` limits itself to satisfiable dimensions
-    # Broadcastable values can only be drawn for dims 0-3 for these shapes
-    shape = data.draw(st.sampled_from((5, 3, 2, 1), (0, 3, 2, 1)), label="shape")
-    broadcastable_shape = data.draw(
-        nps.broadcastable_shapes(
-            shape, min_side=2, max_side=3, min_dims=3, max_dims=max_dims
-        ),
-        label="broadcastable_shapes",
-    )
-    assert len(broadcastable_shape) == 3
-    # error if drawn shape for b is not broadcast-compatible
-    _broadcast_shapes(shape, broadcastable_shape)
-
-
-@settings(deadline=None)
-@given(
-    max_side=st.sampled_from(3, None),
-    min_dims=st.integers(0, 4),
-    num_shapes=st.integers(1, 3),
-    data=st.data(),
-)
-def test_mutually_broadcastable_shape_adjusts_max_dim_with_default_bounds(
-    max_side, min_dims, num_shapes, data
-):
-    # Ensures that `mutually_broadcastable_shapes` limits itself to satisfiable dimensions
-    # when a default `max_dims` is derived.
-    base_shape = data.draw(
-        st.sampled_from((5, 3, 2, 1), (0, 3, 2, 1)), label="base_shape"
-    )
-
-    try:
-        shapes, result = data.draw(
-            nps.mutually_broadcastable_shapes(
-                num_shapes=num_shapes,
-                base_shape=base_shape,
-                min_side=2,
-                max_side=max_side,
-                min_dims=min_dims,
-            ),
-            label="shapes, result",
-        )
-    except InvalidArgument:
-        # There is no satisfiable `max_dims` for us to tune
-        assert min_dims == 4 and (max_side == 3 or base_shape0 == 0)
-        return
-
-    if max_side == 3 or base_shape0 == 0:
-        assert all(len(s) <= 3 for s in shapes)
-    elif min_dims == 4:
-        assert all(4 <= len(s) for s in shapes)
-
-    # error if drawn shape for b is not broadcast-compatible
-    assert len(shapes) == num_shapes
-    assert result == _broadcast_shapes(base_shape, *shapes)
-
-
-@settings(deadline=None, max_examples=10)
-@given(min_dims=st.integers(0, 32), min_side=st.integers(2, 3), data=st.data())
-def test_broadcastable_shape_shrinking_with_singleton_out_of_bounds(
-    min_dims, min_side, data
-):
-    max_dims = data.draw(st.none() | st.integers(min_dims, 32), label="max_dims")
-    max_side = data.draw(st.none() | st.integers(min_side, 6), label="max_side")
-    shape = data.draw(st.integers(1, 4).map(lambda n: n * (1,)), label="shape")
-    smallest = minimal(
-        nps.broadcastable_shapes(
-            shape,
-            min_side=min_side,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        )
-    )
-    assert smallest == (min_side,) * min_dims
-
-
-@settings(deadline=None, max_examples=50)
-@given(
-    num_shapes=st.integers(1, 4),
-    min_dims=st.integers(0, 4),
-    min_side=st.integers(2, 3),
-    data=st.data(),
-)
-def test_mutually_broadcastable_shapes_shrinking_with_singleton_out_of_bounds(
-    num_shapes, min_dims, min_side, data
-):
-    """Ensures that shapes minimize to `(min_side,) * min_dims` when singleton dimensions
-    are disallowed."""
-    max_dims = data.draw(st.none() | st.integers(min_dims, 4), label="max_dims")
-    max_side = data.draw(
-        st.one_of(st.none(), st.integers(min_side, 6)), label="max_side"
-    )
-    ndims = data.draw(st.integers(1, 4), label="ndim")
-    base_shape = (1,) * ndims
-    smallest_shapes, result = minimal(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=num_shapes,
-            base_shape=base_shape,
-            min_side=min_side,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        )
-    )
-    note(f"(smallest_shapes, result): {(smallest_shapes, result)}")
-    assert len(smallest_shapes) == num_shapes
-    assert result == _broadcast_shapes(base_shape, *smallest_shapes)
-    for smallest in smallest_shapes:
-        assert smallest == (min_side,) * min_dims
-
-
-@given(
-    num_shapes=st.integers(1, 4),
-    min_dims=st.integers(1, 32),
-    max_side=st.integers(1, 6),
-    data=st.data(),
-)
-def test_mutually_broadcastable_shapes_only_singleton_is_valid(
-    num_shapes, min_dims, max_side, data
-):
-    """Ensures that, when all aligned base-shape dim sizes are larger
-    than ``max_side``, only singletons can be drawn"""
-    max_dims = data.draw(st.integers(min_dims, 32), label="max_dims")
-    base_shape = data.draw(
-        nps.array_shapes(min_side=max_side + 1, min_dims=1), label="base_shape"
-    )
-    input_shapes, result = data.draw(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=num_shapes,
-            base_shape=base_shape,
-            min_side=1,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        ),
-        label="input_shapes, result",
-    )
-
-    assert len(input_shapes) == num_shapes
-    assert result == _broadcast_shapes(base_shape, *input_shapes)
-    for shape in input_shapes:
-        assert all(i == 1 for i in shape-len(base_shape) :)
-
-
-@settings(deadline=None)
-@given(
-    shape=nps.array_shapes(min_dims=0, max_dims=3, min_side=0, max_side=5),
-    max_dims=st.integers(0, 6),
-    data=st.data(),
-)
-def test_broadcastable_shape_can_generate_arbitrary_ndims(shape, max_dims, data):
-    # ensures that generates shapes can possess any length in min_dims, max_dims
-    desired_ndim = data.draw(st.integers(0, max_dims), label="desired_ndim")
-    min_dims = data.draw(
-        st.one_of(st.none(), st.integers(0, desired_ndim)), label="min_dims"
-    )
-    # check default arg behavior too
-    kwargs = {"min_dims": min_dims} if min_dims is not None else {}
-    find_any(
-        nps.broadcastable_shapes(shape, min_side=0, max_dims=max_dims, **kwargs),
-        lambda x: len(x) == desired_ndim,
-        settings(max_examples=10**6),
-    )
-
-
-@settings(deadline=None)
-@given(
-    num_shapes=st.integers(1, 3),
-    base_shape=nps.array_shapes(min_dims=0, max_dims=3, min_side=0, max_side=5),
-    max_dims=st.integers(0, 4),
-    data=st.data(),
-)
-def test_mutually_broadcastable_shapes_can_generate_arbitrary_ndims(
-    num_shapes, base_shape, max_dims, data
-):
-    # ensures that each generated shape can possess any length in min_dims, max_dims
-    desired_ndims = data.draw(
-        st.lists(st.integers(0, max_dims), min_size=num_shapes, max_size=num_shapes),
-        label="desired_ndims",
-    )
-    min_dims = data.draw(
-        st.one_of(st.none(), st.integers(0, min(desired_ndims))), label="min_dims"
-    )
-    # check default arg behavior too
-    kwargs = {"min_dims": min_dims} if min_dims is not None else {}
-    find_any(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=num_shapes,
-            base_shape=base_shape,
-            min_side=0,
-            max_dims=max_dims,
-            **kwargs,
-        ),
-        lambda x: {len(s) for s in x.input_shapes} == set(desired_ndims),
-        settings(max_examples=10**6),
-    )
-
-
-@settings(deadline=None)
-@given(
-    base_shape=nps.array_shapes(min_dims=0, max_dims=3, min_side=0, max_side=2),
-    max_dims=st.integers(1, 4),
-)
-def test_mutually_broadcastable_shapes_can_generate_interesting_singletons(
-    base_shape, max_dims
-):
-
-    find_any(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=2,
-            base_shape=base_shape,
-            min_side=0,
-            max_dims=max_dims,
-        ),
-        lambda x: any(a != b for a, b in zip(*(s::-1 for s in x.input_shapes))),  # type: ignore
-    )
-
-
-@pytest.mark.parametrize("base_shape", (), (0,), (1,), (2,), (1, 2), (2, 1), (2, 2))
-def test_mutually_broadcastable_shapes_can_generate_mirrored_singletons(base_shape):
-    def f(shapes: nps.BroadcastableShapes):
-        x, y = shapes.input_shapes
-        return x.count(1) == 1 and y.count(1) == 1 and x::-1 == y
-
-    find_any(
-        nps.mutually_broadcastable_shapes(
-            num_shapes=2,
-            base_shape=base_shape,
-            min_side=0,
-            max_side=3,
-            min_dims=2,
-            max_dims=2,
-        ),
-        f,
-    )
-
-
-@settings(deadline=None)
-@given(
-    shape=nps.array_shapes(min_dims=1, min_side=1),
-    dtype=st.one_of(nps.unsigned_integer_dtypes(), nps.integer_dtypes()),
-    data=st.data(),
-)
-def test_advanced_integer_index_is_valid_with_default_result_shape(shape, dtype, data):
-    index = data.draw(nps.integer_array_indices(shape, dtype=dtype))
-    x = np.zeros(shape)
-    out = xindex  # raises if the index is invalid
-    assert not np.shares_memory(x, out)  # advanced indexing should not return a view
-    assert all(dtype == x.dtype for x in index)
-
-
-@settings(deadline=None)
-@given(
-    shape=nps.array_shapes(min_dims=1, min_side=1),
-    min_dims=st.integers(0, 3),
-    min_side=st.integers(0, 3),
-    dtype=st.one_of(nps.unsigned_integer_dtypes(), nps.integer_dtypes()),
-    data=st.data(),
-)
-def test_advanced_integer_index_is_valid_and_satisfies_bounds(
-    shape, min_dims, min_side, dtype, data
-):
-    max_side = data.draw(st.integers(min_side, min_side + 2), label="max_side")
-    max_dims = data.draw(st.integers(min_dims, min_dims + 2), label="max_dims")
-    index = data.draw(
-        nps.integer_array_indices(
-            shape,
-            result_shape=nps.array_shapes(
-                min_dims=min_dims,
-                max_dims=max_dims,
-                min_side=min_side,
-                max_side=max_side,
-            ),
-            dtype=dtype,
-        )
-    )
-    x = np.zeros(shape)
-    out = xindex  # raises if the index is invalid
-    assert all(min_side <= s <= max_side for s in out.shape)
-    assert min_dims <= out.ndim <= max_dims
-    assert not np.shares_memory(x, out)  # advanced indexing should not return a view
-    assert all(dtype == x.dtype for x in index)
-
-
-@settings(deadline=None)
-@given(
-    shape=nps.array_shapes(min_dims=1, min_side=1),
-    min_dims=st.integers(0, 3),
-    min_side=st.integers(0, 3),
-    dtype=st.sampled_from("uint8", "int8"),
-    data=st.data(),
-)
-def test_advanced_integer_index_minimizes_as_documented(
-    shape, min_dims, min_side, dtype, data
-):
-    max_side = data.draw(st.integers(min_side, min_side + 2), label="max_side")
-    max_dims = data.draw(st.integers(min_dims, min_dims + 2), label="max_dims")
-    result_shape = nps.array_shapes(
-        min_dims=min_dims, max_dims=max_dims, min_side=min_side, max_side=max_side
-    )
-    smallest = minimal(
-        nps.integer_array_indices(shape, result_shape=result_shape, dtype=dtype)
-    )
-    desired = len(shape) * (np.zeros(min_dims * min_side),)
-    assert len(smallest) == len(desired)
-    for s, d in zip(smallest, desired):
-        np.testing.assert_array_equal(s, d)
-
-
-@settings(deadline=None, max_examples=10)
-@given(
-    shape=nps.array_shapes(min_dims=1, max_dims=2, min_side=1, max_side=3),
-    data=st.data(),
-)
-def test_advanced_integer_index_can_generate_any_pattern(shape, data):
-    # ensures that generated index-arrays can be used to yield any pattern of elements from an array
-    x = np.arange(np.product(shape)).reshape(shape)
-
-    target = data.draw(
-        nps.arrays(
-            shape=nps.array_shapes(min_dims=1, max_dims=2, min_side=1, max_side=2),
-            elements=st.sampled_from(x.flatten()),
-            dtype=x.dtype,
-        ),
-        label="target",
-    )
-    find_any(
-        nps.integer_array_indices(
-            shape, result_shape=st.just(target.shape), dtype=np.dtype("int8")
-        ),
-        lambda index: np.all(target == xindex),
-        settings(max_examples=10**6),
-    )
-
-
-@pytest.mark.parametrize(
-    "condition",
-    
-        lambda ix: Ellipsis in ix,
-        lambda ix: Ellipsis not in ix,
-        lambda ix: np.newaxis in ix,
-        lambda ix: np.newaxis not in ix,
-    ,
-)
-def test_basic_indices_options(condition):
-    indexers = nps.array_shapes(min_dims=0, max_dims=32).flatmap(
-        lambda shape: nps.basic_indices(shape, allow_newaxis=True)
-    )
-    find_any(indexers, condition)
-
-
-def test_basic_indices_can_generate_empty_tuple():
-    find_any(nps.basic_indices(shape=(0, 0), allow_ellipsis=True), lambda ix: ix == ())
-
-
-def test_basic_indices_can_generate_non_tuples():
-    find_any(
-        nps.basic_indices(shape=(0, 0), allow_ellipsis=True),
-        lambda ix: not isinstance(ix, tuple),
-    )
-
-
-def test_basic_indices_can_generate_long_ellipsis():
-    # Runs of slice(None) - such as 0,:,:,:,0 - can be replaced by e.g. 0,...,0
-    find_any(
-        nps.basic_indices(shape=(1, 0, 0, 0, 1), allow_ellipsis=True),
-        lambda ix: len(ix) == 3 and ix1 == Ellipsis,
-    )
-
-
-@given(
-    nps.basic_indices(shape=(0, 0, 0, 0, 0)).filter(
-        lambda idx: isinstance(idx, tuple) and Ellipsis in idx
-    )
-)
-def test_basic_indices_replaces_whole_axis_slices_with_ellipsis(idx):
-    # `slice(None)` (aka `:`) is the only valid index for an axis of size
-    # zero, so if all dimensions are 0 then a `...` will replace all the
-    # slices because we generate `...` for entire contiguous runs of `:`
-    assert slice(None) not in idx
-
-
-def test_basic_indices_can_generate_indices_not_covering_all_dims():
-    # These "flat indices" are skippable in the underlying BasicIndexStrategy,
-    # so we ensure we're definitely generating them for nps.basic_indices().
-    find_any(
-        nps.basic_indices(shape=(3, 3, 3)),
-        lambda ix: (
-            (not isinstance(ix, tuple) and ix != Ellipsis)
-            or (isinstance(ix, tuple) and Ellipsis not in ix and len(ix) < 3)
-        ),
-    )
-
-
-@given(
-    shape=nps.array_shapes(min_dims=0, max_side=4)
-    | nps.array_shapes(min_dims=0, min_side=0, max_side=10),
-    allow_newaxis=st.booleans(),
-    allow_ellipsis=st.booleans(),
-    data=st.data(),
-)
-def test_basic_indices_generate_valid_indexers(
-    shape, allow_newaxis, allow_ellipsis, data
-):
-    min_dims = data.draw(
-        st.integers(0, 5 if allow_newaxis else len(shape)), label="min_dims"
-    )
-    max_dims = data.draw(
-        st.none() | st.integers(min_dims, 32 if allow_newaxis else len(shape)),
-        label="max_dims",
-    )
-    indexer = data.draw(
-        nps.basic_indices(
-            shape,
-            min_dims=min_dims,
-            max_dims=max_dims,
-            allow_ellipsis=allow_ellipsis,
-            allow_newaxis=allow_newaxis,
-        ),
-        label="indexer",
-    )
-
-    # Check that disallowed things are indeed absent
-    if not allow_newaxis:
-        if isinstance(indexer, tuple):
-            assert 0 <= len(indexer) <= len(shape) + int(allow_ellipsis)
-        else:
-            assert 1 <= len(shape) + int(allow_ellipsis)
-        assert np.newaxis not in shape
-    if not allow_ellipsis:
-        assert Ellipsis not in shape
-
-    if 0 in shape:
-        # If there's a zero in the shape, the array will have no elements.
-        array = np.zeros(shape)
-        assert array.size == 0
-    elif np.prod(shape) <= 10**5:
-        # If it's small enough to instantiate, do so with distinct elements.
-        array = np.arange(np.prod(shape)).reshape(shape)
-    else:
-        # We can't cheat on this one, so just try another.
-        assume(False)
-    view = arrayindexer
-    if not np.isscalar(view):
-        assert min_dims <= view.ndim <= (32 if max_dims is None else max_dims)
-        if view.size:
-            assert np.shares_memory(view, array)
-
-
-# addresses https://github.com/HypothesisWorks/hypothesis/issues/2582
-@given(
-    nps.arrays(
-        shape=nps.array_shapes(min_dims=0, min_side=0), dtype=nps.floating_dtypes()
-    )
-)
-def test_array_owns_memory(x: np.ndarray):
-    assert x.base is None
-    assert x....base is x

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_gufunc.py Deleted

@@ -1,224 +0,0 @@
-# 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 numpy as np
-import pytest
-from pytest import param
-
-from hypothesis import example, given, note, settings, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra import numpy as nps
-from hypothesis.extra._array_helpers import (
-    _SIGNATURE,
-    _hypothesis_parse_gufunc_signature,
-)
-
-from tests.common.debug import find_any, minimal
-
-
-def use_signature_examples(func):
-    for sig in 
-        "(),()->()",
-        "(i)->()",
-        "(i),(i)->()",
-        "(m,n),(n,p)->(m,p)",
-        "(n),(n,p)->(p)",
-        "(m,n),(n)->(m)",
-        "(m?,n),(n,p?)->(m?,p?)",
-        "(3),(3)->(3)",
-    :
-        func = example(sig)(func)
-    return func
-
-
-def hy_sig_2_np_sig(hy_sig):
-    return (
-        tuple(d.strip("?") for d in shape) for shape in hy_sig.input_shapes,
-        tuple(d.strip("?") for d in hy_sig.result_shape),
-    )
-
-
-@use_signature_examples
-@example("()->(%s),()" % ",".join(33 * "0"))
-@given(st.from_regex(np.lib.function_base._SIGNATURE))
-def test_numpy_signature_parses(sig):
-    if sig == "(m?,n),(n,p?)->(m?,p?)":  # matmul example
-        return
-
-    np_sig = np.lib.function_base._parse_gufunc_signature(sig)
-    try:
-        hy_sig = _hypothesis_parse_gufunc_signature(sig, all_checks=False)
-        assert np_sig == hy_sig_2_np_sig(hy_sig)
-    except InvalidArgument:
-        shape_too_long = any(len(s) > 32 for s in np_sig0 + np_sig1)
-        multiple_outputs = len(np_sig1) > 1
-        assert shape_too_long or multiple_outputs
-
-        # Now, if we can fix this up does it validate?
-        in_, out = sig.split("->")
-        sig = in_ + "->" + out.split(",(")0
-        np_sig = np.lib.function_base._parse_gufunc_signature(sig)
-        if all(len(s) <= 32 for s in np_sig0 + np_sig1):
-            hy_sig = _hypothesis_parse_gufunc_signature(sig, all_checks=False)
-            assert np_sig == hy_sig_2_np_sig(hy_sig)
-
-
-@use_signature_examples
-@given(st.from_regex(_SIGNATURE))
-def test_hypothesis_signature_parses(sig):
-    hy_sig = _hypothesis_parse_gufunc_signature(sig, all_checks=False)
-    try:
-        np_sig = np.lib.function_base._parse_gufunc_signature(sig)
-        assert np_sig == hy_sig_2_np_sig(hy_sig)
-    except ValueError:
-        assert "?" in sig
-        # We can always fix this up, and it should then always validate.
-        sig = sig.replace("?", "")
-        hy_sig = _hypothesis_parse_gufunc_signature(sig, all_checks=False)
-        np_sig = np.lib.function_base._parse_gufunc_signature(sig)
-        assert np_sig == hy_sig_2_np_sig(hy_sig)
-
-
-def test_frozen_dims_signature():
-    _hypothesis_parse_gufunc_signature("(2),(3)->(4)")
-
-
-@st.composite
-def gufunc_arrays(draw, shape_strat, **kwargs):
-    """An example user strategy built on top of mutually_broadcastable_shapes."""
-    input_shapes, result_shape = draw(shape_strat)
-    arrays_strat = st.tuples(*(nps.arrays(shape=s, **kwargs) for s in input_shapes))
-    return draw(arrays_strat), result_shape
-
-
-@given(
-    gufunc_arrays(
-        nps.mutually_broadcastable_shapes(signature=np.matmul.signature),
-        dtype="float64",
-        elements=st.floats(0, 1000),
-    )
-)
-def test_matmul_gufunc_shapes(everything):
-    arrays, result_shape = everything
-    out = np.matmul(*arrays)
-    assert out.shape == result_shape
-
-
-@settings(deadline=None, max_examples=10)
-@pytest.mark.parametrize(
-    "target_sig",
-    ("(i),(i)->()", "(m,n),(n,p)->(m,p)", "(n),(n,p)->(p)", "(m,n),(n)->(m)"),
-)
-@given(data=st.data())
-def test_matmul_signature_can_exercise_all_combination_of_optional_dims(
-    target_sig, data
-):
-    target_shapes = data.draw(
-        nps.mutually_broadcastable_shapes(signature=target_sig, max_dims=0)
-    )
-    find_any(
-        nps.mutually_broadcastable_shapes(
-            signature="(m?,n),(n,p?)->(m?,p?)", max_dims=0
-        ),
-        lambda shapes: shapes == target_shapes,
-        settings(max_examples=10**6),
-    )
-
-
-@settings(deadline=None, max_examples=50)
-@given(
-    min_dims=st.integers(0, 4),
-    min_side=st.integers(2, 3),
-    n_fixed=st.booleans(),
-    data=st.data(),
-)
-def test_matmul_sig_shrinks_as_documented(min_dims, min_side, n_fixed, data):
-    sig = "(m?,n),(n,p?)->(m?,p?)"
-    if n_fixed:
-        n_value = data.draw(st.integers(0, 4))
-        sig = sig.replace("n", str(n_value))
-    else:
-        n_value = min_side
-
-    note(f"signature: {sig}")
-    max_dims = data.draw(st.none() | st.integers(min_dims, 4), label="max_dims")
-    max_side = data.draw(st.none() | st.integers(min_side, 6), label="max_side")
-
-    smallest_shapes, result = minimal(
-        nps.mutually_broadcastable_shapes(
-            signature=sig,
-            min_side=min_side,
-            max_side=max_side,
-            min_dims=min_dims,
-            max_dims=max_dims,
-        )
-    )
-    note(f"(smallest_shapes, result): {(smallest_shapes, result)}")
-
-    # if min_dims >= 1 then core dims are never excluded
-    # otherwise, should shrink towards excluding all optional dims
-    expected_input_0 = (
-        (n_value,) if min_dims == 0 else (min_side,) * min_dims + (min_side, n_value)
-    )
-    assert expected_input_0 == smallest_shapes0
-
-    expected_input_1 = (
-        (n_value,) if min_dims == 0 else (min_side,) * min_dims + (n_value, min_side)
-    )
-    assert expected_input_1 == smallest_shapes1
-
-
-def gufunc_sig_to_einsum_sig(gufunc_sig):
-    """E.g. (i,j),(j,k)->(i,k) becomes ...ij,...jk->...ik"""
-
-    def einlabels(labels):
-        assert "x" not in labels, "we reserve x for fixed-dimensions"
-        return "..." + "".join(i if not i.isdigit() else "x" for i in labels)
-
-    gufunc_sig = _hypothesis_parse_gufunc_signature(gufunc_sig)
-    input_sig = ",".join(map(einlabels, gufunc_sig.input_shapes))
-    return input_sig + "->" + einlabels(gufunc_sig.result_shape)
-
-
-@pytest.mark.parametrize(
-    "gufunc_sig",
-    
-        param("()->()", id="unary sum"),
-        param("(),()->()", id="binary sum"),
-        param("(),(),()->()", id="trinary sum"),
-        param("(i)->()", id="sum1d"),
-        param("(i,j)->(j)", id="sum rows"),
-        param("(i),(i)->()", id="inner1d"),
-        param("(i),(i),(i)->()", id="trinary inner1d"),
-        param("(m,n),(n,p)->(m,p)", id="matmat"),
-        param("(n),(n,p)->(p)", id="vecmat"),
-        param("(i,t),(j,t)->(i,j)", id="outer-inner"),
-        param("(3),(3)->(3)", id="cross1d"),
-        param("(i,j)->(j,i)", id="transpose"),
-        param("(i),(j)->(i,j)", id="outer"),
-        param("(i,3),(3,k)->(3,i,k)", id="fixed dim outer product"),
-        param("(i),(j),(k)->(i,j,k)", id="trinary outer"),
-        param("(i,i)->(i)", id="trace"),
-        param("(j,i,i,j)->(i,j)", id="bigger trace"),
-        param("(k),(j,i,k,i,j),(j,i)->(i,j)", id="trace product"),
-    ,
-)
-@given(data=st.data())
-def test_einsum_gufunc_shapes(gufunc_sig, data):
-    arrays, result_shape = data.draw(
-        gufunc_arrays(
-            nps.mutually_broadcastable_shapes(signature=gufunc_sig),
-            dtype="float64",
-            elements=st.floats(0, 1000),
-        ),
-        label="arrays, result_shape",
-    )
-    out = np.einsum(gufunc_sig_to_einsum_sig(gufunc_sig), *arrays)
-    assert out.shape == result_shape

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_import.py Deleted

@@ -1,38 +0,0 @@
-# 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/.
-
-SHOULD_NOT_IMPORT_NUMPY = """
-import sys
-from hypothesis import given, strategies as st
-
-@given(st.integers() | st.floats() | st.sampled_from("a", "b"))
-def test_no_numpy_import(x):
-    assert "numpy" not in sys.modules
-"""
-
-
-def test_hypothesis_is_not_the_first_to_import_numpy(testdir):
-    # We only import numpy if the user did so first.
-    result = testdir.runpytest(testdir.makepyfile(SHOULD_NOT_IMPORT_NUMPY))
-    result.assert_outcomes(passed=1, failed=0)
-
-
-# We check the wildcard import works on the module level because that's the only
-# place Python actually allows us to use them.
-try:
-    from hypothesis.extra.numpy import *  # noqa: F401, F403
-
-    star_import_works = True
-except AttributeError:
-    star_import_works = False
-
-
-def test_wildcard_import():
-    assert star_import_works

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_narrow_floats.py Deleted

@@ -1,53 +0,0 @@
-# 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 numpy as np
-import pytest
-
-from hypothesis import given
-from hypothesis.extra.numpy import arrays, from_dtype, integer_dtypes
-from hypothesis.strategies import data, floats, integers
-
-
-@pytest.mark.parametrize("dtype", np.float16, np.float32, np.float64)
-@pytest.mark.parametrize("low", -2.0, -1.0, 0.0, 1.0)
-@given(data())
-def test_bad_float_exclude_min_in_array(dtype, low, data):
-    elements = floats(
-        low, low + 1, exclude_min=True, width=np.dtype(dtype).itemsize * 8
-    )
-    x = data.draw(arrays(dtype, shape=(1,), elements=elements), label="x")
-    assert np.all(low < x)
-
-
-@given(floats(width=32))
-def test_float32_exactly_representable(x):
-    clipped = np.dtype("float32").type(x)
-    if np.isnan(x):
-        assert np.isnan(clipped)
-    else:
-        assert x == float(clipped)
-
-
-@given(floats(width=16))
-def test_float16_exactly_representable(x):
-    clipped = np.dtype("float16").type(x)
-    if np.isnan(x):
-        assert np.isnan(clipped)
-    else:
-        assert x == float(clipped)
-
-
-@given(data=data(), dtype=integer_dtypes())
-def test_floor_ceil_lossless(data, dtype):
-    # Regression test for issue #1667; ceil converting numpy integers
-    # to float and back to int with loss of exact value.
-    x = data.draw(from_dtype(dtype))
-    assert data.draw(integers(x, x)) == x

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_randomness.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/numpy/test_sampled_from.py Deleted

@@ -1,34 +0,0 @@
-# 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/.
-
-from hypothesis import given
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra import numpy as npst
-from hypothesis.strategies import data, sampled_from
-
-from tests.common.utils import fails_with
-
-
-@given(
-    data(), npst.arrays(dtype=npst.scalar_dtypes(), shape=npst.array_shapes(max_dims=1))
-)
-def test_can_sample_1D_numpy_array_without_warning(data, arr):
-    data.draw(sampled_from(arr))
-
-
-@fails_with(InvalidArgument)
-@given(
-    data(),
-    npst.arrays(
-        dtype=npst.scalar_dtypes(), shape=npst.array_shapes(min_dims=2, max_dims=5)
-    ),
-)
-def test_sampling_multi_dimensional_arrays_is_deprecated(data, arr):
-    data.draw(sampled_from(arr))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas/helpers.py Deleted

@@ -1,33 +0,0 @@
-# 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 numpy as np
-
-PANDAS_TIME_DTYPES = tuple(map(np.dtype, "<M8ns", "<m8ns", ">M8ns", ">m8ns"))
-
-
-def supported_by_pandas(dtype):
-    """Checks whether the dtype is one that can be correctly handled by
-    Pandas."""
-    # Pandas does not support non-native byte orders and things go amusingly
-    # wrong in weird places if you try to use them. See
-    # https://pandas.pydata.org/pandas-docs/stable/gotchas.html#byte-ordering-issues
-    if dtype.byteorder not in ("|", "="):
-        return False
-
-    # Pandas only supports a limited range of timedelta and datetime dtypes
-    # compared to the full range that numpy supports and will convert
-    # everything to those types (possibly increasing precision in the course of
-    # doing so, which can cause problems if this results in something which
-    # does not fit into the desired word type. As a result we want to filter
-    # out any timedelta or datetime dtypes that are not of the desired types.
-    if dtype.kind in ("m", "M"):
-        return dtype in PANDAS_TIME_DTYPES
-    return True

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas/test_argument_validation.py Deleted

@@ -1,99 +0,0 @@
-# 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/.
-
-from datetime import datetime
-
-import pandas as pd
-
-from hypothesis import given, strategies as st
-from hypothesis.extra import pandas as pdst
-
-from tests.common.arguments import argument_validation_test, e
-from tests.common.utils import checks_deprecated_behaviour
-
-BAD_ARGS = 
-    e(pdst.data_frames),
-    e(pdst.data_frames, pdst.columns(1, dtype="not a dtype")),
-    e(pdst.data_frames, pdst.columns(1, elements="not a strategy")),
-    e(pdst.data_frames, pdst.columns()),
-    e(pdst.data_frames, , index=),
-    e(pdst.data_frames, , rows=st.fixed_dictionaries({"A": st.just(1)})),
-    e(pdst.data_frames, pdst.columns(1)),
-    e(pdst.data_frames, pdst.columns(1, dtype=float, fill=1)),
-    e(pdst.data_frames, pdst.columns(1, dtype=float, elements=1)),
-    e(pdst.data_frames, pdst.columns(1, fill=1, dtype=float)),
-    e(pdst.data_frames, pdst.columns("A", "A", dtype=float)),
-    e(pdst.data_frames, pdst.columns(1, elements=st.none(), dtype=int)),
-    e(pdst.data_frames, 1),
-    e(pdst.data_frames, 1),
-    e(pdst.data_frames, pdst.columns(1, dtype="category")),
-    e(
-        pdst.data_frames,
-        pdst.columns("A", dtype=bool),
-        rows=st.tuples(st.booleans(), st.booleans()),
-    ),
-    e(
-        pdst.data_frames,
-        pdst.columns(1, elements=st.booleans()),
-        rows=st.tuples(st.booleans()),
-    ),
-    e(pdst.data_frames, rows=st.integers(), index=pdst.range_indexes(0, 0)),
-    e(pdst.data_frames, rows=st.integers(), index=pdst.range_indexes(1, 1)),
-    e(pdst.data_frames, pdst.columns(1, dtype=int), rows=st.integers()),
-    e(
-        pdst.data_frames,
-        columns=pdst.columns("a", "b", dtype=str, elements=st.text()),
-        rows=st.just({"a": "x"}),
-        index=pdst.indexes(dtype=int, min_size=1),
-    ),
-    e(
-        pdst.data_frames,
-        columns=pdst.columns("a", "b", dtype=str, elements=st.text()),
-        rows=st.just("x"),
-        index=pdst.indexes(dtype=int, min_size=1),
-    ),
-    e(pdst.indexes),
-    e(pdst.indexes, dtype="category"),
-    e(pdst.indexes, dtype="not a dtype"),
-    e(pdst.indexes, elements="not a strategy"),
-    e(pdst.indexes, elements=st.text(), dtype=float),
-    e(pdst.indexes, elements=st.none(), dtype=int),
-    e(pdst.indexes, dtype=int, max_size=0, min_size=1),
-    e(pdst.indexes, dtype=int, unique="true"),
-    e(pdst.indexes, dtype=int, min_size="0"),
-    e(pdst.indexes, dtype=int, max_size="1"),
-    e(pdst.range_indexes, 1, 0),
-    e(pdst.range_indexes, min_size="0"),
-    e(pdst.range_indexes, max_size="1"),
-    e(pdst.series),
-    e(pdst.series, dtype="not a dtype"),
-    e(pdst.series, elements="not a strategy"),
-    e(pdst.series, elements=st.none(), dtype=int),
-    e(pdst.series, dtype="category"),
-    e(pdst.series, index="not a strategy"),
-
-
-
-test_raise_invalid_argument = argument_validation_test(BAD_ARGS)
-
-lo, hi = pd.Timestamp(2017, 1, 1), pd.Timestamp(2084, 12, 21)
-
-
-@given(st.datetimes(min_value=lo, max_value=hi))
-def test_timestamp_as_datetime_bounds(dt):
-    # Would have caught https://github.com/HypothesisWorks/hypothesis/issues/2406
-    assert isinstance(dt, datetime)
-    assert lo <= dt <= hi
-    assert not isinstance(dt, pd.Timestamp)
-
-
-@checks_deprecated_behaviour
-def test_confusing_object_dtype_aliases():
-    pdst.series(elements=st.tuples(st.integers()), dtype=tuple).example()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas/test_data_frame.py Deleted

@@ -1,259 +0,0 @@
-# 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 numpy as np
-import pytest
-
-from hypothesis import HealthCheck, given, reject, settings, strategies as st
-from hypothesis.extra import numpy as npst, pandas as pdst
-
-from tests.common.debug import find_any
-from tests.pandas.helpers import supported_by_pandas
-
-
-@given(pdst.data_frames(pdst.column("a", dtype=int), pdst.column("b", dtype=float)))
-def test_can_have_columns_of_distinct_types(df):
-    assert df"a".dtype == np.dtype(int)
-    assert df"b".dtype == np.dtype(float)
-
-
-@given(
-    pdst.data_frames(
-        pdst.column(dtype=int), index=pdst.range_indexes(min_size=1, max_size=5)
-    )
-)
-def test_respects_size_bounds(df):
-    assert 1 <= len(df) <= 5
-
-
-@given(pdst.data_frames(pdst.columns("A", "B", dtype=float)))
-def test_can_specify_just_column_names(df):
-    df"A"
-    df"B"
-
-
-@given(pdst.data_frames(pdst.columns(2, dtype=float)))
-def test_can_specify_just_column_count(df):
-    df0
-    df1
-
-
-@given(
-    pdst.data_frames(
-        rows=st.fixed_dictionaries({"A": st.integers(1, 10), "B": st.floats()})
-    )
-)
-def test_gets_the_correct_data_shape_for_just_rows(table):
-    assert table"A".dtype == np.dtype("int64")
-    assert table"B".dtype == np.dtype(float)
-
-
-@given(
-    pdst.data_frames(
-        columns=pdst.columns("A", "B", dtype=int),
-        rows=st.lists(st.integers(0, 1000), min_size=2, max_size=2).map(sorted),
-    )
-)
-def test_can_specify_both_rows_and_columns_list(d):
-    assert d"A".dtype == np.dtype(int)
-    assert d"B".dtype == np.dtype(int)
-    for _, r in d.iterrows():
-        assert r"A" <= r"B"
-
-
-@given(
-    pdst.data_frames(
-        columns=pdst.columns("A", "B", dtype=int),
-        rows=st.lists(st.integers(0, 1000), min_size=2, max_size=2)
-        .map(sorted)
-        .map(tuple),
-    )
-)
-def test_can_specify_both_rows_and_columns_tuple(d):
-    assert d"A".dtype == np.dtype(int)
-    assert d"B".dtype == np.dtype(int)
-    for _, r in d.iterrows():
-        assert r"A" <= r"B"
-
-
-@given(
-    pdst.data_frames(
-        columns=pdst.columns("A", "B", dtype=int),
-        rows=st.lists(st.integers(0, 1000), min_size=2, max_size=2).map(
-            lambda x: {"A": min(x), "B": max(x)}
-        ),
-    )
-)
-def test_can_specify_both_rows_and_columns_dict(d):
-    assert d"A".dtype == np.dtype(int)
-    assert d"B".dtype == np.dtype(int)
-    for _, r in d.iterrows():
-        assert r"A" <= r"B"
-
-
-@given(
-    pdst.data_frames(
-        
-            pdst.column(
-                "A",
-                fill=st.just(np.nan),
-                dtype=float,
-                elements=st.floats(allow_nan=False),
-            )
-        ,
-        rows=st.builds(dict),
-    )
-)
-def test_can_fill_in_missing_elements_from_dict(df):
-    assert np.isnan(df"A").all()
-
-
-@st.composite
-def column_strategy(draw):
-    name = draw(st.none() | st.text())
-    dtype = draw(npst.scalar_dtypes().filter(supported_by_pandas))
-    pass_dtype = not draw(st.booleans())
-    if pass_dtype:
-        pass_elements = not draw(st.booleans())
-    else:
-        pass_elements = True
-    if pass_elements:
-        elements = npst.from_dtype(dtype)
-    else:
-        elements = None
-
-    unique = draw(st.booleans())
-    fill = st.nothing() if draw(st.booleans()) else None
-
-    return pdst.column(
-        name=name, dtype=dtype, unique=unique, fill=fill, elements=elements
-    )
-
-
-@given(pdst.data_frames(pdst.columns(1, dtype=np.dtype("<M8ns"))))
-def test_data_frames_with_timestamp_columns(df):
-    pass
-
-
-@given(
-    pdst.data_frames(
-        pdst.columns("A", dtype=float, fill=st.just(np.nan), unique=True)
-    )
-)
-def test_unique_column_with_fill(df):
-    assert len(set(df"A")) == len(df"A")
-
-
-@settings(suppress_health_check=HealthCheck.too_slow)
-@given(st.data())
-def test_arbitrary_data_frames(data):
-    columns = data.draw(
-        st.lists(
-            column_strategy(),
-            unique_by=lambda c: c.name if c.name is not None else np.nan,
-        )
-    )
-
-    try:
-        # Use raw data to work around pandas bug in repr. See
-        # https://github.com/pandas-dev/pandas/issues/27484
-        df = data.conjecture_data.draw(pdst.data_frames(columns))
-    except Exception as e:
-        if type(e).__name__ == "OutOfBoundsDatetime":
-            # See https://github.com/HypothesisWorks/hypothesis-python/pull/826
-            reject()
-        else:
-            raise
-    data_frame_columns = list(df)
-
-    assert len(data_frame_columns) == len(columns)
-
-    for i, (c, n) in enumerate(zip(columns, df)):
-        if c.name is None:
-            assert n == i
-        else:
-            assert c.name == n
-
-    for i, c in enumerate(columns):
-        column_name = data_frame_columnsi
-        values = dfcolumn_name
-        if c.unique:
-            assert len(set(values)) == len(values)
-
-
-@given(
-    pdst.data_frames(
-        pdst.columns("A", unique=True, dtype=int), rows=st.tuples(st.integers(0, 10))
-    )
-)
-def test_can_specify_unique_with_rows(df):
-    column = df"A"
-    assert len(set(column)) == len(column)
-
-
-def test_uniqueness_does_not_affect_other_rows_1():
-    data_frames = pdst.data_frames(
-        
-            pdst.column("A", dtype=int, unique=True),
-            pdst.column("B", dtype=int, unique=False),
-        ,
-        rows=st.tuples(st.integers(0, 10), st.integers(0, 10)),
-        index=pdst.range_indexes(2, 2),
-    )
-    find_any(data_frames, lambda x: x"B"0 == x"B"1)
-
-
-def test_uniqueness_does_not_affect_other_rows_2():
-    data_frames = pdst.data_frames(
-        
-            pdst.column("A", dtype=bool, unique=False),
-            pdst.column("B", dtype=int, unique=True),
-        ,
-        rows=st.tuples(st.booleans(), st.integers(0, 10)),
-        index=pdst.range_indexes(2, 2),
-    )
-    find_any(data_frames, lambda x: x"A"0 == x"A"1)
-
-
-@given(
-    pdst.data_frames(pdst.columns("A", dtype=int, fill=st.just(7)), rows=st.tuples())
-)
-def test_will_fill_missing_columns_in_tuple_row(df):
-    for d in df"A":
-        assert d == 7
-
-
-@settings(suppress_health_check=HealthCheck.filter_too_much)
-@given(
-    pdst.data_frames(
-        index=pdst.range_indexes(10, 10),
-        columns=pdst.column(elements=st.integers(0, 9), fill=None, unique=True),
-    )
-)
-def test_can_generate_unique_columns(df):
-    assert set(df0) == set(range(10))
-
-
-@pytest.mark.skip(reason="Just works on Pandas 1.4, though the changelog is silent")
-@pytest.mark.parametrize("dtype", None, object)
-def test_expected_failure_from_omitted_object_dtype(dtype):
-    # See https://github.com/HypothesisWorks/hypothesis/issues/3133
-    col = pdst.column(elements=st.sets(st.text(), min_size=1), dtype=dtype)
-
-    @given(pdst.data_frames(columns=col))
-    def works_with_object_dtype(df):
-        pass
-
-    if dtype is object:
-        works_with_object_dtype()
-    else:
-        assert dtype is None
-        with pytest.raises(ValueError, match="Maybe passing dtype=object would help"):
-            works_with_object_dtype()

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas/test_indexes.py Deleted

@@ -1,122 +0,0 @@
-# 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 numpy as np
-import pandas
-import pytest
-
-from hypothesis import HealthCheck, given, reject, settings, strategies as st
-from hypothesis.errors import Unsatisfiable
-from hypothesis.extra import numpy as npst, pandas as pdst
-
-from tests.pandas.helpers import supported_by_pandas
-
-
-@given(pdst.indexes(dtype=int, max_size=0))
-def test_gets_right_dtype_for_empty_indices(ix):
-    assert ix.dtype == np.dtype("int64")
-
-
-@given(pdst.indexes(elements=st.integers(0, 2**63 - 1), max_size=0))
-def test_gets_right_dtype_for_empty_indices_with_elements(ix):
-    assert ix.dtype == np.dtype("int64")
-
-
-def test_does_not_generate_impossible_conditions():
-    with pytest.raises(Unsatisfiable):
-        pdst.indexes(min_size=3, max_size=3, dtype=bool).example()
-
-
-@given(pdst.indexes(dtype=bool, unique=True))
-def test_unique_indexes_of_small_values(ix):
-    assert len(ix) <= 2
-    assert len(set(ix)) == len(ix)
-
-
-@given(pdst.indexes(dtype=bool, min_size=2, unique=True))
-def test_unique_indexes_of_many_small_values(ix):
-    assert len(ix) == 2
-    assert len(set(ix)) == len(ix)
-
-
-@given(pdst.indexes(dtype="int8", name=st.just("test_name")))
-def test_name_passed_on(s):
-    assert s.name == "test_name"
-
-
-# Sizes that fit into an int64 without overflow
-range_sizes = st.integers(0, 2**63 - 1)
-
-
-@given(range_sizes, range_sizes | st.none(), st.data())
-def test_arbitrary_range_index(i, j, data):
-    if j is not None:
-        i, j = sorted((i, j))
-    data.draw(pdst.range_indexes(i, j))
-
-
-@given(pdst.range_indexes())
-def test_basic_range_indexes(ix):
-    assert isinstance(ix, pandas.RangeIndex)
-
-
-@settings(suppress_health_check=HealthCheck.too_slow)
-@given(st.data())
-def test_generate_arbitrary_indices(data):
-    min_size = data.draw(st.integers(0, 10), "min_size")
-    max_size = data.draw(st.none() | st.integers(min_size, min_size + 10), "max_size")
-    unique = data.draw(st.booleans(), "unique")
-    dtype = data.draw(
-        st.one_of(
-            npst.boolean_dtypes(),
-            npst.integer_dtypes(endianness="="),
-            npst.floating_dtypes(endianness="="),
-            npst.complex_number_dtypes(endianness="="),
-            npst.datetime64_dtypes(endianness="="),
-            npst.timedelta64_dtypes(endianness="="),
-        ).filter(supported_by_pandas),
-        "dtype",
-    )
-    pass_elements = data.draw(st.booleans(), "pass_elements")
-
-    converted_dtype = pandas.Index(, dtype=dtype).dtype
-
-    try:
-        inferred_dtype = pandas.Index(data.draw(npst.from_dtype(dtype))).dtype
-
-        if pass_elements:
-            elements = npst.from_dtype(dtype)
-            dtype = None
-        else:
-            elements = None
-
-        index = data.draw(
-            pdst.indexes(
-                elements=elements,
-                dtype=dtype,
-                min_size=min_size,
-                max_size=max_size,
-                unique=unique,
-            )
-        )
-
-    except Exception as e:
-        if type(e).__name__ == "OutOfBoundsDatetime":
-            # See https://github.com/HypothesisWorks/hypothesis-python/pull/826
-            reject()
-        else:
-            raise
-    if dtype is None:
-        assert index.dtype == inferred_dtype
-    else:
-        assert index.dtype == converted_dtype
-
-    if unique:
-        assert len(set(index.values)) == len(index)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pandas/test_series.py Deleted

@@ -1,63 +0,0 @@
-# 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 numpy as np
-import pandas
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.extra import numpy as npst, pandas as pdst
-
-from tests.common.debug import find_any
-from tests.pandas.helpers import supported_by_pandas
-
-
-@given(st.data())
-def test_can_create_a_series_of_any_dtype(data):
-    dtype = np.dtype(data.draw(npst.scalar_dtypes()))
-    assume(supported_by_pandas(dtype))
-    # Use raw data to work around pandas bug in repr. See
-    # https://github.com/pandas-dev/pandas/issues/27484
-    series = data.conjecture_data.draw(pdst.series(dtype=dtype))
-    assert series.dtype == pandas.Series(, dtype=dtype).dtype
-
-
-@given(pdst.series(dtype=float, index=pdst.range_indexes(min_size=2, max_size=5)))
-def test_series_respects_size_bounds(s):
-    assert 2 <= len(s) <= 5
-
-
-def test_can_fill_series():
-    nan_backed = pdst.series(elements=st.floats(allow_nan=False), fill=st.just(np.nan))
-    find_any(nan_backed, lambda x: np.isnan(x).any())
-
-
-@given(pdst.series(dtype=int))
-def test_can_generate_integral_series(s):
-    assert s.dtype == np.dtype(int)
-
-
-@given(pdst.series(elements=st.integers(0, 10)))
-def test_will_use_dtype_of_elements(s):
-    assert s.dtype == np.dtype("int64")
-
-
-@given(pdst.series(elements=st.floats(allow_nan=False)))
-def test_will_use_a_provided_elements_strategy(s):
-    assert not np.isnan(s).any()
-
-
-@given(pdst.series(dtype="int8", unique=True))
-def test_unique_series_are_unique(s):
-    assert len(s) == len(set(s))
-
-
-@given(pdst.series(dtype="int8", name=st.just("test_name")))
-def test_name_passed_on(s):
-    assert s.name == "test_name"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_capture.py Deleted

@@ -1,120 +0,0 @@
-# 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 sys
-
-import pytest
-
-from hypothesis.internal.compat import PYPY, WINDOWS, escape_unicode_characters
-
-pytest_plugins = "pytester"
-
-TESTSUITE = """
-from hypothesis import given, settings, Verbosity
-from hypothesis.strategies import integers
-
-@settings(verbosity=Verbosity.verbose)
-@given(integers())
-def test_should_be_verbose(x):
-    pass
-
-"""
-
-
-@pytest.mark.parametrize("capture,expected", ("no", True), ("fd", False))
-def test_output_without_capture(testdir, capture, expected):
-    script = testdir.makepyfile(TESTSUITE)
-    result = testdir.runpytest(script, "--verbose", "--capture", capture)
-    out = "\n".join(result.stdout.lines)
-    assert "test_should_be_verbose" in out
-    assert ("Trying example" in out) == expected
-    assert result.ret == 0
-
-
-UNICODE_EMITTING = """
-import pytest
-from hypothesis import given, settings, Verbosity
-from hypothesis.strategies import text
-import sys
-
-def test_emits_unicode():
-    @settings(verbosity=Verbosity.verbose)
-    @given(text())
-    def test_should_emit_unicode(t):
-        assert all(ord(c) <= 1000 for c in t), ascii(t)
-    with pytest.raises(AssertionError):
-        test_should_emit_unicode()
-"""
-
-
-@pytest.mark.xfail(
-    WINDOWS,
-    reason="Encoding issues in running the subprocess, possibly pytest's fault",
-    strict=False,  # It's possible, if rare, for this to pass on Windows too.
-)
-def test_output_emitting_unicode(testdir, monkeypatch):
-    monkeypatch.setenv("LC_ALL", "C")
-    monkeypatch.setenv("LANG", "C")
-    script = testdir.makepyfile(UNICODE_EMITTING)
-    result = getattr(testdir, "runpytest_subprocess", testdir.runpytest)(
-        script, "--verbose", "--capture=no"
-    )
-    out = "\n".join(result.stdout.lines)
-    assert "test_emits_unicode" in out
-    assert chr(1001) in out or escape_unicode_characters(chr(1001)) in out
-    assert result.ret == 0
-
-
-def get_line_num(token, result, skip_n=0):
-    skipped = 0
-    for i, line in enumerate(result.stdout.lines):
-        if token in line:
-            if skip_n == skipped:
-                return i
-            else:
-                skipped += 1
-    raise AssertionError(
-        f"Token {token!r} not found (skipped {skipped} of planned {skip_n} skips)"
-    )
-
-
-TRACEBACKHIDE_HEALTHCHECK = """
-from hypothesis import given, settings
-from hypothesis.strategies import integers
-import time
-@given(integers().map(lambda x: time.sleep(0.2)))
-def test_healthcheck_traceback_is_hidden(x):
-    pass
-"""
-
-
-def test_healthcheck_traceback_is_hidden(testdir):
-    script = testdir.makepyfile(TRACEBACKHIDE_HEALTHCHECK)
-    result = testdir.runpytest(script, "--verbose")
-    def_token = "__ test_healthcheck_traceback_is_hidden __"
-    timeout_token = ": FailedHealthCheck"
-    def_line = get_line_num(def_token, result)
-    timeout_line = get_line_num(timeout_token, result)
-    seven_min = (3, 9) if PYPY else (3, 8)
-    expected = 6 if sys.version_info:2 < seven_min else 7
-    assert timeout_line - def_line == expected
-
-
-COMPOSITE_IS_NOT_A_TEST = """
-from hypothesis.strategies import composite
-@composite
-def test_data_factory(draw):
-    pass
-"""
-
-
-def test_deprecation_of_strategies_as_tests(testdir):
-    script = testdir.makepyfile(COMPOSITE_IS_NOT_A_TEST)
-    testdir.runpytest(script).assert_outcomes(failed=1)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_checks.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_compat.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_doctest.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_fixtures.py Deleted

@@ -1,212 +0,0 @@
-# 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/.
-
-from unittest.mock import Mock, create_autospec
-
-import pytest
-
-from hypothesis import example, given
-from hypothesis.strategies import integers
-
-from tests.common.utils import fails
-
-pytest_plugins = "pytester"
-
-
-@pytest.fixture(scope="session")
-def infinity():
-    return float("inf")
-
-
-@pytest.fixture(scope="module")
-def mock_fixture():
-    return Mock()
-
-
-@pytest.fixture(scope="module")
-def spec_fixture():
-    class Foo:
-        def __init__(self):
-            pass
-
-        def bar(self):
-            return "baz"
-
-    return create_autospec(Foo)
-
-
-@given(integers())
-def test_can_mix_fixture_and_positional_strategy(infinity, xs):
-    # Hypothesis fills arguments from the right, so if @given() uses
-    # positional arguments then any strategies need to be on the right.
-    assert xs <= infinity
-
-
-@given(xs=integers())
-def test_can_mix_fixture_and_keyword_strategy(xs, infinity):
-    assert xs <= infinity
-
-
-@example(xs=0)
-@given(xs=integers())
-def test_can_mix_fixture_example_and_keyword_strategy(xs, infinity):
-    assert xs <= infinity
-
-
-@fails
-@given(integers())
-def test_can_inject_mock_via_fixture(mock_fixture, xs):
-    """A negative test is better for this one - this condition uncovers a bug
-    whereby the mock fixture is executed instead of the test body and always
-    succeeds. If this test fails, then we know we've run the test body instead
-    of the mock.
-    """
-    raise AssertionError
-
-
-@given(integers())
-def test_can_inject_autospecced_mock_via_fixture(spec_fixture, xs):
-    spec_fixture.bar.return_value = float("inf")
-    assert xs <= spec_fixture.bar()
-
-
-TESTSUITE = """
-import pytest
-from hypothesis import given, strategies as st
-
-@pytest.fixture(scope="function", autouse=True)
-def autofix(request):
-    pass
-
-@given(x=st.integers())
-def test_requests_function_scoped_fixture(capsys, x):
-    pass
-
-@pytest.mark.parametrize("percent", "%", "%s")
-@given(x=st.integers())
-def test_requests_function_scoped_fixture_percent_parametrized(capsys, x, percent):
-    # See https://github.com/HypothesisWorks/hypothesis/issues/2469
-    pass
-
-class TestClass:
-    @given(x=st.integers())
-    def test_requests_method_scoped_fixture(capsys, x):
-        pass
-
-@given(x=st.integers())
-def test_autouse_function_scoped_fixture(x):
-    pass
-"""
-
-
-def test_given_plus_function_scoped_non_autouse_fixtures_are_deprecated(testdir):
-    script = testdir.makepyfile(TESTSUITE)
-    testdir.runpytest(script).assert_outcomes(passed=1, failed=4)
-
-
-CONFTEST_SUPPRESS = """
-from hypothesis import HealthCheck, settings
-
-settings.register_profile(
-    "suppress",
-    suppress_health_check=HealthCheck.function_scoped_fixture,
-)
-"""
-
-
-def test_suppress_fixture_health_check_via_profile(testdir):
-    script = testdir.makepyfile(TESTSUITE)
-    testdir.makeconftest(CONFTEST_SUPPRESS)
-
-    testdir.runpytest(script).assert_outcomes(passed=1, failed=4)
-    testdir.runpytest(script, "--hypothesis-profile=suppress").assert_outcomes(passed=5)
-
-
-TESTSCRIPT_SUPPRESS_FIXTURE = """
-import pytest
-from hypothesis import HealthCheck, given, settings, strategies as st
-
-@given(x=st.integers())
-def test_fails_health_check(capsys, x):
-    pass
-
-@settings(suppress_health_check=HealthCheck.function_scoped_fixture)
-@given(x=st.integers())
-def test_suppresses_health_check(capsys, x):
-    pass
-
-@given(x=st.integers())
-@settings(suppress_health_check=HealthCheck.function_scoped_fixture)
-def test_suppresses_health_check_2(capsys, x):
-    pass
-"""
-
-
-def test_suppress_health_check_function_scoped_fixture(testdir):
-    script = testdir.makepyfile(TESTSCRIPT_SUPPRESS_FIXTURE)
-    testdir.runpytest(script).assert_outcomes(passed=2, failed=1)
-
-
-TESTSCRIPT_OVERRIDE_FIXTURE = """
-import pytest
-from hypothesis import given, strategies as st
-
-@pytest.fixture(scope="function", name="event_loop")
-def event_loop_1():
-    return
-
-@pytest.fixture(scope="module", name="event_loop")
-def event_loop_2():
-    return
-
-@given(x=st.integers())
-def test_override_fixture(event_loop, x):
-    pass
-"""
-
-
-def test_given_plus_overridden_fixture(testdir):
-    script = testdir.makepyfile(TESTSCRIPT_OVERRIDE_FIXTURE)
-    testdir.runpytest(script, "-Werror").assert_outcomes(passed=1, failed=0)
-
-
-TESTSCRIPT_FIXTURE_THEN_GIVEN = """
-import pytest
-from hypothesis import given, strategies as st
-
-@given(x=st.integers())
-@pytest.fixture()
-def test(x):
-    pass
-"""
-
-
-def test_given_fails_if_already_decorated_with_fixture(testdir):
-    script = testdir.makepyfile(TESTSCRIPT_FIXTURE_THEN_GIVEN)
-    testdir.runpytest(script).assert_outcomes(failed=1)
-
-
-TESTSCRIPT_GIVEN_THEN_FIXTURE = """
-import pytest
-from hypothesis import given, strategies as st
-
-@pytest.fixture()
-@given(x=st.integers())
-def test(x):
-    pass
-"""
-
-
-def test_fixture_errors_if_already_decorated_with_given(testdir):
-    script = testdir.makepyfile(TESTSCRIPT_GIVEN_THEN_FIXTURE)
-    if int(pytest.__version__.split(".")0) > 5:
-        testdir.runpytest(script).assert_outcomes(errors=1)
-    else:
-        testdir.runpytest(script).assert_outcomes(error=1)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_junit.py Deleted

@@ -1,73 +0,0 @@
-# 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 xml.etree.ElementTree as ET
-from pathlib import Path
-
-pytest_plugins = "pytester"
-
-
-TESTSUITE = """
-from hypothesis import given
-from hypothesis.strategies import integers
-
-@given(integers())
-def test_valid(x):
-    assert x == x
-
-@given(integers())
-def test_invalid(x):
-    assert x != x
-"""
-
-
-def _run_and_get_junit(testdir, *args):
-    script = testdir.makepyfile(TESTSUITE)
-    testdir.runpytest(script, "--junit-xml=out.xml", *args)
-    return ET.parse(Path(testdir.tmpdir) / "out.xml").getroot()
-
-
-def _findall_from_root(junit_xml, path):
-    if junit_xml.tag == "testsuites":
-        return junit_xml.findall(f"./testsuite/{path}")
-    # This case only exists for tests against Pytest before 5.1.0;
-    # see https://github.com/pytest-dev/pytest/commit/a43ba78d3bde
-    return junit_xml.findall(f"./{path}")
-
-
-def suite_properties_ok(junit_xml):
-    # Check whether <properties> is included in <testsuite>.  This is currently not
-    # the case when using pytest-xdist, which is a shame, but we can live with it.
-    testsuite_props = _findall_from_root(junit_xml, "properties")
-    return len(testsuite_props) == 1 and {
-        prop.get("name") for prop in testsuite_props0.findall("property")
-    } == {
-        "hypothesis-statistics-test_outputs_valid_xunit2.py::test_valid",
-        "hypothesis-statistics-test_outputs_valid_xunit2.py::test_invalid",
-    }
-
-
-def test_outputs_valid_xunit2(testdir):
-    # The thing we really care about with pytest-xdist + junitxml is that we don't
-    # break xunit2 compatibility by putting <properties> inside <testcase>.
-    junit_xml = _run_and_get_junit(testdir)
-    testcase_props = _findall_from_root(junit_xml, "testcase/properties")
-    assert len(testcase_props) == 0
-    # Check whether <properties> is included in <testsuite>
-    assert suite_properties_ok(junit_xml)
-
-
-def test_outputs_valid_xunit2_with_xdist(testdir):
-    junit_xml = _run_and_get_junit(testdir, "-n2")
-    testcase_props = _findall_from_root(junit_xml, "testcase/properties")
-    assert len(testcase_props) == 0
-    # If <properties> is included in <testsuite>, this assertion will fail.
-    # That would be a GOOD THING, and we would remove the `not` to prevent regressions.
-    assert not suite_properties_ok(junit_xml)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_mark.py Deleted

@@ -1,57 +0,0 @@
-# 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/.
-
-pytest_plugins = "pytester"
-
-
-TESTSUITE = """
-from hypothesis import given
-from hypothesis.strategies import integers
-
-@given(integers())
-def test_foo(x):
-    pass
-
-def test_bar():
-    pass
-"""
-
-
-def test_can_select_mark(testdir):
-    script = testdir.makepyfile(TESTSUITE)
-    result = testdir.runpytest(
-        script, "--verbose", "--strict-markers", "-m", "hypothesis"
-    )
-    out = "\n".join(result.stdout.lines)
-    assert "1 passed, 1 deselected" in out
-
-
-UNITTEST_TESTSUITE = """
-from hypothesis import given
-from hypothesis.strategies import integers
-from unittest import TestCase
-
-class TestStuff(TestCase):
-    @given(integers())
-    def test_foo(self, x):
-        pass
-
-    def test_bar(self):
-        pass
-"""
-
-
-def test_can_select_mark_on_unittest(testdir):
-    script = testdir.makepyfile(UNITTEST_TESTSUITE)
-    result = testdir.runpytest(
-        script, "--verbose", "--strict-markers", "-m", "hypothesis"
-    )
-    out = "\n".join(result.stdout.lines)
-    assert "1 passed, 1 deselected" in out

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_parametrized_db_keys.py Deleted

@@ -1,35 +0,0 @@
-# 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/.
-
-DB_KEY_TESTCASE = """
-from hypothesis import settings, given
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.strategies import booleans
-import pytest
-
-DB = InMemoryExampleDatabase()
-
-
-@settings(database=DB)
-@given(booleans())
-@pytest.mark.parametrize("hi", (1, 2, 3))
-@pytest.mark.xfail()
-def test_dummy_for_parametrized_db_keys(hi, i):
-    assert Fail  # Test *must* fail for it to end up the database anyway
-
-
-def test_DB_keys_for_parametrized_test():
-    assert len(DB.data) == 6
-"""
-
-
-def test_db_keys_for_parametrized_tests_are_unique(testdir):
-    script = testdir.makepyfile(DB_KEY_TESTCASE)
-    testdir.runpytest(script).assert_outcomes(xfailed=3, passed=1)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_profiles.py Deleted

@@ -1,53 +0,0 @@
-# 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 pytest
-from _hypothesis_pytestplugin import LOAD_PROFILE_OPTION
-
-from hypothesis.version import __version__
-
-pytest_plugins = "pytester"
-
-
-CONFTEST = """
-from hypothesis._settings import settings
-settings.register_profile("test", settings(max_examples=1))
-"""
-
-TESTSUITE = """
-from hypothesis import given
-from hypothesis.strategies import integers
-from hypothesis._settings import settings
-
-def test_this_one_is_ok():
-    assert settings().max_examples == 1
-"""
-
-
-def test_does_not_run_reporting_hook_by_default(testdir):
-    script = testdir.makepyfile(TESTSUITE)
-    testdir.makeconftest(CONFTEST)
-    result = testdir.runpytest(script, LOAD_PROFILE_OPTION, "test")
-    out = "\n".join(result.stdout.lines)
-    assert "1 passed" in out
-    assert "hypothesis profile" not in out
-    assert __version__ in out
-
-
-@pytest.mark.parametrize("option", "-v", "--hypothesis-verbosity=verbose")
-def test_runs_reporting_hook_in_any_verbose_mode(testdir, option):
-    script = testdir.makepyfile(TESTSUITE)
-    testdir.makeconftest(CONFTEST)
-    result = testdir.runpytest(script, LOAD_PROFILE_OPTION, "test", option)
-    out = "\n".join(result.stdout.lines)
-    assert "1 passed" in out
-    assert "max_examples=1" in out
-    assert "hypothesis profile" in out
-    assert __version__ in out

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_pytest_detection.py Deleted

@@ -1,43 +0,0 @@
-# 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 subprocess
-import sys
-
-from hypothesis import core as core
-
-
-def test_is_running_under_pytest():
-    assert core.running_under_pytest
-
-
-FILE_TO_RUN = """
-import hypothesis.core as core
-assert not core.running_under_pytest
-"""
-
-
-def test_is_not_running_under_pytest(tmpdir):
-    pyfile = tmpdir.join("test.py")
-    pyfile.write(FILE_TO_RUN)
-    subprocess.check_call(sys.executable, str(pyfile))
-
-
-DOES_NOT_IMPORT_HYPOTHESIS = """
-import sys
-
-def test_pytest_plugin_does_not_import_hypothesis():
-    assert "hypothesis" not in sys.modules
-"""
-
-
-def test_plugin_does_not_import_pytest(testdir):
-    testdir.makepyfile(DOES_NOT_IMPORT_HYPOTHESIS)
-    testdir.runpytest_subprocess().assert_outcomes(passed=1)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_reporting.py Deleted

@@ -1,35 +0,0 @@
-# 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/.
-
-pytest_plugins = "pytester"
-
-
-TESTSUITE = """
-from hypothesis import given
-from hypothesis.strategies import lists, integers
-
-@given(integers())
-def test_this_one_is_ok(x):
-    pass
-
-@given(lists(integers()))
-def test_hi(xs):
-    assert False
-"""
-
-
-def test_runs_reporting_hook(testdir):
-    script = testdir.makepyfile(TESTSUITE)
-    result = testdir.runpytest(script, "--verbose")
-    out = "\n".join(result.stdout.lines)
-    assert "test_this_one_is_ok" in out
-    assert "Captured stdout call" not in out
-    assert "Falsifying example" in out
-    assert result.ret != 0

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_runs.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_seeding.py Deleted

@@ -1,110 +0,0 @@
-# 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 re
-
-import pytest
-
-pytest_plugins = "pytester"
-
-
-TEST_SUITE = """
-from hypothesis import given, settings, assume
-import hypothesis.strategies as st
-
-
-first = None
-
-@settings(database=None)
-@given(st.integers())
-def test_fails_once(some_int):
-    assume(abs(some_int) > 1000)
-    global first
-    if first is None:
-        first = some_int
-
-    assert some_int != first
-"""
-
-
-CONTAINS_SEED_INSTRUCTION = re.compile(r"--hypothesis-seed=\d+", re.MULTILINE)
-
-
-@pytest.mark.parametrize("seed", 0, 42, "foo")
-def test_runs_repeatably_when_seed_is_set(seed, testdir):
-    script = testdir.makepyfile(TEST_SUITE)
-
-    results = 
-        testdir.runpytest(
-            script, "--verbose", "--strict-markers", "--hypothesis-seed", str(seed)
-        )
-        for _ in range(2)
-    
-
-    for r in results:
-        for l in r.stdout.lines:
-            assert "--hypothesis-seed" not in l
-
-    failure_lines = l for r in results for l in r.stdout.lines if "some_int=" in l
-
-    assert len(failure_lines) == 2
-    assert failure_lines0 == failure_lines1
-
-
-HEALTH_CHECK_FAILURE = """
-import os
-
-from hypothesis import given, strategies as st, assume, reject
-
-RECORD_EXAMPLES = <file>
-
-if os.path.exists(RECORD_EXAMPLES):
-    target = None
-    with open(RECORD_EXAMPLES, 'r') as i:
-        seen = set(map(int, i.read().strip().split("\\n")))
-else:
-    target = open(RECORD_EXAMPLES, 'w')
-
-@given(st.integers())
-def test_failure(i):
-    if target is None:
-        assume(i not in seen)
-    else:
-        target.write(f"{i}\\n")
-        reject()
-"""
-
-
-def test_repeats_healthcheck_when_following_seed_instruction(testdir, tmpdir):
-    health_check_test = HEALTH_CHECK_FAILURE.replace(
-        "<file>", repr(str(tmpdir.join("seen")))
-    )
-
-    script = testdir.makepyfile(health_check_test)
-
-    initial = testdir.runpytest(script, "--verbose", "--strict-markers")
-
-    match = CONTAINS_SEED_INSTRUCTION.search("\n".join(initial.stdout.lines))
-    initial_output = "\n".join(initial.stdout.lines)
-
-    match = CONTAINS_SEED_INSTRUCTION.search(initial_output)
-    assert match is not None
-
-    rerun = testdir.runpytest(script, "--verbose", "--strict-markers", match.group(0))
-    rerun_output = "\n".join(rerun.stdout.lines)
-
-    assert "FailedHealthCheck" in rerun_output
-    assert "--hypothesis-seed" not in rerun_output
-
-    rerun2 = testdir.runpytest(
-        script, "--verbose", "--strict-markers", "--hypothesis-seed=10"
-    )
-    rerun2_output = "\n".join(rerun2.stdout.lines)
-    assert "FailedHealthCheck" not in rerun2_output

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_skipping.py Deleted

@@ -1,41 +0,0 @@
-# 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/.
-
-pytest_plugins = "pytester"
-
-
-PYTEST_TESTSUITE = """
-from hypothesis import given
-from hypothesis.strategies import integers
-import pytest
-
-@given(xs=integers())
-def test_to_be_skipped(xs):
-    # We always try the simplest example first, raising a Skipped exception
-    # which we know to propagate immediately...
-    if xs == 0:
-        pytest.skip()
-    # But the pytest 3.0 internals don't have such an exception, so we keep
-    # going and raise a MultipleFailures error.  Ah well.
-    else:
-        assert xs == 0
-"""
-
-
-def test_no_falsifying_example_if_pytest_skip(testdir):
-    """If ``pytest.skip() is called during a test, Hypothesis should not
-    continue running the test and shrink process, nor should it print anything
-    about falsifying examples."""
-    script = testdir.makepyfile(PYTEST_TESTSUITE)
-    result = testdir.runpytest(
-        script, "--verbose", "--strict-markers", "-m", "hypothesis"
-    )
-    out = "\n".join(result.stdout.lines)
-    assert "Falsifying example" not in out

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/pytest/test_statistics.py Deleted

@@ -1,124 +0,0 @@
-# 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 pytest
-from _hypothesis_pytestplugin import PRINT_STATISTICS_OPTION
-
-pytest_plugins = "pytester"
-
-
-def get_output(testdir, suite, *args):
-    script = testdir.makepyfile(suite)
-    result = testdir.runpytest(script, *args)
-    return "\n".join(result.stdout.lines)
-
-
-TESTSUITE = """
-from hypothesis import HealthCheck, given, settings, assume
-from hypothesis.strategies import integers
-import time
-import warnings
-from hypothesis.errors import HypothesisDeprecationWarning
-
-warnings.simplefilter('always', HypothesisDeprecationWarning)
-
-
-@given(integers())
-def test_all_valid(x):
-    pass
-
-
-@settings(max_examples=100, suppress_health_check=HealthCheck.all())
-@given(integers())
-def test_iterations(x):
-    assume(x == 13)
-"""
-
-
-def test_does_not_run_statistics_by_default(testdir):
-    out = get_output(testdir, TESTSUITE)
-    assert "Hypothesis Statistics" not in out
-
-
-def test_prints_statistics_given_option(testdir):
-    out = get_output(testdir, TESTSUITE, PRINT_STATISTICS_OPTION)
-    assert "Hypothesis Statistics" in out
-    assert "max_examples=100" in out
-    assert "< 10% of examples satisfied assumptions" in out
-
-
-def test_prints_statistics_given_option_under_xdist(testdir):
-    out = get_output(testdir, TESTSUITE, PRINT_STATISTICS_OPTION, "-n", "2")
-    assert "Hypothesis Statistics" in out
-    assert "max_examples=100" in out
-    assert "< 10% of examples satisfied assumptions" in out
-
-
-def test_prints_statistics_given_option_with_junitxml(testdir):
-    out = get_output(testdir, TESTSUITE, PRINT_STATISTICS_OPTION, "--junit-xml=out.xml")
-    assert "Hypothesis Statistics" in out
-    assert "max_examples=100" in out
-    assert "< 10% of examples satisfied assumptions" in out
-
-
-@pytest.mark.skipif(
-    tuple(map(int, pytest.__version__.split("."):2)) < (5, 4), reason="too old"
-)
-def test_prints_statistics_given_option_under_xdist_with_junitxml(testdir):
-    out = get_output(
-        testdir, TESTSUITE, PRINT_STATISTICS_OPTION, "-n", "2", "--junit-xml=out.xml"
-    )
-    assert "Hypothesis Statistics" in out
-    assert "max_examples=100" in out
-    assert "< 10% of examples satisfied assumptions" in out
-
-
-UNITTEST_TESTSUITE = """
-
-from hypothesis import given
-from hypothesis.strategies import integers
-from unittest import TestCase
-
-
-class TestStuff(TestCase):
-    @given(integers())
-    def test_all_valid(self, x):
-        pass
-"""
-
-
-def test_prints_statistics_for_unittest_tests(testdir):
-    script = testdir.makepyfile(UNITTEST_TESTSUITE)
-    result = testdir.runpytest(script, PRINT_STATISTICS_OPTION)
-    out = "\n".join(result.stdout.lines)
-    assert "Hypothesis Statistics" in out
-    assert "TestStuff::test_all_valid" in out
-    assert "max_examples=100" in out
-
-
-STATEFUL_TESTSUITE = """
-from hypothesis.stateful import RuleBasedStateMachine, rule
-
-class Stuff(RuleBasedStateMachine):
-    @rule()
-    def step(self):
-        pass
-
-TestStuff = Stuff.TestCase
-"""
-
-
-def test_prints_statistics_for_stateful_tests(testdir):
-    script = testdir.makepyfile(STATEFUL_TESTSUITE)
-    result = testdir.runpytest(script, PRINT_STATISTICS_OPTION)
-    out = "\n".join(result.stdout.lines)
-    assert "Hypothesis Statistics" in out
-    assert "TestStuff::runTest" in out
-    assert "max_examples=100" in out

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_deferred_strategies.py Deleted

@@ -1,42 +0,0 @@
-# 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/.
-
-from hypothesis import strategies as st
-
-from tests.common.debug import minimal
-
-
-def test_large_branching_tree():
-    tree = st.deferred(lambda: st.integers() | st.tuples(tree, tree, tree, tree, tree))
-    assert minimal(tree) == 0
-    assert minimal(tree, lambda x: isinstance(x, tuple)) == (0,) * 5
-
-
-def test_non_trivial_json():
-    json = st.deferred(lambda: st.none() | st.floats() | st.text() | lists | objects)
-
-    lists = st.lists(json)
-    objects = st.dictionaries(st.text(), json)
-
-    assert minimal(json) is None
-
-    small_list = minimal(json, lambda x: isinstance(x, list) and x)
-    assert small_list == None
-
-    x = minimal(json, lambda x: isinstance(x, dict) and isinstance(x.get(""), list))
-
-    assert x == {"": }
-
-
-def test_self_recursive_lists():
-    x = st.deferred(lambda: st.lists(x))
-    assert minimal(x) == 
-    assert minimal(x, bool) == 
-    assert minimal(x, lambda x: len(x) > 1) == ,

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_discovery_ability.py Deleted

@@ -1,366 +0,0 @@
-# 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/.
-
-# -*- coding: utf-8 -*-
-"""Statistical tests over the forms of the distributions in the standard set of
-definitions.
-
-These tests all take the form of a classic hypothesis test with the null
-hypothesis being that the probability of some event occurring when
-drawing data from the distribution produced by some specifier is >=
-REQUIRED_P
-"""
-
-import collections
-import math
-import re
-
-from hypothesis import HealthCheck, settings as Settings
-from hypothesis.errors import UnsatisfiedAssumption
-from hypothesis.internal import reflection
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.strategies import (
-    binary,
-    booleans,
-    floats,
-    integers,
-    just,
-    lists,
-    one_of,
-    sampled_from,
-    sets,
-    text,
-    tuples,
-)
-
-from tests.common.utils import no_shrink
-
-RUNS = 100
-
-
-INITIAL_LAMBDA = re.compile("^lambda^:*:\\s*")
-
-
-def strip_lambda(s):
-    return INITIAL_LAMBDA.sub("", s)
-
-
-class HypothesisFalsified(AssertionError):
-    pass
-
-
-def define_test(specifier, predicate, condition=None, p=0.5, suppress_health_check=()):
-    required_runs = int(RUNS * p)
-
-    def run_test():
-        if condition is None:
-
-            def _condition(x):
-                return True
-
-            condition_string = ""
-        else:
-            _condition = condition
-            condition_string = strip_lambda(
-                reflection.get_pretty_function_description(condition)
-            )
-
-        def test_function(data):
-            try:
-                value = data.draw(specifier)
-            except UnsatisfiedAssumption:
-                data.mark_invalid()
-            if not _condition(value):
-                data.mark_invalid()
-            if predicate(value):
-                data.mark_interesting()
-
-        successes = 0
-        actual_runs = 0
-        for actual_runs in range(1, RUNS + 1):
-            # We choose the max_examples a bit larger than default so that we
-            # run at least 100 examples outside of the small example generation
-            # part of the generation phase.
-            runner = ConjectureRunner(
-                test_function,
-                settings=Settings(
-                    max_examples=150,
-                    phases=no_shrink,
-                    suppress_health_check=suppress_health_check,
-                ),
-            )
-            runner.run()
-            if runner.interesting_examples:
-                successes += 1
-                if successes >= required_runs:
-                    return
-
-            # If we reach a point where it's impossible to hit our target even
-            # if every remaining attempt were to succeed, give up early and
-            # report failure.
-            if (required_runs - successes) > (RUNS - actual_runs):
-                break
-
-        event = reflection.get_pretty_function_description(predicate)
-        if condition is not None:
-            event += "|"
-            event += condition_string
-
-        raise HypothesisFalsified(
-            f"P({event}) ~ {successes} / {actual_runs} = "
-            f"{successes / actual_runs:.2f} < {required_runs / RUNS:.2f}; "
-            "rejected"
-        )
-
-    return run_test
-
-
-test_can_produce_zero = define_test(integers(), lambda x: x == 0)
-test_can_produce_large_magnitude_integers = define_test(
-    integers(), lambda x: abs(x) > 1000
-)
-test_can_produce_large_positive_integers = define_test(integers(), lambda x: x > 1000)
-test_can_produce_large_negative_integers = define_test(integers(), lambda x: x < -1000)
-
-
-def long_list(xs):
-    return len(xs) >= 10
-
-
-test_can_produce_unstripped_strings = define_test(text(), lambda x: x != x.strip())
-
-test_can_produce_stripped_strings = define_test(text(), lambda x: x == x.strip())
-
-test_can_produce_multi_line_strings = define_test(text(), lambda x: "\n" in x)
-
-test_can_produce_ascii_strings = define_test(
-    text(), lambda x: all(ord(c) <= 127 for c in x)
-)
-
-test_can_produce_long_strings_with_no_ascii = define_test(
-    text(min_size=5), lambda x: all(ord(c) > 127 for c in x), p=0.1
-)
-
-test_can_produce_short_strings_with_some_non_ascii = define_test(
-    text(), lambda x: any(ord(c) > 127 for c in x), condition=lambda x: len(x) <= 3
-)
-
-test_can_produce_large_binary_strings = define_test(binary(), lambda x: len(x) > 20)
-
-test_can_produce_positive_infinity = define_test(floats(), lambda x: x == math.inf)
-
-test_can_produce_negative_infinity = define_test(floats(), lambda x: x == -math.inf)
-
-test_can_produce_nan = define_test(floats(), math.isnan)
-
-test_can_produce_floats_near_left = define_test(floats(0, 1), lambda t: t < 0.2)
-
-test_can_produce_floats_near_right = define_test(floats(0, 1), lambda t: t > 0.8)
-
-test_can_produce_floats_in_middle = define_test(floats(0, 1), lambda t: 0.2 <= t <= 0.8)
-
-test_can_produce_long_lists = define_test(lists(integers()), long_list, p=0.3)
-
-test_can_produce_short_lists = define_test(lists(integers()), lambda x: len(x) <= 10)
-
-test_can_produce_the_same_int_twice = define_test(
-    lists(integers()), lambda t: len(set(t)) < len(t)
-)
-
-
-def distorted_value(x):
-    c = collections.Counter(x)
-    return min(c.values()) * 3 <= max(c.values())
-
-
-def distorted(x):
-    return distorted_value(map(type, x))
-
-
-test_sampled_from_large_number_can_mix = define_test(
-    lists(sampled_from(range(50)), min_size=50), lambda x: len(set(x)) >= 25
-)
-
-
-test_sampled_from_often_distorted = define_test(
-    lists(sampled_from(range(5))), distorted_value, condition=lambda x: len(x) >= 3
-)
-
-
-test_non_empty_subset_of_two_is_usually_large = define_test(
-    sets(sampled_from((1, 2))), lambda t: len(t) == 2
-)
-
-test_subset_of_ten_is_sometimes_empty = define_test(
-    sets(integers(1, 10)), lambda t: len(t) == 0
-)
-
-test_mostly_sensible_floats = define_test(floats(), lambda t: t + 1 > t)
-
-test_mostly_largish_floats = define_test(
-    floats(), lambda t: t + 1 > 1, condition=lambda x: x > 0
-)
-
-test_ints_can_occasionally_be_really_large = define_test(
-    integers(), lambda t: t >= 2**63
-)
-
-test_mixing_is_sometimes_distorted = define_test(
-    lists(booleans() | tuples()),
-    distorted,
-    condition=lambda x: len(set(map(type, x))) == 2,
-    suppress_health_check=HealthCheck.filter_too_much,
-)
-
-test_mixes_2_reasonably_often = define_test(
-    lists(booleans() | tuples()), lambda x: len(set(map(type, x))) > 1, condition=bool
-)
-
-test_partial_mixes_3_reasonably_often = define_test(
-    lists(booleans() | tuples() | just("hi")),
-    lambda x: 1 < len(set(map(type, x))) < 3,
-    condition=bool,
-)
-
-test_mixes_not_too_often = define_test(
-    lists(booleans() | tuples()), lambda x: len(set(map(type, x))) == 1, condition=bool
-)
-
-test_integers_are_usually_non_zero = define_test(integers(), lambda x: x != 0)
-
-test_integers_are_sometimes_zero = define_test(integers(), lambda x: x == 0)
-
-test_integers_are_often_small = define_test(integers(), lambda x: abs(x) <= 100)
-
-
-test_integers_are_often_small_but_not_that_small = define_test(
-    integers(), lambda x: 50 <= abs(x) <= 255
-)
-
-
-# This series of tests checks that the one_of() strategy flattens branches
-# correctly.  We assert that the probability of any branch is >= 0.1,
-# approximately (1/8 = 0.125), regardless of how heavily nested it is in the
-# strategy.
-
-# This first strategy chooses an integer between 0 and 7 (inclusive).
-one_of_nested_strategy = one_of(
-    just(0),
-    one_of(
-        just(1), just(2), one_of(just(3), just(4), one_of(just(5), just(6), just(7)))
-    ),
-)
-
-for i in range(8):
-    exec(
-        f"""test_one_of_flattens_branches_{i} = define_test(
-        one_of_nested_strategy, lambda x: x == {i}
-    )"""
-    )
-
-
-xor_nested_strategy = just(0) | (
-    just(1) | just(2) | (just(3) | just(4) | (just(5) | just(6) | just(7)))
-)
-
-for i in range(8):
-    exec(
-        f"""test_xor_flattens_branches_{i} = define_test(
-        xor_nested_strategy, lambda x: x == {i}
-    )"""
-    )
-
-
-# This strategy tests interactions with `map()`.  They generate integers
-# from the set {1, 4, 6, 16, 20, 24, 28, 32}.
-def double(x):
-    return x * 2
-
-
-one_of_nested_strategy_with_map = one_of(
-    just(1),
-    one_of(
-        (just(2) | just(3)).map(double),
-        one_of(
-            (just(4) | just(5)).map(double),
-            one_of((just(6) | just(7) | just(8)).map(double)),
-        ).map(double),
-    ),
-)
-
-for i in (1, 4, 6, 16, 20, 24, 28, 32):
-    exec(
-        f"""test_one_of_flattens_map_branches_{i} = define_test(
-        one_of_nested_strategy_with_map, lambda x: x == {i}
-    )"""
-    )
-
-
-# This strategy tests interactions with `flatmap()`.  It generates lists
-# of length 0-7 (inclusive) in which every element is `None`.
-one_of_nested_strategy_with_flatmap = just(None).flatmap(
-    lambda x: one_of(
-        just(x * 0),
-        just(x * 1),
-        one_of(
-            just(x * 2),
-            just(x * 3),
-            one_of(just(x * 4), just(x * 5), one_of(just(x * 6), just(x * 7))),
-        ),
-    )
-)
-
-for i in range(8):
-    exec(
-        f"""test_one_of_flattens_flatmap_branches_{i} = define_test(
-        one_of_nested_strategy_with_flatmap, lambda x: len(x) == {i}
-    )"""
-    )
-
-
-xor_nested_strategy_with_flatmap = just(None).flatmap(
-    lambda x: (
-        just(x * 0)
-        | just(x * 1)
-        | (
-            just(x * 2)
-            | just(x * 3)
-            | (just(x * 4) | just(x * 5) | (just(x * 6) | just(x * 7)))
-        )
-    )
-)
-
-for i in range(8):
-    exec(
-        f"""test_xor_flattens_flatmap_branches_{i} = define_test(
-        xor_nested_strategy_with_flatmap, lambda x: len(x) == {i}
-    )"""
-    )
-
-
-# This strategy tests interactions with `filter()`.  It generates the even
-# integers {0, 2, 4, 6} in equal measures.
-one_of_nested_strategy_with_filter = one_of(
-    just(0),
-    just(1),
-    one_of(just(2), just(3), one_of(just(4), just(5), one_of(just(6), just(7)))),
-).filter(lambda x: x % 2 == 0)
-
-for i in range(4):
-    exec(
-        f"""test_one_of_flattens_filter_branches_{i} = define_test(
-        one_of_nested_strategy_with_filter, lambda x: x == 2 * {i}
-    )"""
-    )
-
-
-test_long_duplicates_strings = define_test(
-    tuples(text(), text()), lambda s: len(s0) >= 5 and s0 == s1
-)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_float_shrinking.py Deleted

@@ -1,58 +0,0 @@
-# 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 pytest
-
-from hypothesis import (
-    HealthCheck,
-    Verbosity,
-    assume,
-    example,
-    given,
-    settings,
-    strategies as st,
-)
-from hypothesis.internal.compat import ceil
-
-from tests.common.debug import minimal
-
-
-def test_shrinks_to_simple_floats():
-    assert minimal(st.floats(), lambda x: x > 1) == 2.0
-    assert minimal(st.floats(), lambda x: x > 0) == 1.0
-
-
-@pytest.mark.parametrize("n", 1, 2, 3, 8, 10)
-def test_can_shrink_in_variable_sized_context(n):
-    x = minimal(st.lists(st.floats(), min_size=n), any)
-    assert len(x) == n
-    assert x.count(0.0) == n - 1
-    assert 1 in x
-
-
-@example(1.7976931348623157e308)
-@example(1.5)
-@given(st.floats(min_value=0, allow_infinity=False, allow_nan=False))
-@settings(deadline=None, suppress_health_check=HealthCheck.all())
-def test_shrinks_downwards_to_integers(f):
-    g = minimal(st.floats(), lambda x: x >= f, settings(verbosity=Verbosity.quiet))
-    assert g == ceil(f)
-
-
-@example(1)
-@given(st.integers(1, 2**16 - 1))
-@settings(deadline=None, suppress_health_check=HealthCheck.all(), max_examples=10)
-def test_shrinks_downwards_to_integers_when_fractional(b):
-    g = minimal(
-        st.floats(),
-        lambda x: assume((0 < x < (2**53)) and int(x) != x) and x >= b,
-        settings=settings(verbosity=Verbosity.quiet, max_examples=10**6),
-    )
-    assert g == b + 0.5

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_integers.py Deleted

@@ -1,113 +0,0 @@
-# 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/.
-
-from random import Random
-
-from hypothesis import (
-    HealthCheck,
-    Phase,
-    Verbosity,
-    assume,
-    example,
-    given,
-    reject,
-    settings,
-    strategies as st,
-)
-from hypothesis.internal.conjecture.data import ConjectureData, Status, StopTest
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-from hypothesis.internal.conjecture.utils import INT_SIZES
-
-
-@st.composite
-def problems(draw):
-    while True:
-        buf = bytearray(draw(st.binary(min_size=16, max_size=16)))
-        while buf and not buf-1:
-            buf.pop()
-        try:
-            d = ConjectureData.for_buffer(buf)
-            k = d.draw(st.integers())
-            stop = d.draw_bits(8)
-        except (StopTest, IndexError):
-            pass
-        else:
-            if stop > 0 and k > 0:
-                return (draw(st.integers(0, k - 1)), bytes(d.buffer))
-
-
-@example((2, b"\x00\x00\n\x01"))
-@example((1, b"\x00\x00\x06\x01"))
-@example(problem=(32768, b"\x03\x01\x00\x00\x00\x00\x00\x01\x00\x02\x01"))
-@settings(
-    suppress_health_check=HealthCheck.all(),
-    deadline=None,
-    max_examples=10,
-    verbosity=Verbosity.normal,
-)
-@given(problems())
-def test_always_reduces_integers_to_smallest_suitable_sizes(problem):
-    n, blob = problem
-    try:
-        d = ConjectureData.for_buffer(blob)
-        k = d.draw(st.integers())
-        stop = bloblen(d.buffer)
-    except (StopTest, IndexError):
-        reject()
-
-    assume(k > n)
-    assume(stop > 0)
-
-    def f(data):
-        k = data.draw(st.integers())
-        data.output = repr(k)
-        if data.draw_bits(8) == stop and k >= n:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        f,
-        random=Random(0),
-        settings=settings(
-            suppress_health_check=HealthCheck.all(),
-            phases=(Phase.shrink,),
-            database=None,
-            verbosity=Verbosity.debug,
-        ),
-        database_key=None,
-    )
-
-    runner.cached_test_function(blob)
-
-    assert runner.interesting_examples
-
-    (v,) = runner.interesting_examples.values()
-
-    shrinker = runner.new_shrinker(v, lambda x: x.status == Status.INTERESTING)
-
-    shrinker.fixate_shrink_passes("minimize_individual_blocks")
-
-    v = shrinker.shrink_target
-
-    m = ConjectureData.for_buffer(v.buffer).draw(st.integers())
-    assert m == n
-
-    # Upper bound on the length needed is calculated as follows:
-    # * We have an initial byte at the beginning to decide the length of the
-    #   integer.
-    # * We have a terminal byte as the stop value.
-    # * The rest is the integer payload. This should be n. Including the sign
-    #   bit, n needs (1 + n.bit_length()) / 8 bytes (rounded up). But we only
-    #   have power of two sizes, so it may be up to a factor of two more than
-    #   that.
-    bits_needed = 1 + n.bit_length()
-    actual_bits_needed = min(s for s in INT_SIZES if s >= bits_needed)
-    bytes_needed = actual_bits_needed // 8
-    # 3 extra bytes: two for the sampler, one for the capping value.
-    assert len(v.buffer) == 3 + bytes_needed

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_normalization.py Deleted

@@ -1,63 +0,0 @@
-# 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/.
-
-from itertools import islice
-from random import Random
-
-import pytest
-
-from hypothesis import strategies as st
-from hypothesis.errors import UnsatisfiedAssumption
-from hypothesis.internal.conjecture.shrinking import dfas
-
-from tests.quality.test_shrinking_order import iter_values
-
-
-@pytest.fixture
-def normalize_kwargs(request):
-    if request.config.getoption("--hypothesis-learn-to-normalize"):
-        return {"allowed_to_update": True, "required_successes": 1000}
-    else:
-        return {"allowed_to_update": False, "required_successes": 10}
-
-
-@pytest.mark.parametrize("n", range(10, -1, -1))
-@pytest.mark.parametrize(
-    "strategy",
-    st.floats(), st.text(), st.datetimes(),
-    ids=repr,
-)
-def test_common_strategies_normalize_small_values(strategy, n, normalize_kwargs):
-
-    excluded = list(map(repr, islice(iter_values(strategy, unique_by=repr), n)))
-
-    def test_function(data):
-        try:
-            v = data.draw(strategy)
-        except UnsatisfiedAssumption:
-            data.mark_invalid()
-        data.output = repr(v)
-        if repr(v) not in excluded:
-            data.mark_interesting()
-
-    dfas.normalize(repr(strategy), test_function, **normalize_kwargs)
-
-
-@pytest.mark.parametrize("strategy", st.emails(), st.complex_numbers(), ids=repr)
-def test_harder_strategies_normalize_to_minimal(strategy, normalize_kwargs):
-    def test_function(data):
-        try:
-            v = data.draw(strategy)
-        except UnsatisfiedAssumption:
-            data.mark_invalid()
-        data.output = repr(v)
-        data.mark_interesting()
-
-    dfas.normalize(repr(strategy), test_function, random=Random(0), **normalize_kwargs)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_poisoned_lists.py Deleted

@@ -1,87 +0,0 @@
-# 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/.
-
-from random import Random
-
-import pytest
-
-from hypothesis import settings, strategies as st
-from hypothesis.internal.compat import ceil
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.conjecture.engine import ConjectureData, ConjectureRunner
-from hypothesis.strategies._internal import SearchStrategy
-
-POISON = "POISON"
-
-
-class Poisoned(SearchStrategy):
-    def __init__(self, poison_chance):
-        super().__init__()
-        self.__poison_chance = poison_chance
-        self.__ints = st.integers(0, 10)
-
-    def do_draw(self, data):
-        if cu.biased_coin(data, self.__poison_chance):
-            return POISON
-        else:
-            return data.draw(self.__ints)
-
-
-class LinearLists(SearchStrategy):
-    def __init__(self, elements, size):
-        super().__init__()
-        self.__length = st.integers(0, size)
-        self.__elements = elements
-
-    def do_draw(self, data):
-        return data.draw(self.__elements) for _ in range(data.draw(self.__length))
-
-
-class Matrices(SearchStrategy):
-    def __init__(self, elements, size):
-        super().__init__()
-        self.__length = st.integers(0, ceil(size**0.5))
-        self.__elements = elements
-
-    def do_draw(self, data):
-        n = data.draw(self.__length)
-        m = data.draw(self.__length)
-
-        return data.draw(self.__elements) for _ in range(n * m)
-
-
-LOTS = 10**6
-
-TRIAL_SETTINGS = settings(max_examples=LOTS, database=None)
-
-
-@pytest.mark.parametrize(
-    "seed", 2282791295271755424, 1284235381287210546, 14202812238092722246, 26097
-)
-@pytest.mark.parametrize("size", 5, 10, 20)
-@pytest.mark.parametrize("p", 0.01, 0.1)
-@pytest.mark.parametrize("strategy_class", LinearLists, Matrices)
-def test_minimal_poisoned_containers(seed, size, p, strategy_class, monkeypatch):
-    elements = Poisoned(p)
-    strategy = strategy_class(elements, size)
-
-    def test_function(data):
-        v = data.draw(strategy)
-        data.output = repr(v)
-        if POISON in v:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test_function, random=Random(seed), settings=TRIAL_SETTINGS
-    )
-    runner.run()
-    (v,) = runner.interesting_examples.values()
-    result = ConjectureData.for_buffer(v.buffer).draw(strategy)
-    assert len(result) == 1

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_poisoned_trees.py Deleted

@@ -1,122 +0,0 @@
-# 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/.
-
-from random import Random
-
-import pytest
-
-from hypothesis import HealthCheck, settings
-from hypothesis.internal.conjecture import utils as cu
-from hypothesis.internal.conjecture.engine import ConjectureData, ConjectureRunner
-from hypothesis.strategies._internal import SearchStrategy
-
-POISON = "POISON"
-
-MAX_INT = 2**32 - 1
-
-
-class PoisonedTree(SearchStrategy):
-    """Generates variable sized tuples with an implicit tree structure.
-
-    The actual result is flattened out, but the hierarchy is implicit in
-    the data.
-    """
-
-    def __init__(self, p):
-        super().__init__()
-        self.__p = p
-
-    def do_draw(self, data):
-        if cu.biased_coin(data, self.__p):
-            return data.draw(self) + data.draw(self)
-        else:
-            # We draw n as two separate calls so that it doesn't show up as a
-            # single block. If it did, the heuristics that allow us to move
-            # blocks around would fire and it would move right, which would
-            # then allow us to shrink it more easily.
-            n = (data.draw_bits(16) << 16) | data.draw_bits(16)
-            if n == MAX_INT:
-                return (POISON,)
-            else:
-                return (None,)
-
-
-LOTS = 10**6
-
-
-TEST_SETTINGS = settings(
-    database=None,
-    suppress_health_check=HealthCheck.all(),
-    max_examples=LOTS,
-    deadline=None,
-)
-
-
-@pytest.mark.parametrize("size", 2, 5, 10)
-@pytest.mark.parametrize("seed", 0, 15993493061449915028)
-def test_can_reduce_poison_from_any_subtree(size, seed):
-    """This test validates that we can minimize to any leaf node of a binary
-    tree, regardless of where in the tree the leaf is."""
-    random = Random(seed)
-
-    # Initially we create the minimal tree of size n, regardless of whether it
-    # is poisoned (which it won't be - the poison event essentially never
-    # happens when drawing uniformly at random).
-
-    # Choose p so that the expected size of the tree is equal to the desired
-    # size.
-    p = 1.0 / (2.0 - 1.0 / size)
-    strat = PoisonedTree(p)
-
-    def test_function(data):
-        v = data.draw(strat)
-        if len(v) >= size:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(test_function, random=random, settings=TEST_SETTINGS)
-
-    runner.generate_new_examples()
-    runner.shrink_interesting_examples()
-
-    (data,) = runner.interesting_examples.values()
-
-    assert len(ConjectureData.for_buffer(data.buffer).draw(strat)) == size
-
-    starts = b.start for b in data.blocks if b.length == 2
-    assert len(starts) % 2 == 0
-
-    for i in range(0, len(starts), 2):
-        # Now for each leaf position in the tree we try inserting a poison
-        # value artificially. Additionally, we add a marker to the end that
-        # must be preserved. The marker means that we are not allow to rely on
-        # discarding the end of the buffer to get the desired shrink.
-        u = startsi
-        marker = bytes(1, 2, 3, 4)
-
-        def test_function_with_poison(data):
-            v = data.draw(strat)
-            m = data.draw_bytes(len(marker))
-            if POISON in v and m == marker:
-                data.mark_interesting()
-
-        runner = ConjectureRunner(
-            test_function_with_poison, random=random, settings=TEST_SETTINGS
-        )
-
-        runner.cached_test_function(
-            data.buffer:u + bytes(255) * 4 + data.bufferu + 4 : + marker
-        )
-
-        assert runner.interesting_examples
-        runner.shrink_interesting_examples()
-
-        (shrunk,) = runner.interesting_examples.values()
-
-        assert ConjectureData.for_buffer(shrunk.buffer).draw(strat) == (POISON,)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_shrink_quality.py Deleted

@@ -1,394 +0,0 @@
-# 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/.
-
-from collections import OrderedDict, namedtuple
-from fractions import Fraction
-from functools import reduce
-
-import pytest
-
-import hypothesis.strategies as st
-from hypothesis import assume, settings
-from hypothesis.strategies import (
-    booleans,
-    builds,
-    dictionaries,
-    fixed_dictionaries,
-    fractions,
-    frozensets,
-    integers,
-    just,
-    lists,
-    none,
-    sampled_from,
-    sets,
-    text,
-    tuples,
-)
-
-from tests.common.debug import minimal
-from tests.common.utils import flaky
-
-
-def test_integers_from_minimizes_leftwards():
-    assert minimal(integers(min_value=101)) == 101
-
-
-def test_minimize_bounded_integers_to_zero():
-    assert minimal(integers(-10, 10)) == 0
-
-
-def test_minimize_bounded_integers_to_positive():
-    zero = 0
-
-    def not_zero(x):
-        return x != zero
-
-    assert minimal(integers(-10, 10).filter(not_zero)) == 1
-
-
-def test_minimal_fractions_1():
-    assert minimal(fractions()) == Fraction(0)
-
-
-def test_minimal_fractions_2():
-    assert minimal(fractions(), lambda x: x >= 1) == Fraction(1)
-
-
-def test_minimal_fractions_3():
-    assert minimal(lists(fractions()), lambda s: len(s) >= 5) == Fraction(0) * 5
-
-
-def test_minimize_string_to_empty():
-    assert minimal(text()) == ""
-
-
-def test_minimize_one_of():
-    for _ in range(100):
-        assert minimal(integers() | text() | booleans()) in (0, "", False)
-
-
-def test_minimize_mixed_list():
-    mixed = minimal(lists(integers() | text()), lambda x: len(x) >= 10)
-    assert set(mixed).issubset({0, ""})
-
-
-def test_minimize_longer_string():
-    assert minimal(text(), lambda x: len(x) >= 10) == "0" * 10
-
-
-def test_minimize_longer_list_of_strings():
-    assert minimal(lists(text()), lambda x: len(x) >= 10) == "" * 10
-
-
-def test_minimize_3_set():
-    assert minimal(sets(integers()), lambda x: len(x) >= 3) in ({0, 1, 2}, {-1, 0, 1})
-
-
-def test_minimize_3_set_of_tuples():
-    assert minimal(sets(tuples(integers())), lambda x: len(x) >= 2) == {(0,), (1,)}
-
-
-def test_minimize_sets_of_sets():
-    elements = integers(1, 100)
-    size = 8
-    set_of_sets = minimal(sets(frozensets(elements), min_size=size))
-    assert frozenset() in set_of_sets
-    assert len(set_of_sets) == size
-    for s in set_of_sets:
-        if len(s) > 1:
-            assert any(s != t and t.issubset(s) for t in set_of_sets)
-
-
-def test_can_simplify_flatmap_with_bounded_left_hand_size():
-    assert (
-        minimal(booleans().flatmap(lambda x: lists(just(x))), lambda x: len(x) >= 10)
-        == False * 10
-    )
-
-
-def test_can_simplify_across_flatmap_of_just():
-    assert minimal(integers().flatmap(just)) == 0
-
-
-def test_can_simplify_on_right_hand_strategy_of_flatmap():
-    assert minimal(integers().flatmap(lambda x: lists(just(x)))) == 
-
-
-@flaky(min_passes=5, max_runs=5)
-def test_can_ignore_left_hand_side_of_flatmap():
-    assert (
-        minimal(integers().flatmap(lambda x: lists(integers())), lambda x: len(x) >= 10)
-        == 0 * 10
-    )
-
-
-def test_can_simplify_on_both_sides_of_flatmap():
-    assert (
-        minimal(integers().flatmap(lambda x: lists(just(x))), lambda x: len(x) >= 10)
-        == 0 * 10
-    )
-
-
-def test_flatmap_rectangles():
-    lengths = integers(min_value=0, max_value=10)
-
-    def lists_of_length(n):
-        return lists(sampled_from("ab"), min_size=n, max_size=n)
-
-    xs = minimal(
-        lengths.flatmap(lambda w: lists(lists_of_length(w))),
-        lambda x: "a", "b" in x,
-        settings=settings(database=None, max_examples=2000),
-    )
-    assert xs == "a", "b"
-
-
-@flaky(min_passes=5, max_runs=5)
-@pytest.mark.parametrize("dict_class", dict, OrderedDict)
-def test_dictionary(dict_class):
-    assert (
-        minimal(dictionaries(keys=integers(), values=text(), dict_class=dict_class))
-        == dict_class()
-    )
-
-    x = minimal(
-        dictionaries(keys=integers(), values=text(), dict_class=dict_class),
-        lambda t: len(t) >= 3,
-    )
-    assert isinstance(x, dict_class)
-    assert set(x.values()) == {""}
-    for k in x:
-        if k < 0:
-            assert k + 1 in x
-        if k > 0:
-            assert k - 1 in x
-
-
-def test_minimize_single_element_in_silly_large_int_range():
-    ir = integers(-(2**256), 2**256)
-    assert minimal(ir, lambda x: x >= -(2**255)) == 0
-
-
-def test_minimize_multiple_elements_in_silly_large_int_range():
-    desired_result = 0 * 20
-
-    ir = integers(-(2**256), 2**256)
-    x = minimal(lists(ir), lambda x: len(x) >= 20, timeout_after=20)
-    assert x == desired_result
-
-
-def test_minimize_multiple_elements_in_silly_large_int_range_min_is_not_dupe():
-    ir = integers(0, 2**256)
-    target = list(range(20))
-
-    x = minimal(
-        lists(ir),
-        lambda x: (assume(len(x) >= 20) and all(xi >= targeti for i in target)),
-        timeout_after=60,
-    )
-    assert x == target
-
-
-def test_find_large_union_list():
-    size = 10
-
-    def large_mostly_non_overlapping(xs):
-        union = reduce(set.union, xs)
-        return len(union) >= size
-
-    result = minimal(
-        lists(sets(integers(), min_size=1), min_size=1),
-        large_mostly_non_overlapping,
-        timeout_after=120,
-    )
-    assert len(result) == 1
-    union = reduce(set.union, result)
-    assert len(union) == size
-    assert max(union) == min(union) + len(union) - 1
-
-
-@pytest.mark.parametrize("n", 0, 1, 10, 100, 1000)
-@pytest.mark.parametrize(
-    "seed", 13878544811291720918, 15832355027548327468, 12901656430307478246
-)
-def test_containment(n, seed):
-    iv = minimal(
-        tuples(lists(integers()), integers()),
-        lambda x: x1 in x0 and x1 >= n,
-        timeout_after=60,
-    )
-    assert iv == (n, n)
-
-
-def test_duplicate_containment():
-    ls, i = minimal(
-        tuples(lists(integers()), integers()),
-        lambda s: s0.count(s1) > 1,
-        timeout_after=100,
-    )
-    assert ls == 0, 0
-    assert i == 0
-
-
-@pytest.mark.parametrize("seed", 11, 28, 37)
-def test_reordering_bytes(seed):
-    ls = minimal(lists(integers()), lambda x: sum(x) >= 10 and len(x) >= 3)
-    assert ls == sorted(ls)
-
-
-def test_minimize_long_list():
-    assert (
-        minimal(lists(booleans(), min_size=50), lambda x: len(x) >= 70) == False * 70
-    )
-
-
-def test_minimize_list_of_longish_lists():
-    size = 5
-    xs = minimal(
-        lists(lists(booleans())),
-        lambda x: len(t for t in x if any(t) and len(t) >= 2) >= size,
-    )
-    assert len(xs) == size
-    for x in xs:
-        assert x == False, True
-
-
-def test_minimize_list_of_fairly_non_unique_ints():
-    xs = minimal(lists(integers()), lambda x: len(set(x)) < len(x))
-    assert len(xs) == 2
-
-
-def test_list_with_complex_sorting_structure():
-    xs = minimal(
-        lists(lists(booleans())),
-        lambda x: list(reversed(t)) for t in x > x and len(x) > 3,
-    )
-    assert len(xs) == 4
-
-
-def test_list_with_wide_gap():
-    xs = minimal(lists(integers()), lambda x: x and (max(x) > min(x) + 10 > 0))
-    assert len(xs) == 2
-    xs.sort()
-    assert xs1 == 11 + xs0
-
-
-def test_minimize_namedtuple():
-    T = namedtuple("T", ("a", "b"))
-    tab = minimal(builds(T, integers(), integers()), lambda x: x.a < x.b)
-    assert tab.b == tab.a + 1
-
-
-def test_minimize_dict():
-    tab = minimal(
-        fixed_dictionaries({"a": booleans(), "b": booleans()}),
-        lambda x: x"a" or x"b",
-    )
-    assert not (tab"a" and tab"b")
-
-
-def test_minimize_list_of_sets():
-    assert minimal(
-        lists(sets(booleans())), lambda x: len(list(filter(None, x))) >= 3
-    ) == ({False} * 3)
-
-
-def test_minimize_list_of_lists():
-    assert minimal(
-        lists(lists(integers())), lambda x: len(list(filter(None, x))) >= 3
-    ) == (0 * 3)
-
-
-def test_minimize_list_of_tuples():
-    xs = minimal(lists(tuples(integers(), integers())), lambda x: len(x) >= 2)
-    assert xs == (0, 0), (0, 0)
-
-
-def test_minimize_multi_key_dicts():
-    assert minimal(dictionaries(keys=booleans(), values=booleans()), bool) == {
-        False: False
-    }
-
-
-def test_multiple_empty_lists_are_independent():
-    x = minimal(lists(lists(none(), max_size=0)), lambda t: len(t) >= 2)
-    u, v = x
-    assert u is not v
-
-
-def test_can_find_sets_unique_by_incomplete_data():
-    size = 5
-    ls = minimal(
-        lists(tuples(integers(), integers()), unique_by=max), lambda x: len(x) >= size
-    )
-    assert len(ls) == size
-    values = sorted(map(max, ls))
-    assert values-1 - values0 == size - 1
-    for u, _ in ls:
-        assert u <= 0
-
-
-@pytest.mark.parametrize("n", range(10))
-def test_lists_forced_near_top(n):
-    assert minimal(
-        lists(integers(), min_size=n, max_size=n + 2), lambda t: len(t) == n + 2
-    ) == 0 * (n + 2)
-
-
-def test_sum_of_pair():
-    assert minimal(
-        tuples(integers(0, 1000), integers(0, 1000)), lambda x: sum(x) > 1000
-    ) == (1, 1000)
-
-
-def test_calculator_benchmark():
-    """This test comes from
-    https://github.com/jlink/shrinking-challenge/blob/main/challenges/calculator.md,
-    which is originally from Pike, Lee. "SmartCheck: automatic and efficient
-    counterexample reduction and generalization."
-    Proceedings of the 2014 ACM SIGPLAN symposium on Haskell. 2014.
-    """
-
-    expression = st.deferred(
-        lambda: st.one_of(
-            st.integers(),
-            st.tuples(st.just("+"), expression, expression),
-            st.tuples(st.just("/"), expression, expression),
-        )
-    )
-
-    def div_subterms(e):
-        if isinstance(e, int):
-            return True
-        if e0 == "/" and e-1 == 0:
-            return False
-        return div_subterms(e1) and div_subterms(e2)
-
-    def evaluate(e):
-        if isinstance(e, int):
-            return e
-        elif e0 == "+":
-            return evaluate(e1) + evaluate(e2)
-        else:
-            assert e0 == "/"
-            return evaluate(e1) // evaluate(e2)
-
-    def is_failing(e):
-        assume(div_subterms(e))
-        try:
-            evaluate(e)
-            return False
-        except ZeroDivisionError:
-            return True
-
-    x = minimal(expression, is_failing)
-
-    assert x == ("/", 0, ("+", 0, 0))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_shrinking_order.py Deleted

@@ -1,134 +0,0 @@
-# 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/.
-
-from itertools import islice
-from random import Random
-
-from hypothesis import HealthCheck, Verbosity, settings, strategies as st
-from hypothesis.errors import UnsatisfiedAssumption
-from hypothesis.internal.conjecture.data import ConjectureData, Status
-from hypothesis.internal.conjecture.dfa.lstar import LStar
-from hypothesis.internal.conjecture.engine import BUFFER_SIZE, ConjectureRunner
-from hypothesis.internal.conjecture.junkdrawer import uniform
-
-LEARNERS = {}
-
-
-def learner_for(strategy):
-    """Returns an LStar learner that predicts whether a buffer
-    corresponds to a discard free choice sequence leading to
-    a valid value for this strategy."""
-    try:
-        return LEARNERSstrategy
-    except KeyError:
-        pass
-
-    def test_function(data):
-        try:
-            data.draw(strategy)
-        except UnsatisfiedAssumption:
-            data.mark_invalid()
-        data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test_function,
-        settings=settings(
-            database=None,
-            verbosity=Verbosity.quiet,
-            suppress_health_check=HealthCheck.all(),
-        ),
-        random=Random(0),
-        ignore_limits=True,
-    )
-
-    def predicate(s):
-        result = runner.cached_test_function(s)
-        if result.status < Status.VALID:
-            return False
-        if result.has_discards:
-            return False
-        return result.buffer == s
-
-    learner = LStar(predicate)
-
-    runner.run()
-
-    (v,) = runner.interesting_examples.values()
-
-    # We make sure the learner has properly learned small examples.
-    # This is all fairly ad hoc but is mostly designed to get it
-    # to understand what the smallest example is and avoid any
-    # loops at the beginning of the DFA that don't really exist.
-    learner.learn(v.buffer)
-
-    for n in 1, 2, 3:
-        for _ in range(5):
-            learner.learn(uniform(runner.random, n) + v.buffer)
-
-    prev = -1
-    while learner.generation != prev:
-        prev = learner.generation
-
-        for _ in range(10):
-            s = uniform(runner.random, len(v.buffer)) + bytes(BUFFER_SIZE)
-            learner.learn(s)
-            data = runner.cached_test_function(s)
-            if data.status >= Status.VALID:
-                learner.learn(data.buffer)
-
-    LEARNERSstrategy = learner
-    return learner
-
-
-def iter_values(strategy, unique_by=lambda s: s):
-    """Iterate over the values that can be generated by ``strategy``
-    in what is, as best as we can figure, shortlex-ascending order.
-
-    The same value may have multiple, redundant, representations,
-    and we don't want to yield it more than once, so we deduplicate.
-    If the value is not hashable, pass some suitable key (e.g. repr)
-    as unique_by.
-    """
-    learner = learner_for(strategy)
-
-    seen = set()
-
-    while True:
-        for s in learner.dfa.all_matching_strings():
-            if not learner.member(s):
-                # This string matched the DFA but didn't
-                # satisfy the membership test. We relearn
-                # the string, improving our learner, and
-                # restart the loop.
-                learner.learn(s)
-                break
-            result = ConjectureData.for_buffer(s).draw(strategy)
-            key = unique_by(result)
-            if key in seen:
-                continue
-            seen.add(key)
-            yield result
-        else:
-            break
-
-
-def test_characters_start_with_the_digits():
-    assert list(islice(iter_values(st.characters()), 10)) == 
-        "0",
-        "1",
-        "2",
-        "3",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8",
-        "9",
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/quality/test_zig_zagging.py Deleted

@@ -1,114 +0,0 @@
-# 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/.
-
-from math import log
-from random import Random
-
-from hypothesis import (
-    HealthCheck,
-    Phase,
-    Verbosity,
-    assume,
-    example,
-    given,
-    settings,
-    strategies as st,
-)
-from hypothesis.internal.compat import ceil, int_from_bytes
-from hypothesis.internal.conjecture.data import ConjectureData
-from hypothesis.internal.conjecture.engine import ConjectureRunner
-
-
-@st.composite
-def problem(draw):
-    b = draw(st.binary(min_size=1, max_size=8))
-    m = int_from_bytes(b) * 256
-    assume(m > 0)
-    marker = draw(st.binary(max_size=8))
-    bound = draw(st.integers(0, m - 1))
-    return (b, marker, bound)
-
-
-base_settings = settings(
-    database=None,
-    deadline=None,
-    suppress_health_check=HealthCheck.all(),
-    max_examples=10,
-    verbosity=Verbosity.normal,
-    phases=(Phase.explicit, Phase.generate),
-)
-
-
-@example((b"\x10\x00\x00\x00\x00\x00", b"", 2861143707951135))
-@example((b"\x05Cn", b"%\x1b\xa0\xfa", 12394667))
-@example((b"\x179 f", b"\xf5|", 24300326997))
-@example((b"\x05*\xf5\xe5\nh", b"", 1076887621690235))
-@example((b"=", b"", 2508))
-@example((b"\x01\x00", b"", 20048))
-@example((b"\x01", b"", 0))
-@example((b"\x02", b"", 258))
-@example((b"\x08", b"", 1792))
-@example((b"\x0c", b"", 0))
-@example((b"\x01", b"", 1))
-@settings(
-    base_settings,
-    verbosity=Verbosity.normal,
-    phases=(
-        # We disable shrinking for this test because when it fails it's a sign
-        # that the shrinker is working really badly, so it ends up very slow!
-        Phase.explicit,
-        Phase.generate,
-    ),
-    max_examples=20,
-)
-@given(problem())
-def test_avoids_zig_zag_trap(p):
-    b, marker, lower_bound = p
-
-    n_bits = 8 * (len(b) + 1)
-
-    def test_function(data):
-        m = data.draw_bits(n_bits)
-        if m < lower_bound:
-            data.mark_invalid()
-        n = data.draw_bits(n_bits)
-        if data.draw_bytes(len(marker)) != marker:
-            data.mark_invalid()
-        if abs(m - n) == 1:
-            data.mark_interesting()
-
-    runner = ConjectureRunner(
-        test_function,
-        database_key=None,
-        settings=settings(base_settings, phases=(Phase.generate, Phase.shrink)),
-        random=Random(0),
-    )
-
-    runner.cached_test_function(b + bytes(0) + b + bytes(1) + marker)
-
-    assert runner.interesting_examples
-
-    runner.run()
-
-    (v,) = runner.interesting_examples.values()
-
-    data = ConjectureData.for_buffer(v.buffer)
-
-    m = data.draw_bits(n_bits)
-    n = data.draw_bits(n_bits)
-    assert m == lower_bound
-    if m == 0:
-        assert n == 1
-    else:
-        assert n == m - 1
-
-    budget = 2 * n_bits * ceil(log(n_bits, 2)) + 2
-
-    assert runner.shrinks <= budget

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/redis Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/redis/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/redis/test_redis_exampledatabase.py Deleted

@@ -1,92 +0,0 @@
-# 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 pytest
-from fakeredis import FakeRedis
-
-from hypothesis import strategies as st
-from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.errors import InvalidArgument
-from hypothesis.extra.redis import RedisExampleDatabase
-from hypothesis.stateful import Bundle, RuleBasedStateMachine, rule
-
-
-@pytest.mark.parametrize(
-    "kw",
-    
-        {"redis": "not a redis instance"},
-        {"redis": FakeRedis(), "expire_after": 10},  # not a timedelta
-        {"redis": FakeRedis(), "key_prefix": "not a bytestring"},
-    ,
-)
-def test_invalid_args_raise(kw):
-    with pytest.raises(InvalidArgument):
-        RedisExampleDatabase(**kw)
-
-
-def test_all_methods():
-    db = RedisExampleDatabase(FakeRedis())
-    db.save(b"key1", b"value")
-    assert list(db.fetch(b"key1")) == b"value"
-    db.move(b"key1", b"key2", b"value")
-    assert list(db.fetch(b"key1")) == 
-    assert list(db.fetch(b"key2")) == b"value"
-    db.delete(b"key2", b"value")
-    assert list(db.fetch(b"key2")) == 
-    db.delete(b"key2", b"unknown value")
-
-
-class DatabaseComparison(RuleBasedStateMachine):
-    def __init__(self):
-        super().__init__()
-        self.dbs = 
-            InMemoryExampleDatabase(),
-            RedisExampleDatabase(FakeRedis()),
-        
-
-    keys = Bundle("keys")
-    values = Bundle("values")
-
-    @rule(target=keys, k=st.binary())
-    def k(self, k):
-        return k
-
-    @rule(target=values, v=st.binary())
-    def v(self, v):
-        return v
-
-    @rule(k=keys, v=values)
-    def save(self, k, v):
-        for db in self.dbs:
-            db.save(k, v)
-
-    @rule(k=keys, v=values)
-    def delete(self, k, v):
-        for db in self.dbs:
-            db.delete(k, v)
-
-    @rule(k1=keys, k2=keys, v=values)
-    def move(self, k1, k2, v):
-        for db in self.dbs:
-            db.move(k1, k2, v)
-
-    @rule(k=keys)
-    def values_agree(self, k):
-        last = None
-        last_db = None
-        for db in self.dbs:
-            keys = set(db.fetch(k))
-            if last is not None:
-                assert last == keys, (last_db, db)
-            last = keys
-            last_db = db
-
-
-TestDBs = DatabaseComparison.TestCase

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/typing_extensions Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/typing_extensions/__init__.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tests/typing_extensions/test_backported_types.py Deleted

@@ -1,298 +0,0 @@
-# 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 collections
-import sys
-from typing import Callable, Dict, List, Union
-
-import pytest
-from typing_extensions import (
-    Annotated,
-    Concatenate,
-    DefaultDict,
-    Literal,
-    NewType,
-    NotRequired,
-    ParamSpec,
-    Required,
-    Type,
-    TypedDict,
-    TypeGuard,
-)
-
-from hypothesis import assume, given, strategies as st
-from hypothesis.errors import InvalidArgument
-from hypothesis.strategies import from_type
-from hypothesis.strategies._internal.types import NON_RUNTIME_TYPES
-
-from tests.common.debug import assert_all_examples, find_any
-
-# See also nocover/test_type_lookp.py
-
-
-@pytest.mark.parametrize("value", "dog", b"goldfish", 42, 63.4, -80.5, False)
-def test_typing_extensions_Literal(value):
-    assert from_type(Literalvalue).example() == value
-
-
-@given(st.data())
-def test_typing_extensions_Literal_nested(data):
-    lit = Literal
-    values = 
-        (lit"hamster", 0, ("hamster", 0)),
-        (lit26, False, "bunny", 130, (26, False, "bunny", 130)),
-        (litlit1, {1}),
-        (litlit1, 2, {1, 2}),
-        (lit1, lit2, 3, {1, 2, 3}),
-        (litlitlit1, lit2, litlit3, lit4, {1, 2, 3, 4}),
-        # See https://github.com/HypothesisWorks/hypothesis/pull/2886
-        (UnionLiteral"hamster", Literal"bunny", {"hamster", "bunny"}),
-        (Unionlitlit1, lit2, litlit3, lit4, {1, 2, 3, 4}),
-    
-    literal_type, flattened_literals = data.draw(st.sampled_from(values))
-    assert data.draw(st.from_type(literal_type)) in flattened_literals
-
-
-class A(TypedDict):
-    a: int
-
-
-@given(from_type(A))
-def test_simple_typeddict(value):
-    assert type(value) == dict
-    assert set(value) == {"a"}
-    assert isinstance(value"a", int)
-
-
-def test_typing_extensions_Type_int():
-    assert from_type(Typeint).example() is int
-
-
-@given(from_type(TypeUnionstr, list))
-def test_typing_extensions_Type_Union(ex):
-    assert ex in (str, list)
-
-
-def test_resolves_NewType():
-    typ = NewType("T", int)
-    nested = NewType("NestedT", typ)
-    uni = NewType("UnionT", Unionint, None)
-    assert isinstance(from_type(typ).example(), int)
-    assert isinstance(from_type(nested).example(), int)
-    assert isinstance(from_type(uni).example(), (int, type(None)))
-
-
-@given(from_type(DefaultDictint, int))
-def test_defaultdict(ex):
-    assert isinstance(ex, collections.defaultdict)
-    assume(ex)
-    assert all(isinstance(elem, int) for elem in ex)
-    assert all(isinstance(elem, int) for elem in ex.values())
-
-
-@pytest.mark.parametrize(
-    "annotated_type,expected_strategy_repr",
-    
-        (Annotatedint, "foo", "integers()"),
-        (AnnotatedListfloat, "foo", "lists(floats())"),
-        (AnnotatedAnnotatedstr, "foo", "bar", "text()"),
-        (
-            AnnotatedAnnotatedListDictstr, bool, "foo", "bar",
-            "lists(dictionaries(keys=text(), values=booleans()))",
-        ),
-    ,
-)
-def test_typing_extensions_Annotated(annotated_type, expected_strategy_repr):
-    assert repr(st.from_type(annotated_type)) == expected_strategy_repr
-
-
-PositiveInt = Annotatedint, st.integers(min_value=1)
-MoreThenTenInt = AnnotatedPositiveInt, st.integers(min_value=10 + 1)
-WithTwoStrategies = Annotatedint, st.integers(), st.none()
-ExtraAnnotationNoStrategy = AnnotatedPositiveInt, "metadata"
-
-
-def arg_positive(x: PositiveInt):
-    assert x > 0
-
-
-def arg_more_than_ten(x: MoreThenTenInt):
-    assert x > 10
-
-
-@given(st.data())
-def test_annotated_positive_int(data):
-    data.draw(st.builds(arg_positive))
-
-
-@given(st.data())
-def test_annotated_more_than_ten(data):
-    data.draw(st.builds(arg_more_than_ten))
-
-
-@given(st.data())
-def test_annotated_with_two_strategies(data):
-    assert data.draw(st.from_type(WithTwoStrategies)) is None
-
-
-@given(st.data())
-def test_annotated_extra_metadata(data):
-    assert data.draw(st.from_type(ExtraAnnotationNoStrategy)) > 0
-
-
-@pytest.mark.parametrize("non_runtime_type", NON_RUNTIME_TYPES)
-def test_non_runtime_type_cannot_be_resolved(non_runtime_type):
-    strategy = st.from_type(non_runtime_type)
-    with pytest.raises(
-        InvalidArgument, match="there is no such thing as a runtime instance"
-    ):
-        strategy.example()
-
-
-@pytest.mark.parametrize("non_runtime_type", NON_RUNTIME_TYPES)
-def test_non_runtime_type_cannot_be_registered(non_runtime_type):
-    with pytest.raises(
-        InvalidArgument, match="there is no such thing as a runtime instance"
-    ):
-        st.register_type_strategy(non_runtime_type, st.none())
-
-
-@pytest.mark.skipif(sys.version_info <= (3, 7), reason="requires python3.8 or higher")
-def test_callable_with_concatenate():
-    P = ParamSpec("P")
-    func_type = CallableConcatenateint, P, None
-    strategy = st.from_type(func_type)
-    with pytest.raises(
-        InvalidArgument,
-        match="Hypothesis can't yet construct a strategy for instances of a Callable type",
-    ):
-        strategy.example()
-
-    with pytest.raises(InvalidArgument, match="Cannot register generic type"):
-        st.register_type_strategy(func_type, st.none())
-
-
-@pytest.mark.skipif(sys.version_info <= (3, 7), reason="requires python3.8 or higher")
-def test_callable_with_paramspec():
-    P = ParamSpec("P")
-    func_type = CallableP, None
-    strategy = st.from_type(func_type)
-    with pytest.raises(
-        InvalidArgument,
-        match="Hypothesis can't yet construct a strategy for instances of a Callable type",
-    ):
-        strategy.example()
-
-    with pytest.raises(InvalidArgument, match="Cannot register generic type"):
-        st.register_type_strategy(func_type, st.none())
-
-
-@pytest.mark.skipif(sys.version_info <= (3, 7), reason="requires python3.8 or higher")
-def test_callable_return_typegard_type():
-    strategy = st.from_type(Callable, TypeGuardint)
-    with pytest.raises(
-        InvalidArgument,
-        match="Hypothesis cannot yet construct a strategy for callables "
-        "which are PEP-647 TypeGuards",
-    ):
-        strategy.example()
-
-    with pytest.raises(InvalidArgument, match="Cannot register generic type"):
-        st.register_type_strategy(Callable, TypeGuardint, st.none())
-
-
-class Movie(TypedDict):  # implicitly total=True
-    title: str
-    year: NotRequiredint
-
-
-@given(from_type(Movie))
-def test_typeddict_not_required(value):
-    assert type(value) == dict
-    assert set(value).issubset({"title", "year"})
-    assert isinstance(value"title", str)
-    if "year" in value:
-        assert isinstance(value"year", int)
-
-
-def test_typeddict_not_required_can_skip():
-    find_any(from_type(Movie), lambda movie: "year" not in movie)
-
-
-class OtherMovie(TypedDict, total=False):
-    title: Requiredstr
-    year: int
-
-
-@given(from_type(OtherMovie))
-def test_typeddict_required(value):
-    assert type(value) == dict
-    assert set(value).issubset({"title", "year"})
-    assert isinstance(value"title", str)
-    if "year" in value:
-        assert isinstance(value"year", int)
-
-
-def test_typeddict_required_must_have():
-    assert_all_examples(from_type(OtherMovie), lambda movie: "title" in movie)
-
-
-class Story(TypedDict, total=True):
-    author: str
-
-
-class Book(Story, total=False):
-    pages: int
-
-
-class Novel(Book):
-    genre: Requiredstr
-    rating: NotRequiredstr
-
-
-@pytest.mark.parametrize(
-    "check,condition",
-    
-        pytest.param(
-            assert_all_examples,
-            lambda novel: "author" in novel,
-            id="author-is-required",
-        ),
-        pytest.param(
-            assert_all_examples, lambda novel: "genre" in novel, id="genre-is-required"
-        ),
-        pytest.param(
-            find_any, lambda novel: "pages" in novel, id="pages-may-be-present"
-        ),
-        pytest.param(
-            find_any, lambda novel: "pages" not in novel, id="pages-may-be-absent"
-        ),
-        pytest.param(
-            find_any, lambda novel: "rating" in novel, id="rating-may-be-present"
-        ),
-        pytest.param(
-            find_any, lambda novel: "rating" not in novel, id="rating-may-be-absent"
-        ),
-    ,
-)
-def test_required_and_not_required_keys(check, condition):
-    check(from_type(Novel), condition)
-
-
-def test_typeddict_error_msg():
-    with pytest.raises(TypeError, match="is not valid as type argument"):
-
-        class Foo(TypedDict):
-            attr: Required
-
-    with pytest.raises(TypeError, match="is not valid as type argument"):
-
-        class Bar(TypedDict):
-            attr: NotRequired

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-python/tox.ini Deleted

@@ -1,178 +0,0 @@
-tox
-envlist = py{37,py37,38,py38,39,py39,310,311,312}-{brief,prettyquick,full,custom}
-toxworkdir={env:TOX_WORK_DIR:.tox}
-
-testenv
-deps =
-    -r../requirements/test.txt
-whitelist_externals=
-    bash
-passenv=
-    HOME
-    LC_ALL
-    COVERAGE_FILE
-    TOXENV
-    # Allow CI builds (or user builds) to force coloured terminal output.
-    PY_COLORS
-setenv=
-    PYTHONDEVMODE=1
-    brief: HYPOTHESIS_PROFILE=speedy
-commands =
-    full: bash scripts/basic-test.sh
-    brief: python -bb -X dev -m pytest tests/cover/test_testdecorators.py {posargs}
-    prettyquick: python -bb -X dev -m pytest tests/cover/
-    custom: python -bb -X dev -m pytest {posargs}
-
-testenv:py310-pyjion
-deps =
-    -r../requirements/test.txt
-    # We'd like to pin this, but pip-compile has to run under Python 3.10 (+)
-    # to do so and that's painful because other tools aren't compatible yet.
-    # If it's mid-2022, try again, starting by updating ci_version to 3.10
-    pyjion
-commands =
-    # TODO: restore `-n auto` https://github.com/tonybaloney/Pyjion/issues/456
-    # TODO: re-enable in Actions main.yml once this actually works
-    pyjion -m pytest tests/cover tests/pytest tests/nocover
-
-testenv:quality
-deps=
-    -r../requirements/test.txt
-commands=
-    python -bb -X dev -m pytest tests/quality/ -n auto
-
-# Note: when adding or removing tested Pandas versions, make sure to update the
-# docs in numpy.py too.  To see current download rates of each minor version:
-# https://pepy.tech/project/pandas?versions=0.25.*&versions=1.0.*&versions=1.1.*&versions=1.2.*&versions=1.3.*
-testenv:pandas25
-deps =
-    -r../requirements/test.txt
-    pandas~=0.25.0
-commands =
-    python -bb -X dev -m pytest tests/pandas -n auto
-
-testenv:pandas10
-deps =
-    -r../requirements/test.txt
-    pandas~=1.0.0
-commands =
-    python -bb -X dev -m pytest tests/pandas -n auto
-
-testenv:pandas11
-deps =
-    -r../requirements/test.txt
-    pandas~=1.1.5
-commands =
-    python -bb -X dev -m pytest tests/pandas -n auto
-
-testenv:pandas12
-deps =
-    -r../requirements/test.txt
-    pandas~=1.2.5
-commands =
-    python -bb -X dev -m pytest tests/pandas -n auto
-
-testenv:pandas13
-deps =
-    -r../requirements/test.txt
-    pandas~=1.3.4
-commands =
-    python -bb -X dev -m pytest tests/pandas -n auto
-# Adding a new pandas?  See comment above!
-
-testenv:django22
-commands =
-    pip install .pytz
-    pip install django~=2.2.25
-    python -bb -X dev -m tests.django.manage test tests.django
-
-testenv:django32
-commands =
-    pip install .pytz
-    pip install django~=3.2.10
-    python -bb -X dev -m tests.django.manage test tests.django
-
-testenv:django40
-commands =
-    pip install django~=4.0.0
-    python -bb -X dev -m tests.django.manage test tests.django
-
-testenv:nose
-deps =
-    nose
-commands=
-    nosetests tests/cover/test_testdecorators.py
-
-testenv:pytest46
-deps =
-    -r../requirements/test.txt
-commands=
-    pip install pytest==4.6.11 pytest-xdist==1.34
-    python -bb -X dev -m pytest tests/pytest tests/cover/test_testdecorators.py
-
-testenv:pytest54
-deps =
-    -r../requirements/test.txt
-commands=
-    pip install pytest==5.4.3 pytest-xdist
-    python -bb -X dev -m pytest tests/pytest tests/cover/test_testdecorators.py
-
-testenv:pytest62
-deps =
-    -r../requirements/test.txt
-commands=
-    pip install pytest==6.2.5 pytest-xdist
-    python -bb -X dev -m pytest tests/pytest tests/cover/test_testdecorators.py
-
-testenv:pytest7
-deps =
-    -r../requirements/test.txt
-commands=
-    pip install pytest==7.* pytest-xdist
-    python -bb -X dev -m pytest tests/pytest tests/cover/test_testdecorators.py
-
-testenv:coverage
-deps =
-    -r../requirements/coverage.txt
-whitelist_externals=
-    rm
-setenv=
-    PYTHONDEVMODE=1
-    HYPOTHESIS_INTERNAL_COVERAGE=true
-commands_pre =
-    rm -f branch-check
-    pip install .zoneinfo
-    python -m coverage --version
-    python -m coverage debug sys
-    # Explicitly erase any old .coverage file so the report never sees it.
-    python -m coverage erase
-# Produce a coverage report even if the test suite fails.
-# (The tox task will still count as failed.)
-ignore_errors = true
-commands =
-    python -bb -X dev -m coverage run --rcfile=.coveragerc --source=hypothesis -m pytest -n0 --strict-markers --ff {posargs} \
-        tests/cover tests/conjecture tests/datetime tests/numpy tests/pandas tests/lark tests/redis tests/dpcontracts tests/codemods tests/typing_extensions
-    python -m coverage report -m --fail-under=100 --show-missing --skip-covered
-    python scripts/validate_branch_check.py
-
-
-testenv:conjecture-coverage
-deps =
-    -r../requirements/coverage.txt
-setenv=
-    PYTHONDEVMODE=1
-    HYPOTHESIS_INTERNAL_COVERAGE=true
-commands_pre =
-    python -m coverage erase
-ignore_errors = true
-commands =
-    python -bb -X dev -m coverage run --rcfile=.coveragerc --source=hypothesis.internal.conjecture -m pytest -n0 --strict-markers tests/conjecture
-    python -m coverage report -m --fail-under=100 --show-missing --skip-covered
-
-
-testenv:examples3
-deps=
-    -r../requirements/test.txt
-commands=
-    python -m pip install --editable examples/example_hypothesis_entrypoint
-    python -bb -X dev -m pytest examples

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/.gitignore Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/.rspec Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/.rubocop.yml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/.ruby-version Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/CHANGELOG.md Deleted

@@ -1,143 +0,0 @@
-# Hypothesis for Ruby 0.7.1 (2021-03-27)
-
-This patch fixes some internal typos.  There is no user-visible change.
-
-# Hypothesis for Ruby 0.7.0 (2021-03-12)
-
-Moves rake from being a a runtime dependency to being a development dependency. Rake is used to run tests but is not required for consumers of hypothesis-ruby.
-
-# Hypothesis for Ruby 0.6.1 (2021-02-01)
-
-This patch contains minor performance improvements for `HypothesisCoreIntegers` class instantiation.
-
-# Hypothesis for Ruby 0.6.0 (2021-01-27)
-
-Adds support for skipping shrinking. While shrinking is extremely helpful and important in general, it has the potential to be quite time consuming. It can be useful to observe a raw failure before choosing to allow the engine to try to shrink. hypothesis-python(https://hypothesis.readthedocs.io/en/latest/settings.html#phases) already provides the ability to skip shrinking, so there is precedent for this being useful. While `hypothesis-ruby` does not have the concept of other "Phases" yet, we can still start off the API by using this concept.
-
-Usage:
-
-```
-hypothesis(phases: Phase.excluding(:shrink)) do
-  # Failures here will be displayed directly and shrinking will be avoided
-end
-```
-
-# Hypothesis for Ruby 0.5.0 (2021-01-25)
-
-Adds support for skipping shrinking. While shrinking is extremely helpful and important in general, it has the potential to be quite time consuming. It can be useful to observe a raw failure before choosing to allow the engine to try to shrink. hypothesis-python(https://hypothesis.readthedocs.io/en/latest/settings.html#phases) already provides the ability to skip shrinking, so there is precedent for this being useful. While `hypothesis-ruby` does not have the concept of other "Phases" yet, we can still start off the API by using this concept.
-
-Usage:
-
-```
-hypothesis(phases: Phase.excluding(:shrink)) do
-  # Failures here will be displayed directly and shrinking will be avoided
-end
-```
-
-# Hypothesis for Ruby 0.4.0 (2021-01-12)
-
-This removes hypothesis-ruby's dependence on RSpec. Now, it can be used with any Ruby test runner.
-
-# Hypothesis for Ruby 0.3.0 (2021-01-08)
-
-This release converts Hypothesis for Ruby to use RuTie(https://github.com/danielpclark/rutie)
-instead of the deprecated Helix(https://github.com/tildeio/helix), restoring compatibility
-with recent versions of Rust.  Thanks to Alex Weisberger for taking this on!
-
-# Hypothesis for Ruby 0.2.0 (2018-10-24)
-
-This release adds an example database to Hypothesis for Ruby. This means that when a test fails,
-it will automatically reuse the previously shown example when you rerun it, without having to
-manually pass a seed.
-
-# Hypothesis for Ruby 0.1.2 (2018-09-24)
-
-This release makes the code usable via a direct require.
-I.e. no need for rubygems or any special LOAD_PATH.
-
-For example, if the base directory were in /opt, you'd just say:
-require "/opt/hypothesis/hypothesis-ruby/lib/hypothesis"
-
-# Hypothesis for Ruby 0.1.1 (2018-08-31)
-
-This release fixes minor documentation issues.
-
-Thanks to Tessa Bradbury for this contribution.
-
-# Hypothesis for Ruby 0.1.0 (2018-07-16)
-
-This release adds support for reporting multiple exceptions when Hypothesis
-finds more than one way for the test to fail.
-
-# Hypothesis for Ruby 0.0.15 (2018-06-25)
-
-This release fixes an occasional `RuntimeError` that could occur
-when shrinking a failing test.
-
-# Hypothesis for Ruby 0.0.14 (2018-06-25)
-
-This release updates the release date to the correct date, as part of fixing a
-bug which caused the last couple of releases (0.0.11, 0.0.12, and 0.0.13) to
-have an incorrect date.
-
-# Hypothesis for Ruby 0.0.13 (2018-06-25)
-
-This release moves the core Rust engine into the separate Conjecture crate. It
-should have no user visible effect.
-
-# Hypothesis for Ruby 0.0.12 (2018-06-23)
-
-This release is the beginning of splitting out the Rust core of Hypothesis
-Ruby into a separate `conjecture` crate for the non-Ruby-specific components
-of it.
-
-It should have no user visible impact.
-
-# Hypothesis for Ruby 0.0.11 (2018-06-22)
-
-This release has no user-visible changes other than updating the gemspec's
-homepage attribute.
-
-## Hypothesis for Ruby 0.0.10 (2018-04-26)
-
-This release is another update to shrinking:
-
-* Cases where the value may be simplified without necessarily
-  becoming smaller will have better results.
-* Duplicated values can now sometimes be simultaneously shrunk.
-
-## Hypothesis for Ruby 0.0.9 (2018-04-20)
-
-This improves Hypothesis for Ruby's shrinking to be much closer
-to Hypothesis for Python's. It's still far from complete, and even
-in cases where it has the same level of quality it will often be
-significantly slower, but examples should now be much more consistent,
-especially in cases where you are using e.g. `built_as`.
-
-## Hypothesis for Ruby 0.0.8 (2018-02-20)
-
-This release fixes the dependency on Rake to be in a more sensible range.
-
-## Hypothesis for Ruby 0.0.7 (2018-02-19)
-
-This release updates an error in the README.
-
-## Hypothesis for Ruby 0.0.6 (2018-02-19)
-
-This release just updates the gem description.
-
-## Hypothesis for Ruby 0.0.5 (2018-02-19)
-
-This is a trivial release to test the release automation.
-It should have no user visible impact.
-
-## Hypothesis for Ruby 0.0.3 (2018-02-19)
-
-This is an initial developer preview of Hypothesis for Ruby.
-It's ready to use, but isn't yet stable and has significant
-limitations. It is mostly released so that people can easily give
-feedback on the API and implementation, and is likely to change
-substantially before a stable release.
-
-Note that while there were some earlier release numbers internally,
-these were pulled. This is the first official release.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/Cargo.toml Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/Gemfile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/Gemfile.lock Deleted

@@ -1,68 +0,0 @@
-PATH
-  remote: .
-  specs:
-    hypothesis-specs (0.7.0)
-      rutie (~> 0.0.3)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.4.0)
-    diff-lcs (1.3)
-    docile (1.1.5)
-    json (2.1.0)
-    minitest (5.8.5)
-    parallel (1.12.1)
-    parser (2.5.1.0)
-      ast (~> 2.4.0)
-    powerpack (0.1.1)
-    rainbow (2.2.2)
-      rake
-    rake (12.3.1)
-    redcarpet (3.4.0)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
-    rubocop (0.51.0)
-      parallel (~> 1.10)
-      parser (>= 2.3.3.1, < 3.0)
-      powerpack (~> 0.1)
-      rainbow (>= 2.2.2, < 3.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.9.0)
-    rutie (0.0.4)
-    simplecov (0.15.1)
-      docile (~> 1.1.0)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    unicode-display_width (1.3.2)
-    yard (0.9.12)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  hypothesis-specs!
-  minitest (~> 5.8.4)
-  rake (>= 10.0, < 14.0)
-  redcarpet (~> 3.4.0)
-  rspec (~> 3.0)
-  rubocop (~> 0.51.0)
-  rutie (~> 0.0.3)
-  simplecov (~> 0.15.1)
-  yard (~> 0.9.12)
-
-BUNDLED WITH
-   2.2.15

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/LICENSE.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/README.markdown Deleted

@@ -1,86 +0,0 @@
-# Hypothesis for Ruby
-
-Hypothesis is a powerful, flexible, and easy to use library for *property-based testing*.
-
-In property-based testing,
-in contrast to traditional *example-based testing*,
-a test is written not against a single example but as a statement that should hold for any of a range of possible values.
-
-## Usage
-
-In Hypothesis for Ruby, a test looks something like this:
-
-```ruby
-require "hypothesis"
-
-RSpec.configure do |config|
-  config.include(Hypothesis)
-  config.include(Hypothesis::Possibilities)
-end
-
-RSpec.describe "removing an element from a list" do
-  it "results in the element no longer being in the list" do
-    hypothesis do
-      # Or lists(of: integers, min_size: 1), but this lets us
-      # demonstrate assume.
-      values = any array(of: integers)
-
-      # If this is not true then the test will stop here.
-      assume values.size > 0
-
-      to_remove = any element_of(values)
-
-      values.delete_at(values.index(to_remove))
-
-      # Will fail if the value was duplicated in the list.
-      expect(values.include?(to_remove)).to be false
-      
-    end
-  end
-end
-```
-
-This would then fail with:
-
-```
-  1) removing an element from a list results in the element no longer being in the list
-     Failure/Error: expect(values.include?(to_remove)).to be false
-
-       Given #1: 0, 0
-       Given #2: 0
-
-       expected false
-            got true
-```
-
-The use of RSpec here is incidental:
-Hypothesis for Ruby works just as well with minitest,
-and should work with anything else you care to use.
-
-## Getting Started
-
-Hypothesis is available on rubygems.org as a developer preview.
-If you want to try it today you can use the current development branch by adding the following to your Gemfile:
-
-```ruby
-gem 'hypothesis-specs'
-```
-
-The API is still in flux, so be warned that you should expect it to break on upgrades!
-Right now this is really more to allow you to try it out and provide feedback than something you should expect to rely on.
-The more feedback we get, the sooner it will get there!
-
-Note that in order to use Hypothesis for Ruby, you will need a rust toolchain installed.
-Please go to https://www.rustup.rs(https://www.rustup.rs) and follow the instructions if you do not already have one. You will most likely need to compile your Ruby executable with the `--enable-shared` option. See here(https://github.com/danielpclark/rutie#dynamic-vs-static-builds).
-
-## Project Status
-
-Hypothesis for Ruby is currently in an *early alpha* stage.
-It works, and has a solid core set of features, but you should expect to find rough edges,
-it is far from feature complete, and the API makes no promises of backwards compatibility.
-
-Right now you should consider it to be more in the spirit of a developer preview.
-You can and should try it out, and hopefully you will find all sorts of interesting bugs in your code by doing so!
-But you'll probably find interesting bugs in Hypothesis too,
-and we'd appreciate you reporting them,
-as well as any just general usability issues or points of confusion you have.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/Rakefile Deleted

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'date'
-require 'open3'
-
-task :build do
-  sh('cargo build --release')
-end
-
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-
-  require 'rake/testtask'
-
-  Rake::TestTask.new(minitests: :build) do |t|
-    t.test_files = FileList'minitests/**/test_*.rb'
-    t.verbose = true
-  end
-
-  task test: %ibuild spec minitests
-  task rspec: %ibuild spec
-  task minitest: %ibuild without_rspec do
-    begin
-      Rake::Task'minitests'.execute
-    ensure
-      Rake::Task'with_rspec'.execute
-    end
-  end
-rescue LoadError
-end
-
-task :without_rspec do
-  sh('bundle config set without rspec')
-end
-
-task :with_rspec do
-  sh('bundle config unset without')
-end
-
-def rubocop(fix:)
-  sh "bundle exec rubocop #{'-a' if fix} lib spec minitests " \
-  'Rakefile hypothesis-specs.gemspec'
-end
-
-task :checkformat do
-  rubocop(fix: false)
-end
-
-task :format do
-  rubocop(fix: true)
-end
-
-begin
-  require 'yard'
-
-  YARD::Rake::YardocTask.new(:runyard) do |t|
-    t.files = 
-      'lib/hypothesis.rb', 'lib/hypothesis/errors.rb',
-      'lib/hypothesis/possible.rb'
-    
-    t.options = '--markup=markdown', '--no-private'
-  end
-
-  task doc: :runyard do
-    YARD::Registry.load
-
-    objs = YARD::Registry.select do |o|
-      is_private = false
-      t = o
-      until t.root?
-        if t.visibility != :public
-          is_private = true
-          break
-        end
-        t = t.parent
-      end
-
-      !is_private && o.docstring.blank?
-    end
-
-    objs.sort_by! { |o| o.name.to_s }
-
-    unless objs.empty?
-      abort "Undocumented objects: #{objs.map(&:name).join(', ')}"
-    end
-  end
-rescue LoadError
-end
-
-GEMSPEC = 'hypothesis-specs.gemspec'
-
-RELEASE_FILE = 'RELEASE.md'
-CHANGELOG = 'CHANGELOG.md'
-
-def run_for_output(*args)
-  out, result = Open3.capture2(*args)
-  abort if result.exitstatus != 0
-  out.strip
-end
-
-task :clean do
-  sh 'git clean -fdx lib'
-  sh 'rm -rf hypothesis-specs*.gem'
-  sh 'rm -rf ../target'
-end
-
-task gem: :clean do
-  sh 'gem build hypothesis-specs.gemspec'
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/docs Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/docs/debt.md Deleted

@@ -1,92 +0,0 @@
-# A Series of Unfortunate Implementation Choices
-
-## In Which The Narrator Seeks To Justify Himself
-
-This project is currently in a somewhat expeditionary state,
-where its goal is not to produce wonderful software that will
-stand the test of time, but instead to prove its concept
-valid and get something working enough for me to decide
-whether it's worth it to continue down this route, and
-to decide whether it's worth it to continue funding it.
-
-As such, whenever presented with the question "Do we want it
-good or do we want it soon?" I am mostly choosing soon.
-
-BUT I am optimistic about the long-term viability of this
-project, and I do not wish to find future-David cursing the
-very name of past-David. In aid of squaring this particular
-circle, I am choosing to document every terrible thing that
-I knowingly do.
-
-The goals of this documentation are:
-
-* To make me feel bad, so that I'm less likely to do things
-  that are awful but not actually needed.
-* To explain the reasoning to future-me and those who come
-  after.
-* To make explicit the conditions under which the awful hack
-  may be removed.
-
-## Awful Hacks
-
-### Threads as a Control Flow Mechanism
-
-Rather than attempt to encode the generation state machine
-explicitly, which was proving to be absolutely awful, I
-decided to continue to write it synchronously. The Rust side
-of the equation does not control calling the test function,
-which makes this tricky (and having the asynchronous interface
-as the main API entry point is a long term good anyway).
-
-The ideal way of doing this would be with something lightweight,
-like a coroutines. The ideal way of doing coroutines would be
-Rust generators(https://doc.rust-lang.org/nightly/unstable-book/language-features/generators.html).
-
-Unfortunately this suffers from two problems:
-
-* It requires rust nightly. I would be prepared to live with this,
-  but it's sub-par.
-* The current implementation is one-way only: resume does not take
-  an argument.
-
-Alternate things tried: 
-
-* libfringe(https://github.com/edef1c/libfringe) seems lovely,
-  but also requires rust-nightly and the released version doesn't
-  actually build on rust nightly
-* I didn't really look into may(https://github.com/Xudong-Huang/may/)
-  after a) getting vaguely warned off it and b) Honestly having
-  coroutine implementation exhaustion at this point.
-
-So at this point I said "Screw it, threads work on stable, and the
-context switching overhead isn't going to be *that* large compared
-to all the other mess that's in this chain, so..."
-
-So, yeah, that's why the main loop runs in a separate thread and
-communicates with the main thread via a synchronous channel.
-
-Can be removed when one of:
-
-* Generators are on stable and support resuming with an argument.
-* libfringe works on stable
-* Either of the above but on unstable, and my frustration with
-  threading bugs (but fearless concurrency, David!) outweighs
-  my desire to not use nightly.
-
-### Stable identifiers from RSpec
-
-Another "I did terrible things to RSpec" entry, sorry. RSpec's
-design here is totally reasonable and sensible and honestly
-probably *is* how you should pass state around, but seems
-to make it impossible to get access to the Example object from
-inside an it block without actually being the definer of the
-block.
-
-See `hypothesis_stable_identifier` for details, but basically I
-couldn't figure out how to get the name of a currently executing
-spec in RSPec from a helper function without some fairly brutal
-hacks where we extract information badly from self.inspect, because
-it's there stored as a string that gets passed in for inspection.
-
-Can be removed when: Someone shows me a better way, or a
-feature is added to RSpec to make this easier.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/docs/design.md Deleted

@@ -1,123 +0,0 @@
-# Design Notes
-
-The current goals of the Hypothesis for Ruby project are:
-
-* To provide a useful but not wholly feature complete version of
-  Hypothesis(https://hypothesis.works/) for Ruby, that works with
-  RSpec (and ideally minitest, but if that at any point proves to
-  be a lot of work this may be dropped. It's not an explicit
-  requirement, but supporting it now makes it much easier to find
-  the right shape of the project design).
-* To provide a mostly feature complete version of the Conjecture
-  engine that powers Hypothesis in Rust, as decoupled from that
-  Ruby front-end as possible.
-
-Hypothesis for Ruby is not intended to be an exact feature for
-feature copy of the Python version. It will have a lot of the same
-underlying functionality, but with a number of changes driven by:
-
-* Trying to make it feel as "ruby native" as possible.
-* The ability to design an API from scratch that lacks many of the
-  constraints imposed both by the earlier much more limited functionality
-  of Hypothesis and the specifics of Python decorators and test
-  frameworks.
-
-## Differences
-
-The most fundamental API differences  between Hypothesis
-for Python and Hypothesis for Ruby are:
-
-* In Python we do a whole giant song and dance about exposing
-  functions for the test runner to call, while in Ruby we just
-  have a function which repeatedly calls a block and then fails.
-* In Python you specify a bunch of given parameters up front,
-  and then if you want values inline in the test you explicitly
-  opt in to it(https://hypothesis.readthedocs.io/en/latest/data.html#drawing-interactively-in-tests),
-  while in Ruby this is not only the default but the only way to
-  get those values.
-* Strategies are called Possibles because strategy is a terrible
-  name that was originally intended to be internal and then leaked
-  into the public API because I wasn't thinking hard about naming.
-* Many of the Possible implementations have different names than
-  the corresponding
-  names in hypothesis-python. There is also a weird dual naming
-  convention for Possibles where there is both e.g. `integers` and
-  `integer` as aliases for each other.
-
-So for example:
-
-```ruby
-RSPec.describe "integer addition" do
-  it "commutes" do
-    hypothesis do
-      m = any integer
-      n = any integer
-      expect(m + n).to eq(n + m)
-    end
-  end
-end
-```
-
-```python
-@given(integers(), integers())
-def test_integers_commute(m, n):
-    assert m + n == n + m
-```
-
-The in-line style is slightly more verbose, but vastly more flexible
-and (I think) reads better. Also mixing in-line and up-front
-styles looks weird, and if we're going to have just one then
-the in-line approach is a strict superset of the functionality
-of the other.
-
-The main reason for these differences are:
-
-* Ruby blocks (and their relation to testing) make this approach
-  much more natural.
-* This functionality was not actually possible when the Hypothesis
-  for Python API was originally designed, which informed the way
-  its API looks.
-
-## Deliberate omissions
-
-The following are currently *not* part of the intended feature set
-of Hypothesis for Ruby:
-
-* Calls to `hypothesis` may not be nested.
-* There will be no equivalent to the stateful testing(https://hypothesis.readthedocs.io/en/latest/stateful.html)
-  (but the very interactive nature of tests in the Ruby API means that
-  the generic state machine stuff is just something you can write in
-  your normal tests).
-* Testing will not be coverage guided (to be fair, it's barely coverage
-  guided in the Python version right now...)
-* There will probably not be a health check system as part of the initial
-  release, or if there is it will be much more basic.
-* Any equivalent to `@reproduce_failure`(https://hypothesis.readthedocs.io/en/latest/reproducing.html#reproducing-an-example-with-with-reproduce-failure)
-
-## Possible omissions
-
-The following will be in this initial project on a "time permitting" basis:
-If everything else is going well and we've got plenty of time, I'll do them,
-but I'm currently anticipating a tightish schedule so these are probably
-for a future release:
-
-* Reporting multiple failing examples per test (this will definitely be supported
-  in the core engine, and if it's easy to support it then it will
-  also be included in the front-end. I currently think it will be
-  easy, but if it's not it will be dropped).
-* adding explicit examples(https://hypothesis.readthedocs.io/en/latest/reproducing.html#providing-explicit-examples).
-
-## Current Project State
-
-The current state is best described as "nascent" - it demonstrates
-a lot of the right moving parts, but has rough edges that you will
-hit almost immediately if you try to use it. Those rough edges need
-to be filed off before it can be built.
-
-Things that don't work yet but will:
-
-* The Possible library is limited, and most of what is there is bad.
-* The shrinker is *very* primitive in comparison to in Python.
-* The example database does not yet exist.
-* It can't actually be installed as a gem! Note that even once it is
-  installable you will need a rust compiler and cargo.

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/ext Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/ext/Makefile Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/ext/extconf.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/hypothesis-specs.gemspec Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis.rb Deleted

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'hypothesis/junkdrawer'
-require_relative 'hypothesis/errors'
-require_relative 'hypothesis/possible'
-require_relative 'hypothesis/testcase'
-require_relative 'hypothesis/engine'
-require_relative 'hypothesis/world'
-
-module Phase
-  SHRINK = :shrink
-
-  module_function
-
-  def all
-    SHRINK
-  end
-
-  def excluding(*phases)
-    unknown_phases = phases.reject { |phase| Phase.all.include?(phase) }
-    unless unknown_phases.empty?
-      raise(
-        ArgumentError,
-        "Attempting to exclude unknown phases: #{unknown_phases}"
-      )
-    end
-
-    all - phases
-  end
-end
-
-# This is the main module for using Hypothesis.
-# It is expected that you will include this in your
-# tests, but its methods are also available on the
-# module itself.
-#
-# The main entry point for using this is the
-# {Hypothesis#hypothesis} method. All of the other
-# methods make sense only inside blocks passed to
-# it.
-module Hypothesis
-  # @!visibility private
-  HYPOTHESIS_LOCATION = File.dirname(__FILE__)
-  # rubocop:disable ClassVars
-  @@setup_called = false
-  # rubocop:enable RuleByName
-
-  def self.setup_called
-    @@setup_called == true
-  end
-
-  def self.included(*)
-    if setup_called == false
-      Rutie.new(:hypothesis_ruby_core).init(
-        'Init_rutie_hypothesis_core',
-        __dir__
-      )
-    end
-    @@setup_called = true
-  end
-
-  # @!visibility private
-  def hypothesis_stable_identifier
-    # Attempt to get a "stable identifier" for any any
-    # call into hypothesis. We use these to create
-    # database keys (or will when we have a database) that
-    # are stable across runs, so that when a test that
-    # previously failed is rerun, we can fetch and reuse
-    # the previous examples.
-
-    # Note that essentially any answer to this method is
-    # "fine" in that the failure mode is that sometimes we
-    # just won't run the same test, but it's nice to keep
-    # this as stable as possible if the code isn't changing.
-
-    # Minitest makes it nice and easy to create a stable
-    # test identifier, because it follows the classic xunit
-    # pattern where a test is just a method invocation on a
-    # fresh test class instance and it's easy to find out
-    # which invocation that was.
-    return "#{self.class.name}::#{@NAME}" if defined? @NAME
-
-    # If we are running in an rspec example then, sadly,
-    # rspec take the entirely unreasonable stance that
-    # the correct way to pass data to a test is by passing
-    # it as a function argument. Honestly, what is this,
-    # Haskell? Ahem. Perfectly reasonable design decisions
-    # on rspec's part, this creates some annoying difficulties
-    # for us. We solve this through brute force and ignorance
-    # by relying on the information we want being in the
-    # inspect for the Example object, even if it's just there
-    # as a string.
-    begin
-      is_rspec = is_a? RSpec::Core::ExampleGroup
-      # We do our coverage testing inside rspec, so this will
-      # never trigger! Though we also don't currently have a
-      # test that covers it outside of rspec...
-      # :nocov:
-    rescue NameError
-      is_rspec = false
-    end
-    # :nocov:
-
-    if is_rspec
-      return 
-        self.class.description,
-        inspect.match(/"(^"+)"/)1
-      .join(' ')
-    end
-
-    # Fallback time! We just walk the stack until we find the
-    # entry point into code we control. This will typically be
-    # where "hypothesis" was called.
-    Thread.current.backtrace.each do |line|
-      return line unless line.include?(Hypothesis::HYPOTHESIS_LOCATION)
-    end
-    # This should never happen unless something very strange is
-    # going on.
-    # :nocov:
-    raise 'BUG: Somehow we have no caller!'
-    # :nocov:
-  end
-
-  # Run a test using Hypothesis.
-  #
-  # For example:
-  #
-  # ```ruby
-  # hypothesis do
-  #   x = any integer
-  #   y = any integer(min: x)
-  #   expect(y).to be >= x
-  # end
-  # ```
-  #
-  # The arguments to `any` are `Possible` instances which
-  # specify the range of value values for it to return.
-  #
-  # Typically you would include this inside some test in your
-  # normal testing framework - e.g. in an rspec it block or a
-  # minitest test method.
-  #
-  # This will run the block many times with integer values for
-  # x and y, and each time it will pass because we specified that
-  # y had a minimum value of x.
-  # If we changed it to `expect(y).to be > x` we would see output
-  # like the following:
-  #
-  # ```
-  # Failure/Error: expect(y).to be > x
-  #
-  # Given #1: 0
-  # Given #2: 0
-  # expected: > 0
-  #      got:   0
-  # ```
-  #
-  # In more detail:
-  #
-  # hypothesis calls its provided block many times. Each invocation
-  # of the block is a *test case*.
-  # A test case has three important features:
-  #
-  # * *givens* are the result of a call to self.any, and are the
-  #   values that make up the test case. These might be values such
-  #   as strings, integers, etc. or they might be values specific to
-  #   your application such as a User object.
-  # * *assumptions*, where you call `self.assume(some_condition)`. If
-  #   an assumption fails (`some_condition` is false), then the test
-  #   case is considered invalid, and is discarded.
-  # * *assertions* are anything that will raise an error if the test
-  #   case should be considered a failure. These could be e.g. RSpec
-  #   expectations or minitest matchers, but anything that throws an
-  #   exception will be treated as a failed assertion.
-  #
-  # A test case which satisfies all of its assumptions and assertions
-  # is *valid*. A test-case which satisfies all of its assumptions but
-  # fails one of its assertions is *failing*.
-  #
-  # A call to hypothesis does the following:
-  #
-  # 1. It first tries to *reuse* failing test cases for previous runs.
-  # 2. If there were no previous failing test cases then it tries to
-  #    *generate* new failing test cases.
-  # 3. If either of the first two phases found failing test cases then
-  #    it will *shrink* those failing test cases.
-  # 4. Finally, it will *display* the shrunk failing test case by
-  #    the error from its failing assertion, modified to show the
-  #    givens of the test case.
-  #
-  # Reuse uses an internal representation of the test case, so examples
-  # from previous runs will obey all of the usual invariants of generation.
-  # However, this means that if you change your test then reuse may not
-  # work. Test cases that have become invalid or passing will be cleaned
-  # up automatically.
-  #
-  # Generation consists of randomly trying test cases until one of
-  # three things has happened:
-  #
-  # 1. It has found a failing test case. At this point it will start
-  #    *shrinking* the test case (see below).
-  # 2. It has found enough valid test cases. At this point it will
-  #    silently stop.
-  # 3. It has found so many invalid test cases that it seems unlikely
-  #    that it will find any more valid ones in a reasonable amount of
-  #    time. At this point it will either silently stop or raise
-  #    `Hypothesis::Unsatisfiable` depending on how many valid
-  #    examples it found.
-  #
-  # *Shrinking* is when Hypothesis takes a failing test case and tries
-  # to make it easier to understand. It does this by replacing the givens
-  # in the test case with smaller and simpler values. These givens will
-  # still come from the possible values, and will obey all the usual
-  # constraints.
-  # In general, shrinking is automatic and you shouldn't need to care
-  # about the details of it. If the test case you're shown at the end
-  # is messy or needlessly large, please file a bug explaining the problem!
-  #
-  # @param max_valid_test_cases Integer The maximum number of valid test
-  #   cases to run without finding a failing test case before stopping.
-  #
-  # @param database String, nil, false A path to a directory where Hypothesis
-  #   should store previously failing test cases. If it is nil, Hypothesis
-  #   will use a default of .hypothesis/examples in the current directory.
-  #   May also be set to false to disable the database functionality.
-  def hypothesis(
-    max_valid_test_cases: 200,
-    phases: Phase.all,
-    database: nil,
-    &block
-  )
-    unless World.current_engine.nil?
-      raise UsageError, 'Cannot nest hypothesis calls'
-    end
-
-    begin
-      World.current_engine = Engine.new(
-        hypothesis_stable_identifier,
-        max_examples: max_valid_test_cases,
-        phases: phases,
-        database: database
-      )
-      World.current_engine.run(&block)
-    ensure
-      World.current_engine = nil
-    end
-  end
-
-  # Supplies a value to be used in your hypothesis.
-  # @note It is invalid to call this method outside of a hypothesis block.
-  # @return Object A value provided by the possible argument.
-  # @param possible Possible A possible that specifies the possible values
-  #   to return.
-  # @param name String, nil An optional name to show next to the result on
-  #   failure. This can be helpful if you have a lot of givens in your
-  #   hypothesis, as it makes it easier to keep track of which is which.
-  def any(possible, name: nil, &block)
-    if World.current_engine.nil?
-      raise UsageError, 'Cannot call any outside of a hypothesis block'
-    end
-
-    World.current_engine.current_source.any(
-      possible, name: name, &block
-    )
-  end
-
-  # Specify an assumption of your test case. Only test cases which satisfy
-  # their assumptions will treated as valid, and all others will be
-  # discarded.
-  # @note It is invalid to call this method outside of a hypothesis block.
-  # @note Try to use this only with "easy" conditions. If the condition is
-  #   too hard to satisfy this can make your testing much worse, because
-  #   Hypothesis will have to retry the test many times and will struggle
-  #   to find "interesting" test cases. For example `assume(x != y)` is
-  #   typically fine, and `assume(x == y)` is rarely a good idea.
-  # @param condition Boolean The condition to assume. If this is false,
-  #   the current test case will be treated as invalid and the block will
-  #   exit by throwing an exception. The next test case will then be run
-  #   as normal.
-  def assume(condition)
-    if World.current_engine.nil?
-      raise UsageError, 'Cannot call assume outside of a hypothesis block'
-    end
-    World.current_engine.current_source.assume(condition)
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis/engine.rb Deleted

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'rutie'
-
-module Hypothesis
-  DEFAULT_DATABASE_PATH = File.join(Dir.pwd, '.hypothesis', 'examples')
-
-  class Engine
-    attr_reader :current_source
-    attr_accessor :is_find
-
-    def initialize(name, options)
-      seed = Random.rand(2**64 - 1)
-
-      database = options.fetch(:database, nil)
-
-      database = DEFAULT_DATABASE_PATH if database.nil?
-
-      database = nil if database == false
-
-      @core_engine = HypothesisCoreEngine.new(
-        name,
-        database,
-        seed,
-        options.fetch(:max_examples),
-        options.fetch(:phases)
-      )
-
-      @exceptions_to_tags = Hash.new { |h, k| hk = h.size }
-    end
-
-    def run
-      loop do
-        core = @core_engine.new_source
-        break if core.nil?
-        @current_source = TestCase.new(core)
-        begin
-          result = yield(@current_source)
-          if is_find && result
-            @core_engine.finish_interesting(core, 0)
-          else
-            @core_engine.finish_valid(core)
-          end
-        rescue UnsatisfiedAssumption
-          @core_engine.finish_invalid(core)
-        rescue DataOverflow
-          @core_engine.finish_overflow(core)
-        rescue Exception => e
-          raise if is_find
-          key = 
-            e.class,
-            HypothesisJunkDrawer.find_first_relevant_line(e.backtrace)
-          
-          @core_engine.finish_interesting(core, @exceptions_to_tagskey)
-        end
-      end
-      if @core_engine.count_failing_examples.zero?
-        raise Unsatisfiable if @core_engine.was_unsatisfiable
-        @current_source = nil
-        return
-      end
-
-      if is_find
-        core = @core_engine.failing_example(0)
-        @current_source = TestCase.new(core, record_draws: true)
-        yield @current_source
-      else
-        exceptions = 
-        (0...@core_engine.count_failing_examples).each do |example|
-          core = @core_engine.failing_example(example)
-          @current_source = TestCase.new(core, print_draws: true)
-
-          begin
-            yield @current_source
-          rescue Exception => e
-            givens = @current_source.print_log
-            given_str = givens.each_with_index.map do |(name, s), i|
-              name = "##{i + 1}" if name.nil?
-              "Given #{name}: #{s}"
-            end.to_a
-
-            if e.respond_to? :hypothesis_data
-              e.hypothesis_data0 = given_str
-            else
-              original_to_s = e.to_s
-              original_inspect = e.inspect
-
-              class <<e
-                attr_accessor :hypothesis_data
-
-                def to_s
-                  '', hypothesis_data0, '', hypothesis_data1.join("\n")
-                end
-
-                def inspect
-                  '', hypothesis_data0, '', hypothesis_data2.join("\n")
-                end
-              end
-              e.hypothesis_data = given_str, original_to_s, original_inspect
-            end
-            raise e if @core_engine.count_failing_examples == 1
-            exceptions.push(e)
-          end
-        end
-        raise Hypothesis::MultipleExceptionError.new(*exceptions)
-      end
-    end
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis/errors.rb Deleted

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Hypothesis
-  # A generic superclass for all errors thrown by
-  # Hypothesis.
-  class HypothesisError < RuntimeError
-  end
-
-  # Indicates that Hypothesis was not able to find
-  # enough valid examples for the test to be meaningful.
-  # (Currently this is only thrown if Hypothesis did not
-  # find *any* valid examples).
-  class Unsatisfiable < HypothesisError
-  end
-
-  # Indicates that the Hypothesis API has been used
-  # incorrectly in some manner.
-  class UsageError < HypothesisError
-  end
-
-  # @!visibility private
-  class UnsatisfiedAssumption < HypothesisError
-  end
-
-  # @!visibility private
-  class DataOverflow < HypothesisError
-  end
-
-  if defined?(RSpec::Core::MultipleExceptionError)
-    MultipleExceptionErrorParent = RSpec::Core::MultipleExceptionError
-  # :nocov:
-  else
-    class MultipleExceptionErrorParent < StandardError
-      def initialize(*exceptions)
-        super()
-
-        @all_exceptions = exceptions.to_a
-      end
-
-      attr_reader :all_exceptions
-    end
-  end
-
-  class MultipleExceptionError < MultipleExceptionErrorParent
-    def message
-      jd = HypothesisJunkDrawer
-      "Test raised #{all_exceptions.length} distinct errors:\n\n" +
-        all_exceptions.map do |e|
-          location = jd.find_first_relevant_line(e.backtrace).sub(/:in.+$/, '')
-          backtrace = jd.prune_backtrace(e.backtrace)
-          "#{e.class} at #{location}:\n" \
-            "#{e.message}\n#{backtrace.map { |s| '  ' + s }
-              .join("\n")}"
-        end.join("\n\n")
-    end
-
-    def backtrace
-      
-    end
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis/junkdrawer.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis/possible.rb Deleted

@@ -1,370 +0,0 @@
-# frozen_string_literal: true
-
-# @!visibility private
-class HypothesisCoreRepeatValues
-  def should_continue(source)
-    result = _should_continue(source.wrapped_data)
-    raise Hypothesis::DataOverflow if result.nil?
-    result
-  end
-end
-
-module Hypothesis
-  class <<self
-    include Hypothesis
-  end
-
-  # A Possible describes a range of valid values that
-  # can result from a call to {Hypothesis#any}.
-  # This class should not be subclassed directly, but
-  # instead should always be constructed using methods
-  # from {Hypothesis::Possibilities}.
-  class Possible
-    # @!visibility private
-    include Hypothesis
-
-    # A Possible value constructed by passing one of these
-    # Possible values to the provided block.
-    #
-    # e.g. the Possible values of `integers.map { |i| i * 2 }`
-    # are all even integers.
-    #
-    # @return Possible
-    # @yield A possible value of self.
-    def map
-      Implementations::CompositePossible.new do
-        yield any(self)
-      end
-    end
-
-    alias collect map
-
-    # One of these Possible values selected such that
-    # the block returns a true value for it.
-    #
-    # e.g. the Possible values of
-    # `integers.filter { |i| i % 2 == 0}`  are all even
-    # integers (but will typically be less efficient
-    # than the one suggested in {Possible#map}.
-    #
-    # @note Similar warnings to {Hypothesis#assume} apply
-    #   here: If the condition is difficult to satisfy this
-    #   may impact the performance and quality of your
-    #   testing.
-    #
-    # @return Possible
-    # @yield A possible value of self.
-    def select
-      Implementations::CompositePossible.new do
-        result = nil
-        4.times do |i|
-          assume(i < 3)
-          result = any self
-          break if yield(result)
-        end
-        result
-      end
-    end
-
-    alias filter select
-
-    # @!visibility private
-    module Implementations
-      # @!visibility private
-      class CompositePossible < Possible
-        def initialize(block = nil, &implicit)
-          @block = block || implicit
-        end
-
-        # @!visibility private
-        def provide(&block)
-          (@block || block).call
-        end
-      end
-
-      # @!visibility private
-      class PossibleFromCore < Possible
-        def initialize(core_possible)
-          @core_possible = core_possible
-        end
-
-        # @!visibility private
-        def provide
-          data = World.current_engine.current_source
-          result = @core_possible.provide(data.wrapped_data)
-          raise Hypothesis::DataOverflow if result.nil?
-          result
-        end
-      end
-    end
-  end
-
-  # A module of many common {Possible} implementations.
-  # Rather than subclassing Possible yourself you should use
-  # methods from this module to construct Possible values.`
-  #
-  # You can use methods from this module by including
-  # Hypothesis::Possibilities in your tests, or by calling them
-  # on the module object directly.
-  #
-  # Most methods in this module that return a Possible have
-  # two names: A singular and a plural name. These are
-  # simply aliases and are identical in every way, but are
-  # provided to improve readability. For example
-  # `any integer` reads better than `any integers`
-  # but `arrays(of: integers)` reads better than
-  # `arrays(of: integer)`.
-  module Possibilities
-    include Hypothesis
-
-    class <<self
-      include Possibilities
-    end
-
-    # built_as lets you chain multiple Possible values together,
-    # by providing whatever value results from its block.
-    #
-    # For example the following provides an array plus some
-    # element from that array:
-    #
-    # ```ruby
-    #   built_as do
-    #     ls = any array(of: integers)
-    #     # Or min_size: 1 above, but this shows use of
-    #     # assume
-    #     assume ls.size > 0
-    #     i = any element_of(ls)
-    #     ls, i
-    #   end
-    # ```
-    #
-    # @return Possible A Possible whose possible values are
-    #   any result from the passed block.
-    def built_as(&block)
-      Hypothesis::Possible::Implementations::CompositePossible.new(block)
-    end
-
-    alias values_built_as built_as
-
-    # A Possible boolean value
-    # @return Possible
-    def booleans
-      integers(min: 0, max: 1).map { |i| i == 1 }
-    end
-
-    alias boolean booleans
-
-    # A Possible unicode codepoint.
-    # @return Possible
-    # @param min Integer The smallest codepoint to provide
-    # @param max Integer The largest codepoint to provide
-    def codepoints(min: 1, max: 1_114_111)
-      base = integers(min: min, max: max)
-      if min <= 126
-        from(integers(min: min, max: 126, max.min), base)
-      else
-        base
-      end
-    end
-
-    alias codepoint codepoints
-
-    # A Possible String
-    # @return Possible
-    # @param codepoints Possible, nil The Possible codepoints
-    #   that can be found in the string. If nil,
-    #   will default to self.codepoints. These
-    #   will be further filtered to ensure the generated string is
-    #   valid.
-    # @param min_size Integer The smallest valid length for a
-    #   provided string
-    # @param max_size Integer The largest valid length for a
-    #   provided string
-    def strings(codepoints: nil, min_size: 0, max_size: 10)
-      codepoints = self.codepoints if codepoints.nil?
-      codepoints = codepoints.select do |i|
-        begin
-          i.pack('U*').codepoints
-          true
-        rescue ArgumentError
-          false
-        end
-      end
-      arrays(of: codepoints, min_size: min_size, max_size: max_size).map do |ls|
-        ls.pack('U*')
-      end
-    end
-
-    alias string strings
-
-    # A Possible Hash, where all possible values have a fixed
-    # shape.
-    # This is used for hashes where you know exactly what the
-    # keys are, and different keys may have different possible values.
-    # For example, hashes_of_shape(a: integers, b: booleans)
-    # will give you values like `{a: 11, b: false}`.
-    # @return Possible
-    # @param hash Hash A hash describing the values to provide.
-    #  The keys will be present unmodified in the provided hashes,
-    #  mapping to their Possible value in the result.
-    def hashes_of_shape(hash)
-      built_as do
-        result = {}
-        hash.each { |k, v| resultk = any(v) }
-        result
-      end
-    end
-
-    alias hash_of_shape hashes_of_shape
-
-    # A Possible Hash of variable shape.
-    # @return Possible
-    # @param keys Possible the possible keys
-    # @param values Possible the possible values
-    def hashes_with(keys:, values:, min_size: 0, max_size: 10)
-      built_as do
-        result = {}
-        rep = HypothesisCoreRepeatValues.new(
-          min_size, max_size, (min_size + max_size) * 0.5
-        )
-        source = World.current_engine.current_source
-        while rep.should_continue(source)
-          key = any keys
-          if result.include?(key)
-            rep.reject
-          else
-            resultkey = any values
-          end
-        end
-        result
-      end
-    end
-
-    alias hash_with hashes_with
-
-    # A Possible Arrays of a fixed shape.
-    # This is used for arrays where you know exactly how many
-    # elements there are, and different values may be possible
-    # at different positions.
-    # For example, arrays_of_shape(strings, integers)
-    # will give you values like "a", 1
-    # @return Possible
-    # @param elements Array<Possible> A variable number of Possible.
-    #   values. The provided array will have this many values, with
-    #   each value possible for the corresponding argument. If elements
-    #   contains an array it will be flattened first, so e.g.
-    #   arrays_of_shape(a, b) is equivalent to arrays_of_shape(a, b)
-    def arrays_of_shape(*elements)
-      elements = elements.flatten
-      built_as do
-        elements.map { |e| any e }.to_a
-      end
-    end
-
-    alias array_of_shape arrays_of_shape
-
-    # A Possible Array of variable shape.
-    # This is used for arrays where the size may vary and the same values
-    # are possible at any position.
-    # For example, arrays(of: booleans) might provide false, true, false.
-    # @return Possible
-    # @param of Possible The possible elements of the array.
-    # @param min_size Integer The smallest valid size of a provided array
-    # @param max_size Integer The largest valid size of a provided array
-    def arrays(of:, min_size: 0, max_size: 10)
-      built_as do
-        result = 
-        rep = HypothesisCoreRepeatValues.new(
-          min_size, max_size, (min_size + max_size) * 0.5
-        )
-        source = World.current_engine.current_source
-        result.push any(of) while rep.should_continue(source)
-        result
-      end
-    end
-
-    alias array arrays
-
-    # A Possible where the possible values are any one of a number
-    # of other possible values.
-    # For example, from(strings, integers) could provide either of "a"
-    # or 1.
-    # @note This has a slightly non-standard aliasing. It reads more
-    #   nicely if you write `any from(a, b, c)` but e.g.
-    #   `arrays(of: mix_of(a, b, c))`.
-    #
-    # @return Possible
-    # @param components Array<Possible> A number of Possible values,
-    #   where the result will include any value possible from any of
-    #   them. If components contains an
-    #   array it will be flattened first, so e.g. from(a, b)
-    #   is equivalent to from(a, b)
-    def from(*components)
-      components = components.flatten
-      indexes = from_hypothesis_core(
-        HypothesisCoreBoundedIntegers.new(components.size - 1)
-      )
-      built_as do
-        i = any indexes
-        any componentsi
-      end
-    end
-
-    alias mix_of from
-
-    # A Possible where any one of a fixed array of values is possible.
-    # @note these values are provided as is, so if the provided
-    #   values are mutated in the test you should be careful to make
-    #   sure each test run gets a fresh value (if you use this Possible
-    #   in line in the test you don't need to worry about this, this
-    #   is only a problem if you define the Possible outside of your
-    #   hypothesis block).
-    # @return Possible
-    # @param values Enumerable A collection of possible values.
-    def element_of(values)
-      values = values.to_a
-      indexes = from_hypothesis_core(
-        HypothesisCoreBoundedIntegers.new(values.size - 1)
-      )
-      built_as do
-        values.fetch(any(indexes))
-      end
-    end
-
-    alias elements_of element_of
-
-    # A Possible integer
-    # @return Possible
-    # @param min Integer The smallest value integer to provide.
-    # @param max Integer The largest value integer to provide.
-    def integers(min: nil, max: nil)
-      base = from_hypothesis_core HypothesisCoreIntegers.new
-      if min.nil? && max.nil?
-        base
-      elsif min.nil?
-        built_as { max - any(base).abs }
-      elsif max.nil?
-        built_as { min + any(base).abs }
-      else
-        bounded = from_hypothesis_core(
-          HypothesisCoreBoundedIntegers.new(max - min)
-        )
-        if min.zero?
-          bounded
-        else
-          built_as { min + any(bounded) }
-        end
-      end
-    end
-
-    alias integer integers
-
-    private
-
-    def from_hypothesis_core(core)
-      Hypothesis::Possible::Implementations::PossibleFromCore.new(
-        core
-      )
-    end
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis/testcase.rb Deleted

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Hypothesis
-  # A TestCase class provides a concrete representation of
-  # an executing test case. You do not normally need to use this
-  # within the body of the test, but it exists to be used as
-  # an argument to {Hypothesis::Possibilities::built_as}.
-  # @!visibility private
-  class TestCase
-    # @!visibility private
-    attr_reader :draws, :print_log, :print_draws, :wrapped_data
-
-    # @!visibility private
-    def initialize(wrapped_data, print_draws: false, record_draws: false)
-      @wrapped_data = wrapped_data
-
-      @draws =  if record_draws
-      @print_log =  if print_draws
-      @depth = 0
-    end
-
-    def assume(condition)
-      raise UnsatisfiedAssumption unless condition
-    end
-
-    # @!visibility private
-    def any(possible = nil, name: nil, &block)
-      top_level = @depth.zero?
-
-      begin
-        @depth += 1
-        possible ||= block
-        @wrapped_data.start_draw
-        result = possible.provide(&block)
-        @wrapped_data.stop_draw
-        if top_level
-          draws&.push(result)
-          print_log&.push(name, result.inspect)
-        end
-        result
-      ensure
-        @depth -= 1
-      end
-    end
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/lib/hypothesis/world.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/minitests Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/minitests/test_multiple_failures.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/minitests/test_stable_identifier.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/scripts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/scripts/run-tests-isolated.sh Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/secrets.tar.enc Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/arrays_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/backtrace_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/bad_usage_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/basic_examples_spec.rb Deleted

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-def expect_failure(&block)
-  expect(&block).to raise_exception(RSpec::Expectations::ExpectationNotMetError)
-end
-
-RSpec.describe 'basic hypothesis tests' do
-  they 'think integer addition is commutative' do
-    hypothesis do
-      x = any integers
-      y = any integers
-      expect(x + y).to eq(y + x)
-    end
-  end
-
-  they 'are able to find zero values' do
-    expect_failure do
-      hypothesis do
-        x = any integers
-        expect(x).not_to eq(0)
-      end
-    end
-  end
-
-  they 'are able to filter out values' do
-    hypothesis do
-      x = any integers
-      assume x != 0
-      1 / x
-    end
-  end
-
-  they 'find that string addition is not commutative' do
-    expect_failure do
-      hypothesis do
-        x = any strings
-        y = any strings
-        expect(x + y).to be == y + x
-      end
-    end
-  end
-
-  they 'raise unsatisfiable when all assumptions fail' do
-    expect do
-      hypothesis do
-        any integers
-        assume false
-      end
-    end.to raise_exception(Hypothesis::Unsatisfiable)
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/boolean_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/choice_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/database_spec.rb Deleted

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'database usage' do
-  it 'saves a minimal failing example' do
-    expect do
-      hypothesis do
-        n = any integer
-        expect(n).to be < 10
-      end
-    end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
-
-    saved = Dir.glob("#{Hypothesis::DEFAULT_DATABASE_PATH}/*/*")
-    expect(saved.length).to be == 1
-  end
-
-  it 'can be disabled' do
-    expect do
-      hypothesis(database: false) do
-        n = any integer
-        expect(n).to be < 10
-      end
-    end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
-    expect(File.exist?(Hypothesis::DEFAULT_DATABASE_PATH)).to be false
-  end
-
-  it 'replays a previously failing example' do
-    # This is a very unlikely value to be hit on by random. The first
-    # time we run the test we fail for any value larger than it.
-    # This then shrinks to exactly equal to magic. The second time we
-    # run the test we only fail in this exact magic value. This
-    # demonstrates replay from the previous test is working.
-    magic = 17_658
-
-    expect do
-      hypothesis do
-        n = any integer
-        expect(n).to be < magic
-      end
-    end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
-
-    expect do
-      hypothesis do
-        n = any integer
-        expect(n).not_to be == magic
-      end
-    end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
-  end
-
-  it 'cleans out passing examples' do
-    expect do
-      hypothesis do
-        n = any integer
-        expect(n).to be < 10
-      end
-    end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
-
-    saved = Dir.glob("#{Hypothesis::DEFAULT_DATABASE_PATH}/*/*")
-    expect(saved.length).to be == 1
-
-    hypothesis do
-      any integer
-    end
-
-    saved = Dir.glob("#{Hypothesis::DEFAULT_DATABASE_PATH}/*/*")
-    expect(saved.length).to be == 0
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/debug_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/example_discovery_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/example_printing_spec.rb Deleted

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'printing examples' do
-  it 'adds a statement to the exceptions string' do
-    expect do
-      hypothesis do
-        n = any integers
-        expect(n).to eq(0)
-      end
-    end.to raise_exception(/Given #1/)
-  end
-
-  it 'adds multiple statements to the exceptions string' do
-    expect do
-      hypothesis do
-        n = any integers
-        m = any integers
-        expect(n).to eq(m)
-      end
-    end.to raise_exception(/Given #1.+Given #2/m)
-  end
-
-  it 'includes the name in the Given' do
-    expect do
-      hypothesis do
-        n = any integers, name: 'fred'
-        expect(n).to eq(1)
-      end
-    end.to raise_exception(/Given fred:/)
-  end
-
-  it 'does not mangle names if you reuse exceptions' do
-    shared = Exception.new('Stuff')
-    3.times do
-      expect do
-        hypothesis do
-          any integers
-          raise shared
-        end
-      end.to raise_exception do |ex|
-        expect(ex).to equal(shared)
-        expect(ex.to_s.scan(/Given/).count).to eq(1)
-        expect(ex.to_s.scan(/Stuff/).count).to eq(1)
-      end
-    end
-  end
-
-  it 'does not include nested anys in printing' do
-    expect do
-      hypothesis do
-        value = any built_as do
-          any integers
-          any integers
-          any integers
-        end
-        expect(value).to eq(0)
-      end
-    end.to raise_exception(RSpec::Expectations::ExpectationNotMetError) do |ex|
-      expect(ex.to_s.scan(/Given/).count).to eq(1)
-    end
-  end
-
-  it 'includes Given in inspect as well as to_s' do
-    expect do
-      hypothesis do
-        n = any integers
-        expect(n).to eq(0)
-      end
-    end.to raise_exception do |ex|
-      expect(ex.inspect).to match(/Given #1/)
-    end
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/example_shrinking_spec.rb Deleted

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-RSpec.describe 'shrinking' do
-  include Hypothesis::Debug
-
-  it 'finds lower bounds on integers' do
-    n, = find { any(integers) >= 10 }
-    expect(n).to eq(10)
-  end
-
-  it 'iterates to a fixed point' do
-    @original = nil
-
-    a, b = find do
-      m = any integers
-      n = any integers
-      m > n && n > 0
-    end
-
-    expect(a).to eq(2)
-    expect(b).to eq(1)
-  end
-
-  it 'can shrink through a chain' do
-    ls, = find do
-      x = any built_as do
-        n = any integers(min: 1, max: 100)
-        any arrays(of: integers(min: 0, max: 10), min_size: n, max_size: n)
-      end
-      x.sum >= 50
-    end
-
-    expect(ls).to_not include(0)
-  end
-
-  it 'can shrink through a chain without deleting first element' do
-    10.times do
-      ls, = find do
-        x = any built_as do
-          n = any integers(min: 1, max: 100)
-          any arrays(of: integers(min: 0, max: 10), min_size: n, max_size: n)
-        end
-        assume x0 > 0
-        x.sum >= 50
-      end
-
-      expect(ls).to_not include(0)
-    end
-  end
-
-  it 'can shrink duplicate elements' do
-    10.times do
-      ls, = find do
-        x = any array(of: integers(min: 0, max: 100))
-        significant = x.select { |n| n > 0 }
-        Set.new(significant).length < significant.length
-      end
-      expect(ls).to eq(1, 1)
-    end
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/hashes_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/integer_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/mixing_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/multiple_failures_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/phase_specification_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/provided_list_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/spec_helper.rb Deleted

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov'
-SimpleCov.minimum_coverage 100
-
-class PrintingFormatter
-  # Takes a SimpleCov::Result and generates a string out of it
-  def format(result)
-    bad = 
-    result.files.each do |file|
-      bad.push file if file.covered_percent < 100.0
-    end
-
-    unless bad.empty?
-      puts 'Files with missing coverage!'
-      bad.each do |file|
-        lines = file.source_lines.select { |l| l.coverage == 0 }
-                    .map(&:line_number).sort
-        s = lines0
-        groups = s, s
-        lines.each do |i|
-          if i <= groups-1-1 + 1
-            groups-1-1 = i
-          else
-            groups.push(i, i)
-          end
-        end
-        markers = 
-        groups.each do |g|
-          if g0 == g1
-            markers.push(g0.to_s)
-          else
-            markers.push(g.join('-'))
-          end
-        end
-        puts "#{file.filename}: #{markers.join(', ')}"
-      end
-    end
-  end
-end
-
-SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new(
-  SimpleCov::Formatter::HTMLFormatter, PrintingFormatter
-)
-
-SimpleCov.start do
-  add_filter do |source_file|
-    name = source_file.filename
-    !(name.include?('/hypothesis-ruby/lib/') || name.end_with?('hypothesis.rb'))
-  end
-end
-
-require 'hypothesis'
-
-module Hypothesis
-  module Debug
-    class NoSuchExample < HypothesisError
-    end
-
-    def find(options = {}, &block)
-      unless Hypothesis::World.current_engine.nil?
-        raise UsageError, 'Cannot nest hypothesis calls'
-      end
-      begin
-        Hypothesis::World.current_engine = Hypothesis::Engine.new(
-          'find',
-          max_examples: options.fetch(:max_examples, 1000),
-          phases: options.fetch(:phases, Phase.all)
-        )
-        Hypothesis::World.current_engine.is_find = true
-        Hypothesis::World.current_engine.run(&block)
-        source = Hypothesis::World.current_engine.current_source
-        raise NoSuchExample if source.nil?
-        source.draws
-      ensure
-        Hypothesis::World.current_engine = nil
-      end
-    end
-
-    def find_any(options = {}, &block)
-      # Currently the same as find, but once we have config
-      # options for shrinking it will turn that off.
-      find(options, &block)
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.alias_example_to :they
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-  config.disable_monkey_patching!
-
-  config.warnings = true
-
-  config.default_formatter = 'doc'
-
-  config.profile_examples = 10
-
-  config.order = :random
-
-  Kernel.srand config.seed
-
-  config.include(Hypothesis)
-  config.include(Hypothesis::Possibilities)
-
-  config.before(:each) do
-    FileUtils.rm_rf Hypothesis::DEFAULT_DATABASE_PATH
-  end
-end

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/stable_identifier_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/spec/strings_spec.rb Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/src Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/hypothesis-ruby/src/lib.rs Deleted

@@ -1,492 +0,0 @@
-#macro_use
-extern crate rutie;
-#macro_use
-extern crate lazy_static;
-extern crate conjecture;
-
-use std::convert::TryFrom;
-use std::mem;
-
-use rutie::{
-    AnyException, AnyObject, Array, Boolean, Class, Exception, Float, Integer, NilClass, Object,
-    RString, Symbol, VM,
-};
-
-use conjecture::data::{DataSource, Status, TestResult};
-use conjecture::database::{BoxedDatabase, DirectoryDatabase, NoDatabase};
-use conjecture::distributions;
-use conjecture::distributions::Repeat;
-use conjecture::engine::{Engine, Phase};
-
-pub struct HypothesisCoreDataSourceStruct {
-    source: Option<DataSource>,
-}
-
-impl HypothesisCoreDataSourceStruct {
-    fn new(engine: &mut HypothesisCoreEngineStruct) -> HypothesisCoreDataSourceStruct {
-        HypothesisCoreDataSourceStruct {
-            source: mem::take(&mut engine.pending),
-        }
-    }
-
-    fn start_draw(&mut self) {
-        if let Some(ref mut source) = self.source {
-            source.start_draw();
-        }
-    }
-
-    fn stop_draw(&mut self) {
-        if let Some(ref mut source) = self.source {
-            source.stop_draw();
-        }
-    }
-}
-
-wrappable_struct!(
-    HypothesisCoreDataSourceStruct,
-    HypothesisCoreDataSourceStructWrapper,
-    HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER
-);
-
-class!(HypothesisCoreDataSource);
-
-#rustfmt::skip
-methods!(
-    HypothesisCoreDataSource,
-    itself,
-    fn ruby_hypothesis_core_data_source_start_draw() -> NilClass {
-        itself
-            .get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER)
-            .start_draw();
-
-        NilClass::new()
-    }
-    fn ruby_hypothesis_core_data_source_stop_draw() -> NilClass {
-        itself
-            .get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER)
-            .stop_draw();
-
-        NilClass::new()
-    }
-);
-
-pub struct HypothesisCoreEngineStruct {
-    engine: Engine,
-    pending: Option<DataSource>,
-    interesting_examples: Vec<TestResult>,
-}
-
-impl HypothesisCoreEngineStruct {
-    fn new(
-        name: String,
-        database_path: Option<String>,
-        seed: u64,
-        max_examples: u64,
-        phases: Vec<Phase>,
-    ) -> HypothesisCoreEngineStruct {
-        let xs: u32; 2 = seed as u32, (seed >> 32) as u32;
-        let db: BoxedDatabase = match database_path {
-            None => Box::new(NoDatabase),
-            Some(path) => Box::new(DirectoryDatabase::new(path)),
-        };
-
-        HypothesisCoreEngineStruct {
-            engine: Engine::new(name, max_examples, phases, &xs, db),
-            pending: None,
-            interesting_examples: Vec::new(),
-        }
-    }
-
-    fn new_source(&mut self) -> Option<HypothesisCoreDataSourceStruct> {
-        match self.engine.next_source() {
-            None => {
-                self.interesting_examples = self.engine.list_minimized_examples();
-                None
-            }
-            Some(source) => {
-                self.pending = Some(source);
-                Some(HypothesisCoreDataSourceStruct::new(self))
-            }
-        }
-    }
-
-    fn count_failing_examples(&self) -> usize {
-        self.interesting_examples.len()
-    }
-
-    fn failing_example(&mut self, i: usize) -> HypothesisCoreDataSourceStruct {
-        self.pending = Some(DataSource::from_vec(
-            self.interesting_examplesi.record.clone(),
-        ));
-        HypothesisCoreDataSourceStruct::new(self)
-    }
-
-    fn was_unsatisfiable(&mut self) -> bool {
-        self.engine.was_unsatisfiable()
-    }
-
-    fn finish_overflow(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
-        mark_child_status(&mut self.engine, child, Status::Overflow);
-    }
-
-    fn finish_valid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
-        mark_child_status(&mut self.engine, child, Status::Valid);
-    }
-
-    fn finish_invalid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
-        mark_child_status(&mut self.engine, child, Status::Invalid);
-    }
-
-    fn finish_interesting(&mut self, child: &mut HypothesisCoreDataSourceStruct, label: u64) {
-        mark_child_status(&mut self.engine, child, Status::Interesting(label));
-    }
-}
-
-wrappable_struct!(
-    HypothesisCoreEngineStruct,
-    HypothesisCoreEngineStructWrapper,
-    HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER
-);
-
-class!(HypothesisCoreEngine);
-
-#rustfmt::skip
-methods!(
-    HypothesisCoreEngine,
-    itself,
-    fn ruby_hypothesis_core_engine_new(
-        name: RString,
-        database_path: RString,
-        seed: Integer,
-        max_example: Integer,
-        phases: Array
-    ) -> AnyObject {
-        let rust_phases = safe_access(phases)
-            .into_iter()
-            .map(|ruby_phase| {
-                let phase_sym = safe_access(ruby_phase.try_convert_to::<Symbol>());
-                let phase = Phase::try_from(phase_sym.to_str())
-                    .map_err(|e| AnyException::new("ArgumentError", Some(&e)));
-
-                safe_access(phase)
-            })
-            .collect();
-
-        let core_engine = HypothesisCoreEngineStruct::new(
-            safe_access(name).to_string(),
-            database_path.ok().map(|p| p.to_string()),
-            safe_access(seed).to_u64(),
-            safe_access(max_example).to_u64(),
-            rust_phases,
-        );
-
-        Class::from_existing("HypothesisCoreEngine")
-            .wrap_data(core_engine, &*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER)
-    }
-    fn ruby_hypothesis_core_engine_new_source() -> AnyObject {
-        match itself
-            .get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER)
-            .new_source()
-        {
-            Some(ds) => Class::from_existing("HypothesisCoreDataSource")
-                .wrap_data(ds, &*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER),
-            None => NilClass::new().into(),
-        }
-    }
-    fn ruby_hypothesis_core_engine_finish_overflow(child: AnyObject) -> NilClass {
-        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-        let mut rdata_source = safe_access(child);
-        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-
-        core_engine.finish_overflow(data_source);
-
-        NilClass::new()
-    }
-    fn ruby_hypothesis_core_engine_finish_valid(child: AnyObject) -> NilClass {
-        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-        let mut rdata_source = safe_access(child);
-        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-
-        core_engine.finish_valid(data_source);
-
-        NilClass::new()
-    }
-    fn ruby_hypothesis_core_engine_finish_invalid(child: AnyObject) -> NilClass {
-        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-        let mut rdata_source = safe_access(child);
-        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-
-        core_engine.finish_invalid(data_source);
-
-        NilClass::new()
-    }
-    fn ruby_hypothesis_core_engine_finish_interesting(
-        child: AnyObject,
-        label: Integer
-    ) -> NilClass {
-        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-        let mut rdata_source = safe_access(child);
-        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-
-        core_engine.finish_interesting(data_source, safe_access(label).to_u64());
-
-        NilClass::new()
-    }
-    fn ruby_hypothesis_core_engine_count_failing_examples() -> Integer {
-        let core_engine = itself.get_data(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-
-        Integer::new(core_engine.count_failing_examples() as i64)
-    }
-    fn ruby_hypothesis_core_failing_example(i: Integer) -> AnyObject {
-        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-        let int = safe_access(i).to_u64() as usize;
-
-        let data_source = core_engine.failing_example(int);
-
-        Class::from_existing("HypothesisCoreDataSource")
-            .wrap_data(data_source, &*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER)
-    }
-    fn ruby_hypothesis_core_engine_was_unsatisfiable() -> Boolean {
-        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
-
-        Boolean::new(core_engine.was_unsatisfiable())
-    }
-);
-
-pub struct HypothesisCoreIntegersStruct {
-    bitlengths: distributions::Sampler,
-}
-
-impl HypothesisCoreIntegersStruct {
-    fn new() -> HypothesisCoreIntegersStruct {
-        HypothesisCoreIntegersStruct {
-            bitlengths: distributions::good_bitlengths(),
-        }
-    }
-
-    fn provide(&mut self, data: &mut HypothesisCoreDataSourceStruct) -> Option<i64> {
-        data.source.as_mut().and_then(|ref mut source| {
-            distributions::integer_from_bitlengths(source, &self.bitlengths).ok()
-        })
-    }
-}
-
-wrappable_struct!(
-    HypothesisCoreIntegersStruct,
-    HypothesisCoreIntegersStructWrapper,
-    HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER
-);
-
-class!(HypothesisCoreIntegers);
-
-#rustfmt::skip
-methods!(
-    HypothesisCoreIntegers,
-    itself,
-    fn ruby_hypothesis_core_integers_new() -> AnyObject {
-        let core_integers = HypothesisCoreIntegersStruct::new();
-
-        Class::from_existing("HypothesisCoreIntegers")
-            .wrap_data(core_integers, &*HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER)
-    }
-    fn ruby_hypothesis_core_integers_provide(data: AnyObject) -> AnyObject {
-        let core_integers = itself.get_data_mut(&*HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER);
-        let mut rdata = safe_access(data);
-        let data_source = rdata.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-
-        match core_integers.provide(data_source) {
-            Some(i) => Integer::new(i).into(),
-            None => NilClass::new().into(),
-        }
-    }
-);
-
-pub struct HypothesisCoreRepeatValuesStruct {
-    repeat: Repeat,
-}
-
-impl HypothesisCoreRepeatValuesStruct {
-    fn new(
-        min_count: u64,
-        max_count: u64,
-        expected_count: f64,
-    ) -> HypothesisCoreRepeatValuesStruct {
-        HypothesisCoreRepeatValuesStruct {
-            repeat: Repeat::new(min_count, max_count, expected_count),
-        }
-    }
-
-    fn _should_continue(&mut self, data: &mut HypothesisCoreDataSourceStruct) -> Option<bool> {
-        return data
-            .source
-            .as_mut()
-            .and_then(|ref mut source| self.repeat.should_continue(source).ok());
-    }
-
-    fn reject(&mut self) {
-        self.repeat.reject();
-    }
-}
-
-wrappable_struct!(
-    HypothesisCoreRepeatValuesStruct,
-    HypothesisCoreRepeatValuesStructWrapper,
-    HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER
-);
-
-class!(HypothesisCoreRepeatValues);
-
-#rustfmt::skip
-methods!(
-    HypothesisCoreRepeatValues,
-    itself,
-    fn ruby_hypothesis_core_repeat_values_new(
-        min_count: Integer,
-        max_count: Integer,
-        expected_count: Float
-    ) -> AnyObject {
-        let repeat_values = HypothesisCoreRepeatValuesStruct::new(
-            safe_access(min_count).to_u64(),
-            safe_access(max_count).to_u64(),
-            safe_access(expected_count).to_f64(),
-        );
-
-        Class::from_existing("HypothesisCoreRepeatValues").wrap_data(
-            repeat_values,
-            &*HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER,
-        )
-    }
-    fn ruby_hypothesis_core_repeat_values_should_continue(data: AnyObject) -> AnyObject {
-        let mut rdata = safe_access(data);
-        let mut data_source = rdata.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-
-        let should_continue = itself
-            .get_data_mut(&*HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER)
-            ._should_continue(data_source);
-
-        match should_continue {
-            Some(b) => Boolean::new(b).into(),
-            None => NilClass::new().into(),
-        }
-    }
-    fn ruby_hypothesis_core_repeat_values_reject() -> NilClass {
-        let repeat_values = itself.get_data_mut(&*HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER);
-
-        repeat_values.reject();
-
-        NilClass::new()
-    }
-);
-
-pub struct HypothesisCoreBoundedIntegersStruct {
-    max_value: u64,
-}
-
-impl HypothesisCoreBoundedIntegersStruct {
-    fn provide(&mut self, data: &mut HypothesisCoreDataSourceStruct) -> Option<u64> {
-        data.source
-            .as_mut()
-            .and_then(|ref mut source| distributions::bounded_int(source, self.max_value).ok())
-    }
-}
-
-wrappable_struct!(
-    HypothesisCoreBoundedIntegersStruct,
-    HypothesisCoreBoundedIntegersStructWrapper,
-    HYPOTHESIS_CORE_BOUNDED_INTEGERS_STRUCT_WRAPPER
-);
-
-class!(HypothesisCoreBoundedIntegers);
-
-#rustfmt::skip
-methods!(
-    HypothesisCoreBoundedIntegers,
-    itself,
-    fn ruby_hypothesis_core_bounded_integers_new(max_value: Integer) -> AnyObject {
-        let bounded_integers = HypothesisCoreBoundedIntegersStruct {
-            max_value: safe_access(max_value).to_u64(),
-        };
-
-        Class::from_existing("HypothesisCoreBoundedIntegers").wrap_data(
-            bounded_integers,
-            &*HYPOTHESIS_CORE_BOUNDED_INTEGERS_STRUCT_WRAPPER,
-        )
-    }
-    fn ruby_hypothesis_core_bounded_integers_provide(data: AnyObject) -> AnyObject {
-        let mut rdata = safe_access(data);
-        let data_source = rdata.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
-        let bounded_integers =
-            itself.get_data_mut(&*HYPOTHESIS_CORE_BOUNDED_INTEGERS_STRUCT_WRAPPER);
-
-        match bounded_integers.provide(data_source) {
-            Some(i) => Integer::from(i).into(),
-            None => NilClass::new().into(),
-        }
-    }
-);
-
-#allow(non_snake_case)
-#no_mangle
-pub extern "C" fn Init_rutie_hypothesis_core() {
-    Class::new("HypothesisCoreEngine", None).define(|klass| {
-        klass.def_self("new", ruby_hypothesis_core_engine_new);
-        klass.def("new_source", ruby_hypothesis_core_engine_new_source);
-        klass.def(
-            "count_failing_examples",
-            ruby_hypothesis_core_engine_count_failing_examples,
-        );
-        klass.def("failing_example", ruby_hypothesis_core_failing_example);
-        klass.def(
-            "was_unsatisfiable",
-            ruby_hypothesis_core_engine_was_unsatisfiable,
-        );
-        klass.def(
-            "finish_overflow",
-            ruby_hypothesis_core_engine_finish_overflow,
-        );
-        klass.def("finish_valid", ruby_hypothesis_core_engine_finish_valid);
-        klass.def("finish_invalid", ruby_hypothesis_core_engine_finish_invalid);
-        klass.def(
-            "finish_interesting",
-            ruby_hypothesis_core_engine_finish_interesting,
-        );
-    });
-
-    Class::new("HypothesisCoreDataSource", None).define(|klass| {
-        klass.def("start_draw", ruby_hypothesis_core_data_source_start_draw);
-        klass.def("stop_draw", ruby_hypothesis_core_data_source_stop_draw);
-    });
-
-    Class::new("HypothesisCoreIntegers", None).define(|klass| {
-        klass.def_self("new", ruby_hypothesis_core_integers_new);
-        klass.def("provide", ruby_hypothesis_core_integers_provide);
-    });
-
-    Class::new("HypothesisCoreRepeatValues", None).define(|klass| {
-        klass.def_self("new", ruby_hypothesis_core_repeat_values_new);
-        klass.def(
-            "_should_continue",
-            ruby_hypothesis_core_repeat_values_should_continue,
-        );
-        klass.def("reject", ruby_hypothesis_core_repeat_values_reject);
-    });
-
-    Class::new("HypothesisCoreBoundedIntegers", None).define(|klass| {
-        klass.def_self("new", ruby_hypothesis_core_bounded_integers_new);
-        klass.def("provide", ruby_hypothesis_core_bounded_integers_provide);
-    });
-}
-
-fn mark_child_status(
-    engine: &mut Engine,
-    child: &mut HypothesisCoreDataSourceStruct,
-    status: Status,
-) {
-    if let Some(source) = mem::take(&mut child.source) {
-        engine.mark_finished(source, status)
-    }
-}
-
-fn safe_access<T>(value: Result<T, AnyException>) -> T {
-    value.map_err(VM::raise_ex).unwrap()
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/mypy.ini Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/notebooks Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/notebooks/Designing a better simplifier.ipynb Deleted

@@ -1,4911 +0,0 @@
-{
- "cells": 
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "# Designing a better simplifier\n",
-    "\n",
-    "This is a notebook talking through some of the considerations in the design of Hypothesis's approach to simplification.\n",
-    "\n",
-    "It doesn't perfectly mirror what actually happens in Hypothesis, but it should give some consideration to the sort of things that Hypothesis does and why it takes a particular approach.\n",
-    "\n",
-    "In order to simplify the scope of this document we are only going to\n",
-    "concern ourselves with lists of integers. There are a number of API considerations involved in expanding beyond that point, however most of the algorithmic considerations are the same.\n",
-    "\n",
-    "The big difference between lists of integers and the general case is that integers can never be too complex. In particular we will rapidly get to the point where individual elements can be simplified in usually only log(n) calls. When dealing with e.g. lists of lists this is a much more complicated proposition. That may be covered in another notebook.\n",
-    "\n",
-    "Our objective here is to minimize the number of times we check the condition. We won't be looking at actual timing performance, because usually the speed of the condition is the bottleneck there (and where it's not, everything is fast enough that we need not worry)."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": ,
-   "source": 
-    "def greedy_shrink(ls, constraint, shrink):\n",
-    "    \"\"\"\n",
-    "    This is the \"classic\" QuickCheck algorithm which takes a shrink function\n",
-    "    which will iterate over simpler versions of an example. We are trying\n",
-    "    to find a local minima: That is an example ls such that condition(ls)\n",
-    "    is True but that constraint(t) is False for each t in shrink(ls).\n",
-    "    \"\"\"\n",
-    "    while True:\n",
-    "        for s in shrink(ls):\n",
-    "            if constraint(s):\n",
-    "                ls = s\n",
-    "                break\n",
-    "        else:\n",
-    "            return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def shrink1(ls):\n",
-    "    \"\"\"\n",
-    "    This is our prototype shrink function. It is very bad. It makes the\n",
-    "    mistake of only making very small changes to an example each time.\n",
-    "    \n",
-    "    Most people write something like this the first time they come to\n",
-    "    implement example shrinking. In particular early Hypothesis very much\n",
-    "    made this mistake.\n",
-    "    \n",
-    "    What this does:\n",
-    "    \n",
-    "    For each index, if the value of the index is non-zero we try\n",
-    "    decrementing it by 1.\n",
-    "    \n",
-    "    We then (regardless of if it's zero) try the list with the value at\n",
-    "    that index deleted.\n",
-    "    \"\"\"\n",
-    "    for i in range(len(ls)):\n",
-    "        s = list(ls)\n",
-    "        if si > 0:\n",
-    "            si -= 1\n",
-    "            yield list(s)\n",
-    "        del si\n",
-    "        yield list(s)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": ,
-   "source": 
-    "def show_trace(start, constraint, simplifier):\n",
-    "    \"\"\"\n",
-    "    This is a debug function. You shouldn't concern yourself with\n",
-    "    its implementation too much.\n",
-    "    \n",
-    "    What it does is print out every intermediate step in applying a\n",
-    "    simplifier (a function of the form (list, constraint) -> list)\n",
-    "    along with whether it is a successful shrink or not.\n",
-    "    \"\"\"\n",
-    "    if start is None:\n",
-    "        while True:\n",
-    "            start = gen_list()\n",
-    "            if constraint(start):\n",
-    "                break\n",
-    "\n",
-    "    shrinks = 0\n",
-    "    tests = 0\n",
-    "\n",
-    "    def print_shrink(ls):\n",
-    "        tests0 += 1\n",
-    "        if constraint(ls):\n",
-    "            shrinks0 += 1\n",
-    "            print(\"✓\", ls)\n",
-    "            return True\n",
-    "        else:\n",
-    "            print(\"✗\", ls)\n",
-    "        return False\n",
-    "    print(\"✓\", start)\n",
-    "    simplifier(start, print_shrink)\n",
-    "    print()\n",
-    "    print(\"%d shrinks with %d function calls\" % (\n",
-    "            shrinks0, tests0))"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": ,
-   "source": 
-    "from functools import partial"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 5, 5\n",
-      "✓ 4, 5\n",
-      "✓ 3, 5\n",
-      "✓ 2, 5\n",
-      "✓ 1, 5\n",
-      "✓ 0, 5\n",
-      "✗ 5\n",
-      "✓ 0, 4\n",
-      "✗ 4\n",
-      "✓ 0, 3\n",
-      "✗ 3\n",
-      "✓ 0, 2\n",
-      "✗ 2\n",
-      "✓ 0, 1\n",
-      "✗ 1\n",
-      "✓ 0, 0\n",
-      "✗ 0\n",
-      "✗ 0\n",
-      "\n",
-      "10 shrinks with 17 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(5, 5, lambda x: len(x) >= 2, partial(greedy_shrink, shrink=shrink1))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "That worked reasonably well, but it sure was a lot of function calls for such a small amount of shrinking. What would have happened if we'd started with 100, 100?"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def shrink2(ls):\n",
-    "    \"\"\"\n",
-    "    Here is an improved shrink function. We first try deleting each element\n",
-    "    and then we try making each element smaller, but we do so from the left\n",
-    "    hand side instead of the right. This means we will always find the\n",
-    "    smallest value that can go in there, but we will do so much sooner.\n",
-    "    \"\"\"\n",
-    "    for i in range(len(ls)):\n",
-    "        s = list(ls)\n",
-    "        del si\n",
-    "        yield list(s)\n",
-    "        \n",
-    "    for i in range(len(ls)):\n",
-    "        for x in range(lsi):\n",
-    "            s = list(ls)\n",
-    "            si = x\n",
-    "            yield s"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 5, 5\n",
-      "✗ 5\n",
-      "✗ 5\n",
-      "✓ 0, 5\n",
-      "✗ 5\n",
-      "✗ 0\n",
-      "✓ 0, 0\n",
-      "✗ 0\n",
-      "✗ 0\n",
-      "\n",
-      "2 shrinks with 8 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(5, 5, lambda x: len(x) >= 2, partial(\n",
-    "        greedy_shrink, shrink=shrink2))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This did indeed reduce the number of function calls significantly - we immediately determine that the value in the cell doesn't matter and we can just put zero there. \n",
-    "\n",
-    "But what would have happened if the value *did* matter?"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 1000\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 2\n",
-      "✗ 3\n",
-      "✗ 4\n",
-      "✗ 5\n",
-      "✗ 6\n",
-      "✗ 7\n",
-      "✗ 8\n",
-      "✗ 9\n",
-      "✗ 10\n",
-      "✗ 11\n",
-      "✗ 12\n",
-      "✗ 13\n",
-      "✗ 14\n",
-      "✗ 15\n",
-      "✗ 16\n",
-      "✗ 17\n",
-      "✗ 18\n",
-      "✗ 19\n",
-      "✗ 20\n",
-      "✗ 21\n",
-      "✗ 22\n",
-      "✗ 23\n",
-      "✗ 24\n",
-      "✗ 25\n",
-      "✗ 26\n",
-      "✗ 27\n",
-      "✗ 28\n",
-      "✗ 29\n",
-      "✗ 30\n",
-      "✗ 31\n",
-      "✗ 32\n",
-      "✗ 33\n",
-      "✗ 34\n",
-      "✗ 35\n",
-      "✗ 36\n",
-      "✗ 37\n",
-      "✗ 38\n",
-      "✗ 39\n",
-      "✗ 40\n",
-      "✗ 41\n",
-      "✗ 42\n",
-      "✗ 43\n",
-      "✗ 44\n",
-      "✗ 45\n",
-      "✗ 46\n",
-      "✗ 47\n",
-      "✗ 48\n",
-      "✗ 49\n",
-      "✗ 50\n",
-      "✗ 51\n",
-      "✗ 52\n",
-      "✗ 53\n",
-      "✗ 54\n",
-      "✗ 55\n",
-      "✗ 56\n",
-      "✗ 57\n",
-      "✗ 58\n",
-      "✗ 59\n",
-      "✗ 60\n",
-      "✗ 61\n",
-      "✗ 62\n",
-      "✗ 63\n",
-      "✗ 64\n",
-      "✗ 65\n",
-      "✗ 66\n",
-      "✗ 67\n",
-      "✗ 68\n",
-      "✗ 69\n",
-      "✗ 70\n",
-      "✗ 71\n",
-      "✗ 72\n",
-      "✗ 73\n",
-      "✗ 74\n",
-      "✗ 75\n",
-      "✗ 76\n",
-      "✗ 77\n",
-      "✗ 78\n",
-      "✗ 79\n",
-      "✗ 80\n",
-      "✗ 81\n",
-      "✗ 82\n",
-      "✗ 83\n",
-      "✗ 84\n",
-      "✗ 85\n",
-      "✗ 86\n",
-      "✗ 87\n",
-      "✗ 88\n",
-      "✗ 89\n",
-      "✗ 90\n",
-      "✗ 91\n",
-      "✗ 92\n",
-      "✗ 93\n",
-      "✗ 94\n",
-      "✗ 95\n",
-      "✗ 96\n",
-      "✗ 97\n",
-      "✗ 98\n",
-      "✗ 99\n",
-      "✗ 100\n",
-      "✗ 101\n",
-      "✗ 102\n",
-      "✗ 103\n",
-      "✗ 104\n",
-      "✗ 105\n",
-      "✗ 106\n",
-      "✗ 107\n",
-      "✗ 108\n",
-      "✗ 109\n",
-      "✗ 110\n",
-      "✗ 111\n",
-      "✗ 112\n",
-      "✗ 113\n",
-      "✗ 114\n",
-      "✗ 115\n",
-      "✗ 116\n",
-      "✗ 117\n",
-      "✗ 118\n",
-      "✗ 119\n",
-      "✗ 120\n",
-      "✗ 121\n",
-      "✗ 122\n",
-      "✗ 123\n",
-      "✗ 124\n",
-      "✗ 125\n",
-      "✗ 126\n",
-      "✗ 127\n",
-      "✗ 128\n",
-      "✗ 129\n",
-      "✗ 130\n",
-      "✗ 131\n",
-      "✗ 132\n",
-      "✗ 133\n",
-      "✗ 134\n",
-      "✗ 135\n",
-      "✗ 136\n",
-      "✗ 137\n",
-      "✗ 138\n",
-      "✗ 139\n",
-      "✗ 140\n",
-      "✗ 141\n",
-      "✗ 142\n",
-      "✗ 143\n",
-      "✗ 144\n",
-      "✗ 145\n",
-      "✗ 146\n",
-      "✗ 147\n",
-      "✗ 148\n",
-      "✗ 149\n",
-      "✗ 150\n",
-      "✗ 151\n",
-      "✗ 152\n",
-      "✗ 153\n",
-      "✗ 154\n",
-      "✗ 155\n",
-      "✗ 156\n",
-      "✗ 157\n",
-      "✗ 158\n",
-      "✗ 159\n",
-      "✗ 160\n",
-      "✗ 161\n",
-      "✗ 162\n",
-      "✗ 163\n",
-      "✗ 164\n",
-      "✗ 165\n",
-      "✗ 166\n",
-      "✗ 167\n",
-      "✗ 168\n",
-      "✗ 169\n",
-      "✗ 170\n",
-      "✗ 171\n",
-      "✗ 172\n",
-      "✗ 173\n",
-      "✗ 174\n",
-      "✗ 175\n",
-      "✗ 176\n",
-      "✗ 177\n",
-      "✗ 178\n",
-      "✗ 179\n",
-      "✗ 180\n",
-      "✗ 181\n",
-      "✗ 182\n",
-      "✗ 183\n",
-      "✗ 184\n",
-      "✗ 185\n",
-      "✗ 186\n",
-      "✗ 187\n",
-      "✗ 188\n",
-      "✗ 189\n",
-      "✗ 190\n",
-      "✗ 191\n",
-      "✗ 192\n",
-      "✗ 193\n",
-      "✗ 194\n",
-      "✗ 195\n",
-      "✗ 196\n",
-      "✗ 197\n",
-      "✗ 198\n",
-      "✗ 199\n",
-      "✗ 200\n",
-      "✗ 201\n",
-      "✗ 202\n",
-      "✗ 203\n",
-      "✗ 204\n",
-      "✗ 205\n",
-      "✗ 206\n",
-      "✗ 207\n",
-      "✗ 208\n",
-      "✗ 209\n",
-      "✗ 210\n",
-      "✗ 211\n",
-      "✗ 212\n",
-      "✗ 213\n",
-      "✗ 214\n",
-      "✗ 215\n",
-      "✗ 216\n",
-      "✗ 217\n",
-      "✗ 218\n",
-      "✗ 219\n",
-      "✗ 220\n",
-      "✗ 221\n",
-      "✗ 222\n",
-      "✗ 223\n",
-      "✗ 224\n",
-      "✗ 225\n",
-      "✗ 226\n",
-      "✗ 227\n",
-      "✗ 228\n",
-      "✗ 229\n",
-      "✗ 230\n",
-      "✗ 231\n",
-      "✗ 232\n",
-      "✗ 233\n",
-      "✗ 234\n",
-      "✗ 235\n",
-      "✗ 236\n",
-      "✗ 237\n",
-      "✗ 238\n",
-      "✗ 239\n",
-      "✗ 240\n",
-      "✗ 241\n",
-      "✗ 242\n",
-      "✗ 243\n",
-      "✗ 244\n",
-      "✗ 245\n",
-      "✗ 246\n",
-      "✗ 247\n",
-      "✗ 248\n",
-      "✗ 249\n",
-      "✗ 250\n",
-      "✗ 251\n",
-      "✗ 252\n",
-      "✗ 253\n",
-      "✗ 254\n",
-      "✗ 255\n",
-      "✗ 256\n",
-      "✗ 257\n",
-      "✗ 258\n",
-      "✗ 259\n",
-      "✗ 260\n",
-      "✗ 261\n",
-      "✗ 262\n",
-      "✗ 263\n",
-      "✗ 264\n",
-      "✗ 265\n",
-      "✗ 266\n",
-      "✗ 267\n",
-      "✗ 268\n",
-      "✗ 269\n",
-      "✗ 270\n",
-      "✗ 271\n",
-      "✗ 272\n",
-      "✗ 273\n",
-      "✗ 274\n",
-      "✗ 275\n",
-      "✗ 276\n",
-      "✗ 277\n",
-      "✗ 278\n",
-      "✗ 279\n",
-      "✗ 280\n",
-      "✗ 281\n",
-      "✗ 282\n",
-      "✗ 283\n",
-      "✗ 284\n",
-      "✗ 285\n",
-      "✗ 286\n",
-      "✗ 287\n",
-      "✗ 288\n",
-      "✗ 289\n",
-      "✗ 290\n",
-      "✗ 291\n",
-      "✗ 292\n",
-      "✗ 293\n",
-      "✗ 294\n",
-      "✗ 295\n",
-      "✗ 296\n",
-      "✗ 297\n",
-      "✗ 298\n",
-      "✗ 299\n",
-      "✗ 300\n",
-      "✗ 301\n",
-      "✗ 302\n",
-      "✗ 303\n",
-      "✗ 304\n",
-      "✗ 305\n",
-      "✗ 306\n",
-      "✗ 307\n",
-      "✗ 308\n",
-      "✗ 309\n",
-      "✗ 310\n",
-      "✗ 311\n",
-      "✗ 312\n",
-      "✗ 313\n",
-      "✗ 314\n",
-      "✗ 315\n",
-      "✗ 316\n",
-      "✗ 317\n",
-      "✗ 318\n",
-      "✗ 319\n",
-      "✗ 320\n",
-      "✗ 321\n",
-      "✗ 322\n",
-      "✗ 323\n",
-      "✗ 324\n",
-      "✗ 325\n",
-      "✗ 326\n",
-      "✗ 327\n",
-      "✗ 328\n",
-      "✗ 329\n",
-      "✗ 330\n",
-      "✗ 331\n",
-      "✗ 332\n",
-      "✗ 333\n",
-      "✗ 334\n",
-      "✗ 335\n",
-      "✗ 336\n",
-      "✗ 337\n",
-      "✗ 338\n",
-      "✗ 339\n",
-      "✗ 340\n",
-      "✗ 341\n",
-      "✗ 342\n",
-      "✗ 343\n",
-      "✗ 344\n",
-      "✗ 345\n",
-      "✗ 346\n",
-      "✗ 347\n",
-      "✗ 348\n",
-      "✗ 349\n",
-      "✗ 350\n",
-      "✗ 351\n",
-      "✗ 352\n",
-      "✗ 353\n",
-      "✗ 354\n",
-      "✗ 355\n",
-      "✗ 356\n",
-      "✗ 357\n",
-      "✗ 358\n",
-      "✗ 359\n",
-      "✗ 360\n",
-      "✗ 361\n",
-      "✗ 362\n",
-      "✗ 363\n",
-      "✗ 364\n",
-      "✗ 365\n",
-      "✗ 366\n",
-      "✗ 367\n",
-      "✗ 368\n",
-      "✗ 369\n",
-      "✗ 370\n",
-      "✗ 371\n",
-      "✗ 372\n",
-      "✗ 373\n",
-      "✗ 374\n",
-      "✗ 375\n",
-      "✗ 376\n",
-      "✗ 377\n",
-      "✗ 378\n",
-      "✗ 379\n",
-      "✗ 380\n",
-      "✗ 381\n",
-      "✗ 382\n",
-      "✗ 383\n",
-      "✗ 384\n",
-      "✗ 385\n",
-      "✗ 386\n",
-      "✗ 387\n",
-      "✗ 388\n",
-      "✗ 389\n",
-      "✗ 390\n",
-      "✗ 391\n",
-      "✗ 392\n",
-      "✗ 393\n",
-      "✗ 394\n",
-      "✗ 395\n",
-      "✗ 396\n",
-      "✗ 397\n",
-      "✗ 398\n",
-      "✗ 399\n",
-      "✗ 400\n",
-      "✗ 401\n",
-      "✗ 402\n",
-      "✗ 403\n",
-      "✗ 404\n",
-      "✗ 405\n",
-      "✗ 406\n",
-      "✗ 407\n",
-      "✗ 408\n",
-      "✗ 409\n",
-      "✗ 410\n",
-      "✗ 411\n",
-      "✗ 412\n",
-      "✗ 413\n",
-      "✗ 414\n",
-      "✗ 415\n",
-      "✗ 416\n",
-      "✗ 417\n",
-      "✗ 418\n",
-      "✗ 419\n",
-      "✗ 420\n",
-      "✗ 421\n",
-      "✗ 422\n",
-      "✗ 423\n",
-      "✗ 424\n",
-      "✗ 425\n",
-      "✗ 426\n",
-      "✗ 427\n",
-      "✗ 428\n",
-      "✗ 429\n",
-      "✗ 430\n",
-      "✗ 431\n",
-      "✗ 432\n",
-      "✗ 433\n",
-      "✗ 434\n",
-      "✗ 435\n",
-      "✗ 436\n",
-      "✗ 437\n",
-      "✗ 438\n",
-      "✗ 439\n",
-      "✗ 440\n",
-      "✗ 441\n",
-      "✗ 442\n",
-      "✗ 443\n",
-      "✗ 444\n",
-      "✗ 445\n",
-      "✗ 446\n",
-      "✗ 447\n",
-      "✗ 448\n",
-      "✗ 449\n",
-      "✗ 450\n",
-      "✗ 451\n",
-      "✗ 452\n",
-      "✗ 453\n",
-      "✗ 454\n",
-      "✗ 455\n",
-      "✗ 456\n",
-      "✗ 457\n",
-      "✗ 458\n",
-      "✗ 459\n",
-      "✗ 460\n",
-      "✗ 461\n",
-      "✗ 462\n",
-      "✗ 463\n",
-      "✗ 464\n",
-      "✗ 465\n",
-      "✗ 466\n",
-      "✗ 467\n",
-      "✗ 468\n",
-      "✗ 469\n",
-      "✗ 470\n",
-      "✗ 471\n",
-      "✗ 472\n",
-      "✗ 473\n",
-      "✗ 474\n",
-      "✗ 475\n",
-      "✗ 476\n",
-      "✗ 477\n",
-      "✗ 478\n",
-      "✗ 479\n",
-      "✗ 480\n",
-      "✗ 481\n",
-      "✗ 482\n",
-      "✗ 483\n",
-      "✗ 484\n",
-      "✗ 485\n",
-      "✗ 486\n",
-      "✗ 487\n",
-      "✗ 488\n",
-      "✗ 489\n",
-      "✗ 490\n",
-      "✗ 491\n",
-      "✗ 492\n",
-      "✗ 493\n",
-      "✗ 494\n",
-      "✗ 495\n",
-      "✗ 496\n",
-      "✗ 497\n",
-      "✗ 498\n",
-      "✗ 499\n",
-      "✓ 500\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 2\n",
-      "✗ 3\n",
-      "✗ 4\n",
-      "✗ 5\n",
-      "✗ 6\n",
-      "✗ 7\n",
-      "✗ 8\n",
-      "✗ 9\n",
-      "✗ 10\n",
-      "✗ 11\n",
-      "✗ 12\n",
-      "✗ 13\n",
-      "✗ 14\n",
-      "✗ 15\n",
-      "✗ 16\n",
-      "✗ 17\n",
-      "✗ 18\n",
-      "✗ 19\n",
-      "✗ 20\n",
-      "✗ 21\n",
-      "✗ 22\n",
-      "✗ 23\n",
-      "✗ 24\n",
-      "✗ 25\n",
-      "✗ 26\n",
-      "✗ 27\n",
-      "✗ 28\n",
-      "✗ 29\n",
-      "✗ 30\n",
-      "✗ 31\n",
-      "✗ 32\n",
-      "✗ 33\n",
-      "✗ 34\n",
-      "✗ 35\n",
-      "✗ 36\n",
-      "✗ 37\n",
-      "✗ 38\n",
-      "✗ 39\n",
-      "✗ 40\n",
-      "✗ 41\n",
-      "✗ 42\n",
-      "✗ 43\n",
-      "✗ 44\n",
-      "✗ 45\n",
-      "✗ 46\n",
-      "✗ 47\n",
-      "✗ 48\n",
-      "✗ 49\n",
-      "✗ 50\n",
-      "✗ 51\n",
-      "✗ 52\n",
-      "✗ 53\n",
-      "✗ 54\n",
-      "✗ 55\n",
-      "✗ 56\n",
-      "✗ 57\n",
-      "✗ 58\n",
-      "✗ 59\n",
-      "✗ 60\n",
-      "✗ 61\n",
-      "✗ 62\n",
-      "✗ 63\n",
-      "✗ 64\n",
-      "✗ 65\n",
-      "✗ 66\n",
-      "✗ 67\n",
-      "✗ 68\n",
-      "✗ 69\n",
-      "✗ 70\n",
-      "✗ 71\n",
-      "✗ 72\n",
-      "✗ 73\n",
-      "✗ 74\n",
-      "✗ 75\n",
-      "✗ 76\n",
-      "✗ 77\n",
-      "✗ 78\n",
-      "✗ 79\n",
-      "✗ 80\n",
-      "✗ 81\n",
-      "✗ 82\n",
-      "✗ 83\n",
-      "✗ 84\n",
-      "✗ 85\n",
-      "✗ 86\n",
-      "✗ 87\n",
-      "✗ 88\n",
-      "✗ 89\n",
-      "✗ 90\n",
-      "✗ 91\n",
-      "✗ 92\n",
-      "✗ 93\n",
-      "✗ 94\n",
-      "✗ 95\n",
-      "✗ 96\n",
-      "✗ 97\n",
-      "✗ 98\n",
-      "✗ 99\n",
-      "✗ 100\n",
-      "✗ 101\n",
-      "✗ 102\n",
-      "✗ 103\n",
-      "✗ 104\n",
-      "✗ 105\n",
-      "✗ 106\n",
-      "✗ 107\n",
-      "✗ 108\n",
-      "✗ 109\n",
-      "✗ 110\n",
-      "✗ 111\n",
-      "✗ 112\n",
-      "✗ 113\n",
-      "✗ 114\n",
-      "✗ 115\n",
-      "✗ 116\n",
-      "✗ 117\n",
-      "✗ 118\n",
-      "✗ 119\n",
-      "✗ 120\n",
-      "✗ 121\n",
-      "✗ 122\n",
-      "✗ 123\n",
-      "✗ 124\n",
-      "✗ 125\n",
-      "✗ 126\n",
-      "✗ 127\n",
-      "✗ 128\n",
-      "✗ 129\n",
-      "✗ 130\n",
-      "✗ 131\n",
-      "✗ 132\n",
-      "✗ 133\n",
-      "✗ 134\n",
-      "✗ 135\n",
-      "✗ 136\n",
-      "✗ 137\n",
-      "✗ 138\n",
-      "✗ 139\n",
-      "✗ 140\n",
-      "✗ 141\n",
-      "✗ 142\n",
-      "✗ 143\n",
-      "✗ 144\n",
-      "✗ 145\n",
-      "✗ 146\n",
-      "✗ 147\n",
-      "✗ 148\n",
-      "✗ 149\n",
-      "✗ 150\n",
-      "✗ 151\n",
-      "✗ 152\n",
-      "✗ 153\n",
-      "✗ 154\n",
-      "✗ 155\n",
-      "✗ 156\n",
-      "✗ 157\n",
-      "✗ 158\n",
-      "✗ 159\n",
-      "✗ 160\n",
-      "✗ 161\n",
-      "✗ 162\n",
-      "✗ 163\n",
-      "✗ 164\n",
-      "✗ 165\n",
-      "✗ 166\n",
-      "✗ 167\n",
-      "✗ 168\n",
-      "✗ 169\n",
-      "✗ 170\n",
-      "✗ 171\n",
-      "✗ 172\n",
-      "✗ 173\n",
-      "✗ 174\n",
-      "✗ 175\n",
-      "✗ 176\n",
-      "✗ 177\n",
-      "✗ 178\n",
-      "✗ 179\n",
-      "✗ 180\n",
-      "✗ 181\n",
-      "✗ 182\n",
-      "✗ 183\n",
-      "✗ 184\n",
-      "✗ 185\n",
-      "✗ 186\n",
-      "✗ 187\n",
-      "✗ 188\n",
-      "✗ 189\n",
-      "✗ 190\n",
-      "✗ 191\n",
-      "✗ 192\n",
-      "✗ 193\n",
-      "✗ 194\n",
-      "✗ 195\n",
-      "✗ 196\n",
-      "✗ 197\n",
-      "✗ 198\n",
-      "✗ 199\n",
-      "✗ 200\n",
-      "✗ 201\n",
-      "✗ 202\n",
-      "✗ 203\n",
-      "✗ 204\n",
-      "✗ 205\n",
-      "✗ 206\n",
-      "✗ 207\n",
-      "✗ 208\n",
-      "✗ 209\n",
-      "✗ 210\n",
-      "✗ 211\n",
-      "✗ 212\n",
-      "✗ 213\n",
-      "✗ 214\n",
-      "✗ 215\n",
-      "✗ 216\n",
-      "✗ 217\n",
-      "✗ 218\n",
-      "✗ 219\n",
-      "✗ 220\n",
-      "✗ 221\n",
-      "✗ 222\n",
-      "✗ 223\n",
-      "✗ 224\n",
-      "✗ 225\n",
-      "✗ 226\n",
-      "✗ 227\n",
-      "✗ 228\n",
-      "✗ 229\n",
-      "✗ 230\n",
-      "✗ 231\n",
-      "✗ 232\n",
-      "✗ 233\n",
-      "✗ 234\n",
-      "✗ 235\n",
-      "✗ 236\n",
-      "✗ 237\n",
-      "✗ 238\n",
-      "✗ 239\n",
-      "✗ 240\n",
-      "✗ 241\n",
-      "✗ 242\n",
-      "✗ 243\n",
-      "✗ 244\n",
-      "✗ 245\n",
-      "✗ 246\n",
-      "✗ 247\n",
-      "✗ 248\n",
-      "✗ 249\n",
-      "✗ 250\n",
-      "✗ 251\n",
-      "✗ 252\n",
-      "✗ 253\n",
-      "✗ 254\n",
-      "✗ 255\n",
-      "✗ 256\n",
-      "✗ 257\n",
-      "✗ 258\n",
-      "✗ 259\n",
-      "✗ 260\n",
-      "✗ 261\n",
-      "✗ 262\n",
-      "✗ 263\n",
-      "✗ 264\n",
-      "✗ 265\n",
-      "✗ 266\n",
-      "✗ 267\n",
-      "✗ 268\n",
-      "✗ 269\n",
-      "✗ 270\n",
-      "✗ 271\n",
-      "✗ 272\n",
-      "✗ 273\n",
-      "✗ 274\n",
-      "✗ 275\n",
-      "✗ 276\n",
-      "✗ 277\n",
-      "✗ 278\n",
-      "✗ 279\n",
-      "✗ 280\n",
-      "✗ 281\n",
-      "✗ 282\n",
-      "✗ 283\n",
-      "✗ 284\n",
-      "✗ 285\n",
-      "✗ 286\n",
-      "✗ 287\n",
-      "✗ 288\n",
-      "✗ 289\n",
-      "✗ 290\n",
-      "✗ 291\n",
-      "✗ 292\n",
-      "✗ 293\n",
-      "✗ 294\n",
-      "✗ 295\n",
-      "✗ 296\n",
-      "✗ 297\n",
-      "✗ 298\n",
-      "✗ 299\n",
-      "✗ 300\n",
-      "✗ 301\n",
-      "✗ 302\n",
-      "✗ 303\n",
-      "✗ 304\n",
-      "✗ 305\n",
-      "✗ 306\n",
-      "✗ 307\n",
-      "✗ 308\n",
-      "✗ 309\n",
-      "✗ 310\n",
-      "✗ 311\n",
-      "✗ 312\n",
-      "✗ 313\n",
-      "✗ 314\n",
-      "✗ 315\n",
-      "✗ 316\n",
-      "✗ 317\n",
-      "✗ 318\n",
-      "✗ 319\n",
-      "✗ 320\n",
-      "✗ 321\n",
-      "✗ 322\n",
-      "✗ 323\n",
-      "✗ 324\n",
-      "✗ 325\n",
-      "✗ 326\n",
-      "✗ 327\n",
-      "✗ 328\n",
-      "✗ 329\n",
-      "✗ 330\n",
-      "✗ 331\n",
-      "✗ 332\n",
-      "✗ 333\n",
-      "✗ 334\n",
-      "✗ 335\n",
-      "✗ 336\n",
-      "✗ 337\n",
-      "✗ 338\n",
-      "✗ 339\n",
-      "✗ 340\n",
-      "✗ 341\n",
-      "✗ 342\n",
-      "✗ 343\n",
-      "✗ 344\n",
-      "✗ 345\n",
-      "✗ 346\n",
-      "✗ 347\n",
-      "✗ 348\n",
-      "✗ 349\n",
-      "✗ 350\n",
-      "✗ 351\n",
-      "✗ 352\n",
-      "✗ 353\n",
-      "✗ 354\n",
-      "✗ 355\n",
-      "✗ 356\n",
-      "✗ 357\n",
-      "✗ 358\n",
-      "✗ 359\n",
-      "✗ 360\n",
-      "✗ 361\n",
-      "✗ 362\n",
-      "✗ 363\n",
-      "✗ 364\n",
-      "✗ 365\n",
-      "✗ 366\n",
-      "✗ 367\n",
-      "✗ 368\n",
-      "✗ 369\n",
-      "✗ 370\n",
-      "✗ 371\n",
-      "✗ 372\n",
-      "✗ 373\n",
-      "✗ 374\n",
-      "✗ 375\n",
-      "✗ 376\n",
-      "✗ 377\n",
-      "✗ 378\n",
-      "✗ 379\n",
-      "✗ 380\n",
-      "✗ 381\n",
-      "✗ 382\n",
-      "✗ 383\n",
-      "✗ 384\n",
-      "✗ 385\n",
-      "✗ 386\n",
-      "✗ 387\n",
-      "✗ 388\n",
-      "✗ 389\n",
-      "✗ 390\n",
-      "✗ 391\n",
-      "✗ 392\n",
-      "✗ 393\n",
-      "✗ 394\n",
-      "✗ 395\n",
-      "✗ 396\n",
-      "✗ 397\n",
-      "✗ 398\n",
-      "✗ 399\n",
-      "✗ 400\n",
-      "✗ 401\n",
-      "✗ 402\n",
-      "✗ 403\n",
-      "✗ 404\n",
-      "✗ 405\n",
-      "✗ 406\n",
-      "✗ 407\n",
-      "✗ 408\n",
-      "✗ 409\n",
-      "✗ 410\n",
-      "✗ 411\n",
-      "✗ 412\n",
-      "✗ 413\n",
-      "✗ 414\n",
-      "✗ 415\n",
-      "✗ 416\n",
-      "✗ 417\n",
-      "✗ 418\n",
-      "✗ 419\n",
-      "✗ 420\n",
-      "✗ 421\n",
-      "✗ 422\n",
-      "✗ 423\n",
-      "✗ 424\n",
-      "✗ 425\n",
-      "✗ 426\n",
-      "✗ 427\n",
-      "✗ 428\n",
-      "✗ 429\n",
-      "✗ 430\n",
-      "✗ 431\n",
-      "✗ 432\n",
-      "✗ 433\n",
-      "✗ 434\n",
-      "✗ 435\n",
-      "✗ 436\n",
-      "✗ 437\n",
-      "✗ 438\n",
-      "✗ 439\n",
-      "✗ 440\n",
-      "✗ 441\n",
-      "✗ 442\n",
-      "✗ 443\n",
-      "✗ 444\n",
-      "✗ 445\n",
-      "✗ 446\n",
-      "✗ 447\n",
-      "✗ 448\n",
-      "✗ 449\n",
-      "✗ 450\n",
-      "✗ 451\n",
-      "✗ 452\n",
-      "✗ 453\n",
-      "✗ 454\n",
-      "✗ 455\n",
-      "✗ 456\n",
-      "✗ 457\n",
-      "✗ 458\n",
-      "✗ 459\n",
-      "✗ 460\n",
-      "✗ 461\n",
-      "✗ 462\n",
-      "✗ 463\n",
-      "✗ 464\n",
-      "✗ 465\n",
-      "✗ 466\n",
-      "✗ 467\n",
-      "✗ 468\n",
-      "✗ 469\n",
-      "✗ 470\n",
-      "✗ 471\n",
-      "✗ 472\n",
-      "✗ 473\n",
-      "✗ 474\n",
-      "✗ 475\n",
-      "✗ 476\n",
-      "✗ 477\n",
-      "✗ 478\n",
-      "✗ 479\n",
-      "✗ 480\n",
-      "✗ 481\n",
-      "✗ 482\n",
-      "✗ 483\n",
-      "✗ 484\n",
-      "✗ 485\n",
-      "✗ 486\n",
-      "✗ 487\n",
-      "✗ 488\n",
-      "✗ 489\n",
-      "✗ 490\n",
-      "✗ 491\n",
-      "✗ 492\n",
-      "✗ 493\n",
-      "✗ 494\n",
-      "✗ 495\n",
-      "✗ 496\n",
-      "✗ 497\n",
-      "✗ 498\n",
-      "✗ 499\n",
-      "\n",
-      "1 shrinks with 1003 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(1000, lambda x: sum(x) >= 500,\n",
-    "           partial(greedy_shrink, shrink=shrink2))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "Because we're trying every intermediate value, what we have amounts to a linear probe up to the smallest value that will work. If that smallest value is large, this will take a long time. Our shrinking is still O(n), but n is now the size of the smallest value that will work rather than the starting value. This is still pretty suboptimal.\n",
-    "\n",
-    "What we want to do is try to replace our linear probe with a binary search. What we'll get isn't exactly a binary search, but it's close enough."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def shrink_integer(n):\n",
-    "    \"\"\"\n",
-    "    Shrinker for individual integers.\n",
-    "    \n",
-    "    What happens is that we start from the left, first probing upwards in powers of two.\n",
-    "    \n",
-    "    When this would take us past our target value we then binary chop towards it.\n",
-    "    \"\"\"\n",
-    "    if not n:\n",
-    "        return\n",
-    "    for k in range(64):\n",
-    "        probe = 2 ** k\n",
-    "        if probe >= n:\n",
-    "            break\n",
-    "        yield probe - 1\n",
-    "    probe //= 2\n",
-    "    while True:\n",
-    "        probe = (probe + n) // 2\n",
-    "        yield probe\n",
-    "        if probe == n - 1:\n",
-    "            break\n",
-    "\n",
-    "\n",
-    "def shrink3(ls):\n",
-    "    for i in range(len(ls)):\n",
-    "        s = list(ls)\n",
-    "        del si\n",
-    "        yield list(s)\n",
-    "        for x in shrink_integer(lsi):\n",
-    "            s = list(ls)\n",
-    "            si = x\n",
-    "            yield s"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/plain": 
-       "0, 1, 3, 7, 15, 31, 63, 127, 255, 378, 439, 469, 484, 492, 496, 498, 499"
-      
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "list(shrink_integer(500))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This gives us a reasonable distribution of O(log(n)) values in the middle while still making sure we start with 0 and finish with n - 1.\n",
-    "\n",
-    "In Hypothesis's actual implementation we also try random values in the probe region in case there's something special about things near powers of two, but we won't worry about that here."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 1000\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 3\n",
-      "✗ 7\n",
-      "✗ 15\n",
-      "✗ 31\n",
-      "✗ 63\n",
-      "✗ 127\n",
-      "✗ 255\n",
-      "✓ 511\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 3\n",
-      "✗ 7\n",
-      "✗ 15\n",
-      "✗ 31\n",
-      "✗ 63\n",
-      "✗ 127\n",
-      "✗ 255\n",
-      "✗ 383\n",
-      "✗ 447\n",
-      "✗ 479\n",
-      "✗ 495\n",
-      "✓ 503\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 3\n",
-      "✗ 7\n",
-      "✗ 15\n",
-      "✗ 31\n",
-      "✗ 63\n",
-      "✗ 127\n",
-      "✗ 255\n",
-      "✗ 379\n",
-      "✗ 441\n",
-      "✗ 472\n",
-      "✗ 487\n",
-      "✗ 495\n",
-      "✗ 499\n",
-      "✓ 501\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 3\n",
-      "✗ 7\n",
-      "✗ 15\n",
-      "✗ 31\n",
-      "✗ 63\n",
-      "✗ 127\n",
-      "✗ 255\n",
-      "✗ 378\n",
-      "✗ 439\n",
-      "✗ 470\n",
-      "✗ 485\n",
-      "✗ 493\n",
-      "✗ 497\n",
-      "✗ 499\n",
-      "✓ 500\n",
-      "✗ \n",
-      "✗ 0\n",
-      "✗ 1\n",
-      "✗ 3\n",
-      "✗ 7\n",
-      "✗ 15\n",
-      "✗ 31\n",
-      "✗ 63\n",
-      "✗ 127\n",
-      "✗ 255\n",
-      "✗ 378\n",
-      "✗ 439\n",
-      "✗ 469\n",
-      "✗ 484\n",
-      "✗ 492\n",
-      "✗ 496\n",
-      "✗ 498\n",
-      "✗ 499\n",
-      "\n",
-      "4 shrinks with 79 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(1000, lambda x: sum(x) >= 500, partial(\n",
-    "        greedy_shrink, shrink=shrink3))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This now runs in a much more reasonable number of function calls.\n",
-    "\n",
-    "Now we want to look at how to reduce the number of elements in the list more efficiently. We're currently making the same mistake we did with n umbers. Only reducing one at a time."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2, 2\n",
-      "✓ 2, 2, 2, 2\n",
-      "✓ 2, 2, 2\n",
-      "✓ 2, 2\n",
-      "✗ 2\n",
-      "✗ 0, 2\n",
-      "✓ 1, 2\n",
-      "✗ 2\n",
-      "✗ 0, 2\n",
-      "✗ 1\n",
-      "✗ 1, 0\n",
-      "✗ 1, 1\n",
-      "\n",
-      "19 shrinks with 26 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(2 * 20, lambda x: sum(x) >= 3, partial(\n",
-    "        greedy_shrink, shrink=shrink3))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "We won't try too hard here, because typically our lists are not *that* long. We will just attempt to start by finding a shortish initial prefix that demonstrates the behaviour:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def shrink_to_prefix(ls):\n",
-    "    i = 1\n",
-    "    while i < len(ls):\n",
-    "        yield ls:i\n",
-    "        i *= 2\n",
-    "\n",
-    "\n",
-    "def delete_individual_elements(ls):\n",
-    "    for i in range(len(ls)):\n",
-    "        s = list(ls)\n",
-    "        del si\n",
-    "        yield list(s)\n",
-    "\n",
-    "\n",
-    "def shrink_individual_elements(ls):\n",
-    "    for i in range(len(ls)):\n",
-    "        for x in shrink_integer(lsi):\n",
-    "            s = list(ls)\n",
-    "            si = x\n",
-    "            yield s\n",
-    "            \n",
-    "def shrink4(ls):\n",
-    "    yield from shrink_to_prefix(ls)\n",
-    "    yield from delete_individual_elements(ls)\n",
-    "    yield from shrink_individual_elements(ls)            "
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 2\n",
-      "✓ 2, 2\n",
-      "✗ 2\n",
-      "✗ 2\n",
-      "✗ 2\n",
-      "✗ 0, 2\n",
-      "✓ 1, 2\n",
-      "✗ 1\n",
-      "✗ 2\n",
-      "✗ 1\n",
-      "✗ 0, 2\n",
-      "✗ 1, 0\n",
-      "✗ 1, 1\n",
-      "\n",
-      "2 shrinks with 13 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(2 * 20, lambda x: sum(x) >= 3, partial(\n",
-    "        greedy_shrink, shrink=shrink4))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "The problem we now want to address is the fact that when we're shrinking elements we're only shrinking them one at a time. This means that even though we're only O(log(k)) in each element, we're O(log(k)^n) in the whole list where n is the length of the list. For even very modest k this is bad.\n",
-    "\n",
-    "In general we may not be able to fix this, but in practice for a lot of common structures we can exploit similarity to try to do simultaneous shrinking.\n",
-    "\n",
-    "Here is our starting example: We start and finish with all identical values. We would like to be able to shortcut through a lot of the uninteresting intermediate examples somehow."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 20, 20, 20, 20, 20, 20, 20\n",
-      "✗ 20\n",
-      "✗ 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✓ 20, 20, 20, 20, 20, 20\n",
-      "✗ 20\n",
-      "✗ 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✓ 20, 20, 20, 20, 20\n",
-      "✗ 20\n",
-      "✗ 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 0, 20, 20, 20, 20\n",
-      "✗ 1, 20, 20, 20, 20\n",
-      "✗ 3, 20, 20, 20, 20\n",
-      "✓ 7, 20, 20, 20, 20\n",
-      "✗ 7\n",
-      "✗ 7, 20\n",
-      "✗ 7, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 7, 20, 20, 20\n",
-      "✗ 7, 20, 20, 20\n",
-      "✗ 7, 20, 20, 20\n",
-      "✗ 7, 20, 20, 20\n",
-      "✗ 0, 20, 20, 20, 20\n",
-      "✗ 1, 20, 20, 20, 20\n",
-      "✗ 3, 20, 20, 20, 20\n",
-      "✓ 5, 20, 20, 20, 20\n",
-      "✗ 5\n",
-      "✗ 5, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 0, 20, 20, 20, 20\n",
-      "✗ 1, 20, 20, 20, 20\n",
-      "✗ 3, 20, 20, 20, 20\n",
-      "✗ 4, 20, 20, 20, 20\n",
-      "✗ 5, 0, 20, 20, 20\n",
-      "✗ 5, 1, 20, 20, 20\n",
-      "✗ 5, 3, 20, 20, 20\n",
-      "✓ 5, 7, 20, 20, 20\n",
-      "✗ 5\n",
-      "✗ 5, 7\n",
-      "✗ 5, 7, 20, 20\n",
-      "✗ 7, 20, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 5, 7, 20, 20\n",
-      "✗ 5, 7, 20, 20\n",
-      "✗ 5, 7, 20, 20\n",
-      "✗ 0, 7, 20, 20, 20\n",
-      "✗ 1, 7, 20, 20, 20\n",
-      "✗ 3, 7, 20, 20, 20\n",
-      "✗ 4, 7, 20, 20, 20\n",
-      "✗ 5, 0, 20, 20, 20\n",
-      "✗ 5, 1, 20, 20, 20\n",
-      "✗ 5, 3, 20, 20, 20\n",
-      "✓ 5, 5, 20, 20, 20\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 5, 20, 20, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 0, 5, 20, 20, 20\n",
-      "✗ 1, 5, 20, 20, 20\n",
-      "✗ 3, 5, 20, 20, 20\n",
-      "✗ 4, 5, 20, 20, 20\n",
-      "✗ 5, 0, 20, 20, 20\n",
-      "✗ 5, 1, 20, 20, 20\n",
-      "✗ 5, 3, 20, 20, 20\n",
-      "✗ 5, 4, 20, 20, 20\n",
-      "✗ 5, 5, 0, 20, 20\n",
-      "✗ 5, 5, 1, 20, 20\n",
-      "✗ 5, 5, 3, 20, 20\n",
-      "✓ 5, 5, 7, 20, 20\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 7, 20\n",
-      "✗ 5, 7, 20, 20\n",
-      "✗ 5, 7, 20, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 5, 7, 20\n",
-      "✗ 5, 5, 7, 20\n",
-      "✗ 0, 5, 7, 20, 20\n",
-      "✗ 1, 5, 7, 20, 20\n",
-      "✗ 3, 5, 7, 20, 20\n",
-      "✗ 4, 5, 7, 20, 20\n",
-      "✗ 5, 0, 7, 20, 20\n",
-      "✗ 5, 1, 7, 20, 20\n",
-      "✗ 5, 3, 7, 20, 20\n",
-      "✗ 5, 4, 7, 20, 20\n",
-      "✗ 5, 5, 0, 20, 20\n",
-      "✗ 5, 5, 1, 20, 20\n",
-      "✗ 5, 5, 3, 20, 20\n",
-      "✓ 5, 5, 5, 20, 20\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 5, 20, 20\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 0, 5, 5, 20, 20\n",
-      "✗ 1, 5, 5, 20, 20\n",
-      "✗ 3, 5, 5, 20, 20\n",
-      "✗ 4, 5, 5, 20, 20\n",
-      "✗ 5, 0, 5, 20, 20\n",
-      "✗ 5, 1, 5, 20, 20\n",
-      "✗ 5, 3, 5, 20, 20\n",
-      "✗ 5, 4, 5, 20, 20\n",
-      "✗ 5, 5, 0, 20, 20\n",
-      "✗ 5, 5, 1, 20, 20\n",
-      "✗ 5, 5, 3, 20, 20\n",
-      "✗ 5, 5, 4, 20, 20\n",
-      "✗ 5, 5, 5, 0, 20\n",
-      "✗ 5, 5, 5, 1, 20\n",
-      "✗ 5, 5, 5, 3, 20\n",
-      "✓ 5, 5, 5, 7, 20\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 7, 20\n",
-      "✗ 5, 5, 7, 20\n",
-      "✗ 5, 5, 7, 20\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 0, 5, 5, 7, 20\n",
-      "✗ 1, 5, 5, 7, 20\n",
-      "✗ 3, 5, 5, 7, 20\n",
-      "✗ 4, 5, 5, 7, 20\n",
-      "✗ 5, 0, 5, 7, 20\n",
-      "✗ 5, 1, 5, 7, 20\n",
-      "✗ 5, 3, 5, 7, 20\n",
-      "✗ 5, 4, 5, 7, 20\n",
-      "✗ 5, 5, 0, 7, 20\n",
-      "✗ 5, 5, 1, 7, 20\n",
-      "✗ 5, 5, 3, 7, 20\n",
-      "✗ 5, 5, 4, 7, 20\n",
-      "✗ 5, 5, 5, 0, 20\n",
-      "✗ 5, 5, 5, 1, 20\n",
-      "✗ 5, 5, 5, 3, 20\n",
-      "✓ 5, 5, 5, 5, 20\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 5, 20\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 5, 5, 5, 20\n",
-      "✗ 1, 5, 5, 5, 20\n",
-      "✗ 3, 5, 5, 5, 20\n",
-      "✗ 4, 5, 5, 5, 20\n",
-      "✗ 5, 0, 5, 5, 20\n",
-      "✗ 5, 1, 5, 5, 20\n",
-      "✗ 5, 3, 5, 5, 20\n",
-      "✗ 5, 4, 5, 5, 20\n",
-      "✗ 5, 5, 0, 5, 20\n",
-      "✗ 5, 5, 1, 5, 20\n",
-      "✗ 5, 5, 3, 5, 20\n",
-      "✗ 5, 5, 4, 5, 20\n",
-      "✗ 5, 5, 5, 0, 20\n",
-      "✗ 5, 5, 5, 1, 20\n",
-      "✗ 5, 5, 5, 3, 20\n",
-      "✗ 5, 5, 5, 4, 20\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✓ 5, 5, 5, 5, 7\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 5, 5, 5, 7\n",
-      "✗ 1, 5, 5, 5, 7\n",
-      "✗ 3, 5, 5, 5, 7\n",
-      "✗ 4, 5, 5, 5, 7\n",
-      "✗ 5, 0, 5, 5, 7\n",
-      "✗ 5, 1, 5, 5, 7\n",
-      "✗ 5, 3, 5, 5, 7\n",
-      "✗ 5, 4, 5, 5, 7\n",
-      "✗ 5, 5, 0, 5, 7\n",
-      "✗ 5, 5, 1, 5, 7\n",
-      "✗ 5, 5, 3, 5, 7\n",
-      "✗ 5, 5, 4, 5, 7\n",
-      "✗ 5, 5, 5, 0, 7\n",
-      "✗ 5, 5, 5, 1, 7\n",
-      "✗ 5, 5, 5, 3, 7\n",
-      "✗ 5, 5, 5, 4, 7\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✓ 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 5, 5, 5, 5\n",
-      "✗ 1, 5, 5, 5, 5\n",
-      "✗ 3, 5, 5, 5, 5\n",
-      "✗ 4, 5, 5, 5, 5\n",
-      "✗ 5, 0, 5, 5, 5\n",
-      "✗ 5, 1, 5, 5, 5\n",
-      "✗ 5, 3, 5, 5, 5\n",
-      "✗ 5, 4, 5, 5, 5\n",
-      "✗ 5, 5, 0, 5, 5\n",
-      "✗ 5, 5, 1, 5, 5\n",
-      "✗ 5, 5, 3, 5, 5\n",
-      "✗ 5, 5, 4, 5, 5\n",
-      "✗ 5, 5, 5, 0, 5\n",
-      "✗ 5, 5, 5, 1, 5\n",
-      "✗ 5, 5, 5, 3, 5\n",
-      "✗ 5, 5, 5, 4, 5\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✗ 5, 5, 5, 5, 4\n",
-      "\n",
-      "12 shrinks with 236 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(20 * 7,\n",
-    "           lambda x: len(t for t in x if t >= 5) >= 5,\n",
-    "           partial(greedy_shrink, shrink=shrink4))"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def shrink_shared(ls):\n",
-    "    \"\"\"\n",
-    "    Look for all sets of shared indices and try to perform a simultaneous shrink on\n",
-    "    their value, replacing all of them at once.\n",
-    "    \n",
-    "    In actual Hypothesis we also try replacing only subsets of the values when there\n",
-    "    are more than two shared values, but we won't worry about that here.\n",
-    "    \"\"\"\n",
-    "    shared_indices = {}\n",
-    "    for i in range(len(ls)):\n",
-    "        shared_indices.setdefault(lsi, ).append(i)\n",
-    "    for sharing in shared_indices.values():\n",
-    "        if len(sharing) > 1:\n",
-    "            for v in shrink_integer(lssharing0):\n",
-    "                s = list(ls)\n",
-    "                for i in sharing:\n",
-    "                    si = v\n",
-    "                yield s\n",
-    "\n",
-    "\n",
-    "def shrink5(ls):\n",
-    "    yield from shrink_to_prefix(ls)\n",
-    "    yield from delete_individual_elements(ls)\n",
-    "    yield from shrink_shared(ls)\n",
-    "    yield from shrink_individual_elements(ls)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 20, 20, 20, 20, 20, 20, 20\n",
-      "✗ 20\n",
-      "✗ 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✓ 20, 20, 20, 20, 20, 20\n",
-      "✗ 20\n",
-      "✗ 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✓ 20, 20, 20, 20, 20\n",
-      "✗ 20\n",
-      "✗ 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 20, 20, 20, 20\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✓ 7, 7, 7, 7, 7\n",
-      "✗ 7\n",
-      "✗ 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✓ 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✗ 4, 4, 4, 4, 4\n",
-      "✗ 0, 5, 5, 5, 5\n",
-      "✗ 1, 5, 5, 5, 5\n",
-      "✗ 3, 5, 5, 5, 5\n",
-      "✗ 4, 5, 5, 5, 5\n",
-      "✗ 5, 0, 5, 5, 5\n",
-      "✗ 5, 1, 5, 5, 5\n",
-      "✗ 5, 3, 5, 5, 5\n",
-      "✗ 5, 4, 5, 5, 5\n",
-      "✗ 5, 5, 0, 5, 5\n",
-      "✗ 5, 5, 1, 5, 5\n",
-      "✗ 5, 5, 3, 5, 5\n",
-      "✗ 5, 5, 4, 5, 5\n",
-      "✗ 5, 5, 5, 0, 5\n",
-      "✗ 5, 5, 5, 1, 5\n",
-      "✗ 5, 5, 5, 3, 5\n",
-      "✗ 5, 5, 5, 4, 5\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✗ 5, 5, 5, 5, 4\n",
-      "\n",
-      "4 shrinks with 64 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(20 * 7,\n",
-    "           lambda x: len(t for t in x if t >= 5) >= 5,\n",
-    "           partial(greedy_shrink, shrink=shrink5))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This achieves the desired result. We rapidly progress through all of the intermediate stages. We do still have to perform individual shrinks at the end unfortunately (this is unavoidable), but the size of the elements is much smaller now so it takes less time.\n",
-    "\n",
-    "Unfortunately while this solves the problem in this case it's almost useless, because unless you find yourself in the exact right starting position it never does anything."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 20, 21, 22, 23, 24, 25, 26\n",
-      "✗ 20\n",
-      "✗ 20, 21\n",
-      "✗ 20, 21, 22, 23\n",
-      "✓ 21, 22, 23, 24, 25, 26\n",
-      "✗ 21\n",
-      "✗ 21, 22\n",
-      "✗ 21, 22, 23, 24\n",
-      "✓ 22, 23, 24, 25, 26\n",
-      "✗ 22\n",
-      "✗ 22, 23\n",
-      "✗ 22, 23, 24, 25\n",
-      "✗ 23, 24, 25, 26\n",
-      "✗ 22, 24, 25, 26\n",
-      "✗ 22, 23, 25, 26\n",
-      "✗ 22, 23, 24, 26\n",
-      "✗ 22, 23, 24, 25\n",
-      "✗ 0, 23, 24, 25, 26\n",
-      "✗ 1, 23, 24, 25, 26\n",
-      "✗ 3, 23, 24, 25, 26\n",
-      "✓ 7, 23, 24, 25, 26\n",
-      "✗ 7\n",
-      "✗ 7, 23\n",
-      "✗ 7, 23, 24, 25\n",
-      "✗ 23, 24, 25, 26\n",
-      "✗ 7, 24, 25, 26\n",
-      "✗ 7, 23, 25, 26\n",
-      "✗ 7, 23, 24, 26\n",
-      "✗ 7, 23, 24, 25\n",
-      "✗ 0, 23, 24, 25, 26\n",
-      "✗ 1, 23, 24, 25, 26\n",
-      "✗ 3, 23, 24, 25, 26\n",
-      "✓ 5, 23, 24, 25, 26\n",
-      "✗ 5\n",
-      "✗ 5, 23\n",
-      "✗ 5, 23, 24, 25\n",
-      "✗ 23, 24, 25, 26\n",
-      "✗ 5, 24, 25, 26\n",
-      "✗ 5, 23, 25, 26\n",
-      "✗ 5, 23, 24, 26\n",
-      "✗ 5, 23, 24, 25\n",
-      "✗ 0, 23, 24, 25, 26\n",
-      "✗ 1, 23, 24, 25, 26\n",
-      "✗ 3, 23, 24, 25, 26\n",
-      "✗ 4, 23, 24, 25, 26\n",
-      "✗ 5, 0, 24, 25, 26\n",
-      "✗ 5, 1, 24, 25, 26\n",
-      "✗ 5, 3, 24, 25, 26\n",
-      "✓ 5, 7, 24, 25, 26\n",
-      "✗ 5\n",
-      "✗ 5, 7\n",
-      "✗ 5, 7, 24, 25\n",
-      "✗ 7, 24, 25, 26\n",
-      "✗ 5, 24, 25, 26\n",
-      "✗ 5, 7, 25, 26\n",
-      "✗ 5, 7, 24, 26\n",
-      "✗ 5, 7, 24, 25\n",
-      "✗ 0, 7, 24, 25, 26\n",
-      "✗ 1, 7, 24, 25, 26\n",
-      "✗ 3, 7, 24, 25, 26\n",
-      "✗ 4, 7, 24, 25, 26\n",
-      "✗ 5, 0, 24, 25, 26\n",
-      "✗ 5, 1, 24, 25, 26\n",
-      "✗ 5, 3, 24, 25, 26\n",
-      "✓ 5, 5, 24, 25, 26\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 24, 25\n",
-      "✗ 5, 24, 25, 26\n",
-      "✗ 5, 24, 25, 26\n",
-      "✗ 5, 5, 25, 26\n",
-      "✗ 5, 5, 24, 26\n",
-      "✗ 5, 5, 24, 25\n",
-      "✗ 0, 0, 24, 25, 26\n",
-      "✗ 1, 1, 24, 25, 26\n",
-      "✗ 3, 3, 24, 25, 26\n",
-      "✗ 4, 4, 24, 25, 26\n",
-      "✗ 0, 5, 24, 25, 26\n",
-      "✗ 1, 5, 24, 25, 26\n",
-      "✗ 3, 5, 24, 25, 26\n",
-      "✗ 4, 5, 24, 25, 26\n",
-      "✗ 5, 0, 24, 25, 26\n",
-      "✗ 5, 1, 24, 25, 26\n",
-      "✗ 5, 3, 24, 25, 26\n",
-      "✗ 5, 4, 24, 25, 26\n",
-      "✗ 5, 5, 0, 25, 26\n",
-      "✗ 5, 5, 1, 25, 26\n",
-      "✗ 5, 5, 3, 25, 26\n",
-      "✓ 5, 5, 7, 25, 26\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 7, 25\n",
-      "✗ 5, 7, 25, 26\n",
-      "✗ 5, 7, 25, 26\n",
-      "✗ 5, 5, 25, 26\n",
-      "✗ 5, 5, 7, 26\n",
-      "✗ 5, 5, 7, 25\n",
-      "✗ 0, 0, 7, 25, 26\n",
-      "✗ 1, 1, 7, 25, 26\n",
-      "✗ 3, 3, 7, 25, 26\n",
-      "✗ 4, 4, 7, 25, 26\n",
-      "✗ 0, 5, 7, 25, 26\n",
-      "✗ 1, 5, 7, 25, 26\n",
-      "✗ 3, 5, 7, 25, 26\n",
-      "✗ 4, 5, 7, 25, 26\n",
-      "✗ 5, 0, 7, 25, 26\n",
-      "✗ 5, 1, 7, 25, 26\n",
-      "✗ 5, 3, 7, 25, 26\n",
-      "✗ 5, 4, 7, 25, 26\n",
-      "✗ 5, 5, 0, 25, 26\n",
-      "✗ 5, 5, 1, 25, 26\n",
-      "✗ 5, 5, 3, 25, 26\n",
-      "✓ 5, 5, 5, 25, 26\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 25\n",
-      "✗ 5, 5, 25, 26\n",
-      "✗ 5, 5, 25, 26\n",
-      "✗ 5, 5, 25, 26\n",
-      "✗ 5, 5, 5, 26\n",
-      "✗ 5, 5, 5, 25\n",
-      "✗ 0, 0, 0, 25, 26\n",
-      "✗ 1, 1, 1, 25, 26\n",
-      "✗ 3, 3, 3, 25, 26\n",
-      "✗ 4, 4, 4, 25, 26\n",
-      "✗ 0, 5, 5, 25, 26\n",
-      "✗ 1, 5, 5, 25, 26\n",
-      "✗ 3, 5, 5, 25, 26\n",
-      "✗ 4, 5, 5, 25, 26\n",
-      "✗ 5, 0, 5, 25, 26\n",
-      "✗ 5, 1, 5, 25, 26\n",
-      "✗ 5, 3, 5, 25, 26\n",
-      "✗ 5, 4, 5, 25, 26\n",
-      "✗ 5, 5, 0, 25, 26\n",
-      "✗ 5, 5, 1, 25, 26\n",
-      "✗ 5, 5, 3, 25, 26\n",
-      "✗ 5, 5, 4, 25, 26\n",
-      "✗ 5, 5, 5, 0, 26\n",
-      "✗ 5, 5, 5, 1, 26\n",
-      "✗ 5, 5, 5, 3, 26\n",
-      "✓ 5, 5, 5, 7, 26\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 7, 26\n",
-      "✗ 5, 5, 7, 26\n",
-      "✗ 5, 5, 7, 26\n",
-      "✗ 5, 5, 5, 26\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 0, 0, 0, 7, 26\n",
-      "✗ 1, 1, 1, 7, 26\n",
-      "✗ 3, 3, 3, 7, 26\n",
-      "✗ 4, 4, 4, 7, 26\n",
-      "✗ 0, 5, 5, 7, 26\n",
-      "✗ 1, 5, 5, 7, 26\n",
-      "✗ 3, 5, 5, 7, 26\n",
-      "✗ 4, 5, 5, 7, 26\n",
-      "✗ 5, 0, 5, 7, 26\n",
-      "✗ 5, 1, 5, 7, 26\n",
-      "✗ 5, 3, 5, 7, 26\n",
-      "✗ 5, 4, 5, 7, 26\n",
-      "✗ 5, 5, 0, 7, 26\n",
-      "✗ 5, 5, 1, 7, 26\n",
-      "✗ 5, 5, 3, 7, 26\n",
-      "✗ 5, 5, 4, 7, 26\n",
-      "✗ 5, 5, 5, 0, 26\n",
-      "✗ 5, 5, 5, 1, 26\n",
-      "✗ 5, 5, 5, 3, 26\n",
-      "✓ 5, 5, 5, 5, 26\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 26\n",
-      "✗ 5, 5, 5, 26\n",
-      "✗ 5, 5, 5, 26\n",
-      "✗ 5, 5, 5, 26\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 0, 0, 0, 26\n",
-      "✗ 1, 1, 1, 1, 26\n",
-      "✗ 3, 3, 3, 3, 26\n",
-      "✗ 4, 4, 4, 4, 26\n",
-      "✗ 0, 5, 5, 5, 26\n",
-      "✗ 1, 5, 5, 5, 26\n",
-      "✗ 3, 5, 5, 5, 26\n",
-      "✗ 4, 5, 5, 5, 26\n",
-      "✗ 5, 0, 5, 5, 26\n",
-      "✗ 5, 1, 5, 5, 26\n",
-      "✗ 5, 3, 5, 5, 26\n",
-      "✗ 5, 4, 5, 5, 26\n",
-      "✗ 5, 5, 0, 5, 26\n",
-      "✗ 5, 5, 1, 5, 26\n",
-      "✗ 5, 5, 3, 5, 26\n",
-      "✗ 5, 5, 4, 5, 26\n",
-      "✗ 5, 5, 5, 0, 26\n",
-      "✗ 5, 5, 5, 1, 26\n",
-      "✗ 5, 5, 5, 3, 26\n",
-      "✗ 5, 5, 5, 4, 26\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✓ 5, 5, 5, 5, 7\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 7\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 0, 0, 0, 7\n",
-      "✗ 1, 1, 1, 1, 7\n",
-      "✗ 3, 3, 3, 3, 7\n",
-      "✗ 4, 4, 4, 4, 7\n",
-      "✗ 0, 5, 5, 5, 7\n",
-      "✗ 1, 5, 5, 5, 7\n",
-      "✗ 3, 5, 5, 5, 7\n",
-      "✗ 4, 5, 5, 5, 7\n",
-      "✗ 5, 0, 5, 5, 7\n",
-      "✗ 5, 1, 5, 5, 7\n",
-      "✗ 5, 3, 5, 5, 7\n",
-      "✗ 5, 4, 5, 5, 7\n",
-      "✗ 5, 5, 0, 5, 7\n",
-      "✗ 5, 5, 1, 5, 7\n",
-      "✗ 5, 5, 3, 5, 7\n",
-      "✗ 5, 5, 4, 5, 7\n",
-      "✗ 5, 5, 5, 0, 7\n",
-      "✗ 5, 5, 5, 1, 7\n",
-      "✗ 5, 5, 5, 3, 7\n",
-      "✗ 5, 5, 5, 4, 7\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✓ 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✗ 4, 4, 4, 4, 4\n",
-      "✗ 0, 5, 5, 5, 5\n",
-      "✗ 1, 5, 5, 5, 5\n",
-      "✗ 3, 5, 5, 5, 5\n",
-      "✗ 4, 5, 5, 5, 5\n",
-      "✗ 5, 0, 5, 5, 5\n",
-      "✗ 5, 1, 5, 5, 5\n",
-      "✗ 5, 3, 5, 5, 5\n",
-      "✗ 5, 4, 5, 5, 5\n",
-      "✗ 5, 5, 0, 5, 5\n",
-      "✗ 5, 5, 1, 5, 5\n",
-      "✗ 5, 5, 3, 5, 5\n",
-      "✗ 5, 5, 4, 5, 5\n",
-      "✗ 5, 5, 5, 0, 5\n",
-      "✗ 5, 5, 5, 1, 5\n",
-      "✗ 5, 5, 5, 3, 5\n",
-      "✗ 5, 5, 5, 4, 5\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✗ 5, 5, 5, 5, 4\n",
-      "\n",
-      "12 shrinks with 264 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(20 + i for i in range(7),\n",
-    "           lambda x: len(t for t in x if t >= 5) >= 5,\n",
-    "           partial(greedy_shrink, shrink=shrink5))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "So what we're going to try to do is to try a simplification first which *creates* that exact right starting condition. Further it's one that will be potentially very useful even if we don't actually have the situation where we have shared shrinks.\n",
-    "\n",
-    "What we're going to do is we're going to use values from the list to act as evidence for how complex things need to be. Starting from the smallest, we'll try capping the array at each individual value and see what happens.\n",
-    "\n",
-    "As well as being potentially a very rapid shrink, this creates lists with lots of duplicates, which enables the simultaneous shrinking to shine."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def replace_with_simpler(ls):\n",
-    "    if not ls:\n",
-    "        return\n",
-    "    values = set(ls)\n",
-    "    values.remove(max(ls))\n",
-    "    values = sorted(values)\n",
-    "    for v in values:\n",
-    "        yield min(v, l) for l in ls\n",
-    "\n",
-    "\n",
-    "def shrink6(ls):\n",
-    "    yield from shrink_to_prefix(ls)\n",
-    "    yield from delete_individual_elements(ls)\n",
-    "    yield from replace_with_simpler(ls)\n",
-    "    yield from shrink_shared(ls)\n",
-    "    yield from shrink_individual_elements(ls)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 20, 21, 22, 23, 24, 25, 26\n",
-      "✗ 20\n",
-      "✗ 20, 21\n",
-      "✗ 20, 21, 22, 23\n",
-      "✓ 21, 22, 23, 24, 25, 26\n",
-      "✗ 21\n",
-      "✗ 21, 22\n",
-      "✗ 21, 22, 23, 24\n",
-      "✓ 22, 23, 24, 25, 26\n",
-      "✗ 22\n",
-      "✗ 22, 23\n",
-      "✗ 22, 23, 24, 25\n",
-      "✗ 23, 24, 25, 26\n",
-      "✗ 22, 24, 25, 26\n",
-      "✗ 22, 23, 25, 26\n",
-      "✗ 22, 23, 24, 26\n",
-      "✗ 22, 23, 24, 25\n",
-      "✓ 22, 22, 22, 22, 22\n",
-      "✗ 22\n",
-      "✗ 22, 22\n",
-      "✗ 22, 22, 22, 22\n",
-      "✗ 22, 22, 22, 22\n",
-      "✗ 22, 22, 22, 22\n",
-      "✗ 22, 22, 22, 22\n",
-      "✗ 22, 22, 22, 22\n",
-      "✗ 22, 22, 22, 22\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✓ 7, 7, 7, 7, 7\n",
-      "✗ 7\n",
-      "✗ 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 7, 7, 7, 7\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✓ 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✗ 0, 0, 0, 0, 0\n",
-      "✗ 1, 1, 1, 1, 1\n",
-      "✗ 3, 3, 3, 3, 3\n",
-      "✗ 4, 4, 4, 4, 4\n",
-      "✗ 0, 5, 5, 5, 5\n",
-      "✗ 1, 5, 5, 5, 5\n",
-      "✗ 3, 5, 5, 5, 5\n",
-      "✗ 4, 5, 5, 5, 5\n",
-      "✗ 5, 0, 5, 5, 5\n",
-      "✗ 5, 1, 5, 5, 5\n",
-      "✗ 5, 3, 5, 5, 5\n",
-      "✗ 5, 4, 5, 5, 5\n",
-      "✗ 5, 5, 0, 5, 5\n",
-      "✗ 5, 5, 1, 5, 5\n",
-      "✗ 5, 5, 3, 5, 5\n",
-      "✗ 5, 5, 4, 5, 5\n",
-      "✗ 5, 5, 5, 0, 5\n",
-      "✗ 5, 5, 5, 1, 5\n",
-      "✗ 5, 5, 5, 3, 5\n",
-      "✗ 5, 5, 5, 4, 5\n",
-      "✗ 5, 5, 5, 5, 0\n",
-      "✗ 5, 5, 5, 5, 1\n",
-      "✗ 5, 5, 5, 5, 3\n",
-      "✗ 5, 5, 5, 5, 4\n",
-      "\n",
-      "5 shrinks with 73 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(20 + i for i in range(7),\n",
-    "           lambda x: len(t for t in x if t >= 5) >= 5,\n",
-    "           partial(greedy_shrink, shrink=shrink6))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "Now we're going to start looking at some numbers.\n",
-    "\n",
-    "What we'll do is we'll generate 1000 random lists satisfying some predicate, and then simplify them down to the smallest possible examples satisfying those predicates. This lets us verify that these aren't just cherry-picked examples and our methods help in the general case. We fix the set of examples per predicate so that we're comparing like for like.\n",
-    "\n",
-    "A more proper statistical treatment would probably be a good idea."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "from collections import OrderedDict\n",
-    "\n",
-    "conditions = OrderedDict(\n",
-    "    (\"length >= 2\", lambda xs: len(xs) >= 2),\n",
-    "    (\"sum >= 500\", lambda xs: sum(xs) >= 500),\n",
-    "    (\"sum >= 3\", lambda xs: sum(xs) >= 3),\n",
-    "    (\"At least 10 by 5\", lambda xs: len(\n",
-    "        t for t in xs if t >= 5) >= 10),\n",
-    ")"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/plain": 
-       "17861213645196285187,\n",
-       " 15609796832515195084,\n",
-       " 8808697621832673046,\n",
-       " 1013319847337885109,\n",
-       " 1252281976438780211,\n",
-       " 15526909770962854196,\n",
-       " 2065337703776048239,\n",
-       " 11654092230944134701,\n",
-       " 5554896851708700201,\n",
-       " 17485190250805381572,\n",
-       " 7700396730246958474,\n",
-       " 402840882133605445,\n",
-       " 5303116940477413125,\n",
-       " 7459257850255946545,\n",
-       " 10349184495871650178,\n",
-       " 4361155591615075311,\n",
-       " 15194020468024244632,\n",
-       " 14428821588688846242,\n",
-       " 5754975712549869618,\n",
-       " 13740966788951413307,\n",
-       " 15209704957418077856,\n",
-       " 12562588328524673262,\n",
-       " 8415556016795311987,\n",
-       " 3993098291779210741,\n",
-       " 16874756914619597640,\n",
-       " 7932421182532982309,\n",
-       " 1080869529149674704,\n",
-       " 13878842261614060122,\n",
-       " 229976195287031921,\n",
-       " 8378461140013520338,\n",
-       " 6189522326946191255,\n",
-       " 16684625600934047114,\n",
-       " 12533448641134015292,\n",
-       " 10459192142175991903,\n",
-       " 15688511015570391481,\n",
-       " 3091340728247101611,\n",
-       " 4034760776171697910,\n",
-       " 6258572097778886531,\n",
-       " 13555449085571665140,\n",
-       " 6727488149749641424,\n",
-       " 7125107819562430884,\n",
-       " 1557872425804423698,\n",
-       " 4810250441100696888,\n",
-       " 10500486959813930693,\n",
-       " 841300069403644975,\n",
-       " 9278626999406014662,\n",
-       " 17219731431761688449,\n",
-       " 15650446646901259126,\n",
-       " 8683172055034528265,\n",
-       " 5138373693056086816,\n",
-       " 4055877702343936882,\n",
-       " 5696765901584750542,\n",
-       " 7133363948804979946,\n",
-       " 988518370429658551,\n",
-       " 16302597472193523184,\n",
-       " 579078764159525857,\n",
-       " 10678347012503400890,\n",
-       " 8433836779160269996,\n",
-       " 13884258181758870664,\n",
-       " 13594877609651310055"
-      
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "import random\n",
-    "\n",
-    "N_EXAMPLES = 1000\n",
-    "\n",
-    "datasets = {}\n",
-    "\n",
-    "def gen_list(rnd):\n",
-    "    return \n",
-    "        random.getrandbits(64)\n",
-    "        for _ in range(random.randint(0, 100))\n",
-    "    \n",
-    "\n",
-    "def dataset_for(condition):\n",
-    "    if condition in datasets:\n",
-    "        return datasetscondition\n",
-    "    constraint = conditionscondition\n",
-    "    dataset = \n",
-    "    rnd = random.Random(condition)\n",
-    "    while len(dataset) < N_EXAMPLES:\n",
-    "        ls = gen_list(rnd)\n",
-    "        if constraint(ls):\n",
-    "            dataset.append(ls)\n",
-    "    datasetscondition = dataset\n",
-    "    return dataset\n",
-    "\n",
-    "dataset_for(\"sum >= 3\")1"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/plain": 
-       "13"
-      
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "# In order to avoid run-away cases where things will take basically forever\n",
-    "# we cap at 5000 as \"you've taken too long. Stop it\". Because we're only ever\n",
-    "# showing the worst case scenario we'll just display this as > 5000 if we ever\n",
-    "# hit it and it won't distort statistics.\n",
-    "MAX_COUNT = 5000\n",
-    "\n",
-    "class MaximumCountExceeded(Exception):\n",
-    "    pass\n",
-    "\n",
-    "def call_counts(condition, simplifier):\n",
-    "    constraint = conditionscondition\n",
-    "    dataset = dataset_for(condition)\n",
-    "    counts = \n",
-    "\n",
-    "    for ex in dataset:\n",
-    "        counter = 0\n",
-    "    \n",
-    "        def run_and_count(ls):\n",
-    "            counter0 += 1\n",
-    "            if counter0 > MAX_COUNT:\n",
-    "                raise MaximumCountExceeded()\n",
-    "            return constraint(ls)\n",
-    "    \n",
-    "        try:\n",
-    "            simplifier(ex, run_and_count)\n",
-    "            counts.extend(counter)\n",
-    "        except MaximumCountExceeded:\n",
-    "            counts.append(MAX_COUNT + 1)\n",
-    "            break\n",
-    "    return counts\n",
-    "            \n",
-    "def worst_case(condition, simplifier):\n",
-    "    return max(call_counts(condition, simplifier))\n",
-    "\n",
-    "worst_case(\n",
-    "    \"length >= 2\",\n",
-    "    partial(greedy_shrink, shrink=shrink6))"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": ,
-   "source": 
-    "from IPython.display import HTML\n",
-    "\n",
-    "def compare_simplifiers(named_simplifiers):\n",
-    "    \"\"\"\n",
-    "    Given a list of (name, simplifier) pairs, output a table comparing\n",
-    "    the worst case performance of each on our current set of examples.\n",
-    "    \"\"\"\n",
-    "    html_fragments = \n",
-    "    html_fragments.append(\"<table>\\n<thead>\\n<tr>\")\n",
-    "    header = \"Condition\"\n",
-    "    header.extend(name for name, _ in named_simplifiers)\n",
-    "    for h in header:\n",
-    "        html_fragments.append(\"<th>%s</th>\" % (h,))\n",
-    "    html_fragments.append(\"</tr>\\n</thead>\\n<tbody>\")\n",
-    "    \n",
-    "    for name in conditions:\n",
-    "        bits = name.replace(\">\", \"&gt;\")        \n",
-    "        for _, simplifier in named_simplifiers:\n",
-    "            value = worst_case(name, simplifier)\n",
-    "            if value <= MAX_COUNT:\n",
-    "                bits.append(str(value))\n",
-    "            else:\n",
-    "                bits.append(\" &gt; %d\" % (MAX_COUNT,))\n",
-    "        html_fragments.append(\"<tr>  \")\n",
-    "        html_fragments.append(' '.join(\n",
-    "                \"<td>%s</td>\" % (b,) for b in bits))\n",
-    "        html_fragments.append(\"</tr>\")\n",
-    "    html_fragments.append(\"</tbody>\\n</table>\")\n",
-    "    return HTML('\\n'.join(html_fragments))"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>2</th>\n",
-       "<th>3</th>\n",
-       "<th>4</th>\n",
-       "<th>5</th>\n",
-       "<th>6</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>106</td> <td>105</td> <td>13</td> <td>13</td> <td>13</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>1102</td> <td>178</td> <td>80</td> <td>80</td> <td>80</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>108</td> <td>107</td> <td>9</td> <td>9</td> <td>9</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>535</td> <td>690</td> <td>809</td> <td>877</td> <td>144</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "   (f.__name__-1, partial(greedy_shrink, shrink=f))\n",
-    "   for f in shrink2, shrink3, shrink4, shrink5, shrink6\n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "So you can see from the above table, the iterations 2 through 5 were a little ambiguous ion that they helped a lot in the cases they were designed to help with but hurt in other cases. 6 however is clearly the best of the lot, being no worse than any of the others on any of the cases and often significantly better.\n",
-    "\n",
-    "Rather than continuing to refine our shrink further, we instead look to improvements to how we use shrinking. We'll start by noting a simple optimization: If you look at our traces above, we often checked the same example twice. We're only interested in deterministic conditions, so this isn't useful to do. So we'll start by simply pruning out all duplicates. This should have exactly the same set and order of successful shrinks but will avoid a bunch of redundant work."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def greedy_shrink_with_dedupe(ls, constraint, shrink):\n",
-    "    seen = set()\n",
-    "    while True:\n",
-    "        for s in shrink(ls):\n",
-    "            key = tuple(s)\n",
-    "            if key in seen:\n",
-    "                continue\n",
-    "            seen.add(key)\n",
-    "            if constraint(s):\n",
-    "                ls = s\n",
-    "                break\n",
-    "        else:\n",
-    "            return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>Normal</th>\n",
-       "<th>Deduped</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>13</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>80</td> <td>35</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>9</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>144</td> <td>107</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "   (\"Normal\", partial(greedy_shrink, shrink=shrink6)),\n",
-    "   (\"Deduped\", partial(greedy_shrink_with_dedupe,\n",
-    "                       shrink=shrink6)),\n",
-    "\n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "As expected, this is a significant improvement in some cases. It is logically impossible that it could ever make things worse, but it's nice that it makes it better.\n",
-    "\n",
-    "So far we've only looked at things where the interaction between elements was fairly light - the sum cases the values of other elements mattered a bit, but shrinking an integer could never enable other shrinks. Lets look at one where this is not the case: Where our condition is that we have at least 10 distinct elements."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 100, 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100\n",
-      "✗ 100, 101\n",
-      "✗ 100, 101, 102, 103\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107\n",
-      "✗ 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 108\n",
-      "✗ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100\n",
-      "✗ 100, 101, 101, 101, 101, 101, 101, 101, 101, 101\n",
-      "✗ 100, 101, 102, 102, 102, 102, 102, 102, 102, 102\n",
-      "✗ 100, 101, 102, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 100, 101, 102, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 100, 101, 102, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 108, 108\n",
-      "✓ 0, 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 101\n",
-      "✗ 0, 101, 102, 103\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 107\n",
-      "✗ 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 101, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 101, 102, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 101, 102, 103, 105, 106, 107, 108, 109\n",
-      "✗ 0, 101, 102, 103, 104, 106, 107, 108, 109\n",
-      "✗ 0, 101, 102, 103, 104, 105, 107, 108, 109\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 108, 109\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 107, 109\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 101, 101, 101, 101, 101, 101, 101, 101, 101\n",
-      "✗ 0, 101, 102, 102, 102, 102, 102, 102, 102, 102\n",
-      "✗ 0, 101, 102, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 0, 101, 102, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 0, 101, 102, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 0, 101, 102, 103, 104, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 102, 103\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 107\n",
-      "✗ 1, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 102, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 102, 103, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 102, 103, 104, 106, 107, 108, 109\n",
-      "✗ 0, 1, 102, 103, 104, 105, 107, 108, 109\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 108, 109\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 107, 109\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 102, 102, 102, 102, 102, 102, 102, 102\n",
-      "✗ 0, 1, 102, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 0, 1, 102, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 0, 1, 102, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 102, 103, 104, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 3, 103\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 107\n",
-      "✗ 1, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 103, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 103, 104, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 103, 104, 105, 107, 108, 109\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 108, 109\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 107, 109\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 3, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 3, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 0, 1, 3, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 0, 1, 3, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 3, 103, 104, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 103\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 107\n",
-      "✗ 1, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 103, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 103, 104, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 103, 104, 105, 107, 108, 109\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 108, 109\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 107, 109\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 0, 1, 2, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 0, 1, 2, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 103, 104, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 107\n",
-      "✗ 1, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 104, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 104, 105, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 108, 109\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 107, 109\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 104, 104, 104, 104, 104, 104\n",
-      "✗ 0, 1, 2, 3, 104, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 104, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 107\n",
-      "✗ 1, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 7, 105, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 108, 109\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 107, 109\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 7, 7, 7, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 7, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 7, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 107\n",
-      "✗ 1, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 105, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 107, 109\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 5, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 5, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 5, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 107\n",
-      "✗ 1, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 105, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 107, 109\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 105, 105, 105, 105, 105\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 4, 105, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 107\n",
-      "✗ 1, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 107, 109\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 7, 7, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 4, 7, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 107\n",
-      "✗ 1, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 107, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 106, 106, 106\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 4, 5, 106, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 107\n",
-      "✗ 1, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 107, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 107\n",
-      "✗ 1, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 107, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 107, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 107, 107, 107\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 107, 108, 108\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 108\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 108, 108\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 15\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 15, 15\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 11\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 11, 11\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 9\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 9, 9\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 1\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 7\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 1\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 7\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 1\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 7\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0\n",
-      "✗ 0, 1\n",
-      "✗ 0, 1, 2, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7\n",
-      "✗ 1, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8\n",
-      "✗ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "✗ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1\n",
-      "✗ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2\n",
-      "✗ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3\n",
-      "✗ 0, 1, 2, 3, 4, 4, 4, 4, 4, 4\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 6, 6\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 1\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 7\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "\n",
-      "20 shrinks with 848 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(100 + i for i in range(10),\n",
-    "           lambda x: len(set(x)) >= 10,\n",
-    "           partial(greedy_shrink, shrink=shrink6))"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This does not do very well at all.\n",
-    "\n",
-    "The reason it doesn't is that we keep trying useless shrinks. e.g. none of the shrinks done by shrink\\_to\\_prefix, replace\\_with\\_simpler or shrink\\_shared will ever do anything useful here.\n",
-    "\n",
-    "So lets switch to an approach where we try shrink types until they stop working and then we move on to the next type:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def multicourse_shrink1(ls, constraint):\n",
-    "    seen = set()\n",
-    "    for shrink in \n",
-    "        shrink_to_prefix,\n",
-    "        replace_with_simpler,\n",
-    "        shrink_shared,\n",
-    "        shrink_individual_elements,\n",
-    "    :\n",
-    "        while True:\n",
-    "            for s in shrink(ls):\n",
-    "                key = tuple(s)\n",
-    "                if key in seen:\n",
-    "                    continue\n",
-    "                seen.add(key)\n",
-    "                if constraint(s):\n",
-    "                    ls = s\n",
-    "                    break\n",
-    "            else:\n",
-    "                break\n",
-    "    return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 100, 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100\n",
-      "✗ 100, 101\n",
-      "✗ 100, 101, 102, 103\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107\n",
-      "✗ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100\n",
-      "✗ 100, 101, 101, 101, 101, 101, 101, 101, 101, 101\n",
-      "✗ 100, 101, 102, 102, 102, 102, 102, 102, 102, 102\n",
-      "✗ 100, 101, 102, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 100, 101, 102, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 100, 101, 102, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 108, 108\n",
-      "✓ 0, 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 7, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 7, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 5, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 5, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 7, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 7, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 15, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 15, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 11, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 11, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 9, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 9, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 1\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 7\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 15\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 15\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 11\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 11\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 0, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 0, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 1, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 0, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 1, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 2, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 0, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 1, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 3, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 0, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 1, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 3, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 4, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "\n",
-      "20 shrinks with 318 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(100 + i for i in range(10),\n",
-    "           lambda x: len(set(x)) >= 10,\n",
-    "           multicourse_shrink1)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": ,
-   "source": 
-    "conditions\"10 distinct elements\" = lambda xs: len(set(xs)) >= 10"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>Single pass</th>\n",
-       "<th>Multi pass</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>6</td> <td>4</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>35</td> <td>34</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>6</td> <td>5</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>107</td> <td>58</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>10 distinct elements</td> <td>623</td> <td>320</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "    (\"Single pass\", partial(greedy_shrink_with_dedupe,\n",
-    "                            shrink=shrink6)),\n",
-    "    (\"Multi pass\", multicourse_shrink1)\n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "So that helped, but not as much as we'd have liked. It's saved us about half the calls, when really we wanted to save 90% of the calls.\n",
-    "\n",
-    "We're on the right track though. The problem is not that our solution isn't good, it's that it didn't go far enough: We're *still* making an awful lot of useless calls. The problem is that each time we shrink the element at index i we try shrinking the elements at indexes 0 through i - 1, and this will never work. So what we want to do is to break shrinking elements into a separate shrinker for each index:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def simplify_index(i):\n",
-    "    def accept(ls):\n",
-    "        if i >= len(ls):\n",
-    "            return\n",
-    "        for v in shrink_integer(lsi):\n",
-    "            s = list(ls)\n",
-    "            si = v\n",
-    "            yield s\n",
-    "    return accept\n",
-    "\n",
-    "def shrinkers_for(ls):\n",
-    "    yield shrink_to_prefix\n",
-    "    yield delete_individual_elements\n",
-    "    yield replace_with_simpler\n",
-    "    yield shrink_shared\n",
-    "    for i in range(len(ls)):\n",
-    "        yield simplify_index(i)\n",
-    "\n",
-    "def multicourse_shrink2(ls, constraint):\n",
-    "    seen = set()\n",
-    "    for shrink in shrinkers_for(ls):\n",
-    "        while True:\n",
-    "            for s in shrink(ls):\n",
-    "                key = tuple(s)\n",
-    "                if key in seen:\n",
-    "                    continue\n",
-    "                seen.add(key)\n",
-    "                if constraint(s):\n",
-    "                    ls = s\n",
-    "                    break\n",
-    "            else:\n",
-    "                break\n",
-    "    return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 100, 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100\n",
-      "✗ 100, 101\n",
-      "✗ 100, 101, 102, 103\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107\n",
-      "✗ 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 104, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 105, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 106, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 107, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 108, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 109\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 108\n",
-      "✗ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100\n",
-      "✗ 100, 101, 101, 101, 101, 101, 101, 101, 101, 101\n",
-      "✗ 100, 101, 102, 102, 102, 102, 102, 102, 102, 102\n",
-      "✗ 100, 101, 102, 103, 103, 103, 103, 103, 103, 103\n",
-      "✗ 100, 101, 102, 103, 104, 104, 104, 104, 104, 104\n",
-      "✗ 100, 101, 102, 103, 104, 105, 105, 105, 105, 105\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 106, 106, 106\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 107, 107\n",
-      "✗ 100, 101, 102, 103, 104, 105, 106, 107, 108, 108\n",
-      "✓ 0, 101, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 0, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 102, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 0, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 1, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 3, 103, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 103, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 0, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 1, 104, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 2, 104, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 0, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 1, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 3, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 7, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 5, 105, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 105, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 0, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 1, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 3, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 7, 106, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 4, 106, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 0, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 1, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 3, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 7, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 5, 107, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 107, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 0, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 1, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 3, 108, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 5, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 6, 108, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 0, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 1, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 3, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 7, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 15, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 11, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 9, 109\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 6, 109\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 1\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 3\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 7\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 15\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 11\n",
-      "✓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9\n",
-      "✗ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8\n",
-      "\n",
-      "20 shrinks with 75 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(100 + i for i in range(10),\n",
-    "           lambda x: len(set(x)) >= 10,\n",
-    "           multicourse_shrink2)"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This worked great! It saved us a huge number of function calls.\n",
-    "\n",
-    "Unfortunately it's wrong. Actually the previous one was wrong too, but this one is more obviously wrong. The problem is that shrinking later elements can unlock more shrinks for earlier elements and we'll never be able to benefit from that here:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 101, 100\n",
-      "✗ 101\n",
-      "✗ 100\n",
-      "✗ 100, 100\n",
-      "✗ 0, 100\n",
-      "✗ 1, 100\n",
-      "✗ 3, 100\n",
-      "✗ 7, 100\n",
-      "✗ 15, 100\n",
-      "✗ 31, 100\n",
-      "✗ 63, 100\n",
-      "✗ 82, 100\n",
-      "✗ 91, 100\n",
-      "✗ 96, 100\n",
-      "✗ 98, 100\n",
-      "✗ 99, 100\n",
-      "✓ 101, 0\n",
-      "\n",
-      "1 shrinks with 16 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(101, 100,\n",
-    "           lambda x: len(x) >= 2 and x0 > x1,\n",
-    "           multicourse_shrink2)"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "Armed with this example we can also show an example where the previous one is wrong because a later simplification unlocks an earlier one because shrinking values allows us to delete more elements:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5, 5, 5\n",
-      "✓ 0, 0, 0, 0, 0, 0, 0, 0\n",
-      "\n",
-      "2 shrinks with 5 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(5 * 10,\n",
-    "           lambda x: x and len(x) > max(x),\n",
-    "           multicourse_shrink1)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "conditions\"First > Second\" = lambda xs: len(xs) >= 2 and xs0 > xs1"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "# Note: We modify this to mask off the high bits because otherwise the probability of\n",
-    "# hitting the condition at random is too low.\n",
-    "conditions\"Size > max & 63\" = lambda xs: xs and len(xs) > (max(xs) & 63)"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "So what we'll try doing is iterating this to a fixed point and see what happens:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def multicourse_shrink3(ls, constraint):\n",
-    "    seen = set()\n",
-    "    while True:\n",
-    "        old_ls = ls\n",
-    "        for shrink in shrinkers_for(ls):\n",
-    "            while True:\n",
-    "                for s in shrink(ls):\n",
-    "                    key = tuple(s)\n",
-    "                    if key in seen:\n",
-    "                        continue\n",
-    "                    seen.add(key)\n",
-    "                    if constraint(s):\n",
-    "                        ls = s\n",
-    "                        break\n",
-    "                else:\n",
-    "                    break\n",
-    "        if ls == old_ls:\n",
-    "            return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 101, 100\n",
-      "✗ 101\n",
-      "✗ 100\n",
-      "✗ 100, 100\n",
-      "✗ 0, 100\n",
-      "✗ 1, 100\n",
-      "✗ 3, 100\n",
-      "✗ 7, 100\n",
-      "✗ 15, 100\n",
-      "✗ 31, 100\n",
-      "✗ 63, 100\n",
-      "✗ 82, 100\n",
-      "✗ 91, 100\n",
-      "✗ 96, 100\n",
-      "✗ 98, 100\n",
-      "✗ 99, 100\n",
-      "✓ 101, 0\n",
-      "✗ 0\n",
-      "✗ 0, 0\n",
-      "✓ 1, 0\n",
-      "✗ 1\n",
-      "\n",
-      "2 shrinks with 20 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(101, 100,\n",
-    "           lambda xs: len(xs) >= 2 and xs0 > xs1,\n",
-    "           multicourse_shrink3)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5, 5\n",
-      "✓ 0, 0, 0, 0, 0, 0\n",
-      "✓ 0\n",
-      "✗ \n",
-      "\n",
-      "5 shrinks with 10 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(5 * 10,\n",
-    "           lambda x: x and len(x) > max(x),\n",
-    "           multicourse_shrink3)"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "So that worked. Yay!\n",
-    "\n",
-    "Lets compare how this does to our single pass implementation."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>Single pass</th>\n",
-       "<th>Multi pass</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>35</td> <td>35</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>107</td> <td>73</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>10 distinct elements</td> <td>623</td> <td>131</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>First &gt; Second</td> <td>1481</td> <td>1445</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Size &gt; max & 63</td> <td>600</td> <td> &gt; 5000</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 42,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "    (\"Single pass\", partial(greedy_shrink_with_dedupe,\n",
-    "                            shrink=shrink6)),\n",
-    "    (\"Multi pass\", multicourse_shrink3)\n",
-    "    \n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "So the answer is generally favourably but *ouch* that last one.\n",
-    "\n",
-    "What's happening there is that because later shrinks are opening up potentially very large improvements accessible to the lower shrinks, the original greedy algorithm can exploit that much better, while the multi pass algorithm spends a lot of time in the later stages with their incremental shrinks.\n",
-    "\n",
-    "Lets see another similar example before we try to fix this:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "import hashlib\n",
-    "\n",
-    "conditions\"Messy\" = lambda xs: hashlib.md5(repr(xs).encode('utf-8')).hexdigest()0 == '0'"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>Single pass</th>\n",
-       "<th>Multi pass</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>35</td> <td>35</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>107</td> <td>73</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>10 distinct elements</td> <td>623</td> <td>131</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>First &gt; Second</td> <td>1481</td> <td>1445</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Size &gt; max & 63</td> <td>600</td> <td> &gt; 5000</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Messy</td> <td>1032</td> <td> &gt; 5000</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 44,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "    (\"Single pass\", partial(greedy_shrink_with_dedupe,\n",
-    "                            shrink=shrink6)),\n",
-    "    (\"Multi pass\", multicourse_shrink3)\n",
-    "    \n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This one is a bit different in that the problem is not that the structure is one we're ill suited to exploiting, it's that there is no structure at all so we have no hope of exploiting it. Literally any change at all will unlock earlier shrinks we could have done.\n",
-    "\n",
-    "What we're going to try to do is hybridize the two approaches. If we notice we're performing an awful lot of shrinks we can take that as a hint that we should be trying again from earlier stages.\n",
-    "\n",
-    "Here is our first approach. We simply restart the whole process every five shrinks:"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "MAX_SHRINKS_PER_RUN = 2\n",
-    "\n",
-    "\n",
-    "def multicourse_shrink4(ls, constraint):\n",
-    "    seen = set()\n",
-    "    while True:\n",
-    "        old_ls = ls\n",
-    "        shrinks_this_run = 0\n",
-    "        for shrink in shrinkers_for(ls):\n",
-    "            while shrinks_this_run < MAX_SHRINKS_PER_RUN:\n",
-    "                for s in shrink(ls):\n",
-    "                    key = tuple(s)\n",
-    "                    if key in seen:\n",
-    "                        continue\n",
-    "                    seen.add(key)\n",
-    "                    if constraint(s):\n",
-    "                        shrinks_this_run += 1\n",
-    "                        ls = s\n",
-    "                        break\n",
-    "                else:\n",
-    "                    break\n",
-    "        if ls == old_ls:\n",
-    "            return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>Single pass</th>\n",
-       "<th>Multi pass</th>\n",
-       "<th>Multi pass with restart</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>6</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>35</td> <td>35</td> <td>35</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>6</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>107</td> <td>73</td> <td>90</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>10 distinct elements</td> <td>623</td> <td>131</td> <td>396</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>First &gt; Second</td> <td>1481</td> <td>1445</td> <td>1463</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Size &gt; max & 63</td> <td>600</td> <td> &gt; 5000</td> <td> &gt; 5000</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Messy</td> <td>1032</td> <td> &gt; 5000</td> <td>1423</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 46,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "    (\"Single pass\", partial(greedy_shrink_with_dedupe,\n",
-    "                            shrink=shrink6)),\n",
-    "    (\"Multi pass\", multicourse_shrink3),\n",
-    "    (\"Multi pass with restart\", multicourse_shrink4)    \n",
-    "    \n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "That works OK, but it's pretty unsatisfying as it loses us most of the benefits of the multi pass shrinking - we're now at most twice as good as the greedy one.\n",
-    "\n",
-    "So what we're going to do is bet on the multi pass working and then gradually degrade to the greedy algorithm as it fails to work."
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": ,
-   "source": 
-    "def multicourse_shrink5(ls, constraint):\n",
-    "    seen = set()\n",
-    "    max_shrinks_per_run = 10\n",
-    "    while True:\n",
-    "        shrinks_this_run = 0\n",
-    "        for shrink in shrinkers_for(ls):\n",
-    "            while shrinks_this_run < max_shrinks_per_run:\n",
-    "                for s in shrink(ls):\n",
-    "                    key = tuple(s)\n",
-    "                    if key in seen:\n",
-    "                        continue\n",
-    "                    seen.add(key)\n",
-    "                    if constraint(s):\n",
-    "                        shrinks_this_run += 1\n",
-    "                        ls = s\n",
-    "                        break\n",
-    "                else:\n",
-    "                    break\n",
-    "        if max_shrinks_per_run > 1:\n",
-    "            max_shrinks_per_run -= 2\n",
-    "        if not shrinks_this_run:\n",
-    "            return ls"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": 
-      "✓ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5\n",
-      "✗ 5\n",
-      "✗ 5, 5\n",
-      "✗ 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5, 5\n",
-      "✓ 5, 5, 5, 5, 5, 5\n",
-      "✗ 5, 5, 5, 5, 5\n",
-      "✓ 0, 0, 0, 0, 0, 0\n",
-      "✓ 0\n",
-      "✗ \n",
-      "\n",
-      "5 shrinks with 10 function calls\n"
-     
-    }
-   ,
-   "source": 
-    "show_trace(5 * 10,\n",
-    "           lambda x: x and len(x) > max(x),\n",
-    "           multicourse_shrink5)"
-   
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": 
-    {
-     "data": {
-      "text/html": 
-       "<table>\n",
-       "<thead>\n",
-       "<tr>\n",
-       "<th>Condition</th>\n",
-       "<th>Single pass</th>\n",
-       "<th>Multi pass</th>\n",
-       "<th>Multi pass with restart</th>\n",
-       "<th>Multi pass with variable restart</th>\n",
-       "</tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr>  \n",
-       "<td>length &gt;= 2</td> <td>6</td> <td>6</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 500</td> <td>35</td> <td>35</td> <td>35</td> <td>35</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>sum &gt;= 3</td> <td>6</td> <td>6</td> <td>6</td> <td>6</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>At least 10 by 5</td> <td>107</td> <td>73</td> <td>90</td> <td>73</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>10 distinct elements</td> <td>623</td> <td>131</td> <td>396</td> <td>212</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>First &gt; Second</td> <td>1481</td> <td>1445</td> <td>1463</td> <td>1168</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Size &gt; max & 63</td> <td>600</td> <td> &gt; 5000</td> <td> &gt; 5000</td> <td>1002</td>\n",
-       "</tr>\n",
-       "<tr>  \n",
-       "<td>Messy</td> <td>1032</td> <td> &gt; 5000</td> <td>1423</td> <td>824</td>\n",
-       "</tr>\n",
-       "</tbody>\n",
-       "</table>"
-      ,
-      "text/plain": 
-       "<IPython.core.display.HTML object>"
-      
-     },
-     "execution_count": 49,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ,
-   "source": 
-    "compare_simplifiers(\n",
-    "    (\"Single pass\", partial(greedy_shrink_with_dedupe,\n",
-    "                            shrink=shrink6)),\n",
-    "    (\"Multi pass\", multicourse_shrink3),        \n",
-    "    (\"Multi pass with restart\", multicourse_shrink4),\n",
-    "    (\"Multi pass with variable restart\", multicourse_shrink5)   \n",
-    ")"
-   
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": 
-    "This is now more or less the current state of the art (it's actually a bit different from the Hypothesis state of the art at the time of this writing. I'm planning to merge some of the things I figured out in the course of writing this back in). We've got something that is able to adaptively take advantage of structure where it is present, but degrades reasonably gracefully back to the more aggressive version that works better in unstructured examples.\n",
-    "\n",
-    "Surprisingly, on some examples it seems to even be best of all of them. I think that's more coincidence than truth though."
-   
-  }
- ,
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.4.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/paper.bib Deleted

@@ -1,200 +0,0 @@
-@inproceedings{DBLP:conf/icfp/ClaessenH00,
-  author    = {Koen Claessen and
-               John Hughes},
-  title     = {QuickCheck: a lightweight tool for random testing of {H}askell programs},
-  booktitle = {{Proceedings of the Fifth ACM SIGPLAN International Conference
-               on Functional Programming (ICFP '00)}},
-  pages     = {268--279},
-  year      = {2000},
-  crossref  = {DBLP:conf/icfp/2000},
-  url       = {https://doi.org/10.1145/351240.351266},
-  doi       = {10.1145/351240.351266},
-  timestamp = {Tue, 06 Nov 2018 16:59:25 +0100},
-  biburl    = {https://dblp.org/rec/bib/conf/icfp/ClaessenH00},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@proceedings{DBLP:conf/icfp/2000,
-  editor    = {Martin Odersky and
-               Philip Wadler},
-  title     = {{Proceedings of the Fifth ACM SIGPLAN International Conference
-               on Functional Programming (ICFP '00)}},
-  publisher = {{ACM}},
-  year      = {2000},
-  isbn      = {1-58113-202-6},
-  timestamp = {Tue, 11 Jun 2013 13:51:25 +0200},
-  biburl    = {https://dblp.org/rec/bib/conf/icfp/2000},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@inproceedings{DBLP:conf/erlang/ArtsHJW06,
-  author    = {Thomas Arts and
-               John Hughes and
-               Joakim Johansson and
-               Ulf T. Wiger},
-  title     = {Testing telecoms software with quviq {QuickCheck}},
-  booktitle = {{Proceedings of the 2006 ACM SIGPLAN Workshop on Erlang}},
-  pages     = {2--10},
-  year      = {2006},
-  crossref  = {DBLP:conf/erlang/2006},
-  url       = {https://doi.org/10.1145/1159789.1159792},
-  doi       = {10.1145/1159789.1159792},
-  timestamp = {Tue, 06 Nov 2018 16:59:37 +0100},
-  biburl    = {https://dblp.org/rec/bib/conf/erlang/ArtsHJW06},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@proceedings{DBLP:conf/erlang/2006,
-  editor    = {Marc Feeley and
-               Philip W. Trinder},
-  title     = {{Proceedings of the 2006 ACM SIGPLAN Workshop on Erlang}},
-  publisher = {{ACM}},
-  year      = {2006},
-  isbn      = {1-59593-490-1},
-  timestamp = {Wed, 02 Apr 2008 10:59:25 +0200},
-  biburl    = {https://dblp.org/rec/bib/conf/erlang/2006},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@misc{PraiseOfPBT,
-  title = {In Praise of Property-Based Testing},
-  howpublished = {\url{https://increment.com/testing/in-praise-of-property-based-testing/}},
-  year={2019},
-  author={David R. MacIver},
-}
-
-@article{DBLP:journals/tse/ZellerH02,
-  author    = {Andreas Zeller and
-               Ralf Hildebrandt},
-  title     = {Simplifying and Isolating Failure-Inducing Input},
-  journal   = {{IEEE} Trans. Software Eng.},
-  volume    = {28},
-  number    = {2},
-  pages     = {183--200},
-  year      = {2002},
-  url       = {https://doi.org/10.1109/32.988498},
-  doi       = {10.1109/32.988498},
-  timestamp = {Wed, 14 Nov 2018 10:49:20 +0100},
-  biburl    = {https://dblp.org/rec/bib/journals/tse/ZellerH02},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@inproceedings{DBLP:conf/pldi/RegehrCCEEY12,
-  author    = {John Regehr and
-               Yang Chen and
-               Pascal Cuoq and
-               Eric Eide and
-               Chucky Ellison and
-               Xuejun Yang},
-  title     = {Test-case reduction for {C} compiler bugs},
-  booktitle = {{ACM SIGPLAN Conference on Programming Language Design and Implementation,
-               (PLDI '12)}},
-  pages     = {335--346},
-  year      = {2012},
-  crossref  = {DBLP:conf/pldi/2012},
-  url       = {https://doi.org/10.1145/2254064.2254104},
-  doi       = {10.1145/2254064.2254104},
-  timestamp = {Wed, 14 Nov 2018 10:54:59 +0100},
-  biburl    = {https://dblp.org/rec/bib/conf/pldi/RegehrCCEEY12},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@proceedings{DBLP:conf/pldi/2012,
-  editor    = {Jan Vitek and
-               Haibo Lin and
-               Frank Tip},
-  title     = {{ACM SIGPLAN Conference on Programming Language Design and Implementation,
-               (PLDI '12)}},
-  publisher = {{ACM}},
-  year      = {2012},
-  url       = {http://dl.acm.org/citation.cfm?id=2254064},
-  isbn      = {978-1-4503-1205-9},
-  timestamp = {Tue, 12 Jun 2012 19:17:55 +0200},
-  biburl    = {https://dblp.org/rec/bib/conf/pldi/2012},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-
-@article{astropy:2013,
-Adsnote = {Provided by the SAO/NASA Astrophysics Data System},
-Adsurl = {http://adsabs.harvard.edu/abs/2013A%26A...558A..33A},
-Archiveprefix = {arXiv},
-Author = {{Astropy Collaboration} and {Robitaille}, T.~P. and {Tollerud}, E.~J. and {Greenfield}, P. and {Droettboom}, M. and {Bray}, E. and {Aldcroft}, T. and {Davis}, M. and {Ginsburg}, A. and {Price-Whelan}, A.~M. and {Kerzendorf}, W.~E. and {Conley}, A. and {Crighton}, N. and {Barbary}, K. and {Muna}, D. and {Ferguson}, H. and {Grollier}, F. and {Parikh}, M.~M. and {Nair}, P.~H. and {Unther}, H.~M. and {Deil}, C. and {Woillez}, J. and {Conseil}, S. and {Kramer}, R. and {Turner}, J.~E.~H. and {Singer}, L. and {Fox}, R. and {Weaver}, B.~A. and {Zabalza}, V. and {Edwards}, Z.~I. and {Azalee Bostroem}, K. and {Burke}, D.~J. and {Casey}, A.~R. and {Crawford}, S.~M. and {Dencheva}, N. and {Ely}, J. and {Jenness}, T. and {Labrie}, K. and {Lim}, P.~L. and {Pierfederici}, F. and {Pontzen}, A. and {Ptak}, A. and {Refsdal}, B. and {Servillat}, M. and {Streicher}, O.},
-Doi = {10.1051/0004-6361/201322068},
-Eid = {A33},
-Eprint = {1307.6212},
-Journal = {\aap},
-Keywords = {methods: data analysis, methods: miscellaneous, virtual observatory tools},
-Month = oct,
-Pages = {A33},
-Primaryclass = {astro-ph.IM},
-Title = {{Astropy: A community Python package for astronomy}},
-Volume = 558,
-Year = 2013,
-Bdsk-Url-1 = {https://dx.doi.org/10.1051/0004-6361/201322068}}
-
-@article{astropy:2018,
-Adsnote = {Provided by the SAO/NASA Astrophysics Data System},
-Adsurl = {https://ui.adsabs.harvard.edu/#abs/2018AJ....156..123T},
-Author = {{Price-Whelan}, A.~M. and {Sip{\H{o}}cz}, B.~M. and {G{\"u}nther}, H.~M. and {Lim}, P.~L. and {Crawford}, S.~M. and {Conseil}, S. and {Shupe}, D.~L. and {Craig}, M.~W. and {Dencheva}, N. and {Ginsburg}, A. and {VanderPlas}, J.~T. and {Bradley}, L.~D. and {P{\'e}rez-Su{\'a}rez}, D. and {de Val-Borro}, M. and {Paper Contributors}, (Primary and {Aldcroft}, T.~L. and {Cruz}, K.~L. and {Robitaille}, T.~P. and {Tollerud}, E.~J. and {Coordination Committee}, (Astropy and {Ardelean}, C. and {Babej}, T. and {Bach}, Y.~P. and {Bachetti}, M. and {Bakanov}, A.~V. and {Bamford}, S.~P. and {Barentsen}, G. and {Barmby}, P. and {Baumbach}, A. and {Berry}, K.~L. and {Biscani}, F. and {Boquien}, M. and {Bostroem}, K.~A. and {Bouma}, L.~G. and {Brammer}, G.~B. and {Bray}, E.~M. and {Breytenbach}, H. and {Buddelmeijer}, H. and {Burke}, D.~J. and {Calderone}, G. and {Cano Rodr{\'\i}guez}, J.~L. and {Cara}, M. and {Cardoso}, J.~V.~M. and {Cheedella}, S. and {Copin}, Y. and {Corrales}, L. and {Crichton}, D. and {D{\textquoteright}Avella}, D. and {Deil}, C. and {Depagne}, {\'E}. and {Dietrich}, J.~P. and {Donath}, A. and {Droettboom}, M. and {Earl}, N. and {Erben}, T. and {Fabbro}, S. and {Ferreira}, L.~A. and {Finethy}, T. and {Fox}, R.~T. and {Garrison}, L.~H. and {Gibbons}, S.~L.~J. and {Goldstein}, D.~A. and {Gommers}, R. and {Greco}, J.~P. and {Greenfield}, P. and {Groener}, A.~M. and {Grollier}, F. and {Hagen}, A. and {Hirst}, P. and {Homeier}, D. and {Horton}, A.~J. and {Hosseinzadeh}, G. and {Hu}, L. and {Hunkeler}, J.~S. and {Ivezi{\'c}}, {\v{Z}}. and {Jain}, A. and {Jenness}, T. and {Kanarek}, G. and {Kendrew}, S. and {Kern}, N.~S. and {Kerzendorf}, W.~E. and {Khvalko}, A. and {King}, J. and {Kirkby}, D. and {Kulkarni}, A.~M. and {Kumar}, A. and {Lee}, A. and {Lenz}, D. and {Littlefair}, S.~P. and {Ma}, Z. and {Macleod}, D.~M. and {Mastropietro}, M. and {McCully}, C. and {Montagnac}, S. and {Morris}, B.~M. and {Mueller}, M. and {Mumford}, S.~J. and {Muna}, D. and {Murphy}, N.~A. and {Nelson}, S. and {Nguyen}, G.~H. and {Ninan}, J.~P. and {N{\"o}the}, M. and {Ogaz}, S. and {Oh}, S. and {Parejko}, J.~K. and {Parley}, N. and {Pascual}, S. and {Patil}, R. and {Patil}, A.~A. and {Plunkett}, A.~L. and {Prochaska}, J.~X. and {Rastogi}, T. and {Reddy Janga}, V. and {Sabater}, J. and {Sakurikar}, P. and {Seifert}, M. and {Sherbert}, L.~E. and {Sherwood-Taylor}, H. and {Shih}, A.~Y. and {Sick}, J. and {Silbiger}, M.~T. and {Singanamalla}, S. and {Singer}, L.~P. and {Sladen}, P.~H. and {Sooley}, K.~A. and {Sornarajah}, S. and {Streicher}, O. and {Teuben}, P. and {Thomas}, S.~W. and {Tremblay}, G.~R. and {Turner}, J.~E.~H. and {Terr{\'o}n}, V. and {van Kerkwijk}, M.~H. and {de la Vega}, A. and {Watkins}, L.~L. and {Weaver}, B.~A. and {Whitmore}, J.~B. and {Woillez}, J. and {Zabalza}, V. and {Contributors}, (Astropy},
-Doi = {10.3847/1538-3881/aabc4f},
-Eid = {123},
-Journal = {\aj},
-Keywords = {methods: data analysis, methods: miscellaneous, methods: statistical, reference systems, Astrophysics - Instrumentation and Methods for Astrophysics},
-Month = Sep,
-Pages = {123},
-Primaryclass = {astro-ph.IM},
-Title = {{The Astropy Project: Building an Open-science Project and Status of the v2.0 Core Package}},
-Volume = {156},
-Year = 2018,
-Bdsk-Url-1 = {https://doi.org/10.3847/1538-3881/aabc4f}}
-
-@article{DBLP:journals/cse/WaltCV11,
-  author    = {St{\'{e}}fan van der Walt and
-               S. Chris Colbert and
-               Ga{\"{e}}l Varoquaux},
-  title     = {The {NumPy} Array: {A} Structure for Efficient Numerical Computation},
-  journal   = {Computing in Science and Engineering},
-  volume    = {13},
-  number    = {2},
-  pages     = {22--30},
-  year      = {2011},
-  url       = {https://doi.org/10.1109/MCSE.2011.37},
-  doi       = {10.1109/MCSE.2011.37},
-  timestamp = {Wed, 14 Nov 2018 10:48:31 +0100},
-  biburl    = {https://dblp.org/rec/bib/journals/cse/WaltCV11},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@inproceedings{DBLP:conf/issta/LoscherS17,
-  author    = {Andreas L{\"{o}}scher and
-               Konstantinos Sagonas},
-  title     = {Targeted property-based testing},
-  booktitle = {{Proceedings of the 26th ACM SIGSOFT International Symposium on
-               Software Testing and Analysis}},
-  pages     = {46--56},
-  year      = {2017},
-  crossref  = {DBLP:conf/issta/2017},
-  url       = {https://doi.org/10.1145/3092703.3092711},
-  doi       = {10.1145/3092703.3092711},
-  timestamp = {Wed, 25 Sep 2019 18:08:21 +0200},
-  biburl    = {https://dblp.org/rec/bib/conf/issta/LoscherS17},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@proceedings{DBLP:conf/issta/2017,
-  editor    = {Tevfik Bultan and
-               Koushik Sen},
-  title     = {{Proceedings of the 26th ACM SIGSOFT International Symposium on
-               Software Testing and Analysis}},
-  publisher = {{ACM}},
-  year      = {2017},
-  url       = {https://doi.org/10.1145/3092703},
-  doi       = {10.1145/3092703},
-  isbn      = {978-1-4503-5076-1},
-  timestamp = {Tue, 06 Nov 2018 16:57:30 +0100},
-  biburl    = {https://dblp.org/rec/bib/conf/issta/2017},
-  bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/paper.md Deleted

@@ -1,105 +0,0 @@
----
-title: 'Hypothesis: A new approach to property-based testing'
-date: 1 November 2019
-bibliography: paper.bib
-tags:
-    - Python
-    - testing
-    - test-case reduction
-    - test-case generation
-    - property-based testing
-authors:
-    - name: David R. MacIver
-      orcid: 0000-0002-8635-3223
-      affiliation: 1
-    - name: Zac Hatfield-Dodds
-      orcid: 0000-0002-8646-8362
-      affiliation: 2
-    - name: many other contributors
-      affiliation: 3
-affiliations:
-    - name: Imperial College London
-      index: 1
-    - name: Australian National University
-      index: 2
-    - name: Various
-      index: 3
----
-
-# Summary
-
-*Property-based testing* is a style of testing popularised by the QuickCheck family of libraries,
-first in Haskell @DBLP:conf/icfp/ClaessenH00 and later in Erlang @DBLP:conf/erlang/ArtsHJW06,
-which integrates generated test cases into existing software testing workflows:
-Instead of tests that provide examples of a single concrete behaviour,
-tests specify properties that hold for a wide range of inputs,
-which the testing library then attempts to generate test cases to refute.
-For a general introduction to property-based testing, see @PraiseOfPBT.
-
-Hypothesis is a mature and widely used property-based testing library for Python.
-It has over 100,000 downloads per week^https://pypistats.org/packages/hypothesis, thousands of open source projects use it^https://github.com/HypothesisWorks/hypothesis/network/dependents,
-and in 2018 more than 4% of Python users surveyed by the PSF reported using it^https://www.jetbrains.com/research/python-developers-survey-2018/.
-It will be of interest both to researchers using Python for developing scientific software,
-and to software testing researchers as a platform for research in its own right.
-
-# Hypothesis for Testing Scientific Software
-
-Python has a rich and thriving ecosystem of scientific software, and Hypothesis is helpful for ensuring its correctness.
-Any researcher who tests their software in Python can benefit from these facilities,
-but it is particularly useful for improving the correctness foundational libraries on which the scientific software ecosystem is built.
-For example, it has found bugs in astropy @astropy:2018^e.g. https://github.com/astropy/astropy/pull/9328, https://github.com/astropy/astropy/pull/9532 and numpy @DBLP:journals/cse/WaltCV11^e.g. https://github.com/numpy/numpy/issues/10930, https://github.com/numpy/numpy/issues/13089, https://github.com/numpy/numpy/issues/14239.
-
-Additionally, Hypothesis is easily extensible, and has a number of third-party extensions for specific research applications.
-For example, hypothesis-networkx^https://pypi.org/project/hypothesis-networkx/ generates graph data structures,
-and hypothesis-bio^https://pypi.org/project/hypothesis-bio/ generates formats suitable for bioinformatics.
-As it is used by more researchers, the number of research applications will only increase.
-
-By lowering the barrier to effective testing, Hypothesis makes testing of research software written in Python much more compelling,
-and has the potential to significantly improve the quality of the associated scientific research as a result.
-
-# Hypothesis for Software Testing Research
-
-Hypothesis is a powerful platform for software testing research,
-both because of the wide array of software that can be easily tested with it,
-and because it has a novel implementation that solves a major difficulty faced by prior software testing research.
-
-Much of software testing research boils down to variants on the following problem:
-Given some interestingness condition (e.g., that it triggers a bug in some software),
-how do we generate a "good" test case that satisfies that condition?
-
-Particular sub-problems of this are:
-
-1. How do we generate test cases that satisfy difficult interestingness conditions?
-2. How do we ensure we generate only valid test cases? (the *test-case validity problem* - see @DBLP:conf/pldi/RegehrCCEEY12)
-3. How do we generate human readable test cases?
-
-Traditionally property-based testing has adopted random test-case generation to find interesting test cases,
-followed by test-case reduction (see @DBLP:conf/pldi/RegehrCCEEY12, @DBLP:journals/tse/ZellerH02) to turn them into more human readable ones,
-requiring the users to manually specify a *validity oracle* (a predicate that identifies if an arbitrary test case is valid) to avoid invalid test cases.
-
-The chief limitations of this from a user's point of view are:
-
-* Writing correct validity oracles is difficult and annoying.
-* Random generation, while often much better than hand-written examples, is not especially good at satisfying difficult properties.
-* Writing test-case reducers that work well for your problem domain is a specialised skill that few people have or want to acquire.
-
-The chief limitation from a researcher's point of view is that trying to improve on random generation's ability to find bugs will typically require modification of existing tests to support new ways of generating data,
-and typically these modifications are significantly more complex than writing the random generator would have been.
-Users are rarely going to be willing to undertake the work themselves,
-which leaves researchers in the unfortunate position of having to put in a significant amount of work per project to understand how to test it.
-
-Hypothesis avoids both of these problems by using a single universal representation for test cases.
-Ensuring that test cases produced from this format are valid is relatively easy, no more difficult than ensuring that randomly generated tests cases are valid,
-and improvements to the generation process can operate solely on this universal representation rather than requiring adapting to each test.
-
-Currently Hypothesis uses this format to support two major use cases:
-
-1. It is the basis of its approach to test-case reduction, allowing it to support more powerful test-case reduction than is found in most property-based testing libraries with no user intervention.
-2. It supports Targeted Property-Based Testing @DBLP:conf/issta/LoscherS17, which uses a score to guide testing towards a particular goal (e.g., maximising an error term). In the original implementation this would require custom mutation operators per test,
-   but in Hypothesis this mutation is transparent to the user and they need only specify the goal.
-
-The internal format is flexible and contains rich information about the structure of generated test cases,
-so it is likely future versions of the software will see other features built on top of it,
-and we hope researchers will use it as a vehicle to explore other interesting possibilities for test-case generation.
-
-# References

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/pytest.ini Deleted

@@ -1,20 +0,0 @@
-pytest
-
-# -rfEX :: Print a summary of failures, errors, and xpasses (xfails that pass).
-addopts=--strict-markers --tb=native -p pytester --runpytest=subprocess --durations=20 -rfEX
-xfail_strict = True
-filterwarnings =
-    error
-    ignore::hypothesis.errors.NonInteractiveExampleWarning
-    # https://github.com/pandas-dev/pandas/issues/41199
-    default:Creating a LegacyVersion has been deprecated and will be removed in the next major release:DeprecationWarning
-    default:distutils Version classes are deprecated\. Use packaging\.version instead:DeprecationWarning
-    # https://github.com/pandas-dev/pandas/issues/32056 (?)
-    default:numpy\.ufunc size changed, may indicate binary incompatibility\. Expected 216 from C header, got 232 from PyObject:RuntimeWarning
-    # https://github.com/lark-parser/lark/pull/1140
-    default:module 'sre_constants' is deprecated:DeprecationWarning
-    default:module 'sre_parse' is deprecated:DeprecationWarning
-    # https://github.com/pandas-dev/pandas/issues/34848
-    default:`np\.bool` is a deprecated alias for the builtin `bool`:DeprecationWarning
-    default:`np\.complex` is a deprecated alias for the builtin `complex`:DeprecationWarning
-    default:`np\.object` is a deprecated alias for the builtin `object`:DeprecationWarning

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements/coverage.in Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements/coverage.txt Deleted

@@ -1,109 +0,0 @@
-#
-# This file is autogenerated by pip-compile with python 3.8
-# To update, run:
-#
-#    pip-compile --output-file=requirements/coverage.txt hypothesis-python/setup.py requirements/coverage.in
-#
-async-timeout==4.0.2
-    # via redis
-attrs==21.4.0
-    # via
-    #   hypothesis (hypothesis-python/setup.py)
-    #   pytest
-backports-zoneinfo==0.2.1
-    # via -r requirements/coverage.in
-black==22.3.0
-    # via -r requirements/coverage.in
-click==8.1.3
-    # via
-    #   -r requirements/coverage.in
-    #   black
-coverage==6.4
-    # via -r requirements/coverage.in
-deprecated==1.2.13
-    # via redis
-dpcontracts==0.6.0
-    # via -r requirements/coverage.in
-execnet==1.9.0
-    # via pytest-xdist
-fakeredis==1.8
-    # via -r requirements/coverage.in
-iniconfig==1.1.1
-    # via pytest
-lark-parser==0.12.0
-    # via -r requirements/coverage.in
-libcst==0.4.3
-    # via -r requirements/coverage.in
-mypy-extensions==0.4.3
-    # via
-    #   black
-    #   typing-inspect
-numpy==1.22.4
-    # via
-    #   -r requirements/coverage.in
-    #   pandas
-packaging==21.3
-    # via
-    #   pytest
-    #   redis
-pandas==1.4.2
-    # via -r requirements/coverage.in
-pathspec==0.9.0
-    # via black
-pexpect==4.8.0
-    # via -r requirements/test.in
-platformdirs==2.5.2
-    # via black
-pluggy==1.0.0
-    # via pytest
-ptyprocess==0.7.0
-    # via pexpect
-py==1.11.0
-    # via
-    #   pytest
-    #   pytest-forked
-pyparsing==3.0.9
-    # via packaging
-pytest==7.1.2
-    # via
-    #   -r requirements/test.in
-    #   pytest-forked
-    #   pytest-xdist
-pytest-forked==1.4.0
-    # via pytest-xdist
-pytest-xdist==2.5.0
-    # via -r requirements/test.in
-python-dateutil==2.8.2
-    # via
-    #   -r requirements/coverage.in
-    #   pandas
-pytz==2022.1
-    # via
-    #   -r requirements/coverage.in
-    #   pandas
-pyyaml==6.0
-    # via libcst
-redis==4.3.1
-    # via fakeredis
-six==1.16.0
-    # via
-    #   fakeredis
-    #   python-dateutil
-sortedcontainers==2.4.0
-    # via
-    #   fakeredis
-    #   hypothesis (hypothesis-python/setup.py)
-tomli==2.0.1
-    # via
-    #   black
-    #   pytest
-typing-extensions==4.2.0
-    # via
-    #   -r requirements/coverage.in
-    #   black
-    #   libcst
-    #   typing-inspect
-typing-inspect==0.7.1
-    # via libcst
-wrapt==1.14.1
-    # via deprecated

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements/test.in Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements/test.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements/tools.in Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/requirements/tools.txt Deleted

@@ -1,376 +0,0 @@
-#
-# This file is autogenerated by pip-compile with python 3.8
-# To update, run:
-#
-#    pip-compile --output-file=requirements/tools.txt hypothesis-python/setup.py requirements/tools.in
-#
-alabaster==0.7.12
-    # via sphinx
-asgiref==3.5.2
-    # via django
-astor==0.8.1
-    # via flake8-simplify
-asttokens==2.0.5
-    # via stack-data
-attrs==21.4.0
-    # via
-    #   flake8-bugbear
-    #   hypothesis (hypothesis-python/setup.py)
-    #   pytest
-autoflake==1.4
-    # via shed
-babel==2.10.1
-    # via sphinx
-backcall==0.2.0
-    # via ipython
-backports-zoneinfo==0.2.1
-    # via django
-bandit==1.7.4
-    # via flake8-bandit
-beautifulsoup4==4.11.1
-    # via sphinx-codeautolink
-black==22.3.0
-    # via shed
-bleach==5.0.0
-    # via readme-renderer
-certifi==2022.5.18.1
-    # via requests
-cffi==1.15.0
-    # via cryptography
-charset-normalizer==2.0.12
-    # via requests
-click==8.1.3
-    # via
-    #   black
-    #   pip-tools
-codespell==2.1.0
-    # via -r requirements/tools.in
-com2ann==0.3.0
-    # via shed
-commonmark==0.9.1
-    # via rich
-coverage==6.4
-    # via -r requirements/tools.in
-cryptography==37.0.2
-    # via secretstorage
-decorator==5.1.1
-    # via ipython
-distlib==0.3.4
-    # via virtualenv
-django==4.0.4
-    # via -r requirements/tools.in
-docutils==0.17.1
-    # via
-    #   readme-renderer
-    #   restructuredtext-lint
-    #   sphinx
-    #   sphinx-rtd-theme
-dpcontracts==0.6.0
-    # via -r requirements/tools.in
-executing==0.8.3
-    # via stack-data
-filelock==3.7.0
-    # via
-    #   tox
-    #   virtualenv
-flake8==4.0.1
-    # via
-    #   -r requirements/tools.in
-    #   flake8-2020
-    #   flake8-bandit
-    #   flake8-bugbear
-    #   flake8-builtins
-    #   flake8-comprehensions
-    #   flake8-datetimez
-    #   flake8-docstrings
-    #   flake8-helper
-    #   flake8-mutable
-    #   flake8-noqa
-    #   flake8-polyfill
-    #   flake8-simplify
-    #   flake8-strftime
-flake8-2020==1.6.1
-    # via -r requirements/tools.in
-flake8-bandit==3.0.0
-    # via -r requirements/tools.in
-flake8-bugbear==22.4.25
-    # via -r requirements/tools.in
-flake8-builtins==1.5.3
-    # via -r requirements/tools.in
-flake8-comprehensions==3.10.0
-    # via -r requirements/tools.in
-flake8-datetimez==20.10.0
-    # via -r requirements/tools.in
-flake8-docstrings==1.6.0
-    # via -r requirements/tools.in
-flake8-helper==0.2.1
-    # via flake8-strftime
-flake8-mutable==1.2.0
-    # via -r requirements/tools.in
-flake8-noqa==1.2.2
-    # via -r requirements/tools.in
-flake8-pie==0.15.0
-    # via -r requirements/tools.in
-flake8-plugin-utils==1.3.2
-    # via
-    #   flake8-pytest-style
-    #   flake8-return
-flake8-polyfill==1.0.2
-    # via flake8-bandit
-flake8-pytest-style==1.6.0
-    # via -r requirements/tools.in
-flake8-return==1.1.3
-    # via -r requirements/tools.in
-flake8-simplify==0.19.2
-    # via -r requirements/tools.in
-flake8-strftime==0.3.2
-    # via -r requirements/tools.in
-gitdb==4.0.9
-    # via gitpython
-gitpython==3.1.27
-    # via bandit
-idna==3.3
-    # via requests
-imagesize==1.3.0
-    # via sphinx
-importlib-metadata==4.11.4
-    # via
-    #   keyring
-    #   sphinx
-    #   twine
-iniconfig==1.1.1
-    # via pytest
-ipython==8.4.0
-    # via -r requirements/tools.in
-isort==5.10.1
-    # via shed
-jedi==0.18.1
-    # via ipython
-jeepney==0.8.0
-    # via
-    #   keyring
-    #   secretstorage
-jinja2==3.1.2
-    # via sphinx
-keyring==23.5.1
-    # via twine
-lark-parser==0.12.0
-    # via -r requirements/tools.in
-libcst==0.4.3
-    # via
-    #   -r requirements/tools.in
-    #   shed
-markupsafe==2.1.1
-    # via jinja2
-matplotlib-inline==0.1.3
-    # via ipython
-mccabe==0.6.1
-    # via flake8
-mypy==0.960
-    # via -r requirements/tools.in
-mypy-extensions==0.4.3
-    # via
-    #   black
-    #   mypy
-    #   typing-inspect
-nodeenv==1.6.0
-    # via pyright
-packaging==21.3
-    # via
-    #   pytest
-    #   sphinx
-    #   tox
-parso==0.8.3
-    # via jedi
-pathspec==0.9.0
-    # via black
-pbr==5.9.0
-    # via stevedore
-pep517==0.12.0
-    # via pip-tools
-pexpect==4.8.0
-    # via ipython
-pickleshare==0.7.5
-    # via ipython
-pip-tools==6.6.2
-    # via -r requirements/tools.in
-pkginfo==1.8.2
-    # via twine
-platformdirs==2.5.2
-    # via
-    #   black
-    #   virtualenv
-pluggy==1.0.0
-    # via
-    #   pytest
-    #   tox
-prompt-toolkit==3.0.29
-    # via ipython
-ptyprocess==0.7.0
-    # via pexpect
-pure-eval==0.2.2
-    # via stack-data
-py==1.11.0
-    # via
-    #   pytest
-    #   tox
-pycodestyle==2.8.0
-    # via
-    #   flake8
-    #   flake8-bandit
-pycparser==2.21
-    # via cffi
-pydocstyle==6.1.1
-    # via flake8-docstrings
-pyflakes==2.4.0
-    # via
-    #   autoflake
-    #   flake8
-pygments==2.12.0
-    # via
-    #   ipython
-    #   readme-renderer
-    #   rich
-    #   sphinx
-pyparsing==3.0.9
-    # via packaging
-pyright==1.1.249
-    # via -r requirements/tools.in
-pytest==7.1.2
-    # via -r requirements/tools.in
-python-dateutil==2.8.2
-    # via -r requirements/tools.in
-pytz==2022.1
-    # via babel
-pyupgrade==2.32.1
-    # via shed
-pyyaml==6.0
-    # via
-    #   bandit
-    #   libcst
-readme-renderer==35.0
-    # via twine
-requests==2.27.1
-    # via
-    #   -r requirements/tools.in
-    #   requests-toolbelt
-    #   sphinx
-    #   twine
-requests-toolbelt==0.9.1
-    # via twine
-restructuredtext-lint==1.4.0
-    # via -r requirements/tools.in
-rfc3986==2.0.0
-    # via twine
-rich==12.4.4
-    # via twine
-secretstorage==3.3.2
-    # via keyring
-shed==0.10.0
-    # via -r requirements/tools.in
-six==1.16.0
-    # via
-    #   asttokens
-    #   bleach
-    #   python-dateutil
-    #   tox
-    #   virtualenv
-smmap==5.0.0
-    # via gitdb
-snowballstemmer==2.2.0
-    # via
-    #   pydocstyle
-    #   sphinx
-sortedcontainers==2.4.0
-    # via hypothesis (hypothesis-python/setup.py)
-soupsieve==2.3.2.post1
-    # via beautifulsoup4
-sphinx==4.5.0
-    # via
-    #   -r requirements/tools.in
-    #   sphinx-codeautolink
-    #   sphinx-rtd-theme
-sphinx-codeautolink==0.10.0
-    # via -r requirements/tools.in
-sphinx-hoverxref==1.0.1
-    # via -r requirements/tools.in
-sphinx-rtd-theme==1.0.0
-    # via -r requirements/tools.in
-sphinx-selective-exclude==1.0.3
-    # via -r requirements/tools.in
-sphinxcontrib-applehelp==1.0.2
-    # via sphinx
-sphinxcontrib-devhelp==1.0.2
-    # via sphinx
-sphinxcontrib-htmlhelp==2.0.0
-    # via sphinx
-sphinxcontrib-jsmath==1.0.1
-    # via sphinx
-sphinxcontrib-qthelp==1.0.3
-    # via sphinx
-sphinxcontrib-serializinghtml==1.1.5
-    # via sphinx
-sqlparse==0.4.2
-    # via django
-stack-data==0.2.0
-    # via ipython
-stevedore==3.5.0
-    # via bandit
-tokenize-rt==4.2.1
-    # via pyupgrade
-toml==0.10.2
-    # via
-    #   -r requirements/tools.in
-    #   tox
-tomli==2.0.1
-    # via
-    #   black
-    #   mypy
-    #   pep517
-    #   pytest
-tox==3.25.0
-    # via -r requirements/tools.in
-traitlets==5.2.1.post0
-    # via
-    #   ipython
-    #   matplotlib-inline
-twine==4.0.0
-    # via -r requirements/tools.in
-types-click==7.1.8
-    # via -r requirements/tools.in
-types-pkg-resources==0.1.3
-    # via -r requirements/tools.in
-types-pytz==2021.3.8
-    # via -r requirements/tools.in
-types-redis==4.2.6
-    # via -r requirements/tools.in
-typing-extensions==4.2.0
-    # via
-    #   -r requirements/tools.in
-    #   black
-    #   flake8-noqa
-    #   flake8-pie
-    #   libcst
-    #   mypy
-    #   rich
-    #   typing-inspect
-typing-inspect==0.7.1
-    # via libcst
-urllib3==1.26.9
-    # via
-    #   requests
-    #   twine
-virtualenv==20.14.1
-    # via tox
-wcwidth==0.2.5
-    # via prompt-toolkit
-webencodings==0.5.1
-    # via bleach
-wheel==0.37.1
-    # via pip-tools
-zipp==3.8.0
-    # via importlib-metadata
-
-# The following packages are considered to be unsafe in a requirements file:
-# pip
-# setuptools

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/scripts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/scripts/install.ps1 Deleted

@@ -1,176 +0,0 @@
-# Sample script to install Python and pip under Windows
-# Authors: Olivier Grisel, Jonathan Helmus and Kyle Kastner
-# License: CC0 1.0 Universal: https://creativecommons.org/publicdomain/zero/1.0/
-
-$MINICONDA_URL = "https://repo.continuum.io/miniconda/"
-$BASE_URL = "https://www.python.org/ftp/python/"
-$GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py"
-$GET_PIP_PATH = "C:\get-pip.py"
-
-
-function DownloadPython ($python_version, $platform_suffix) {
-    $webclient = New-Object System.Net.WebClient
-    $filename = "python-" + $python_version + $platform_suffix + ".msi"
-    $url = $BASE_URL + $python_version + "/" + $filename
-
-    $basedir = $pwd.Path + "\"
-    $filepath = $basedir + $filename
-    if (Test-Path $filename) {
-        Write-Host "Reusing" $filepath
-        return $filepath
-    }
-
-    # Download and retry up to 3 times in case of network transient errors.
-    Write-Host "Downloading" $filename "from" $url
-    $retry_attempts = 2
-    for($i=0; $i -lt $retry_attempts; $i++){
-        try {
-            $webclient.DownloadFile($url, $filepath)
-            break
-        }
-        Catch Exception{
-            Start-Sleep 1
-        }
-   }
-   if (Test-Path $filepath) {
-       Write-Host "File saved at" $filepath
-   } else {
-       # Retry once to get the error message if any at the last try
-       $webclient.DownloadFile($url, $filepath)
-   }
-   return $filepath
-}
-
-
-function InstallPython ($python_version, $architecture, $python_home) {
-    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
-    if (Test-Path $python_home) {
-        Write-Host $python_home "already exists, skipping."
-        return $false
-    }
-    if ($architecture -eq "32") {
-        $platform_suffix = ""
-    } else {
-        $platform_suffix = ".amd64"
-    }
-    $msipath = DownloadPython $python_version $platform_suffix
-    Write-Host "Installing" $msipath "to" $python_home
-    $install_log = $python_home + ".log"
-    $install_args = "/qn /log $install_log /i $msipath TARGETDIR=$python_home"
-    $uninstall_args = "/qn /x $msipath"
-    RunCommand "msiexec.exe" $install_args
-    if (-not(Test-Path $python_home)) {
-        Write-Host "Python seems to be installed else-where, reinstalling."
-        RunCommand "msiexec.exe" $uninstall_args
-        RunCommand "msiexec.exe" $install_args
-    }
-    if (Test-Path $python_home) {
-        Write-Host "Python $python_version ($architecture) installation complete"
-    } else {
-        Write-Host "Failed to install Python in $python_home"
-        Get-Content -Path $install_log
-        Exit 1
-    }
-}
-
-function RunCommand ($command, $command_args) {
-    Write-Host $command $command_args
-    Start-Process -FilePath $command -ArgumentList $command_args -Wait -Passthru
-}
-
-
-function InstallPip ($python_home) {
-    $pip_path = $python_home + "\Scripts\pip.exe"
-    $python_path = $python_home + "\python.exe"
-    if (-not(Test-Path $pip_path)) {
-        Write-Host "Installing pip..."
-        $webclient = New-Object System.Net.WebClient
-        $webclient.DownloadFile($GET_PIP_URL, $GET_PIP_PATH)
-        Write-Host "Executing:" $python_path $GET_PIP_PATH
-        Start-Process -FilePath "$python_path" -ArgumentList "$GET_PIP_PATH" -Wait -Passthru
-    } else {
-        Write-Host "pip already installed."
-    }
-}
-
-
-function DownloadMiniconda ($python_version, $platform_suffix) {
-    $webclient = New-Object System.Net.WebClient
-    $filename = "Miniconda-3.5.5-Windows-" + $platform_suffix + ".exe"
-    $url = $MINICONDA_URL + $filename
-
-    $basedir = $pwd.Path + "\"
-    $filepath = $basedir + $filename
-    if (Test-Path $filename) {
-        Write-Host "Reusing" $filepath
-        return $filepath
-    }
-
-    # Download and retry up to 3 times in case of network transient errors.
-    Write-Host "Downloading" $filename "from" $url
-    $retry_attempts = 2
-    for($i=0; $i -lt $retry_attempts; $i++){
-        try {
-            $webclient.DownloadFile($url, $filepath)
-            break
-        }
-        Catch Exception{
-            Start-Sleep 1
-        }
-   }
-   if (Test-Path $filepath) {
-       Write-Host "File saved at" $filepath
-   } else {
-       # Retry once to get the error message if any at the last try
-       $webclient.DownloadFile($url, $filepath)
-   }
-   return $filepath
-}
-
-
-function InstallMiniconda ($python_version, $architecture, $python_home) {
-    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
-    if (Test-Path $python_home) {
-        Write-Host $python_home "already exists, skipping."
-        return $false
-    }
-    if ($architecture -eq "32") {
-        $platform_suffix = "x86"
-    } else {
-        $platform_suffix = "x86_64"
-    }
-    $filepath = DownloadMiniconda $python_version $platform_suffix
-    Write-Host "Installing" $filepath "to" $python_home
-    $install_log = $python_home + ".log"
-    $args = "/S /D=$python_home"
-    Write-Host $filepath $args
-    Start-Process -FilePath $filepath -ArgumentList $args -Wait -Passthru
-    if (Test-Path $python_home) {
-        Write-Host "Python $python_version ($architecture) installation complete"
-    } else {
-        Write-Host "Failed to install Python in $python_home"
-        Get-Content -Path $install_log
-        Exit 1
-    }
-}
-
-
-function InstallMinicondaPip ($python_home) {
-    $pip_path = $python_home + "\Scripts\pip.exe"
-    $conda_path = $python_home + "\Scripts\conda.exe"
-    if (-not(Test-Path $pip_path)) {
-        Write-Host "Installing pip..."
-        $args = "install --yes pip"
-        Write-Host $conda_path $args
-        Start-Process -FilePath "$conda_path" -ArgumentList $args -Wait -Passthru
-    } else {
-        Write-Host "pip already installed."
-    }
-}
-
-function main () {
-    InstallPython $env:PYTHON_VERSION $env:PYTHON_ARCH $env:PYTHON
-    InstallPip $env:PYTHON
-}
-
-main

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/scripts/run_with_env.cmd Deleted

@@ -1,33 +0,0 @@
-:: To build extensions for 64 bit Python 3, we need to configure environment
-:: variables to use the MSVC 2010 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 4 (SDK v7.1)
-::
-:: 32 bit builds do not require specific environment configurations.
-::
-:: Note: this script needs to be run with the /E:ON and /V:ON flags for the
-:: cmd interpreter, at least for (SDK v7.0)
-::
-:: More details at:
-:: https://github.com/cython/cython/wiki/64BitCythonExtensionsOnWindows
-:: https://stackoverflow.com/a/13751649/163740
-::
-:: Author: Olivier Grisel
-:: License: CC0 1.0 Universal: https://creativecommons.org/publicdomain/zero/1.0/
-@ECHO OFF
-
-SET COMMAND_TO_RUN=%*
-SET WIN_SDK_ROOT=C:\Program Files\Microsoft SDKs\Windows
-
-IF "%PYTHON_ARCH%"=="64" (
-    ECHO Configuring Windows SDK v7.1 for Python 3 on a 64 bit architecture
-    SET DISTUTILS_USE_SDK=1
-    SET MSSdk=1
-    "%WIN_SDK_ROOT%\v7.1\Setup\WindowsSdkVer.exe" -q -version:v7.1
-    "%WIN_SDK_ROOT%\v7.1\Bin\SetEnv.cmd" /x64 /release
-    ECHO Executing: %COMMAND_TO_RUN%
-    call %COMMAND_TO_RUN% || EXIT 1
-) ELSE (
-    ECHO Using default MSVC build environment for 32 bit architecture
-    ECHO Executing: %COMMAND_TO_RUN%
-    call %COMMAND_TO_RUN% || EXIT 1
-)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/README.rst Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/ignore-list.txt Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/scripts Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/scripts/common.sh Deleted

@@ -1,38 +0,0 @@
-#!/usr/bin/env bash
-
-# This file is not really a script but is intended for sourcing from other
-# scripts so that they can share a common set of paths conveniently.
-
-set -o errexit
-set -o nounset
-
-HERE="$( cd "$( dirname "${BASH_SOURCE0}" )" && pwd )"
-ROOT="$(git -C "$HERE" rev-parse --show-toplevel)"
-
-export ROOT
-export BUILD_RUNTIMES=${BUILD_RUNTIMES:-$HOME/.cache/hypothesis-build-runtimes}
-export BASE="$BUILD_RUNTIMES"
-export PYENV="$BASE/pyenv"
-export SNAKEPIT="$BASE/python-versions/"
-
-export XDG_CACHE_HOME="$BUILD_RUNTIMES/.cache"
-export CARGO_HOME="$XDG_CACHE_HOME/.cargo"
-export RUSTUP_HOME="$XDG_CACHE_HOME/.rustup"
-
-# Note: Deliberately ignoring BUILD_RUNTIMES configuration because we don't
-# want this to go in cache, because it takes up a huge amount of space and
-# slows everything down!
-export VIRTUALENVS="${TMPDIR:-/tmp}/.hypothesis-runtimes/virtualenvs/"
-export RBENV_VERSION="2.5.1"
-export RBENV_ROOT="$BASE/.rbenv"
-export INSTALLED_RUBY_DIR="$RBENV_ROOT/versions/$RBENV_VERSION/"
-
-export GEM_HOME="$INSTALLED_RUBY_DIR"
-export GEM_PATH="$GEM_HOME"
-
-export PATH="$CARGO_HOME/bin:$INSTALLED_RUBY_DIR/bin:$HOME/.cargo/bin:$PATH"
-
-pythonloc() {
-    VERSION="$1"
-    echo "$SNAKEPIT/$VERSION"
-}

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/scripts/ensure-python.sh Deleted

@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-
-set -o errexit
-set -o nounset
-set -x
-
-HERE="$( cd "$( dirname "${BASH_SOURCE0}" )" && pwd )"
-
-# shellcheck source=tooling/scripts/common.sh
-source "$HERE/common.sh"
-
-# This is to guard against multiple builds in parallel. The various installers will tend
-# to stomp all over each other if you do this and they haven't previously successfully
-# succeeded. We use a lock file to block progress so only one install runs at a time.
-# This script should be pretty fast once files are cached, so the loss of concurrency
-# is not a major problem.
-# This should be using the lockfile command, but that's not available on the
-# containerized travis and we can't install it without sudo.
-# It is unclear if this is actually useful. I was seeing behaviour that suggested
-# concurrent runs of the installer, but I can't seem to find any evidence of this lock
-# ever not being acquired.
-
-VERSION="$1"
-TARGET=$(pythonloc "$VERSION")
-
-if  ! -e "$TARGET/bin/python"  ; then 
-    mkdir -p "$BASE"
-
-    LOCKFILE="$BASE/.install-lockfile"
-    while true; do
-      if mkdir "$LOCKFILE" 2>/dev/null; then
-        echo "Successfully acquired installer."
-        break
-      else
-        echo "Failed to acquire lock. Is another installer running? Waiting a bit."
-      fi
-
-      sleep $(( ( RANDOM % 10 ) + 1 )).$(( RANDOM % 100 ))s
-
-      if (( $(date '+%s') > 300 + $(stat --format=%X "$LOCKFILE") )); then
-        echo "We've waited long enough"
-        rm -rf "$LOCKFILE"
-      fi
-    done
-    trap 'rm -rf $LOCKFILE' EXIT
-
-
-    if  ! -d "$PYENV/.git" ; then
-      rm -rf "$PYENV"
-      git clone https://github.com/yyuu/pyenv.git "$PYENV"
-    else
-      back=$PWD
-      cd "$PYENV"
-      git fetch || echo "Update failed to complete. Ignoring"
-      git reset --hard origin/master
-      cd "$back"
-    fi
-
-    for _ in $(seq 5); do
-        if "$BASE/pyenv/plugins/python-build/bin/python-build" "$VERSION" "$TARGET" ; then
-            exit 0
-        fi
-        echo "Command failed. Retrying..."
-        sleep $(( ( RANDOM % 10 )  + 1 )).$(( RANDOM % 100 ))s
-    done
-fi

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/scripts/ensure-rustup.sh Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/scripts/tool-hash.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/setup.py Deleted

@@ -1,36 +0,0 @@
-# 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 os
-
-import setuptools
-
-
-def local_file(name):
-    return os.path.relpath(os.path.join(os.path.dirname(__file__), name))
-
-
-SOURCE = local_file("src")
-README = local_file("README.rst")
-
-setuptools.setup(
-    name="hypothesis-tooling",
-    # We don't actually ship this, it just has a setup.py for convenience.
-    version="0.0.0",
-    author="David R. MacIver",
-    author_email="david@drmaciver.com",
-    packages=setuptools.find_packages(SOURCE),
-    package_dir={"": SOURCE},
-    url="https://github.com/HypothesisWorks/hypothesis-python/tree/master/tooling",
-    license="MPL v2",
-    description="A library for property-based testing",
-    python_requires=">=3.7",
-    long_description=open(README).read(),
-)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/__init__.py Deleted

@@ -1,168 +0,0 @@
-# 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 os
-import shlex
-import subprocess
-
-
-def current_branch():
-    return (
-        subprocess.check_output("git", "rev-parse", "--abbrev-ref", "HEAD")
-        .decode("ascii")
-        .strip()
-    )
-
-
-def tags():
-    result = 
-        t.decode("ascii") for t in subprocess.check_output("git", "tag").split(b"\n")
-    
-    assert len(set(result)) == len(result)
-    return set(result)
-
-
-ROOT = (
-    subprocess.check_output(
-        "git", "-C", os.path.dirname(__file__), "rev-parse", "--show-toplevel"
-    )
-    .decode("ascii")
-    .strip()
-)
-
-
-REPO_TESTS = os.path.join(ROOT, "whole-repo-tests")
-
-
-def hash_for_name(name):
-    return subprocess.check_output("git", "rev-parse", name).decode("ascii").strip()
-
-
-def is_ancestor(a, b):
-    check = subprocess.call("git", "merge-base", "--is-ancestor", a, b)
-    assert 0 <= check <= 1
-    return check == 0
-
-
-def merge_base(a, b):
-    return subprocess.check_output("git", "merge-base", a, b).strip()
-
-
-def point_of_divergence():
-    return merge_base("HEAD", "origin/master")
-
-
-def has_changes(files):
-    command = 
-        "git",
-        "diff",
-        "--no-patch",
-        "--exit-code",
-        point_of_divergence(),
-        "HEAD",
-        "--",
-        *files,
-    
-    return subprocess.call(command) != 0
-
-
-def has_uncommitted_changes(filename):
-    return subprocess.call("git", "diff", "--exit-code", filename) != 0
-
-
-def last_committer():
-    out, _ = subprocess.Popen(
-        "git", "log", "-1", "--pretty=format:%an",
-        stdout=subprocess.PIPE,
-        universal_newlines=True,
-    ).communicate()
-    return out
-
-
-def git(*args):
-    subprocess.check_call(("git",) + args)
-
-
-TOOLING_COMMITER_NAME = "CI on behalf of the Hypothesis team"
-
-
-def configure_git():
-    git("config", "user.name", TOOLING_COMMITER_NAME)
-    git("config", "user.email", "david@drmaciver.com")
-
-
-def create_tag(tagname):
-    assert tagname not in tags()
-    git("tag", tagname)
-
-
-def push_tag(tagname):
-    assert_can_release()
-    subprocess.check_call("git", "push", "origin", shlex.quote(tagname))
-    subprocess.check_call("git", "push", "origin", "HEAD:master")
-
-
-def assert_can_release():
-    assert not IS_PULL_REQUEST, "Cannot release from pull requests"
-
-
-def modified_files():
-    files = set()
-    for command in 
-        
-            "git",
-            "diff",
-            "--name-only",
-            "--diff-filter=d",
-            point_of_divergence(),
-            "HEAD",
-        ,
-        "git", "diff", "--name-only",
-    :
-        diff_output = subprocess.check_output(command).decode("ascii")
-        for l in diff_output.split("\n"):
-            filepath = l.strip()
-            if filepath and os.path.exists(filepath):
-                files.add(filepath)
-    return files
-
-
-def all_files():
-    return 
-        f
-        for f in subprocess.check_output("git", "ls-files")
-        .decode("ascii")
-        .splitlines()
-        if os.path.exists(f)
-    
-
-
-def changed_files_from_master():
-    """Returns a list of files which have changed between a branch and
-    master."""
-    files = set()
-    command = "git", "diff", "--name-only", "HEAD", "master"
-    diff_output = subprocess.check_output(command).decode("ascii")
-    for line in diff_output.splitlines():
-        filepath = line.strip()
-        if filepath:
-            files.add(filepath)
-    return files
-
-
-IS_PULL_REQUEST = os.environ.get("GITHUB_REF", "").startswith("refs/pull/")
-
-
-def all_projects():
-    import hypothesistooling.projects.conjecturerust as cr
-    import hypothesistooling.projects.hypothesispython as hp
-    import hypothesistooling.projects.hypothesisruby as hr
-
-    return cr, hp, hr

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/__main__.py Deleted

@@ -1,592 +0,0 @@
-# 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 os
-import pathlib
-import re
-import subprocess
-import sys
-from glob import glob
-
-import requests
-from coverage.config import CoverageConfig
-
-import hypothesistooling as tools
-import hypothesistooling.projects.conjecturerust as cr
-import hypothesistooling.projects.hypothesispython as hp
-import hypothesistooling.projects.hypothesisruby as hr
-from hypothesistooling import installers as install, releasemanagement as rm
-from hypothesistooling.scripts import pip_tool
-
-TASKS = {}
-BUILD_FILES = tuple(
-    os.path.join(tools.ROOT, f)
-    for f in "tooling", "requirements", ".github", "hypothesis-python/tox.ini"
-)
-
-
-def task(if_changed=()):
-    if isinstance(if_changed, str):
-        if_changed = (if_changed,)
-
-    def accept(fn):
-        def wrapped(*args, **kwargs):
-            if if_changed and tools.IS_PULL_REQUEST:
-                if not tools.has_changes(if_changed + BUILD_FILES):
-                    changed = ", ".join(if_changed)
-                    print(f"Skipping task due to no changes in {changed}")
-                    return
-            fn(*args, **kwargs)
-
-        wrapped.__name__ = fn.__name__
-        name = fn.__name__.replace("_", "-")
-        if name != "<lambda>":
-            TASKSname = wrapped
-        return wrapped
-
-    return accept
-
-
-@task()
-def check_installed():
-    """No-op task that can be used to test for a successful install (so we
-    don't fail to run if a previous install failed midway)."""
-
-
-def codespell(*files):
-    pip_tool(
-        "codespell",
-        "--check-hidden",
-        "--check-filenames",
-        "--ignore-words=./tooling/ignore-list.txt",
-        "--skip=__pycache__,.mypy_cache,.venv,.git,tlds-alpha-by-domain.txt",
-        *files,
-    )
-
-
-@task()
-def lint():
-    pip_tool(
-        "flake8",
-        *(f for f in tools.all_files() if f.endswith(".py")),
-        "--config",
-        os.path.join(tools.ROOT, ".flake8"),
-    )
-    codespell(*(f for f in tools.all_files() if not f.endswith("by-domain.txt")))
-
-
-def do_release(package):
-    if not package.has_release():
-        print(f"No release for {package.__name__}")
-        return
-
-    os.chdir(package.BASE_DIR)
-
-    print("Updating changelog and version")
-    package.update_changelog_and_version()
-
-    print("Committing changes")
-    rm.commit_pending_release(package)
-
-    print("Building distribution")
-    package.build_distribution()
-
-    print("Looks good to release!")
-
-    tag_name = package.tag_name()
-
-    print(f"Creating tag {tag_name}")
-
-    tools.create_tag(tag_name)
-    tools.push_tag(tag_name)
-
-    print("Uploading distribution")
-    package.upload_distribution()
-
-
-@task()
-def deploy():
-    HEAD = tools.hash_for_name("HEAD")
-    MASTER = tools.hash_for_name("origin/master")
-
-    print("Current head:  ", HEAD)
-    print("Current master:", MASTER)
-
-    if not tools.is_ancestor(HEAD, MASTER):
-        print("Not deploying due to not being on master")
-        sys.exit(0)
-
-    if "TWINE_PASSWORD" not in os.environ:
-        print("Running without access to secure variables, so no deployment")
-        sys.exit(0)
-
-    tools.configure_git()
-
-    for project in tools.all_projects():
-        do_release(project)
-
-    sys.exit(0)
-
-
-# See https://www.linuxfoundation.org/blog/copyright-notices-in-open-source-software-projects/
-HEADER = """
-# 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/.
-""".strip()
-
-
-@task()
-def format():
-    def should_format_file(path):
-        return path.endswith(".py")
-
-    def should_format_doc_file(path):
-        return path.endswith((".rst", ".md"))
-
-    changed = tools.modified_files()
-
-    format_all = os.environ.get("FORMAT_ALL", "").lower() == "true"
-    if "requirements/tools.txt" in changed:
-        # We've changed the tools, which includes a lot of our formatting
-        # logic, so we need to rerun formatters.
-        format_all = True
-
-    files = tools.all_files() if format_all else changed
-
-    doc_files_to_format = f for f in sorted(files) if should_format_doc_file(f)
-    files_to_format = f for f in sorted(files) if should_format_file(f)
-
-    if not (files_to_format or doc_files_to_format):
-        return
-
-    # .coveragerc lists several regex patterns to treat as nocover pragmas, and
-    # we want to find (and delete) cases where # pragma: no cover is redundant.
-    def warn(msg):
-        raise Exception(msg)
-
-    config = CoverageConfig()
-    config.from_file(os.path.join(hp.BASE_DIR, ".coveragerc"), warn=warn, our_file=True)
-    pattern = "|".join(l for l in config.exclude_list if "pragma" not in l)
-    unused_pragma_pattern = re.compile(f"(({pattern}).*)  # pragma: no (branch|cover)")
-    last_header_line = HEADER.splitlines()-1.rstrip()
-
-    for f in files_to_format:
-        lines = 
-        with open(f, encoding="utf-8") as o:
-            shebang = None
-            first = True
-            in_header = True
-            for l in o.readlines():
-                if first:
-                    first = False
-                    if l:2 == "#!":
-                        shebang = l
-                        continue
-                elif in_header and l.rstrip() == last_header_line:
-                    in_header = False
-                    lines = 
-                else:
-                    lines.append(unused_pragma_pattern.sub(r"\1", l))
-        source = "".join(lines).strip()
-        with open(f, "w", encoding="utf-8") as o:
-            if shebang is not None:
-                o.write(shebang)
-                o.write("\n")
-            o.write(HEADER)
-            if source:
-                o.write("\n\n")
-                o.write(source)
-            o.write("\n")
-
-    codespell("--write-changes", *files_to_format, *doc_files_to_format)
-    pip_tool("shed", *files_to_format, *doc_files_to_format)
-
-
-VALID_STARTS = (HEADER.split()0, "#!/usr/bin/env python")
-
-
-@task()
-def check_format():
-    format()
-    n = max(map(len, VALID_STARTS))
-    bad = False
-    for f in tools.all_files():
-        if not f.endswith(".py"):
-            continue
-        with open(f, encoding="utf-8") as i:
-            start = i.read(n)
-            if not any(start.startswith(s) for s in VALID_STARTS):
-                print(f"{f} has incorrect start {start!r}", file=sys.stderr)
-                bad = True
-    assert not bad
-    check_not_changed()
-
-
-def check_not_changed():
-    subprocess.check_call("git", "diff", "--exit-code")
-
-
-@task()
-def compile_requirements(upgrade=False):
-    if upgrade:
-        extra = "--upgrade"
-    else:
-        extra = 
-
-    for f in glob(os.path.join("requirements", "*.in")):
-        base, _ = os.path.splitext(f)
-        pip_tool(
-            "pip-compile",
-            *extra,
-            f,
-            "hypothesis-python/setup.py",
-            "--output-file",
-            base + ".txt",
-            cwd=tools.ROOT,
-        )
-
-
-def update_python_versions():
-    install.ensure_python(PYTHONSci_version)
-    cmd = "~/.cache/hypothesis-build-runtimes/pyenv/bin/pyenv install --list"
-    result = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE).stdout.decode()
-    # pyenv reports available versions in chronological order, so we keep the newest
-    # *unless* our current ends with a digit (is stable) and the candidate does not.
-    stable = re.compile(r".*3\.\d+.\d+$")
-    best = {}
-    for line in map(str.strip, result.splitlines()):
-        if m := re.match(r"(?:pypy)?3\.(?:789|\d\d)", line):
-            key = m.group()
-            if stable.match(line) or not stable.match(best.get(key, line)):
-                bestkey = line
-
-    if best == PYTHONS:
-        return
-
-    # Write the new mapping back to this file
-    thisfile = pathlib.Path(__file__)
-    before = thisfile.read_text()
-    after = re.sub(r"\nPYTHONS = \{^{}+\}", f"\nPYTHONS = {best}", before)
-    thisfile.write_text(after)
-    pip_tool("shed", str(thisfile))
-
-    # Automatically sync ci_version with the version in build.sh
-    build_sh = pathlib.Path(tools.ROOT) / "build.sh"
-    sh_before = build_sh.read_text()
-    sh_after = re.sub(r"3\.\d\d?\.\d\d?", bestci_version, sh_before)
-    if sh_before != sh_after:
-        build_sh.unlink()  # so bash doesn't reload a modified file
-        build_sh.write_text(sh_after)
-        build_sh.chmod(0o755)
-
-
-def update_vendored_files():
-    vendor = pathlib.Path(hp.PYTHON_SRC) / "hypothesis" / "vendor"
-
-    # Turns out that as well as adding new gTLDs, IANA can *terminate* old ones
-    url = "http://data.iana.org/TLD/tlds-alpha-by-domain.txt"
-    fname = vendor / url.split("/")-1
-    new = requests.get(url).content
-    # If only the timestamp in the header comment has changed, skip the update.
-    if fname.read_bytes().splitlines()1: != new.splitlines()1::
-        fname.write_bytes(new)
-
-    # Always require the latest version of the tzdata package
-    tz_url = "https://pypi.org/pypi/tzdata/json"
-    tzdata_version = requests.get(tz_url).json()"info""version"
-    setup = pathlib.Path(hp.BASE_DIR, "setup.py")
-    new = re.sub(r"tzdata>=(.+?) ", f"tzdata>={tzdata_version} ", setup.read_text())
-    setup.write_text(new)
-
-
-def has_diff(file_or_directory):
-    diff = "git", "diff", "--no-patch", "--exit-code", "--", file_or_directory
-    return subprocess.call(diff) != 0
-
-
-@task()
-def upgrade_requirements():
-    update_vendored_files()
-    compile_requirements(upgrade=True)
-    subprocess.call("./build.sh", "format", cwd=tools.ROOT)  # exits 1 if changed
-    if has_diff(hp.PYTHON_SRC) and not os.path.isfile(hp.RELEASE_FILE):
-        if has_diff(f"{hp.PYTHON_SRC}/hypothesis/vendor/tlds-alpha-by-domain.txt"):
-            msg = (
-                "our vendored `list of top-level domains "
-                "<https://www.iana.org/domains/root/db>`__,\nwhich is used by the "
-                "provisional :func:`~hypothesis.provisional.domains` strategy."
-            )
-        else:
-            msg = "our autoformatting tools, improving our code style without any API changes."
-        with open(hp.RELEASE_FILE, mode="w") as f:
-            f.write(f"RELEASE_TYPE: patch\n\nThis patch updates {msg}\n")
-    update_python_versions()
-    subprocess.call("git", "add", ".", cwd=tools.ROOT)
-
-
-@task()
-def check_requirements():
-    compile_requirements(upgrade=False)
-
-
-@task(if_changed=hp.HYPOTHESIS_PYTHON)
-def documentation():
-    try:
-        if hp.has_release():
-            hp.update_changelog_and_version()
-        hp.build_docs()
-    finally:
-        subprocess.check_call(
-            "git", "checkout", "docs/changes.rst", "src/hypothesis/version.py",
-            cwd=hp.HYPOTHESIS_PYTHON,
-        )
-
-
-def run_tox(task, version, *args):
-    python = install.python_executable(version)
-
-    # Create a version of the name that tox will pick up for the correct
-    # interpreter alias.
-    linked_version = os.path.basename(python) + ALIASESversion
-    try:
-        os.symlink(python, linked_version)
-    except FileExistsError:
-        pass
-
-    env = dict(os.environ)
-    python = install.python_executable(version)
-
-    env"PATH" = os.path.dirname(python) + ":" + env"PATH"
-    print(env"PATH")
-
-    pip_tool("tox", "-e", task, *args, env=env, cwd=hp.HYPOTHESIS_PYTHON)
-
-
-# update_python_versions(), above, keeps the contents of this dict up to date.
-# When a version is added or removed, manually update the env lists in tox.ini and
-# workflows/main.yml, and the `Programming Language ::` specifiers in setup.py
-PYTHONS = {
-    "3.7": "3.7.13",
-    "3.8": "3.8.13",
-    "3.9": "3.9.13",
-    "3.10": "3.10.4",
-    "3.11": "3.11-dev",
-    "3.12": "3.12-dev",
-    "pypy3.7": "pypy3.7-7.3.9",
-    "pypy3.8": "pypy3.8-7.3.9",
-    "pypy3.9": "pypy3.9-7.3.9",
-}
-ci_version = "3.8"  # Keep this in sync with GH Actions main.yml
-
-python_tests = task(
-    if_changed=(
-        hp.PYTHON_SRC,
-        hp.PYTHON_TESTS,
-        os.path.join(tools.ROOT, "pytest.ini"),
-        os.path.join(hp.HYPOTHESIS_PYTHON, "scripts"),
-    )
-)
-
-
-# ALIASES are the executable names for each Python version
-ALIASES = {}
-for key, version in PYTHONS.items():
-    if key.startswith("pypy"):
-        ALIASESversion = "pypy3"
-        name = key.replace(".", "")
-    else:
-        ALIASESversion = f"python{key}"
-        name = f"py3{key2:}"
-    TASKSf"check-{name}" = python_tests(
-        lambda n=f"{name}-full", v=version: run_tox(n, v)
-    )
-
-
-@python_tests
-def check_py310_pyjion():
-    run_tox("py310-pyjion", PYTHONS"3.10")
-
-
-@task()
-def tox(*args):
-    if len(args) < 2:
-        print("Usage: ./build.sh tox TOX_ENV PY_VERSION tox args")
-        sys.exit(1)
-    run_tox(args0, args1, *args2:)
-
-
-def standard_tox_task(name):
-    TASKS"check-" + name = python_tests(lambda: run_tox(name, PYTHONSci_version))
-
-
-standard_tox_task("nose")
-standard_tox_task("pytest46")
-standard_tox_task("pytest54")
-standard_tox_task("pytest62")
-
-for n in 22, 32, 40:
-    standard_tox_task(f"django{n}")
-for n in 25, 10, 11, 12, 13:
-    standard_tox_task(f"pandas{n}")
-
-standard_tox_task("coverage")
-standard_tox_task("conjecture-coverage")
-
-
-@task()
-def check_quality():
-    run_tox("quality", PYTHONSci_version)
-
-
-@task(if_changed=(hp.PYTHON_SRC, os.path.join(hp.HYPOTHESIS_PYTHON, "examples")))
-def check_examples3():
-    run_tox("examples3", PYTHONSci_version)
-
-
-@task()
-def check_whole_repo_tests(*args):
-    install.ensure_shellcheck()
-    subprocess.check_call(
-        sys.executable, "-m", "pip", "install", "--upgrade", hp.HYPOTHESIS_PYTHON
-    )
-
-    if not args:
-        args = tools.REPO_TESTS
-    subprocess.check_call(sys.executable, "-m", "pytest", *args)
-
-
-@task()
-def shell():
-    import IPython
-
-    IPython.start_ipython()
-
-
-def ruby_task(fn):
-    return task(if_changed=(hr.HYPOTHESIS_RUBY,))(fn)
-
-
-@ruby_task
-def lint_ruby():
-    hr.rake_task("checkformat")
-
-
-@ruby_task
-def check_ruby_tests():
-    hr.rake_task("rspec")
-    hr.rake_task("minitest")
-
-
-@ruby_task
-def format_rust_in_ruby():
-    hr.cargo("fmt")
-
-
-@ruby_task
-def check_rust_in_ruby_format():
-    hr.cargo("fmt", "--", "--check")
-
-
-@ruby_task
-def lint_rust_in_ruby():
-    hr.cargo("clippy")
-
-
-@ruby_task
-def audit_rust_in_ruby():
-    hr.cargo("install", "cargo-audit")
-    hr.cargo("audit")
-
-
-@task()
-def python(*args):
-    os.execv(sys.executable, (sys.executable,) + args)
-
-
-@task()
-def bundle(*args):
-    hr.bundle(*args)
-
-
-rust_task = task(if_changed=(cr.BASE_DIR,))
-
-
-@rust_task
-def check_rust_tests():
-    cr.cargo("test")
-
-
-@rust_task
-def format_conjecture_rust_code():
-    cr.cargo("fmt")
-
-
-@rust_task
-def check_conjecture_rust_format():
-    cr.cargo("fmt", "--", "--check")
-
-
-@rust_task
-def lint_conjecture_rust():
-    cr.cargo("clippy")
-
-
-@rust_task
-def audit_conjecture_rust():
-    cr.cargo("install", "cargo-audit")
-    cr.cargo("audit")
-
-
-@task()
-def tasks():
-    """Print a list of all task names supported by the build system."""
-    for task_name in sorted(TASKS.keys()):
-        print("    " + task_name)
-
-
-if __name__ == "__main__":
-    if "SNAKEPIT" not in os.environ:
-        print(
-            "This module should not be executed directly, but instead via "
-            "build.sh (which sets up its environment)"
-        )
-        sys.exit(1)
-
-    if len(sys.argv) > 1:
-        task_to_run = sys.argv1
-        args = sys.argv2:
-    else:
-        task_to_run = os.environ.get("TASK")
-        args = ()
-
-    if task_to_run is None:
-        print(
-            "No task specified. Either pass the task to run as an "
-            "argument or as an environment variable TASK. "
-            '(Use "./build.sh tasks" to list all supported task names.)'
-        )
-        sys.exit(1)
-
-    if task_to_run not in TASKS:
-        print(f"\nUnknown task {task_to_run!r}.  Available tasks are:")
-        tasks()
-        sys.exit(1)
-
-    try:
-        TASKStask_to_run(*args)
-    except subprocess.CalledProcessError as e:
-        sys.exit(e.returncode)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/installers.py Deleted

@@ -1,127 +0,0 @@
-# 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/.
-
-"""Module for obtaining various versions of Python.
-
-Currently this is a thin shim around pyenv, but it would be nice to have
-this work on Windows as well by using Anaconda (as our build already
-does).
-"""
-
-import os
-import shutil
-import subprocess
-
-from hypothesistooling import git, scripts
-from hypothesistooling.junkdrawer import once
-
-HOME = os.environ"HOME"
-
-
-def __python_executable(version):
-    return os.path.join(scripts.SNAKEPIT, version, "bin", "python")
-
-
-def python_executable(version):
-    ensure_python(version)
-    return __python_executable(version)
-
-
-PYTHONS = set()
-
-
-def ensure_python(version):
-    if version in PYTHONS:
-        return
-    scripts.run_script("ensure-python.sh", version)
-    target = __python_executable(version)
-    assert os.path.exists(target), target
-    PYTHONS.add(version)
-
-
-STACK = os.path.join(HOME, ".local", "bin", "stack")
-GHC = os.path.join(HOME, ".local", "bin", "ghc")
-SHELLCHECK = shutil.which("shellcheck") or os.path.join(
-    HOME, ".local", "bin", "shellcheck"
-)
-
-
-def ensure_stack():
-    if os.path.exists(STACK):
-        return
-    subprocess.check_call("mkdir -p ~/.local/bin", shell=True)
-    subprocess.check_call(
-        "curl -L https://www.stackage.org/stack/linux-x86_64 "
-        "| tar xz --wildcards --strip-components=1 -C $HOME"
-        "/.local/bin '*/stack'",
-        shell=True,
-    )
-
-
-@once
-def update_stack():
-    ensure_stack()
-    subprocess.check_call(STACK, "update")
-
-
-@once
-def ensure_ghc():
-    if os.path.exists(GHC):
-        return
-    update_stack()
-    subprocess.check_call(STACK, "setup")
-
-
-@once
-def ensure_shellcheck():
-    if os.path.exists(SHELLCHECK):
-        return
-    update_stack()
-    ensure_ghc()
-    subprocess.check_call(STACK, "install", "ShellCheck")
-
-
-@once
-def ensure_rustup():
-    scripts.run_script("ensure-rustup.sh")
-
-
-RUBY_BUILD = os.path.join(scripts.RBENV_ROOT, "plugins", "ruby-build")
-
-RUBY_BIN_DIR = os.path.join(scripts.INSTALLED_RUBY_DIR, "bin")
-
-BUNDLER_EXECUTABLE = os.path.join(RUBY_BIN_DIR, "bundle")
-GEM_EXECUTABLE = os.path.join(RUBY_BIN_DIR, "gem")
-
-RBENV_COMMAND = os.path.join(scripts.RBENV_ROOT, "bin", "rbenv")
-
-
-@once
-def ensure_ruby():
-    if not os.path.exists(scripts.RBENV_ROOT):
-        git("clone", "https://github.com/rbenv/rbenv.git", scripts.RBENV_ROOT)
-
-    if not os.path.exists(RUBY_BUILD):
-        git("clone", "https://github.com/rbenv/ruby-build.git", RUBY_BUILD)
-
-    if not os.path.exists(
-        os.path.join(scripts.RBENV_ROOT, "versions", scripts.RBENV_VERSION)
-    ):
-        subprocess.check_call(RBENV_COMMAND, "install", scripts.RBENV_VERSION)
-
-    subprocess.check_call(GEM_EXECUTABLE, "update", "--system")
-
-    if not (
-        os.path.exists(BUNDLER_EXECUTABLE)
-        and subprocess.call(BUNDLER_EXECUTABLE, "version") == 0
-    ):
-        subprocess.check_call(GEM_EXECUTABLE, "install", "bundler")
-
-    assert os.path.exists(BUNDLER_EXECUTABLE)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/junkdrawer.py Deleted

@@ -1,51 +0,0 @@
-# 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/.
-
-"""Dumping ground module for things that don't have anywhere better to go.
-
-See https://twitter.com/betsythemuffin/status/1003313844108824584
-"""
-
-import ast
-import os
-from contextlib import contextmanager
-
-
-@contextmanager
-def in_dir(d):
-    prev = os.getcwd()
-    try:
-        os.chdir(d)
-        yield
-    finally:
-        os.chdir(prev)
-
-
-def once(fn):
-    def accept():
-        if accept.has_been_called:
-            return
-        fn()
-        accept.has_been_called = True
-
-    accept.has_been_called = False
-    accept.__name__ = fn.__name__
-    return accept
-
-
-def unlink_if_present(path):
-    try:
-        os.unlink(path)
-    except FileNotFoundError:
-        pass
-
-
-def unquote_string(s):
-    return ast.literal_eval(s)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/projects Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/projects/conjecturerust.py Deleted

@@ -1,97 +0,0 @@
-# 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 os
-import subprocess
-
-import hypothesistooling as tools
-from hypothesistooling import installers as install, releasemanagement as rm
-from hypothesistooling.junkdrawer import in_dir, unquote_string
-
-PACKAGE_NAME = "conjecture-rust"
-
-CONJECTURE_RUST = os.path.join(tools.ROOT, PACKAGE_NAME)
-
-BASE_DIR = CONJECTURE_RUST
-
-TAG_PREFIX = PACKAGE_NAME + "-"
-
-RELEASE_FILE = os.path.join(BASE_DIR, "RELEASE.md")
-CHANGELOG_FILE = os.path.join(BASE_DIR, "CHANGELOG.md")
-
-CARGO_FILE = os.path.join(BASE_DIR, "Cargo.toml")
-
-SRC = os.path.join(BASE_DIR, "src")
-
-
-def has_release():
-    """Is there a version of this package ready to release?"""
-    return os.path.exists(RELEASE_FILE)
-
-
-def update_changelog_and_version():
-    """Update the changelog and version based on the current release file."""
-    release_type, release_contents = rm.parse_release_file(RELEASE_FILE)
-    version = current_version()
-    version_info = rm.parse_version(version)
-
-    version, version_info = rm.bump_version_info(version_info, release_type)
-
-    rm.replace_assignment(CARGO_FILE, "version", repr(version))
-
-    rm.update_markdown_changelog(
-        CHANGELOG_FILE,
-        name="Conjecture for Rust",
-        version=version,
-        entry=release_contents,
-    )
-
-
-def cargo(*args):
-    install.ensure_rustup()
-    with in_dir(BASE_DIR):
-        subprocess.check_call(("cargo",) + args)
-
-
-IN_TEST = False
-
-
-def build_distribution():
-    """Build the crate."""
-    if IN_TEST:
-        cargo("package", "--allow-dirty")
-    else:
-        cargo("package")
-
-
-def tag_name():
-    """The tag name for the upcoming release."""
-    return TAG_PREFIX + current_version()
-
-
-def has_source_changes():
-    """Returns True if any source files have changed."""
-    return tools.has_changes(SRC)
-
-
-def current_version():
-    """Returns the current version as specified by the Cargo.toml."""
-    return unquote_string(rm.extract_assignment(CARGO_FILE, "version"))
-
-
-CARGO_CREDENTIALS = os.path.expanduser("~/.cargo/credentials")
-
-
-def upload_distribution():
-    """Upload the built package to crates.io."""
-    tools.assert_can_release()
-    # Credentials are supplied by the CARGO_REGISTRY_TOKEN envvar, which in turn
-    # is set from the repository secrets by GitHub Actions.
-    cargo("publish")

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/projects/hypothesispython.py Deleted

@@ -1,236 +0,0 @@
-# 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 os
-import re
-import shutil
-import subprocess
-import sys
-
-import requests
-
-import hypothesistooling as tools
-from hypothesistooling import releasemanagement as rm
-
-PACKAGE_NAME = "hypothesis-python"
-
-HYPOTHESIS_PYTHON = os.path.join(tools.ROOT, PACKAGE_NAME)
-PYTHON_TAG_PREFIX = "hypothesis-python-"
-
-
-BASE_DIR = HYPOTHESIS_PYTHON
-
-PYTHON_SRC = os.path.join(HYPOTHESIS_PYTHON, "src")
-PYTHON_TESTS = os.path.join(HYPOTHESIS_PYTHON, "tests")
-
-RELEASE_FILE = os.path.join(HYPOTHESIS_PYTHON, "RELEASE.rst")
-
-assert os.path.exists(PYTHON_SRC)
-
-
-__version__ = None
-__version_info__ = None
-
-VERSION_FILE = os.path.join(PYTHON_SRC, "hypothesis/version.py")
-
-with open(VERSION_FILE) as o:
-    exec(o.read())
-
-assert __version__ is not None
-assert __version_info__ is not None
-
-
-def has_release():
-    return os.path.exists(RELEASE_FILE)
-
-
-def parse_release_file():
-    return rm.parse_release_file(RELEASE_FILE)
-
-
-def has_source_changes():
-    return tools.has_changes(PYTHON_SRC)
-
-
-def build_docs(builder="html"):
-    # See https://www.sphinx-doc.org/en/stable/man/sphinx-build.html
-    # (unfortunately most options only have the short flag version)
-    tools.scripts.pip_tool(
-        "sphinx-build",
-        "-n",
-        "-W",
-        "--keep-going",
-        "-T",
-        "-E",
-        "-b",
-        builder,
-        "docs",
-        "docs/_build/" + builder,
-        cwd=HYPOTHESIS_PYTHON,
-    )
-
-
-CHANGELOG_ANCHOR = re.compile(r"^\.\. _v\d+\.\d+\.\d+:$", flags=re.MULTILINE)
-CHANGELOG_BORDER = re.compile(r"^-+$", flags=re.MULTILINE)
-CHANGELOG_HEADER = re.compile(r"^\d+\.\d+\.\d+ - \d\d\d\d-\d\d-\d\d$", flags=re.M)
-
-
-def update_changelog_and_version():
-    global __version_info__
-    global __version__
-
-    contents = changelog()
-    assert "\r" not in contents
-    lines = contents.split("\n")
-    for i, l in enumerate(lines):
-        if CHANGELOG_ANCHOR.match(l):
-            assert CHANGELOG_BORDER.match(linesi + 2), repr(linesi + 2)
-            assert CHANGELOG_HEADER.match(linesi + 3), repr(linesi + 3)
-            assert CHANGELOG_BORDER.match(linesi + 4), repr(linesi + 4)
-            beginning = "\n".join(lines:i)
-            rest = "\n".join(linesi:)
-            assert "\n".join((beginning, rest)) == contents
-            break
-
-    release_type, release_contents = parse_release_file()
-
-    new_version_string, new_version_info = rm.bump_version_info(
-        __version_info__, release_type
-    )
-
-    __version_info__ = new_version_info
-    __version__ = new_version_string
-
-    if release_type == "major":
-        major, _, _ = __version_info__
-        old = f"Hypothesis {major - 1}.x"
-        beginning = beginning.replace(old, f"Hypothesis {major}.x")
-        rest = "\n".join(old, len(old) * "=", "", rest)
-
-    rm.replace_assignment(VERSION_FILE, "__version_info__", repr(new_version_info))
-
-    heading_for_new_version = " - ".join((new_version_string, rm.release_date_string()))
-    border_for_new_version = "-" * len(heading_for_new_version)
-
-    new_changelog_parts = 
-        beginning.strip(),
-        "",
-        f".. _v{new_version_string}:",
-        "",
-        border_for_new_version,
-        heading_for_new_version,
-        border_for_new_version,
-        "",
-        release_contents,
-        "",
-        rest,
-    
-
-    with open(CHANGELOG_FILE, "w") as o:
-        o.write("\n".join(new_changelog_parts))
-
-    # Replace the `since="RELEASEDAY"` argument to `note_deprecation`
-    # with today's date, to record it for future reference.
-    before = 'since="RELEASEDAY"'
-    after = before.replace("RELEASEDAY", rm.release_date_string())
-    for root, _, files in os.walk(PYTHON_SRC):
-        for fname in (os.path.join(root, f) for f in files if f.endswith(".py")):
-            with open(fname) as f:
-                contents = f.read()
-            if before in contents:
-                with open(fname, "w") as f:
-                    f.write(contents.replace(before, after))
-
-
-CHANGELOG_FILE = os.path.join(HYPOTHESIS_PYTHON, "docs", "changes.rst")
-DIST = os.path.join(HYPOTHESIS_PYTHON, "dist")
-
-
-def changelog():
-    with open(CHANGELOG_FILE) as i:
-        return i.read()
-
-
-def build_distribution():
-    if os.path.exists(DIST):
-        shutil.rmtree(DIST)
-    subprocess.check_output(
-        sys.executable, "setup.py", "sdist", "bdist_wheel", "--dist-dir", DIST
-    )
-
-
-def upload_distribution():
-    tools.assert_can_release()
-
-    subprocess.check_call(
-        
-            sys.executable,
-            "-m",
-            "twine",
-            "upload",
-            "--skip-existing",
-            "--username=__token__",
-            os.path.join(DIST, "*"),
-        
-    )
-
-    # Construct plain-text + markdown version of this changelog entry,
-    # with link to canonical source.
-    build_docs(builder="text")
-    textfile = os.path.join(HYPOTHESIS_PYTHON, "docs", "_build", "text", "changes.txt")
-    with open(textfile) as f:
-        lines = f.readlines()
-    entries = i for i, l in enumerate(lines) if CHANGELOG_HEADER.match(l)
-    anchor = current_version().replace(".", "-")
-    changelog_body = (
-        "".join(linesentries0 + 2 : entries1).strip()
-        + "\n\n*The canonical version of these notes (with links) is on readthedocs."
-        f"(https://hypothesis.readthedocs.io/en/latest/changes.html#v{anchor})*"
-    )
-
-    # Create a GitHub release, to trigger Zenodo DOI minting.  See
-    # https://developer.github.com/v3/repos/releases/#create-a-release
-    requests.post(
-        "https://api.github.com/repos/HypothesisWorks/hypothesis/releases",
-        json={
-            "tag_name": tag_name(),
-            "name": "Hypothesis for Python - version " + current_version(),
-            "body": changelog_body,
-        },
-        timeout=120,  # seconds
-        auth=("Zac-HD", os.environ"GH_TOKEN"),
-    ).raise_for_status()
-
-
-def current_version():
-    return __version__
-
-
-def latest_version():
-    versions = 
-
-    for t in tools.tags():
-        if t.startswith(PYTHON_TAG_PREFIX):
-            t = tlen(PYTHON_TAG_PREFIX) :
-        else:
-            continue
-        assert t == t.strip()
-        parts = t.split(".")
-        assert len(parts) == 3
-        v = tuple(map(int, parts))
-        versions.append((v, t))
-
-    _, latest = max(versions)
-
-    return latest
-
-
-def tag_name():
-    return PYTHON_TAG_PREFIX + __version__

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/projects/hypothesisruby.py Deleted

@@ -1,162 +0,0 @@
-# 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 os
-import subprocess
-from glob import glob
-
-import hypothesistooling as tools
-import hypothesistooling.installers as install
-import hypothesistooling.projects.conjecturerust as cr
-import hypothesistooling.releasemanagement as rm
-from hypothesistooling.junkdrawer import in_dir, once
-
-PACKAGE_NAME = "hypothesis-ruby"
-
-HYPOTHESIS_RUBY = os.path.join(tools.ROOT, PACKAGE_NAME)
-
-BASE_DIR = HYPOTHESIS_RUBY
-
-TAG_PREFIX = PACKAGE_NAME + "-"
-
-RELEASE_FILE = os.path.join(BASE_DIR, "RELEASE.md")
-CHANGELOG_FILE = os.path.join(BASE_DIR, "CHANGELOG.md")
-GEMSPEC_FILE = os.path.join(BASE_DIR, "hypothesis-specs.gemspec")
-CARGO_FILE = os.path.join(BASE_DIR, "Cargo.toml")
-GEMFILE_LOCK_FILE = os.path.join(BASE_DIR, "Gemfile.lock")
-CONJECTURE_CARGO_FILE = cr.CARGO_FILE
-
-RUST_SRC = cr.SRC
-RUBY_SRC = os.path.join(BASE_DIR, "lib")
-
-
-def has_release():
-    """Is there a version of this package ready to release?"""
-    return os.path.exists(RELEASE_FILE)
-
-
-def parse_release_file():
-    return rm.parse_release_file(RELEASE_FILE)
-
-
-def update_changelog_and_version():
-    """Update the changelog and version based on the current release file."""
-    release_type, release_contents = parse_release_file()
-    version = current_version()
-    version_info = rm.parse_version(version)
-
-    version, version_info = rm.bump_version_info(version_info, release_type)
-
-    rm.replace_assignment(GEMSPEC_FILE, "s.version", repr(version))
-    rm.replace_assignment(GEMSPEC_FILE, "s.date", repr(rm.release_date_string()))
-
-    rm.update_markdown_changelog(
-        CHANGELOG_FILE,
-        name="Hypothesis for Ruby",
-        version=version,
-        entry=release_contents,
-    )
-    os.unlink(RELEASE_FILE)
-
-
-LOCAL_PATH_DEPENDENCY = "{ path = '../conjecture-rust' }"
-
-
-def update_conjecture_dependency(dependency):
-    rm.replace_assignment(CARGO_FILE, "conjecture", dependency)
-
-
-def build_distribution():
-    """Build the rubygem."""
-    current_dependency = rm.extract_assignment(CARGO_FILE, "conjecture")
-
-    assert current_dependency == LOCAL_PATH_DEPENDENCY, (
-        "Cargo file in a bad state. Expected conjecture dependency to be "
-        f"{LOCAL_PATH_DEPENDENCY} but it was instead {current_dependency}"
-    )
-    conjecture_version = cr.current_version()
-
-    # Update to use latest version of conjecture-rust.
-    try:
-        update_conjecture_dependency(repr(conjecture_version))
-        rake_task("gem")
-    finally:
-        update_conjecture_dependency(LOCAL_PATH_DEPENDENCY)
-
-
-def tag_name():
-    """The tag name for the upcoming release."""
-    return TAG_PREFIX + current_version()
-
-
-def has_source_changes():
-    """Returns True if any source files have changed."""
-    return tools.has_changes(RUST_SRC, RUBY_SRC, GEMSPEC_FILE) or cr.has_release()
-
-
-def current_version():
-    """Returns the current version as specified by the gemspec."""
-    ensure_bundler()
-    return (
-        subprocess.check_output(
-            install.BUNDLER_EXECUTABLE, "exec", "ruby", "-e", RUBY_TO_PRINT_VERSION
-        )
-        .decode("ascii")
-        .strip()
-    )
-
-
-def bundle(*args):
-    ensure_bundler()
-    bundle_command(*args)
-
-
-def bundle_command(*args):
-    with in_dir(BASE_DIR):
-        subprocess.check_call(install.BUNDLER_EXECUTABLE, *args)
-
-
-def rake_task(*args):
-    bundle("exec", "rake", *args)
-
-
-@once
-def ensure_bundler():
-    install.ensure_rustup()
-    install.ensure_ruby()
-    bundle_command("install")
-
-
-def cargo(*args):
-    install.ensure_rustup()
-    with in_dir(BASE_DIR):
-        subprocess.check_call(("cargo",) + args)
-
-
-RUBY_TO_PRINT_VERSION = f"""
-require 'rubygems'
-spec = Gem::Specification::load({GEMSPEC_FILE!r})
-puts spec.version
-""".strip().replace(
-    "\n", "; "
-)
-
-
-RUBYGEMS_CREDENTIALS = os.path.expanduser("~/.gem/credentials")
-
-
-def upload_distribution():
-    """Upload the built package to rubygems."""
-    tools.assert_can_release()
-    # Credentials are supplied by the GEM_HOST_API_KEY envvar, which in turn
-    # is set from the repository secrets by GitHub Actions.
-    subprocess.check_call(
-        install.GEM_EXECUTABLE, "push", *glob("hypothesis-specs-*.gem")
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/releasemanagement.py Deleted

@@ -1,179 +0,0 @@
-# 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/.
-
-"""Helpful common code for release management tasks that is shared across
-multiple projects.
-
-Note that most code in here is brittle and specific to our build and
-probably makes all sorts of undocumented assumptions, even as it looks
-like a nice tidy reusable set of functionality.
-"""
-
-import re
-from datetime import datetime
-
-import hypothesistooling as tools
-
-__RELEASE_DATE_STRING = None
-
-
-def release_date_string():
-    """Returns a date string that represents what should be considered "today"
-    for the purposes of releasing, and ensure that we don't change part way
-    through a release."""
-    global __RELEASE_DATE_STRING
-    if __RELEASE_DATE_STRING is None:
-        __RELEASE_DATE_STRING = datetime.utcnow().strftime("%Y-%m-%d")
-    return __RELEASE_DATE_STRING
-
-
-def assignment_matcher(name):
-    """
-    Matches a single line of the form (some space)name = (some value). e.g.
-    "  foo = 1".
-    The whole line up to the assigned value is the first matching group,
-    the rest of the line is the second matching group.
-    i.e. group 1 is the assignment, group 2 is the value. In the above
-    example group 1 would be "  foo = " and group 2 would be "1"
-    """
-    return re.compile(rf"\A(\s*{re.escape(name)}\s*=\s*)(.+)\Z")
-
-
-def extract_assignment_from_string(contents, name):
-    lines = contents.split("\n")
-
-    matcher = assignment_matcher(name)
-
-    for l in lines:
-        match = matcher.match(l)
-        if match is not None:
-            return match2.strip()
-
-    raise ValueError(f"Key {name} not found in {contents}")
-
-
-def extract_assignment(filename, name):
-    with open(filename) as i:
-        return extract_assignment_from_string(i.read(), name)
-
-
-def replace_assignment_in_string(contents, name, value):
-    lines = contents.split("\n")
-
-    matcher = assignment_matcher(name)
-
-    count = 0
-
-    for i, l in enumerate(lines):
-        match = matcher.match(l)
-        if match is not None:
-            count += 1
-            linesi = match1 + value
-
-    if count == 0:
-        raise ValueError(f"Key {name} not found in {contents}")
-    if count > 1:
-        raise ValueError(f"Key {name} found {count} times in {contents}")
-
-    return "\n".join(lines)
-
-
-def replace_assignment(filename, name, value):
-    """Replaces a single assignment of the form key = value in a file with a
-    new value, attempting to preserve the existing format.
-
-    This is fairly fragile - in particular it knows nothing about
-    the file format. The existing value is simply the rest of the line after
-    the last space after the equals.
-    """
-    with open(filename) as i:
-        contents = i.read()
-    result = replace_assignment_in_string(contents, name, value)
-    with open(filename, "w") as o:
-        o.write(result)
-
-
-RELEASE_TYPE = re.compile(r"^RELEASE_TYPE: +(major|minor|patch)")
-
-
-MAJOR = "major"
-MINOR = "minor"
-PATCH = "patch"
-
-
-VALID_RELEASE_TYPES = (MAJOR, MINOR, PATCH)
-
-
-def parse_release_file(filename):
-    with open(filename) as i:
-        return parse_release_file_contents(i.read(), filename)
-
-
-def parse_release_file_contents(release_contents, filename):
-    release_lines = l.rstrip() for l in release_contents.split("\n")
-
-    m = RELEASE_TYPE.match(release_lines0)
-    if m is not None:
-        release_type = m.group(1)
-        if release_type not in VALID_RELEASE_TYPES:
-            raise ValueError(f"Unrecognised release type {release_type!r}")
-        del release_lines0
-        release_contents = "\n".join(release_lines).strip()
-    else:
-        raise ValueError(
-            f"{filename} does not start by specifying release type. The first "
-            "line of the file should be RELEASE_TYPE: followed by one of "
-            "major, minor, or patch, to specify the type of release that "
-            "this is (i.e. which version number to increment). Instead the "
-            f"first line was {release_lines0!r}"
-        )
-
-    return release_type, release_contents
-
-
-def bump_version_info(version_info, release_type):
-    new_version = list(version_info)
-    bump = VALID_RELEASE_TYPES.index(release_type)
-    new_versionbump += 1
-    for i in range(bump + 1, len(new_version)):
-        new_versioni = 0
-    new_version = tuple(new_version)
-    new_version_string = ".".join(map(str, new_version))
-    return new_version_string, new_version
-
-
-def update_markdown_changelog(changelog, name, version, entry):
-    with open(changelog) as i:
-        prev_contents = i.read()
-
-    title = f"# {name} {version} ({release_date_string()})\n\n"
-
-    with open(changelog, "w") as o:
-        o.write(title)
-        o.write(entry.strip())
-        o.write("\n\n")
-        o.write(prev_contents)
-
-
-def parse_version(version):
-    return tuple(map(int, version.split(".")))
-
-
-def commit_pending_release(project):
-    """Create a commit with the new release."""
-    tools.git("rm", project.RELEASE_FILE)
-    tools.git("add", "-u", project.BASE_DIR)
-
-    tools.git(
-        "commit",
-        "-m",
-        f"Bump {project.PACKAGE_NAME} version to {project.current_version()} "
-        + "and update changelog\n\nskip ci",
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/tooling/src/hypothesistooling/scripts.py Deleted

@@ -1,69 +0,0 @@
-# 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 os
-import re
-import shlex
-import subprocess
-import sys
-
-from hypothesistooling import ROOT
-
-
-def print_command(command, args):
-    args = list(args)
-    ranges = 
-    for i, v in enumerate(args):
-        if os.path.exists(v):
-            if not ranges or ranges-1-1 < i - 1:
-                ranges.append(i, i)
-            elif ranges-1-1 + 1 == i:
-                ranges-1-1 += 1
-    for i, j in ranges:
-        if j > i:
-            argsi = "..."
-            for k in range(i + 1, j + 1):
-                argsk = None
-    args = v for v in args if v is not None
-    print(command, *map(shlex.quote, args))
-
-
-def run_script(script, *args, **kwargs):
-    print_command(script, args)
-    return subprocess.check_call(os.path.join(SCRIPTS, script), *args, **kwargs)
-
-
-SCRIPTS = os.path.join(ROOT, "tooling", "scripts")
-COMMON = os.path.join(SCRIPTS, "common.sh")
-
-
-def __calc_script_variables():
-    exports = re.compile(r"export (A-Z_+)(=|$)")
-
-    with open(COMMON) as i:
-        common = i.read()
-
-    for name, _ in exports.findall(common):
-        globals()name = os.environname
-
-
-__calc_script_variables()
-
-
-def tool_path(name):
-    return os.path.join(os.path.dirname(sys.executable), name)
-
-
-def pip_tool(name, *args, **kwargs):
-    print_command(name, args)
-    r = subprocess.call(tool_path(name), *args, **kwargs)
-
-    if r != 0:
-        sys.exit(r)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_ci_config.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_deploy.py Deleted

@@ -1,42 +0,0 @@
-# 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 os
-
-import pytest
-
-import hypothesistooling as tools
-from hypothesistooling import __main__ as main, releasemanagement as rm
-
-
-@pytest.mark.parametrize(
-    "project", p for p in tools.all_projects() if p.has_release()
-)
-def test_release_file_exists_and_is_valid(project, monkeypatch):
-    if not tools.has_uncommitted_changes(project.BASE_DIR):
-        pytest.xfail("Cannot run release process with uncommitted changes")
-
-    monkeypatch.setattr(tools, "create_tag", lambda *args, **kwargs: None)
-    monkeypatch.setattr(tools, "push_tag", lambda name: None)
-    monkeypatch.setattr(rm, "commit_pending_release", lambda p: None)
-    monkeypatch.setattr(project, "upload_distribution", lambda: None)
-    monkeypatch.setattr(project, "IN_TEST", True, raising=False)
-
-    try:
-        main.do_release(project)
-
-        with open(project.CHANGELOG_FILE) as i:
-            changelog = i.read()
-        assert project.current_version() in changelog
-        assert rm.release_date_string() in changelog
-
-    finally:
-        tools.git("checkout", project.BASE_DIR)
-        os.chdir(tools.ROOT)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_documentation.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_mypy.py Deleted

@@ -1,447 +0,0 @@
-# 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 subprocess
-import textwrap
-
-import pytest
-
-from hypothesistooling.projects.hypothesispython import PYTHON_SRC
-from hypothesistooling.scripts import pip_tool, tool_path
-
-
-def test_mypy_passes_on_hypothesis():
-    pip_tool("mypy", PYTHON_SRC)
-
-
-@pytest.mark.skip(
-    reason="Hypothesis type-annotates the public API as a convenience for users, "
-    "but strict checks for our internals would be a net drag on productivity."
-)
-def test_mypy_passes_on_hypothesis_strict():
-    pip_tool("mypy", "--strict", PYTHON_SRC)
-
-
-def get_mypy_output(fname, *extra_args):
-    return subprocess.run(
-        tool_path("mypy"), *extra_args, fname,
-        encoding="utf-8",
-        capture_output=True,
-        text=True,
-    ).stdout
-
-
-def get_mypy_analysed_type(fname, val):
-    out = get_mypy_output(fname).rstrip()
-    msg = "Success: no issues found in 1 source file"
-    if out.endswith(msg):
-        out = out: -len(msg)
-    assert len(out.splitlines()) == 1
-    # See https://mypy.readthedocs.io/en/latest/common_issues.html#reveal-type
-    # The shell output for `reveal_type(1, 2, 3)` looks like a literal:
-    # file.py:2: error: Revealed type is 'builtins.listbuiltins.int*'
-    return (
-        out.split("Revealed type is ")1
-        .strip()
-        .strip('"' + "'")
-        .replace("builtins.", "")
-        .replace("*", "")
-    )
-
-
-def assert_mypy_errors(fname, expected):
-    out = get_mypy_output(fname, "--no-error-summary", "--show-error-codes")
-    # Shell output looks like:
-    # file.py:2: error: Incompatible types in assignment ... assignment
-
-    def convert_lines():
-        for error_line in out.splitlines():
-            col, category = error_line.split(":")1:3
-            if category.strip() != "error":
-                # mypy outputs "note" messages for overload problems, even with
-                # --hide-error-context. Don't include these
-                continue
-
-            # Intentional print so we can check mypy's output if a test fails
-            print(error_line)
-            error_code = error_line.split("")-1.rstrip("")
-            yield (int(col), error_code)
-
-    assert sorted(convert_lines()) == sorted(expected)
-
-
-@pytest.mark.parametrize(
-    "val,expect",
-    
-        ("integers()", "int"),
-        ("text()", "str"),
-        ("integers().map(str)", "str"),
-        ("booleans().filter(bool)", "bool"),
-        ("lists(none())", "listNone"),
-        ("dictionaries(integers(), datetimes())", "dictint, datetime.datetime"),
-        ("data()", "hypothesis.strategies._internal.core.DataObject"),
-        ("none() | integers()", "UnionNone, int"),
-        # Ex`-1 stands for recursion in the whole type, i.e. Ex`0 == Union...
-        ("recursive(integers(), lists)", "UnionlistEx`-1, int"),
-        # We have overloads for up to five types, then fall back to Any.
-        # (why five?  JSON atoms are None|bool|int|float|str and we do that a lot)
-        ("one_of(integers(), text())", "Unionint, str"),
-        (
-            "one_of(integers(), text(), none(), binary(), builds(list))",
-            "Unionint, str, None, bytes, list_T`1",
-        ),
-        (
-            "one_of(integers(), text(), none(), binary(), builds(list), builds(dict))",
-            "Any",
-        ),
-        ("tuples()", "Tuple"),  # Should be `Tuple()`, but this is what mypy prints
-        ("tuples(integers())", "Tupleint"),
-        ("tuples(integers(), text())", "Tupleint, str"),
-        (
-            "tuples(integers(), text(), integers(), text(), integers())",
-            "Tupleint, str, int, str, int",
-        ),
-        (
-            "tuples(text(), text(), text(), text(), text(), text())",
-            "tupleAny, ...",
-        ),
-    ,
-)
-def test_revealed_types(tmpdir, val, expect):
-    """Check that Mypy picks up the expected `X` in SearchStrategy`X`."""
-    f = tmpdir.join(expect + ".py")
-    f.write(
-        "from hypothesis.strategies import *\n"
-        f"s = {val}\n"
-        "reveal_type(s)\n"  # fmt: skip
-    )
-    typ = get_mypy_analysed_type(str(f.realpath()), val)
-    assert typ == f"hypothesis.strategies._internal.strategies.SearchStrategy{expect}"
-
-
-def test_data_object_type_tracing(tmpdir):
-    f = tmpdir.join("check_mypy_on_st_data.py")
-    f.write(
-        "from hypothesis.strategies import data, integers\n"
-        "d = data().example()\n"
-        "s = d.draw(integers())\n"
-        "reveal_type(s)\n"
-    )
-    got = get_mypy_analysed_type(str(f.realpath()), "data().draw(integers())")
-    assert got == "int"
-
-
-def test_drawfn_type_tracing(tmpdir):
-    f = tmpdir.join("check_mypy_on_st_drawfn.py")
-    f.write(
-        "from hypothesis.strategies import DrawFn, text\n"
-        "def comp(draw: DrawFn) -> str:\n"
-        "    s = draw(text(), 123)\n"
-        "    reveal_type(s)\n"
-        "    return s\n"
-    )
-    got = get_mypy_analysed_type(str(f.realpath()), ...)
-    assert got == "str"
-
-
-def test_settings_preserves_type(tmpdir):
-    f = tmpdir.join("check_mypy_on_settings.py")
-    f.write(
-        "from hypothesis import settings\n"
-        "@settings(max_examples=10)\n"
-        "def f(x: int) -> int:\n"
-        "    return x\n"
-        "reveal_type(f)\n"
-    )
-    got = get_mypy_analysed_type(str(f.realpath()), ...)
-    assert got == "def (x: int) -> int"
-
-
-def test_stateful_bundle_generic_type(tmpdir):
-    f = tmpdir.join("check_mypy_on_stateful_bundle.py")
-    f.write(
-        "from hypothesis.stateful import Bundle\n"
-        "b: Bundleint = Bundle('test')\n"
-        "reveal_type(b.example())\n"
-    )
-    got = get_mypy_analysed_type(str(f.realpath()), ...)
-    assert got == "int"
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-@pytest.mark.parametrize(
-    "target_args",
-    
-        "target=b1",
-        "targets=(b1,)",
-        "targets=(b1, b2)",
-    ,
-)
-@pytest.mark.parametrize("returns", "int", "MultipleResultsint")
-def test_stateful_rule_targets(tmpdir, decorator, target_args, returns):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "b1: Bundleint = Bundle('b1')\n"
-        "b2: Bundleint = Bundle('b2')\n"
-        f"@{decorator}({target_args})\n"
-        f"def my_rule() -> {returns}:\n"
-        "    ...\n"
-    )
-    assert_mypy_errors(str(f.realpath()), )
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-def test_stateful_rule_no_targets(tmpdir, decorator):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        f"@{decorator}()\n"
-        "def my_rule() -> None:\n"
-        "    ...\n"
-    )
-    assert_mypy_errors(str(f.realpath()), )
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-def test_stateful_target_params_mutually_exclusive(tmpdir, decorator):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "b1: Bundleint = Bundle('b1')\n"
-        f"@{decorator}(target=b1, targets=(b1,))\n"
-        "def my_rule() -> int:\n"
-        "    ...\n"
-    )
-    # Also outputs "misc" error "Untyped decorator makes function "my_rule"
-    # untyped, due to the inability to resolve to an appropriate overloaded
-    # variant
-    assert_mypy_errors(str(f.realpath()), (3, "call-overload"), (3, "misc"))
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-@pytest.mark.parametrize(
-    "target_args",
-    
-        "target=b1",
-        "targets=(b1,)",
-        "targets=(b1, b2)",
-        "",
-    ,
-)
-@pytest.mark.parametrize("returns", "int", "MultipleResultsint")
-def test_stateful_target_params_return_type(tmpdir, decorator, target_args, returns):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "b1: Bundlestr = Bundle('b1')\n"
-        "b2: Bundlestr = Bundle('b2')\n"
-        f"@{decorator}({target_args})\n"
-        f"def my_rule() -> {returns}:\n"
-        "    ...\n"
-    )
-    assert_mypy_errors(str(f.realpath()), (4, "arg-type"))
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-def test_stateful_no_target_params_return_type(tmpdir, decorator):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        f"@{decorator}()\n"
-        "def my_rule() -> int:\n"
-        "    ...\n"
-    )
-    assert_mypy_errors(str(f.realpath()), (2, "arg-type"))
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-@pytest.mark.parametrize("use_multi", True, False)
-def test_stateful_bundle_variance(tmpdir, decorator, use_multi):
-    f = tmpdir.join("check_mypy_on_stateful_bundle.py")
-    if use_multi:
-        return_type = "MultipleResultsDog"
-        return_expr = "multiple(dog, dog)"
-    else:
-        return_type = "Dog"
-        return_expr = "dog"
-
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "class Animal: pass\n"
-        "class Dog(Animal): pass\n"
-        "a: BundleAnimal = Bundle('animal')\n"
-        "d: BundleDog = Bundle('dog')\n"
-        f"@{decorator}(target=a, dog=d)\n"
-        f"def my_rule(dog: Dog) -> {return_type}:\n"
-        f"    return {return_expr}\n"
-    )
-    assert_mypy_errors(str(f.realpath()), )
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-def test_stateful_multiple_return(tmpdir, decorator):
-    f = tmpdir.join("check_mypy_on_stateful_multiple.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "b: Bundleint = Bundle('b')\n"
-        f"@{decorator}(target=b)\n"
-        "def my_rule() -> MultipleResultsint:\n"
-        "    return multiple(1, 2, 3)\n"
-    )
-    assert_mypy_errors(str(f.realpath()), )
-
-
-@pytest.mark.parametrize("decorator", "rule", "initialize")
-def test_stateful_multiple_return_invalid(tmpdir, decorator):
-    f = tmpdir.join("check_mypy_on_stateful_multiple.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "b: Bundlestr = Bundle('b')\n"
-        f"@{decorator}(target=b)\n"
-        "def my_rule() -> MultipleResultsint:\n"
-        "    return multiple(1, 2, 3)\n"
-    )
-    assert_mypy_errors(str(f.realpath()), (3, "arg-type"))
-
-
-@pytest.mark.parametrize(
-    "wrapper,expected",
-    
-        ("{}", "int"),
-        ("st.lists({})", "listint"),
-    ,
-)
-def test_stateful_consumes_type_tracing(tmpdir, wrapper, expected):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    wrapped = wrapper.format("consumes(b)")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "from hypothesis import strategies as st\n"
-        "b: Bundleint = Bundle('b')\n"
-        f"s = {wrapped}\n"
-        "reveal_type(s.example())\n"
-    )
-    got = get_mypy_analysed_type(str(f.realpath()), ...)
-    assert got == expected
-
-
-def test_stateful_consumed_bundle_cannot_be_target(tmpdir):
-    f = tmpdir.join("check_mypy_on_stateful_rule.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "b: Bundleint = Bundle('b')\n"
-        "rule(target=consumes(b))\n"
-    )
-    assert_mypy_errors(str(f.realpath()), (3, "call-overload"))
-
-
-def test_raises_for_mixed_pos_kwargs_in_given(tmpdir):
-    f = tmpdir.join("raises_for_mixed_pos_kwargs_in_given.py")
-    f.write(
-        textwrap.dedent(
-            """
-            from hypothesis import given
-            from hypothesis.strategies import text
-
-            @given(text(), x=text())
-            def test_bar(x):
-                ...
-            """
-        )
-    )
-    assert_mypy_errors(str(f.realpath()), (5, "call-overload"))
-
-
-@pytest.mark.parametrize(
-    "return_val,errors",
-    
-        ("True", ),
-        ("0", (2, "arg-type"), (2, "return-value")),
-    ,
-)
-def test_stateful_precondition_requires_predicate(tmpdir, return_val, errors):
-    f = tmpdir.join("check_mypy_on_stateful_precondition.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        f"@precondition(lambda self: {return_val})\n"
-        "def my_rule() -> None: ...\n"
-    )
-    assert_mypy_errors(str(f.realpath()), errors)
-
-
-def test_stateful_precondition_lambda(tmpdir):
-    f = tmpdir.join("check_mypy_on_stateful_precondition.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "class MyMachine(RuleBasedStateMachine):\n"
-        "  valid: bool\n"
-        "  @precondition(lambda self: self.valid)\n"
-        "  @rule()\n"
-        "  def my_rule(self) -> None: ...\n"
-    )
-    # Note that this doesn't fully check the code because of the `Any` parameter
-    # type. `lambda self: self.invalid` would unfortunately pass too
-    assert_mypy_errors(str(f.realpath()), )
-
-
-def test_stateful_precondition_instance_method(tmpdir):
-    f = tmpdir.join("check_mypy_on_stateful_precondition.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "class MyMachine(RuleBasedStateMachine):\n"
-        "  valid: bool\n"
-        "  def check(self) -> bool:\n"
-        "    return self.valid\n"
-        "  @precondition(check)\n"
-        "  @rule()\n"
-        "  def my_rule(self) -> None: ...\n"
-    )
-    assert_mypy_errors(str(f.realpath()), )
-
-
-def test_stateful_precondition_precond_requires_one_arg(tmpdir):
-    f = tmpdir.join("check_mypy_on_stateful_precondition.py")
-    f.write(
-        "from hypothesis.stateful import *\n"
-        "precondition(lambda: True)\n"
-        "precondition(lambda a, b: True)\n"
-    )
-    # Additional "Cannot infer type of lambda" errors
-    assert_mypy_errors(
-        str(f.realpath()),
-        (2, "arg-type"), (2, "misc"), (3, "arg-type"), (3, "misc"),
-    )
-
-
-def test_pos_only_args(tmpdir):
-    f = tmpdir.join("check_mypy_on_pos_arg_only_strats.py")
-    f.write(
-        textwrap.dedent(
-            """
-            import hypothesis.strategies as st
-
-            st.tuples(a1=st.integers())
-            st.tuples(a1=st.integers(), a2=st.integers())
-            
-            st.one_of(a1=st.integers())
-            st.one_of(a1=st.integers(), a2=st.integers())
-            """
-        )
-    )
-    assert_mypy_errors(
-        str(f.realpath()),
-        
-            (4, "call-overload"),
-            (5, "call-overload"),
-            (7, "call-overload"),
-            (8, "call-overload"),
-        ,
-    )

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_pyright.py Deleted

@@ -1,178 +0,0 @@
-# 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/.
-
-from __future__ import annotations
-
-import json
-import subprocess
-import textwrap
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-from hypothesistooling.projects.hypothesispython import HYPOTHESIS_PYTHON, PYTHON_SRC
-from hypothesistooling.scripts import pip_tool, tool_path
-
-
-@pytest.mark.skip(
-    reason="Hypothesis type-annotates the public API as a convenience for users, "
-    "but strict checks for our internals would be a net drag on productivity."
-)
-def test_pyright_passes_on_hypothesis():
-    pip_tool("pyright", "--project", HYPOTHESIS_PYTHON)
-
-
-def test_pyright_passes_on_basic_test(tmp_path: Path):
-    file = tmp_path / "test.py"
-    file.write_text(
-        textwrap.dedent(
-            """
-            import hypothesis
-            import hypothesis.strategies as st
-
-            @hypothesis.given(x=st.text())
-            def test_foo(x: str):
-                assert x == x
-
-            from hypothesis import given
-            from hypothesis.strategies import text
-
-            @given(x=text())
-            def test_bar(x: str):
-                assert x == x
-            """
-        )
-    )
-    _write_config(tmp_path, {"typeCheckingMode": "strict"})
-    assert _get_pyright_errors(file) == 
-
-
-def test_pyright_issue_3296(tmp_path: Path):
-    file = tmp_path / "test.py"
-    file.write_text(
-        textwrap.dedent(
-            """
-            from hypothesis.strategies import lists, integers
-
-            lists(integers()).map(sorted)
-            """
-        )
-    )
-    _write_config(tmp_path, {"typeCheckingMode": "strict"})
-    assert _get_pyright_errors(file) == 
-
-
-def test_pyright_raises_for_mixed_pos_kwargs_in_given(tmp_path: Path):
-    file = tmp_path / "test.py"
-    file.write_text(
-        textwrap.dedent(
-            """
-            from hypothesis import given
-            from hypothesis.strategies import text
-
-            @given(text(), x=text())
-            def test_bar(x: str):
-                pass
-            """
-        )
-    )
-    _write_config(tmp_path, {"typeCheckingMode": "strict"})
-    assert any(
-        e"message".startswith('No overloads for "given" match the provided arguments')
-        for e in _get_pyright_errors(file)
-    )
-
-
-def test_pyright_issue_3348(tmp_path: Path):
-    file = tmp_path / "test.py"
-    file.write_text(
-        textwrap.dedent(
-            """
-            import hypothesis.strategies as st
-
-            st.tuples(st.integers(), st.integers())
-            st.one_of(st.integers(), st.integers())
-            st.one_of(st.integers(), st.floats())  # sequence of strats should be OK
-            st.sampled_from(1, 2)
-            """
-        )
-    )
-    _write_config(tmp_path, {"typeCheckingMode": "strict"})
-    assert _get_pyright_errors(file) == 
-
-
-def test_pyright_tuples_pos_args_only(tmp_path: Path):
-    file = tmp_path / "test.py"
-    file.write_text(
-        textwrap.dedent(
-            """
-            import hypothesis.strategies as st
-
-            st.tuples(a1=st.integers())
-            st.tuples(a1=st.integers(), a2=st.integers())
-            """
-        )
-    )
-    _write_config(tmp_path, {"typeCheckingMode": "strict"})
-    assert any(
-        e"message".startswith(
-            'No overloads for "tuples" match the provided arguments'
-        )
-        for e in _get_pyright_errors(file)
-    )
-
-
-def test_pyright_one_of_pos_args_only(tmp_path: Path):
-    file = tmp_path / "test.py"
-    file.write_text(
-        textwrap.dedent(
-            """
-            import hypothesis.strategies as st
-
-            st.one_of(a1=st.integers())
-            st.one_of(a1=st.integers(), a2=st.integers())
-            """
-        )
-    )
-    _write_config(tmp_path, {"typeCheckingMode": "strict"})
-    assert any(
-        e"message".startswith(
-            'No overloads for "one_of" match the provided arguments'
-        )
-        for e in _get_pyright_errors(file)
-    )
-
-
-# ---------- Helpers for running pyright ---------- #
-
-
-def _get_pyright_output(file: Path) -> dictstr, Any:
-    proc = subprocess.run(
-        tool_path("pyright"), "--outputjson",
-        cwd=file.parent,
-        encoding="utf-8",
-        text=True,
-        capture_output=True,
-    )
-    try:
-        return json.loads(proc.stdout)
-    except Exception:
-        print(proc.stdout)
-        raise
-
-
-def _get_pyright_errors(file: Path) -> listdictstr, Any:
-    return _get_pyright_output(file)"generalDiagnostics"
-
-
-def _write_config(config_dir: Path, data: dictstr, Any | None = None):
-    config = {"extraPaths": PYTHON_SRC, **(data or {})}
-    (config_dir / "pyrightconfig.json").write_text(json.dumps(config))

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_release_files.py Deleted

@@ -1,36 +0,0 @@
-# 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 pytest
-
-import hypothesistooling as tools
-from hypothesistooling import releasemanagement as rm
-from hypothesistooling.projects import hypothesispython as hp
-
-
-@pytest.mark.parametrize("project", tools.all_projects())
-def test_release_file_exists_and_is_valid(project):
-    if project.has_source_changes():
-        assert project.has_release(), (
-            "There are source changes but no RELEASE.rst. Please create "
-            "one to describe your changes."
-        )
-        rm.parse_release_file(project.RELEASE_FILE)
-
-
-@pytest.mark.skipif(not hp.has_release(), reason="Checking that release")
-def test_release_file_has_no_merge_conflicts():
-    _, message = rm.parse_release_file(hp.RELEASE_FILE)
-    assert "<<<" not in message, "Merge conflict in RELEASE.rst"
-    _, *recent_changes, _ = hp.CHANGELOG_ANCHOR.split(hp.changelog(), maxsplit=12)
-    for entry in recent_changes:
-        _, version, old_msg = (x.strip() for x in hp.CHANGELOG_BORDER.split(entry))
-        assert message not in old_msg, f"Release notes already published for {version}"
-        assert old_msg not in message, f"Copied {version} release notes - merge error?"

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_release_management.py Deleted

@@ -1,94 +0,0 @@
-# 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 pytest
-
-from hypothesistooling.releasemanagement import (
-    bump_version_info,
-    parse_release_file_contents,
-    release_date_string,
-    replace_assignment_in_string as replace,
-    update_markdown_changelog,
-)
-
-
-def parse_release(contents):
-    return parse_release_file_contents(contents, "<string>")
-
-
-def test_update_single_line():
-    assert replace("a = 1", "a", "2") == "a = 2"
-
-
-def test_update_without_spaces():
-    assert replace("a=1", "a", "2") == "a=2"
-
-
-def test_update_in_middle():
-    assert replace("a = 1\nb=2\nc = 3", "b", "4") == "a = 1\nb=4\nc = 3"
-
-
-def test_quotes_string_to_assign():
-    assert replace("a.c = 1", "a.c", "2") == "a.c = 2"
-    with pytest.raises(ValueError):
-        replace("abc = 1", "a.c", "2")
-
-
-def test_duplicates_are_errors():
-    with pytest.raises(ValueError):
-        replace("a = 1\na=1", "a", "2")
-
-
-def test_missing_is_error():
-    with pytest.raises(ValueError):
-        replace("", "a", "1")
-
-
-def test_bump_minor_version():
-    assert bump_version_info((1, 1, 1), "minor")0 == "1.2.0"
-
-
-def test_parse_release_file():
-    assert parse_release("RELEASE_TYPE: patch\nhi") == ("patch", "hi")
-    assert parse_release("RELEASE_TYPE: minor\n\n\n\nhi") == ("minor", "hi")
-    assert parse_release("RELEASE_TYPE: major\n \n\nhi") == ("major", "hi")
-
-
-def test_invalid_release():
-    with pytest.raises(ValueError):
-        parse_release("RELEASE_TYPE: wrong\nstuff")
-
-    with pytest.raises(ValueError):
-        parse_release("")
-
-
-TEST_CHANGELOG = f"""
-# A test project 1.2.3 ({release_date_string()})
-
-some stuff happened
-
-# some previous log entry
-"""
-
-
-def test_update_changelog(tmpdir):
-    path = tmpdir.join("CHANGELOG.md")
-    path.write("# some previous log entry\n")
-    update_markdown_changelog(
-        str(path), "A test project", "1.2.3", "some stuff happened"
-    )
-    assert path.read().strip() == TEST_CHANGELOG.strip()
-
-
-def test_changelog_parsing_strips_trailing_whitespace():
-    header = "RELEASE_TYPE: patch\n\n"
-    contents = "Adds a feature\n    indented.\n"
-    level, out = parse_release(header + contents.replace("feature", "feature    "))
-    assert contents.strip() == out

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_requirements.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_rst_is_valid.py Deleted

@@ -1,35 +0,0 @@
-# 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 os
-
-import hypothesistooling as tools
-from hypothesistooling.projects import hypothesispython as hp
-from hypothesistooling.scripts import pip_tool
-
-
-def is_sphinx(f):
-    f = os.path.abspath(f)
-    return f.startswith(os.path.join(hp.HYPOTHESIS_PYTHON, "docs"))
-
-
-ALL_RST = 
-    f
-    for f in tools.all_files()
-    if os.path.basename(f) != "RELEASE.rst" and f.endswith(".rst")
-
-
-
-def test_passes_rst_lint():
-    pip_tool("rst-lint", *(f for f in ALL_RST if not is_sphinx(f)))
-
-
-def test_passes_flake8():
-    pip_tool("flake8", "--select=W191,W291,W292,W293,W391", *ALL_RST)

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_shellcheck.py Deleted

_service:tar_scm:hypothesis-python-6.47.0.tar.gz/whole-repo-tests/test_validate_branch_check.py Deleted

@@ -1,93 +0,0 @@
-# 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 os
-import subprocess
-import sys
-
-from hypothesistooling.projects.hypothesispython import BASE_DIR
-
-BRANCH_CHECK = "branch-check"
-VALIDATE_BRANCH_CHECK = os.path.join(BASE_DIR, "scripts", "validate_branch_check.py")
-
-
-def write_entries(tmp_path, entries):
-    with open(tmp_path / BRANCH_CHECK, "w") as f:
-        f.writelines(json.dumps(entry) + "\n" for entry in entries)
-
-
-def run_validate_branch_check(tmp_path, *, check, **kwargs):
-    return subprocess.run(
-        sys.executable, VALIDATE_BRANCH_CHECK,
-        cwd=tmp_path,
-        text=True,
-        capture_output=True,
-        check=check,
-        **kwargs,
-    )
-
-
-def test_validates_branches(tmp_path):
-    write_entries(
-        tmp_path,
-        
-            {"name": name, "value": value}
-            for name in ("first", "second", "third")
-            for value in (False, True)
-        ,
-    )
-
-    output = run_validate_branch_check(tmp_path, check=True)
-    assert output.stdout == "Successfully validated 3 branches.\n"
-
-
-def test_validates_one_branch(tmp_path):
-    write_entries(
-        tmp_path, {"name": "sole", "value": value} for value in (False, True)
-    )
-
-    output = run_validate_branch_check(tmp_path, check=True)
-    assert output.stdout == "Successfully validated 1 branch.\n"
-
-
-def test_fails_on_zero_branches(tmp_path):
-    write_entries(tmp_path, )
-
-    output = run_validate_branch_check(tmp_path, check=False)
-    assert output.returncode == 1
-    assert output.stdout == "No branches found in the branch-check file?\n"
-
-
-def test_reports_uncovered_branches(tmp_path):
-    write_entries(
-        tmp_path,
-        
-            {"name": "branch that is always taken", "value": True},
-            {"name": "some other branch that is never taken", "value": False},
-            {"name": "covered branch", "value": True},
-            {"name": "covered branch", "value": False},
-        ,
-    )
-
-    output = run_validate_branch_check(tmp_path, check=False)
-    assert output.returncode == 1
-    assert output.stdout == "\n".join(
-        
-            "Some branches were not properly covered.",
-            "",
-            "The following were always True:",
-            "  * branch that is always taken",
-            "",
-            "The following were always False:",
-            "  * some other branch that is never taken",
-            "",
-        
-    )