{"action":"closed","number":392,"pull_request":{"url":"https://api.github.com/repos/kragniz/python-etcd3/pulls/392","id":178706998,"html_url":"https://github.com/kragniz/python-etcd3/pull/392","diff_url":"https://github.com/kragniz/python-etcd3/pull/392.diff","patch_url":"https://github.com/kragniz/python-etcd3/pull/392.patch","issue_url":"https://api.github.com/repos/kragniz/python-etcd3/issues/392","number":392,"state":"closed","locked":false,"title":"Update hypothesis to 3.52.3","user":{"login":"pyup-bot","id":16239342,"avatar_url":"https://avatars0.githubusercontent.com/u/16239342?v=4","gravatar_id":"","url":"https://api.github.com/users/pyup-bot","html_url":"https://github.com/pyup-bot","followers_url":"https://api.github.com/users/pyup-bot/followers","following_url":"https://api.github.com/users/pyup-bot/following{/other_user}","gists_url":"https://api.github.com/users/pyup-bot/gists{/gist_id}","starred_url":"https://api.github.com/users/pyup-bot/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/pyup-bot/subscriptions","organizations_url":"https://api.github.com/users/pyup-bot/orgs","repos_url":"https://api.github.com/users/pyup-bot/repos","events_url":"https://api.github.com/users/pyup-bot/events{/privacy}","received_events_url":"https://api.github.com/users/pyup-bot/received_events","type":"User","site_admin":false},"body":"\nThis PR updates [hypothesis](https://pypi.python.org/pypi/hypothesis) from **3.11.6** to **3.52.3**.\n\n\n\n<details>\n  <summary>Changelog</summary>\n  \n  \n   ### 3.52.3\n   ```\n   -------------------\n\nThis patch fixes the `~hypothesis.settings.min_satisfying_examples` settings\ndocumentation, by explaining that example shrinking is tracked at the level\nof the underlying bytestream rather than the output value.\n\nThe output from :func:`~hypothesis.find` in verbose mode has also been\nadjusted - see :ref:`the example session &lt;verbose-output&gt;` - to avoid\nduplicating lines when the example repr is constant, even if the underlying\nrepresentation has been shrunken.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.52.2\n   ```\n   -------------------\n\nThis release improves the output of failures with\n:ref:`rule based stateful testing &lt;rulebasedstateful&gt;` in two ways:\n\n* The output from it is now usually valid Python code.\n* When the same value has two different names because it belongs to two different\n  bundles, it will now display with the name associated with the correct bundle\n  for a rule argument where it is used.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.52.1\n   ```\n   -------------------\n\nThis release improves the behaviour of  :doc:`stateful testing &lt;stateful&gt;`\nin two ways:\n\n* Previously some runs would run no steps (:issue:`376`). This should no longer\n  happen.\n* RuleBasedStateMachine tests which used bundles extensively would often shrink\n  terribly. This should now be significantly improved, though there is likely\n  a lot more room for improvement.\n\nThis release also involves a low level change to how ranges of integers are\nhandles which may result in other improvements to shrink quality in some cases.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.52.0\n   ```\n   -------------------\n\nThis release deprecates use of :func:`settings(...) &lt;hypothesis.settings&gt;`\nas a decorator, on functions or methods that are not also decorated with\n:func:`given &lt;hypothesis.given&gt;`.  You can still apply these decorators\nin any order, though you should only do so once each.\n\nApplying :func:`given &lt;hypothesis.given&gt;` twice was already deprecated, and\napplying :func:`settings(...) &lt;hypothesis.settings&gt;` twice is deprecated in\nthis release and will become an error in a future version. Neither could ever\nbe used twice to good effect.)\n\nUsing :func:`settings(...) &lt;hypothesis.settings&gt;` as the sole decorator on\na test is completely pointless, so this common usage error will become an\nerror in a future version of Hypothesis.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.51.0\n   ```\n   -------------------\n\nThis release deprecates the ``average_size`` argument to\n:func:`~hypothesis.strategies.lists` and other collection strategies.\nYou should simply delete it wherever it was used in your tests, as it\nno longer has any effect.\n\nIn early versions of Hypothesis, the ``average_size`` argument was treated\nas a hint about the distribution of examples from a strategy.  Subsequent\nimprovements to the conceptual model and the engine for generating and\nshrinking examples mean it is more effective to simply describe what\nconstitutes a valid example, and let our internals handle the distribution.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.50.3\n   ```\n   -------------------\n\nThis patch contains some internal refactoring so that we can run\nwith warnings as errors in CI.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.50.2\n   ```\n   -------------------\n\nThis has no user-visible changes except one slight formatting change to one docstring, to avoid a deprecation warning.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.50.1\n   ```\n   -------------------\n\nThis patch fixes an internal error introduced in 3.48.0, where a check\nfor the Django test runner would expose import-time errors in Django\nconfiguration (:issue:`1167`).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.50.0\n   ```\n   -------------------\n\nThis release improves validation of numeric bounds for some strategies.\n\n- :func:`~hypothesis.strategies.integers` and :func:`~hypothesis.strategies.floats`\n  now raise ``InvalidArgument`` if passed a ``min_value`` or ``max_value``\n  which is not an instance of :class:`~python:numbers.Real`, instead of\n  various internal errors.\n- :func:`~hypothesis.strategies.floats` now converts its bounding values to\n  the nearest float above or below the min or max bound respectively, instead\n  of just casting to float.  The old behaviour was incorrect in that you could\n  generate ``float(min_value)``, even when this was less than ``min_value``\n  itself (possible with eg. fractions).\n- When both bounds are provided to :func:`~hypothesis.strategies.floats` but\n  there are no floats in the interval, such as ``[(2**54)+1 .. (2**55)-1]``,\n  InvalidArgument is raised.\n- :func:`~hypothesis.strategies.decimals` gives a more useful error message\n  if passed a string that cannot be converted to :class:`~python:decimal.Decimal`\n  in a context where this error is not trapped.\n\nCode that previously **seemed** to work may be explicitly broken if there\nwere no floats between ``min_value`` and ``max_value`` (only possible with\nnon-float bounds), or if a bound was not a :class:`~python:numbers.Real`\nnumber but still allowed in :obj:`python:math.isnan` (some custom classes\nwith a ``__float__`` method).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.49.1\n   ```\n   -------------------\n\nThis patch fixes our tests for Numpy dtype strategies on big-endian platforms,\nwhere the strategy behaved correctly but the test assumed that the native byte\norder was little-endian.\n\nThere is no user impact unless you are running our test suite on big-endian\nplatforms.  Thanks to Graham Inggs for reporting :issue:`1164`.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.49.0\n   ```\n   -------------------\n\nThis release deprecates passing ``elements=None`` to collection strategies,\nsuch as :func:`~hypothesis.strategies.lists`.\n\nRequiring ``lists(nothing())`` or ``builds(list)`` instead of ``lists()``\nmeans slightly more typing, but also improves the consistency and\ndiscoverability of our API - as well as showing how to compose or\nconstruct strategies in ways that still work in more complex situations.\n\nPassing a nonzero max_size to a collection strategy where the elements\nstrategy contains no values is now deprecated, and will be an error in a\nfuture version.  The equivalent with ``elements=None`` is already an error.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.48.1\n   ```\n   -------------------\n\nThis patch will minimize examples that would come out non-minimal in previous versions. Thanks to Kyle Reeve for this patch.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.48.0\n   ```\n   -------------------\n\nThis release improves some &quot;unhappy paths&quot; when using Hypothesis\nwith the standard library :mod:`python:unittest` module:\n\n- Applying :func:`given &lt;hypothesis.given&gt;` to a non-test method which is\n  overridden from :class:`python:unittest.TestCase`, such as ``setUp``,\n  raises :attr:`a new health check &lt;hypothesis.settings.not_a_test_method&gt;`.\n  (:issue:`991`)\n- Using :meth:`~python:unittest.TestCase.subTest` within a test decorated\n  with :func:`given &lt;hypothesis.given&gt;` would leak intermediate results\n  when tests were run under the :mod:`python:unittest` test runner.\n  Individual reporting of failing subtests is now disabled during a test\n  using :func:`given &lt;hypothesis.given&gt;`.  (:issue:`1071`)\n- :func:`given &lt;hypothesis.given&gt;` is still not a class decorator, but the\n  error message if you try using it on a class has been improved.\n\nAs a related improvement, using :class:`django:django.test.TestCase` with\n:func:`given &lt;hypothesis.given&gt;` instead of\n:class:`hypothesis.extra.django.TestCase` raises an explicit error instead\nof running all examples in a single database transaction.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.47.0\n   ```\n   -------------------\n\n:obj:`~hypothesis.settings.register_profile` now accepts keyword arguments\nfor specific settings, and the parent settings object is now optional.\nUsing a ``name`` for a registered profile which is not a string was never\nsuggested, but it is now also deprecated and will eventually be an error.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.46.2\n   ```\n   -------------------\n\nThis release removes an unnecessary branch from the code, and has no user-visible impact.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.46.1\n   ```\n   -------------------\n\nThis changes only the formatting of our docstrings and should have no user-visible effects.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.46.0\n   ```\n   -------------------\n\n:func:`~hypothesis.strategies.characters` has improved docs about\nwhat arguments are valid, and additional validation logic to raise a\nclear error early (instead of e.g. silently ignoring a bad argument).\nCategories may be specified as the Unicode &#39;general category&#39;\n(eg ``u&#39;Nd&#39;``), or as the &#39;major category&#39; (eg ``[u&#39;N&#39;, u&#39;Lu&#39;]``\nis equivalent to ``[u&#39;Nd&#39;, u&#39;Nl&#39;, u&#39;No&#39;, u&#39;Lu&#39;]``).\n\nIn previous versions, general categories were supported and all other\ninput was silently ignored.  Now, major categories are supported in\naddition to general categories (which may change the behaviour of some\nexisting code), and all other input is deprecated.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.45.5\n   ```\n   -------------------\n\nThis patch improves strategy inference in :mod:`hypothesis.extra.django`\nto account for some validators in addition to field type - see\n:issue:`1116` for ongoing work in this space.\n\nSpecifically, if a :class:`~django:django.db.models.CharField` or\n:class:`~django:django.db.models.TextField` has an attached\n:class:`~django:django.core.validators.RegexValidator`, we now use\n:func:`~hypothesis.strategies.from_regex` instead of\n:func:`~hypothesis.strategies.text` as the underlying strategy.\nThis allows us to generate examples of the default\n:class:`~django:django.contrib.auth.models.User` model, closing :issue:`1112`.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.45.4\n   ```\n   -------------------\n\nThis patch improves some internal debugging information, fixes\na typo in a validation error message, and expands the documentation\nfor new contributors.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.45.3\n   ```\n   -------------------\n\nThis patch may improve example shrinking slightly for some strategies.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.45.2\n   ```\n   -------------------\n\nThis release makes our docstring style more consistent, thanks to\n:pypi:`flake8-docstrings`.  There are no user-visible changes.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.45.1\n   ```\n   -------------------\n\nThis fixes an indentation issue in docstrings for\n:func:`~hypothesis.strategies.datetimes`, :func:`~hypothesis.strategies.dates`,\n:func:`~hypothesis.strategies.times`, and\n:func:`~hypothesis.strategies.timedeltas`.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.45.0\n   ```\n   -------------------\n\nThis release fixes :func:`~hypothesis.strategies.builds` so that ``target``\ncan be used as a keyword argument for passing values to the target. The target\nitself can still be specified as a keyword argument, but that behavior is now\ndeprecated. The target should be provided as the first positional argument.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.26\n   ```\n   --------------------\n\nThis release fixes some formatting issues in the Hypothesis source code.\nIt should have no externally visible effects.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.25\n   ```\n   --------------------\n\nThis release changes the way in which Hypothesis tries to shrink the size of\nexamples. It probably won&#39;t have much impact, but might make shrinking faster\nin some cases. It is unlikely but not impossible that it will change the\nresulting examples.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.24\n   ```\n   --------------------\n\nThis release fixes dependency information when installing Hypothesis\nfrom a binary &quot;wheel&quot; distribution.\n\n- The ``install_requires`` for :pypi:`enum34` is resolved at install\n  time, rather than at build time (with potentially different results).\n- Django has fixed their ``python_requires`` for versions 2.0.0 onward,\n  simplifying Python2-compatible constraints for downstream projects.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.23\n   ```\n   --------------------\n\nThis release improves shrinking in a class of pathological examples that you\nare probably never hitting in practice. If you *are* hitting them in practice\nthis should be a significant speed up in shrinking. If you are not, you are\nvery unlikely to notice any difference. You might see a slight slow down and/or\nslightly better falsifying examples.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.22\n   ```\n   --------------------\n\nThis release fixes a dependency problem.  It was possible to install\nHypothesis with an old version of :pypi:`attrs`, which would throw a\n``TypeError`` as soon as you tried to import hypothesis.  Specifically, you\nneed attrs 16.0.0 or newer.\n\nHypothesis will now require the correct version of attrs when installing.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.21\n   ```\n   --------------------\n\nThis change adds some additional structural information that Hypothesis will\nuse to guide its search.\n\nYou mostly shouldn&#39;t see much difference from this. The two most likely effects\nyou would notice are:\n\n1. Hypothesis stores slightly more examples in its database for passing tests.\n2. Hypothesis *may* find new bugs that it was previously missing, but it\n   probably won&#39;t (this is a basic implementation of the feature that is\n   intended to support future work. Although it is useful on its own, it&#39;s not\n   *very* useful on its own).\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.20\n   ```\n   --------------------\n\nThis is a small refactoring release that changes how Hypothesis tracks some\ninformation about the boundary of examples in its internal representation.\n\nYou are unlikely to see much difference in behaviour, but memory usage and\nrun time may both go down slightly during normal test execution, and when\nfailing Hypothesis might print its failing example slightly sooner.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.19\n   ```\n   --------------------\n\nThis changes how we compute the default ``average_size`` for all collection\nstrategies. Previously setting a ``max_size`` without setting an\n``average_size`` would have the seemingly paradoxical effect of making data\ngeneration *slower*, because it would raise the average size from its default.\nNow setting ``max_size`` will either leave the default unchanged or lower it\nfrom its default.\n\nIf you are currently experiencing this problem, this may make your tests\nsubstantially faster. If you are not, this will likely have no effect on you.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.18\n   ```\n   --------------------\n\nThis is a small refactoring release that changes how Hypothesis detects when\nthe structure of data generation depends on earlier values generated (e.g. when\nusing :ref:`flatmap &lt;flatmap&gt;` or :func:`~hypothesis.strategies.composite`).\nIt should not have any observable effect on behaviour.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.17\n   ```\n   --------------------\n\nThis release fixes a typo in internal documentation, and has no user-visible impact.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.16\n   ```\n   --------------------\n\nThis release improves test case reduction for recursive data structures.\nHypothesis now guarantees that whenever a strategy calls itself recursively\n(usually this will happen because you are using :func:`~hypothesis.strategies.deferred`),\nany recursive call may replace the top level value. e.g. given a tree structure,\nHypothesis will always try replacing it with a subtree.\n\nAdditionally this introduces a new heuristic that may in some circumstances\nsignificantly speed up test case reduction - Hypothesis should be better at\nimmediately replacing elements drawn inside another strategy with their minimal\npossible value.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.15\n   ```\n   --------------------\n\n:func:`~hypothesis.strategies.from_type` can now resolve recursive types\nsuch as binary trees (:issue:`1004`).  Detection of non-type arguments has\nalso improved, leading to better error messages in many cases involving\n:pep:`forward references &lt;484forward-references&gt;`.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.14\n   ```\n   --------------------\n\nThis release fixes a bug in the shrinker that prevented the optimisations in\n   ```\n   \n  \n  \n   ### 3.44.13\n   ```\n   --------------------\n\nThis release changes the average bit length of values drawn from\n:func:`~hypothesis.strategies.integers` to be much smaller. Additionally it\nchanges the shrinking order so that now size is considered before sign - e.g.\n-1 will be preferred to +10.\n\nThe new internal format for integers required some changes to the minimizer to\nmake work well, so you may also see some improvements to example quality in\nunrelated areas.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.12\n   ```\n   --------------------\n\nThis changes Hypothesis&#39;s internal implementation of weighted sampling. This\nwill affect example distribution and quality, but you shouldn&#39;t see any other\neffects.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.11\n   ```\n   --------------------\n\nThis is a change to some internals around how Hypothesis handles avoiding\ngenerating duplicate examples and seeking out novel regions of the search\nspace.\n\nYou are unlikely to see much difference as a result of it, but it fixes\na bug where an internal assertion could theoretically be triggered and has some\nminor effects on the distribution of examples so could potentially find bugs\nthat have previously been missed.\n\n--------------------\n   ```\n   \n  \n  \n   ### 3.44.10\n   ```\n   --------------------\n\nThis patch avoids creating debug statements when debugging is disabled.\nProfiling suggests this is a 5-10% performance improvement (:issue:`1040`).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.9\n   ```\n   -------------------\n\nThis patch blacklists null characters (``&#39;\\x00&#39;``) in automatically created\nstrategies for Django :obj:`~django:django.db.models.CharField` and\n:obj:`~django:django.db.models.TextField`, due to a database issue which\n`was recently fixed upstream &lt;https://code.djangoproject.com/ticket/28201&gt;`_\n(Hypothesis :issue:`1045`).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.8\n   ```\n   -------------------\n\nThis release makes the Hypothesis shrinker slightly less greedy in order to\navoid local minima - when it gets stuck, it makes a small attempt to search\naround the final example it would previously have returned to find a new\nstarting point to shrink from. This should improve example quality in some\ncases, especially ones where the test data has dependencies among parts of it\nthat make it difficult for Hypothesis to proceed.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.7\n   ```\n   -------------------\n\nThis release adds support for `Django 2\n&lt;https://www.djangoproject.com/weblog/2017/dec/02/django-20-released/&gt;`_ in\nthe hypothesis-django extra.\n\nThis release drops support for Django 1.10, as it is no longer supported by\nthe Django team.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.6\n   ```\n   -------------------\n\nThis release speeds up test case reduction in many examples by being better at\ndetecting large shrinks it can use to discard redundant parts of its input.\nThis will be particularly noticeable in examples that make use of filtering\nand for some integer ranges.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.5\n   ```\n   -------------------\n\nHappy new year!\n\nThis is a no-op release that updates the year range on all of\nthe copyright headers in our source to include 2018.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.4\n   ```\n   -------------------\n\nThis release fixes :issue:`1044`, which slowed tests by up to 6%\ndue to broken caching.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.3\n   ```\n   -------------------\n\nThis release improves the shrinker in cases where examples drawn earlier can\naffect how much data is drawn later (e.g. when you draw a length parameter in\na composite and then draw that many elements). Examples found in cases like\nthis should now be much closer to minimal.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.2\n   ```\n   -------------------\n\nThis is a pure refactoring release which changes how Hypothesis manages its\nset of examples internally. It should have no externally visible effects.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.1\n   ```\n   -------------------\n\nThis release fixes :issue:`997`, in which under some circumstances the body of\ntests run under Hypothesis would not show up when run under coverage even\nthough the tests were run and the code they called outside of the test file\nwould show up normally.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.44.0\n   ```\n   -------------------\n\nThis release adds a new feature: The :ref:`reproduce_failure &lt;reproduce_failure&gt;`,\ndesigned to make it easy to use Hypothesis&#39;s binary format for examples to\nreproduce a problem locally without having to share your example database\nbetween machines.\n\nThis also changes when seeds are printed:\n\n* They will no longer be printed for\n  normal falsifying examples, as there are now adequate ways of reproducing those\n  for all cases, so it just contributes noise.\n* They will once again be printed when reusing examples from the database, as\n  health check failures should now be more reliable in this scenario so it will\n  almost always work in this case.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.43.1\n   ```\n   -------------------\n\nThis release fixes a bug with Hypothesis&#39;s database management - examples that\nwere found in the course of shrinking were saved in a way that indicated that\nthey had distinct causes, and so they would all be retried on the start of the\nnext test. The intended behaviour, which is now what is implemented, is that\nonly a bounded subset of these examples would be retried.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.43.0\n   ```\n   -------------------\n\n:exc:`~hypothesis.errors.HypothesisDeprecationWarning` now inherits from\n:exc:`python:FutureWarning` instead of :exc:`python:DeprecationWarning`,\nas recommended by :pep:`565` for user-facing warnings (:issue:`618`).\nIf you have not changed the default warnings settings, you will now see\neach distinct :exc:`~hypothesis.errors.HypothesisDeprecationWarning`\ninstead of only the first.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.42.2\n   ```\n   -------------------\n\nThis patch fixes :issue:`1017`, where instances of a list or tuple subtype\nused as an argument to a strategy would be coerced to tuple.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.42.1\n   ```\n   -------------------\n\nThis release has some internal cleanup, which makes reading the code\nmore pleasant and may shrink large examples slightly faster.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.42.0\n   ```\n   -------------------\n\nThis release deprecates :ref:`faker-extra`, which was designed as a transition\nstrategy but does not support example shrinking or coverage-guided discovery.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.41.0\n   ```\n   -------------------\n\n:func:`~hypothesis.strategies.sampled_from` can now sample from\none-dimensional numpy ndarrays. Sampling from multi-dimensional\nndarrays still results in a deprecation warning. Thanks to Charlie\nTanksley for this patch.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.40.1\n   ```\n   -------------------\n\nThis release makes two changes:\n\n* It makes the calculation of some of the metadata that Hypothesis uses for\n  shrinking occur lazily. This should speed up performance of test case\n  generation a bit because it no longer calculates information it doesn&#39;t need.\n* It improves the shrinker for certain classes of nested examples. e.g. when\n  shrinking lists of lists, the shrinker is now able to concatenate two\n  adjacent lists together into a single list. As a result of this change,\n  shrinking may get somewhat slower when the minimal example found is large.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.40.0\n   ```\n   -------------------\n\nThis release improves how various ways of seeding Hypothesis interact with the\nexample database:\n\n* Using the example database with :func:`~hypothesis.seed` is now deprecated.\n  You should set ``database=None`` if you are doing that. This will only warn\n  if you actually load examples from the database while using ``seed``.\n* The :attr:`~hypothesis.settings.derandomize` will behave the same way as\n  ``seed``.\n* Using ``--hypothesis-seed`` will disable use of the database.\n* If a test used examples from the database, it will not suggest using a seed\n  to reproduce it, because that won&#39;t work.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.39.0\n   ```\n   -------------------\n\nThis release adds a new health check that checks if the smallest &quot;natural&quot;\npossible example of your test case is very large - this will tend to cause\nHypothesis to generate bad examples and be quite slow.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.9\n   ```\n   -------------------\n\nThis is a documentation release to improve the documentation of shrinking\nbehaviour for Hypothesis&#39;s strategies.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.8\n   ```\n   -------------------\n\nThis release improves the performance of\n:func:`~hypothesis.strategies.characters` when using ``blacklist_characters``\nand :func:`~hypothesis.strategies.from_regex` when using negative character\nclasses.\n\nThe problems this fixes were found in the course of work funded by\n`Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.7\n   ```\n   -------------------\n\nThis is a patch release for :func:`~hypothesis.strategies.from_regex`, which\nhad a bug in handling of the :obj:`python:re.VERBOSE` flag (:issue:`992`).\nFlags are now handled correctly when parsing regex.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.6\n   ```\n   -------------------\n\nThis patch changes a few byte-string literals from double to single quotes,\nthanks to an update in :pypi:`unify`.  There are no user-visible changes.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.5\n   ```\n   -------------------\n\nThis fixes the repr of strategies using lambda that are defined inside\ndecorators to include the lambda source.\n\nThis would mostly have been visible when using the\n:ref:`statistics &lt;statistics&gt;` functionality - lambdas used for e.g. filtering\nwould have shown up with a ``&lt;unknown&gt;`` as their body. This can still happen,\nbut it should happen less often now.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.4\n   ```\n   -------------------\n\nThis release updates the reported :ref:`statistics &lt;statistics&gt;` so that they\nshow approximately what fraction of your test run time is spent in data\ngeneration (as opposed to test execution).\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.3\n   ```\n   -------------------\n\nThis is a documentation release, which ensures code examples are up to date\nby running them as doctests in CI (:issue:`711`).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.2\n   ```\n   -------------------\n\nThis release changes the behaviour of the :attr:`~hypothesis.settings.deadline`\nsetting when used with :func:`~hypothesis.strategies.data`: Time spent inside\ncalls to ``data.draw`` will no longer be counted towards the deadline time.\n\nAs a side effect of some refactoring required for this work, the way flaky\ntests are handled has changed slightly. You are unlikely to see much difference\nfrom this, but some error messages will have changed.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.1\n   ```\n   -------------------\n\nThis patch has a variety of non-user-visible refactorings, removing various\nminor warts ranging from indirect imports to typos in comments.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.38.0\n   ```\n   -------------------\n\nThis release overhauls :doc:`the health check system &lt;healthchecks&gt;`\nin a variety of small ways.\nIt adds no new features, but is nevertheless a minor release because it changes\nwhich tests are likely to fail health checks.\n\nThe most noticeable effect is that some tests that used to fail health checks\nwill now pass, and some that used to pass will fail. These should all be\nimprovements in accuracy. In particular:\n\n* New failures will usually be because they are now taking into account things\n  like use of :func:`~hypothesis.strategies.data` and\n  :func:`~hypothesis.assume` inside the test body.\n* New failures *may* also be because for some classes of example the way data\n  generation performance was measured was artificially faster than real data\n  generation (for most examples that are hitting performance health checks the\n  opposite should be the case).\n* Tests that used to fail health checks and now pass do so because the health\n  check system used to run in a way that was subtly different than the main\n  Hypothesis data generation and lacked some of its support for e.g. large\n  examples.\n\nIf your data generation is especially slow, you may also see your tests get\nsomewhat faster, as there is no longer a separate health check phase. This will\nbe particularly noticeable when rerunning test failures.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.37.0\n   ```\n   -------------------\n\nThis is a deprecation release for some health check related features.\n\nThe following are now deprecated:\n\n* Passing :attr:`~hypothesis.HealthCheck.exception_in_generation` to\n  :attr:`~hypothesis.settings.suppress_health_check`. This no longer does\n  anything even when passed -  All errors that occur during data generation\n  will now be immediately reraised rather than going through the health check\n  mechanism.\n* Passing :attr:`~hypothesis.HealthCheck.random_module` to\n  :attr:`~hypothesis.settings.suppress_health_check`. This hasn&#39;t done anything\n  for a long time, but was never explicitly deprecated. Hypothesis always seeds\n  the random module when running given tests, so this is no longer an error\n  and suppressing it doesn&#39;t do anything.\n* Passing non-:class:`~hypothesis.HealthCheck` values in\n  :attr:`~hypothesis.settings.suppress_health_check`. This was previously\n  allowed but never did anything useful.\n\nIn addition, passing a non-iterable value as :attr:`~hypothesis.settings.suppress_health_check`\nwill now raise an error immediately (it would never have worked correctly, but\nit would previously have failed later). Some validation error messages have\nalso been updated.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.36.1\n   ```\n   -------------------\n\nThis is a yak shaving release, mostly concerned with our own tests.\n\nWhile :func:`~python:inspect.getfullargspec` was documented as deprecated\nin Python 3.5, it never actually emitted a warning.  Our code to silence\nthis (nonexistent) warning has therefore been removed.\n\nWe now run our tests with ``DeprecationWarning`` as an error, and made some\nminor changes to our own tests as a result.  This required similar upstream\nupdates to :pypi:`coverage` and :pypi:`execnet` (a test-time dependency via\n:pypi:`pytest-xdist`).\n\nThere is no user-visible change in Hypothesis itself, but we encourage you\nto consider enabling deprecations as errors in your own tests.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.36.0\n   ```\n   -------------------\n\nThis release adds a setting to the public API, and does some internal cleanup:\n\n- The :attr:`~hypothesis.settings.derandomize` setting is now documented (:issue:`890`)\n- Removed - and disallowed - all &#39;bare excepts&#39; in Hypothesis (:issue:`953`)\n- Documented the :attr:`~hypothesis.settings.strict` setting as deprecated, and\n  updated the build so our docs always match deprecations in the code.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.35.0\n   ```\n   -------------------\n\nThis minor release supports constraining :func:`~hypothesis.strategies.uuids`\nto generate a particular version of :class:`~python:uuid.UUID` (:issue:`721`).\n\nThanks to Dion Misic for this feature.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.34.1\n   ```\n   -------------------\n\nThis patch updates the documentation to suggest\n:func:`builds(callable) &lt;hypothesis.strategies.builds&gt;` instead of\n:func:`just(callable()) &lt;hypothesis.strategies.just&gt;`.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.34.0\n   ```\n   -------------------\n\nHypothesis now emits deprecation warnings if you apply\n:func:`given &lt;hypothesis.given&gt;` more than once to a target.\n\nApplying :func:`given &lt;hypothesis.given&gt;` repeatedly wraps the target multiple\ntimes. Each wrapper will search the space of of possible parameters separately.\nThis is equivalent but will be much more inefficient than doing it with a\nsingle call to :func:`given &lt;hypothesis.given&gt;`.\n\nFor example, instead of\n``given(booleans()) given(integers())``, you could write\n``given(booleans(), integers())``\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.33.1\n   ```\n   -------------------\n\nThis is a bugfix release:\n\n- :func:`~hypothesis.strategies.builds` would try to infer a strategy for\n  required positional arguments of the target from type hints, even if they\n  had been given to :func:`~hypothesis.strategies.builds` as positional\n  arguments (:issue:`946`).  Now it only infers missing required arguments.\n- An internal introspection function wrongly reported ``self`` as a required\n  argument for bound methods, which might also have affected\n  :func:`~hypothesis.strategies.builds`.  Now it knows better.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.33.0\n   ```\n   -------------------\n\nThis release supports strategy inference for more field types in Django\n:func:`~hypothesis.extra.django.models` - you can now omit an argument for\nDate, Time, Duration, Slug, IP Address, and UUID fields.  (:issue:`642`)\n\nStrategy generation for fields with grouped choices now selects choices from\neach group, instead of selecting from the group names.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.32.2\n   ```\n   -------------------\n\nThis patch removes the ``mergedb`` tool, introduced in Hypothesis 1.7.1\non an experimental basis.  It has never actually worked, and the new\n:doc:`Hypothesis example database &lt;database&gt;` is designed to make such a\ntool unnecessary.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.32.1\n   ```\n   -------------------\n\nThis patch has two improvements for strategies based on enumerations.\n\n- :func:`~hypothesis.strategies.from_type` now handles enumerations correctly,\n  delegating to :func:`~hypothesis.strategies.sampled_from`.  Previously it\n  noted that ``Enum.__init__`` has no required arguments and therefore delegated\n  to :func:`~hypothesis.strategies.builds`, which would subsequently fail.\n- When sampling from an :class:`python:enum.Flag`, we also generate combinations\n  of members. Eg for ``Flag(&#39;Permissions&#39;, &#39;READ, WRITE, EXECUTE&#39;)`` we can now\n  generate, ``Permissions.READ``, ``Permissions.READ|WRITE``, and so on.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.32.0\n   ```\n   -------------------\n\nThis changes the default value of\n:attr:`use_coverage=True &lt;hypothesis.settings.use_coverage&gt;` to True when\nrunning on pypy (it was already True on CPython).\n\nIt was previously set to False because we expected it to be too slow, but\nrecent benchmarking shows that actually performance of the feature on pypy is\nfairly acceptable - sometimes it&#39;s slower than on CPython, sometimes it&#39;s\nfaster, but it&#39;s generally within a factor of two either way.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.6\n   ```\n   -------------------\n\nThis patch improves the quality of strategies inferred from Numpy dtypes:\n\n* Integer dtypes generated examples with the upper half of their (non-sign) bits\n  set to zero.  The inferred strategies can now produce any representable integer.\n* Fixed-width unicode- and byte-string dtypes now cap the internal example\n  length, which should improve example and shrink quality.\n* Numpy arrays can only store fixed-size strings internally, and allow shorter\n  strings by right-padding them with null bytes.  Inferred string strategies\n  no longer generate such values, as they can never be retrieved from an array.\n  This improves shrinking performance by skipping useless values.\n\nThis has already been useful in Hypothesis - we found an overflow bug in our\nPandas support, and as a result :func:`~hypothesis.extra.pandas.indexes` and\n:func:`~hypothesis.extra.pandas.range_indexes` now check that ``min_size``\nand ``max_size`` are at least zero.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.5\n   ```\n   -------------------\n\nThis release fixes a performance problem in tests where\n:attr:`~hypothesis.settings.use_coverage` is set to True.\n\nTests experience a slow-down proportionate to the amount of code they cover.\nThis is still the case, but the factor is now low enough that it should be\nunnoticeable. Previously it was large and became much larger in 3.28.4.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.4\n   ```\n   -------------------\n\n:func:`~hypothesis.strategies.from_type` failed with a very confusing error\nif passed a :func:`~python:typing.NewType` (:issue:`901`).  These psudeo-types\nare now unwrapped correctly, and strategy inference works as expected.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.3\n   ```\n   -------------------\n\nThis release makes some small optimisations to our use of coverage that should\nreduce constant per-example overhead. This is probably only noticeable on\nexamples where the test itself is quite fast. On no-op tests that don&#39;t test\nanything you may see up to a fourfold speed increase (which is still\nsignificantly slower than without coverage). On more realistic tests the speed\nup is likely to be less than that.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.2\n   ```\n   -------------------\n\nThis release fixes some formatting and small typos/grammar issues in the\ndocumentation, specifically the page docs/settings.rst, and the inline docs\nfor the various settings.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.1\n   ```\n   -------------------\n\nThis release improves the handling of deadlines so that they act better with\nthe shrinking process. This fixes :issue:`892`.\n\nThis involves two changes:\n\n1. The deadline is raised during the initial generation and shrinking, and then\n   lowered to the set value for final replay. This restricts our attention to\n   examples which exceed the deadline by a more significant margin, which\n   increases their reliability.\n2. When despite the above a test still becomes flaky because it is\n   significantly faster on rerun than it was on its first run, the error\n   message is now more explicit about the nature of this problem, and includes\n   both the initial test run time and the new test run time.\n\nIn addition, this release also clarifies the documentation of the deadline\nsetting slightly to be more explicit about where it applies.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.31.0\n   ```\n   -------------------\n\nThis release blocks installation of Hypothesis on Python 3.3, which\n:PEP:`reached its end of life date on 2017-09-29 &lt;398&gt;`.\n\nThis should not be of interest to anyone but downstream maintainers -\nif you are affected, migrate to a secure version of Python as soon as\npossible or at least seek commercial support.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.30.4\n   ```\n   -------------------\n\nThis release makes several changes:\n\n1. It significantly improves Hypothesis&#39;s ability to use coverage information\n   to find interesting examples.\n2. It reduces the default :attr:`~hypothesis.settings.max_examples` setting from 200 to 100. This takes\n   advantage of the improved algorithm meaning fewer examples are typically\n   needed to get the same testing and is sufficiently better at covering\n   interesting behaviour, and offsets some of the performance problems of\n   running under coverage.\n3. Hypothesis will always try to start its testing with an example that is near\n   minimized.\n\nThe new algorithm for 1 also makes some changes to Hypothesis&#39;s low level data\ngeneration which apply even with coverage turned off. They generally reduce the\ntotal amount of data generated, which should improve test performance somewhat.\nBetween this and 3 you should see a noticeable reduction in test runtime (how\nmuch so depends on your tests and how much example size affects their\nperformance. On our benchmarks, where data generation dominates, we saw up to\na factor of two performance improvement, but it&#39;s unlikely to be that large.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.30.3\n   ```\n   -------------------\n\nThis release fixes some formatting and small typos/grammar issues in the\ndocumentation, specifically the page docs/details.rst, and some inline\ndocs linked from there.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.30.2\n   ```\n   -------------------\n\nThis release changes Hypothesis&#39;s caching approach for functions in\n``hypothesis.strategies``. Previously it would have cached extremely\naggressively and cache entries would never be evicted. Now it adopts a\nleast-frequently used, least recently used key invalidation policy, and is\nsomewhat more conservative about which strategies it caches.\n\nWorkloads which create strategies based on dynamic values, e.g. by using\n:ref:`flatmap &lt;flatmap&gt;` or :func:`~hypothesis.strategies.composite`,\nwill use significantly less memory.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.30.1\n   ```\n   -------------------\n\nThis release fixes a bug where when running with\n:attr:`use_coverage=True &lt;hypothesis.settings.use_coverage&gt;` inside an\nexisting running instance of coverage, Hypothesis would frequently put files\nthat the coveragerc excluded in the report for the enclosing coverage.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.30.0\n   ```\n   -------------------\n\nThis release introduces two new features:\n\n* When a test fails, either with a health check failure or a falsifying example,\n  Hypothesis will print out a seed that led to that failure, if the test is not\n  already running with a fixed seed. You can then recreate that failure using either\n  the :func:`seed &lt;hypothesis.seed&gt;` decorator or (if you are running pytest) with ``--hypothesis-seed``.\n* :pypi:`pytest` users can specify a seed to use for :func:`given &lt;hypothesis.given&gt;` based tests by passing\n  the ``--hypothesis-seed`` command line argument.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.29.0\n   ```\n   -------------------\n\nThis release makes Hypothesis coverage aware. Hypothesis now runs all test\nbodies under coverage, and uses this information to guide its testing.\n\nThe :attr:`~hypothesis.settings.use_coverage` setting can be used to disable\nthis behaviour if you want to test code that is sensitive to coverage being\nenabled (either because of performance or interaction with the trace function).\n\nThe main benefits of this feature are:\n\n* Hypothesis now observes when examples it discovers cover particular lines\n  or branches and stores them in the database for later.\n* Hypothesis will make some use of this information to guide its exploration of\n  the search space and improve the examples it finds (this is currently used\n  only very lightly and will likely improve significantly in future releases).\n\nThis also has the following side-effects:\n\n* Hypothesis now has an install time dependency on the :pypi:`coverage` package.\n* Tests that are already running Hypothesis under coverage will likely get\n  faster.\n* Tests that are not running under coverage now run their test bodies under\n  coverage by default.\n\n\nThis feature is only partially supported under pypy. It is significantly slower\nthan on CPython and is turned off by default as a result, but it should still\nwork correctly if you want to use it.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.28.3\n   ```\n   -------------------\n\nThis release is an internal change that affects how Hypothesis handles\ncalculating certain properties of strategies.\n\nThe primary effect of this is that it fixes a bug where use of\n:func:`~hypothesis.deferred` could sometimes trigger an internal assertion\nerror. However the fix for this bug involved some moderately deep changes to\nhow Hypothesis handles certain constructs so you may notice some additional\nknock-on effects.\n\nIn particular the way Hypothesis handles drawing data from strategies that\ncannot generate any values has changed to bail out sooner than it previously\ndid. This may speed up certain tests, but it is unlikely to make much of a\ndifference in practice for tests that were not already failing with\nUnsatisfiable.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.28.2\n   ```\n   -------------------\n\nThis is a patch release that fixes a bug in the :mod:`hypothesis.extra.pandas`\ndocumentation where it incorrectly referred to :func:`~hypothesis.extra.pandas.column`\ninstead of :func:`~hypothesis.extra.pandas.columns`.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.28.1\n   ```\n   -------------------\n\nThis is a refactoring release. It moves a number of internal uses\nof :func:`~python:collections.namedtuple` over to using attrs based classes, and removes a couple\nof internal namedtuple classes that were no longer in use.\n\nIt should have no user visible impact.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.28.0\n   ```\n   -------------------\n\nThis release adds support for testing :pypi:`pandas` via the :ref:`hypothesis.extra.pandas &lt;hypothesis-pandas&gt;`\nmodule.\n\nIt also adds a dependency on :pypi:`attrs`.\n\nThis work was funded by `Stripe &lt;https://stripe.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.27.1\n   ```\n   -------------------\n\nThis release fixes some formatting and broken cross-references in the\ndocumentation, which includes editing docstrings - and thus a patch release.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.27.0\n   ```\n   -------------------\n\nThis release introduces a :attr:`~hypothesis.settings.deadline`\nsetting to Hypothesis.\n\nWhen set this turns slow tests into errors. By default it is unset but will\nwarn if you exceed 200ms, which will become the default value in a future\nrelease.\n\nThis work was funded by `Smarkets &lt;https://smarkets.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.26.0\n   ```\n   -------------------\n\nHypothesis now emits deprecation warnings if you are using the legacy\nSQLite example database format, or the tool for merging them. These were\nalready documented as deprecated, so this doesn&#39;t change their deprecation\nstatus, only that we warn about it.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.25.1\n   ```\n   -------------------\n\nThis release fixes a bug with generating :doc:`numpy datetime and timedelta types &lt;numpy:reference/arrays.datetime&gt;`:\nWhen inferring the strategy from the dtype, datetime and timedelta dtypes with\nsub-second precision would always produce examples with one second resolution.\nInferring a strategy from a time dtype will now always produce example with the\nsame precision.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.25.0\n   ```\n   -------------------\n\nThis release changes how Hypothesis shrinks and replays examples to take into\naccount that it can encounter new bugs while shrinking the bug it originally\nfound. Previously it would end up replacing the originally found bug with the\nnew bug and show you only that one. Now it is (often) able to recognise when\ntwo bugs are distinct and when it finds more than one will show both.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.24.2\n   ```\n   -------------------\n\nThis release removes the (purely internal and no longer useful)\n``strategy_test_suite`` function and the corresponding strategytests module.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.24.1\n   ```\n   -------------------\n\nThis release improves the reduction of examples involving floating point\nnumbers to produce more human readable examples.\n\nIt also has some general purpose changes to the way the minimizer works\ninternally, which may see some improvement in quality and slow down of test\ncase reduction in cases that have nothing to do with floating point numbers.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.24.0\n   ```\n   -------------------\n\nHypothesis now emits deprecation warnings if you use ``some_strategy.example()`` inside a\ntest function or strategy definition (this was never intended to be supported,\nbut is sufficiently widespread that it warrants a deprecation path).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.23.3\n   ```\n   -------------------\n\nThis is a bugfix release for :func:`~hypothesis.strategies.decimals`\nwith the ``places`` argument.\n\n- No longer fails health checks (:issue:`725`, due to internal filtering)\n- Specifying a ``min_value`` and ``max_value`` without any decimals with\n  ``places`` places between them gives a more useful error message.\n- Works for any valid arguments, regardless of the decimal precision context.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.23.2\n   ```\n   -------------------\n\nThis is a small refactoring release that removes a now-unused parameter to an\ninternal API. It shouldn&#39;t have any user visible effect.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.23.1\n   ```\n   -------------------\n\nHypothesis no longer propagates the dynamic scope of settings into strategy\ndefinitions.\n\nThis release is a small change to something that was never part of the public\nAPI and you will almost certainly not notice any effect unless you&#39;re doing\nsomething surprising, but for example the following code will now give a\ndifferent answer in some circumstances:\n\n.. code-block:: python\n\n    import hypothesis.strategies as st\n    from hypothesis import settings\n\n    CURRENT_SETTINGS = st.builds(lambda: settings.default)\n\n(We don&#39;t actually encourage you writing code like this)\n\nPreviously this would have generated the settings that were in effect at the\npoint of definition of ``CURRENT_SETTINGS``. Now it will generate the settings\nthat are used for the current test.\n\nIt is very unlikely to be significant enough to be visible, but you may also\nnotice a small performance improvement.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.23.0\n   ```\n   -------------------\n\nThis release adds a ``unique`` argument to :func:`~hypothesis.extra.numpy.arrays`\nwhich behaves the same ways as the corresponding one for\n:func:`~hypothesis.strategies.lists`, requiring all of the elements in the\ngenerated array to be distinct.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.22.2\n   ```\n   -------------------\n\nThis release fixes an issue where Hypothesis would raise a ``TypeError`` when\nusing the datetime-related strategies if running with ``PYTHONOPTIMIZE=2``.\nThis bug was introduced in v3.20.0.  (See :issue:`822`)\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.22.1\n   ```\n   -------------------\n\nHypothesis now transparently handles problems with an internal unicode cache,\nincluding file truncation or read-only filesystems (:issue:`767`).\nThanks to Sam Hames for the patch.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.22.0\n   ```\n   -------------------\n\nThis release provides what should be a substantial performance improvement to\nnumpy arrays generated using :ref:`provided numpy support &lt;hypothesis-numpy&gt;`,\nand adds a new ``fill_value`` argument to :func:`~hypothesis.extra.numpy.arrays`\nto control this behaviour.\n\nThis work was funded by `Stripe &lt;https://stripe.com/&gt;`_.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.21.3\n   ```\n   -------------------\n\nThis release fixes some extremely specific circumstances that probably have\nnever occurred in the wild where users of\n:func:`~hypothesis.searchstrategy.deferred` might have seen a RuntimeError from\ntoo much recursion, usually in cases where no valid example could have been\ngenerated anyway.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.21.2\n   ```\n   -------------------\n\nThis release fixes some minor bugs in argument validation:\n\n    * :ref:`hypothesis.extra.numpy &lt;hypothesis-numpy&gt;` dtype strategies would raise an internal error\n      instead of an InvalidArgument exception when passed an invalid\n      endianness specification.\n    * :func:`~hypothesis.strategies.fractions` would raise an internal error instead of an InvalidArgument\n      if passed ``float(&quot;nan&quot;)`` as one of its bounds.\n    * The error message for passing ``float(&quot;nan&quot;)`` as a bound to various\n      strategies has been improved.\n    * Various bound arguments will now raise InvalidArgument in cases where\n      they would previously have raised an internal TypeError or\n      ValueError from the relevant conversion function.\n    * :func:`~hypothesis.strategies.streaming` would not have emitted a\n      deprecation warning when called with an invalid argument.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.21.1\n   ```\n   -------------------\n\nThis release fixes a bug where test failures that were the result of\nan :func:`example &lt;hypothesis.example&gt;` would print an extra stack trace before re-raising the\nexception.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.21.0\n   ```\n   -------------------\n\nThis release deprecates Hypothesis&#39;s strict mode, which turned Hypothesis&#39;s\ndeprecation warnings into errors. Similar functionality can be achieved\nby using :func:`simplefilter(&#39;error&#39;, HypothesisDeprecationWarning) &lt;python:warnings.simplefilter&gt;`.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.20.0\n   ```\n   -------------------\n\nThis release renames the relevant arguments on the\n:func:`~hypothesis.strategies.datetimes`, :func:`~hypothesis.strategies.dates`,\n:func:`~hypothesis.strategies.times`, and :func:`~hypothesis.strategies.timedeltas`\nstrategies to ``min_value`` and ``max_value``, to make them consistent with the\nother strategies in the module.\n\nThe old argument names are still supported but will emit a deprecation warning\nwhen used explicitly as keyword arguments. Arguments passed positionally will\ngo to the new argument names and are not deprecated.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.19.3\n   ```\n   -------------------\n\nThis release provides a major overhaul to the internals of how Hypothesis\nhandles shrinking.\n\nThis should mostly be visible in terms of getting better examples for tests\nwhich make heavy use of :func:`~hypothesis.strategies.composite`,\n:func:`~hypothesis.strategies.data` or :ref:`flatmap &lt;flatmap&gt;` where the data\ndrawn depends a lot on previous choices, especially where size parameters are\naffected. Previously Hypothesis would have struggled to reliably produce\ngood examples here. Now it should do much better. Performance should also be\nbetter for examples with a non-zero ``min_size``.\n\nYou may see slight changes to example generation (e.g. improved example\ndiversity) as a result of related changes to internals, but they are unlikely\nto be significant enough to notice.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.19.2\n   ```\n   -------------------\n\nThis release fixes two bugs in :mod:`hypothesis.extra.numpy`:\n\n* :func:`~hypothesis.extra.numpy.unicode_string_dtypes` didn&#39;t work at all due\n  to an incorrect dtype specifier. Now it does.\n* Various impossible conditions would have been accepted but would error when\n  they fail to produced any example. Now they raise an explicit InvalidArgument\n  error.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.19.1\n   ```\n   -------------------\n\nThis is a bugfix release for :issue:`739`, where bounds for\n:func:`~hypothesis.strategies.fractions` or floating-point\n:func:`~hypothesis.strategies.decimals` were not properly converted to\nintegers before passing them to the integers strategy.\nThis excluded some values that should have been possible, and could\ntrigger internal errors if the bounds lay between adjacent integers.\n\nYou can now bound :func:`~hypothesis.strategies.fractions` with two\narbitrarily close fractions.\n\nIt is now an explicit error to supply a min_value, max_value, and\nmax_denominator to :func:`~hypothesis.strategies.fractions` where the value\nbounds do not include a fraction with denominator at most max_denominator.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.19.0\n   ```\n   -------------------\n\nThis release adds the :func:`~hypothesis.strategies.from_regex` strategy,\nwhich generates strings that contain a match of a regular expression.\n\nThanks to Maxim Kulkin for creating the\n`hypothesis-regex &lt;https://github.com/maximkulkin/hypothesis-regex&gt;`_\npackage and then helping to upstream it! (:issue:`662`)\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.18.5\n   ```\n   -------------------\n\nThis is a bugfix release for :func:`~hypothesis.strategies.integers`.\nPreviously the strategy would hit an internal assertion if passed non-integer\nbounds for ``min_value`` and ``max_value`` that had no integers between them.\nThe strategy now raises InvalidArgument instead.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.18.4\n   ```\n   -------------------\n\nRelease to fix a bug where mocks can be used as test runners under certain\nconditions. Specifically, if a mock is injected into a test via pytest\nfixtures or patch decorators, and that mock is the first argument in the\nlist, hypothesis will think it represents self and turns the mock\ninto a test runner.  If this happens, the affected test always passes\nbecause the mock is executed instead of the test body. Sometimes, it\nwill also fail health checks.\n\nFixes :issue:`491` and a section of :issue:`198`.\nThanks to Ben Peterson for this bug fix.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.18.3\n   ```\n   -------------------\n\nThis release should improve the performance of some tests which\nexperienced a slow down as a result of the 3.13.0 release.\n\nTests most likely to benefit from this are ones that make extensive\nuse of ``min_size`` parameters, but others may see some improvement\nas well.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.18.2\n   ```\n   -------------------\n\nThis release fixes a bug introduced in 3.18.0. If the arguments\n``whitelist_characters`` and ``blacklist_characters`` to\n:func:`~hypothesis.strategies.characters` both contained elements, then an\n``InvalidArgument`` exception would be raised.\n\nThanks to Zac Hatfield-Dodds for reporting and fixing this.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.18.1\n   ```\n   -------------------\n\nThis is a bug fix release to fix :issue:`780`, where\n:func:`~hypothesis.strategies.sets` and similar would trigger health check\nerrors if their element strategy could only produce one element (e.g.\nif it was :func:`~hypothesis.strategies.just`).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.18.0\n   ```\n   -------------------\n\nThis is a feature release:\n\n* :func:`~hypothesis.strategies.characters` now accepts\n  ``whitelist_characters``, particular characters which will be added to those\n  it produces. (:issue:`668`)\n* A bug fix for the internal function ``_union_interval_lists()``, and a rename\n  to ``_union_intervals()``. It now correctly handles all cases where intervals\n  overlap, and it always returns the result as a tuple for tuples.\n\nThanks to Alex Willmer for these.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.17.0\n   ```\n   -------------------\n\nThis release documents :ref:`the previously undocumented phases feature &lt;phases&gt;`,\nmaking it part of the public API. It also updates how the example\ndatabase is used. Principally:\n\n* A ``Phases.reuse`` argument will now correctly control whether examples\n  from the database are run (it previously did exactly the wrong thing and\n  controlled whether examples would be *saved*).\n* Hypothesis will no longer try to rerun *all* previously failing examples.\n  Instead it will replay the smallest previously failing example and a\n  selection of other examples that are likely to trigger any other bugs that\n  will found. This prevents a previous failure from dominating your tests\n  unnecessarily.\n* As a result of the previous change, Hypothesis will be slower about clearing\n  out old examples from the database that are no longer failing (because it can\n  only clear out ones that it actually runs).\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.16.1\n   ```\n   -------------------\n\nThis release makes an implementation change to how Hypothesis handles certain\ninternal constructs.\n\nThe main effect you should see is improvement to the behaviour and performance\nof collection types, especially ones with a ``min_size`` parameter. Many cases\nthat would previously fail due to being unable to generate enough valid\nexamples will now succeed, and other cases should run slightly faster.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.16.0\n   ```\n   -------------------\n\nThis release introduces a deprecation of the timeout feature. This results in\nthe following changes:\n\n* Creating a settings object with an explicit timeout will emit a deprecation\n  warning.\n* If your test stops because it hits the timeout (and has not found a bug) then\n  it will emit a deprecation warning.\n* There is a new value ``unlimited`` which you can import from hypothesis.\n  ``settings(timeout=unlimited)`` will *not* cause a deprecation warning.\n* There is a new health check, ``hung_test``, which will trigger after a test\n  has been running for five minutes if it is not suppressed.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.15.0\n   ```\n   -------------------\n\nThis release deprecates two strategies, :func:`~hypothesis.strategies.choices` and\n:func:`~hypothesis.strategies.streaming`.\n\nBoth of these are somewhat confusing to use and are entirely redundant since the\nintroduction of the :func:`~hypothesis.strategies.data` strategy for interactive\ndrawing in tests, and their use should be replaced with direct use of\n:func:`~hypothesis.strategies.data` instead.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.14.2\n   ```\n   -------------------\n\nThis fixes a bug where Hypothesis would not work correctly on Python 2.7 if you\nhad the :mod:`python:typing` module :pypi:`backport &lt;typing&gt;` installed.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.14.1\n   ```\n   -------------------\n\nThis raises the maximum depth at which Hypothesis starts cutting off data\ngeneration to a more reasonable value which it is harder to hit by accident.\n\nThis resolves (:issue:`751`), in which some examples which previously worked\nwould start timing out, but it will also likely improve the data generation\nquality for complex data types.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.14.0\n   ```\n   -------------------\n\nHypothesis now understands inline type annotations (:issue:`293`):\n\n- If the target of :func:`~hypothesis.strategies.builds` has type annotations,\n  a default strategy for missing required arguments is selected based on the\n  type.  Type-based strategy selection will only override a default if you\n  pass :const:`hypothesis.infer` as a keyword argument.\n\n- If :func:`given &lt;hypothesis.given&gt;` wraps a function with type annotations,\n  you can pass :const:`~hypothesis.infer` as a keyword argument and the\n  appropriate strategy will be substituted.\n\n- You can check what strategy will be inferred for a type with the new\n  :func:`~hypothesis.strategies.from_type` function.\n\n- :func:`~hypothesis.strategies.register_type_strategy` teaches Hypothesis\n  which strategy to infer for custom or unknown types.  You can provide a\n  strategy, or for more complex cases a function which takes the type and\n  returns a strategy.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.13.1\n   ```\n   -------------------\n\nThis is a bug fix release for :issue:`514` - Hypothesis would continue running\nexamples after a :class:`~python:unittest.SkipTest` exception was raised,\nincluding printing a falsifying example.  Skip exceptions from the standard\n:mod:`python:unittest` module, and ``pytest``, ``nose``, or ``unittest2``\nmodules now abort the test immediately without printing output.\n\n-------------------\n   ```\n   \n  \n  \n   ### 3.13.0\n   ```\n   -------------------\n\nThis release has two major aspects to it: The first is the introduction of\n:func:`~hypothesis.strategies.deferred`, which allows more natural definition\nof recursive (including mutually recursive) strategies.\n\nThe second is a number of engine changes designed to support this sort of\nstrategy better. These should have a knock-on effect of also improving the\nperformance of any existing strategies that currently ","created_at":"2018-04-01T00:45:13Z","updated_at":"2018-04-01T03:30:17Z","closed_at":"2018-04-01T03:30:17Z","merged_at":null,"merge_commit_sha":"30cccdc7f49eff0a128c5dc3a3daa3923a577165","assignee":null,"assignees":[],"requested_reviewers":[],"requested_teams":[],"labels":[],"milestone":null,"commits_url":"https://api.github.com/repos/kragniz/python-etcd3/pulls/392/commits","review_comments_url":"https://api.github.com/repos/kragniz/python-etcd3/pulls/392/comments","review_comment_url":"https://api.github.com/repos/kragniz/python-etcd3/pulls/comments{/number}","comments_url":"https://api.github.com/repos/kragniz/python-etcd3/issues/392/comments","statuses_url":"https://api.github.com/repos/kragniz/python-etcd3/statuses/b525c911e889fc8234f503aa7bf48745886c4f00","head":{"label":"kragniz:pyup-update-hypothesis-3.11.6-to-3.52.3","ref":"pyup-update-hypothesis-3.11.6-to-3.52.3","sha":"b525c911e889fc8234f503aa7bf48745886c4f00","user":{"login":"kragniz","id":735008,"avatar_url":"https://avatars2.githubusercontent.com/u/735008?v=4","gravatar_id":"","url":"https://api.github.com/users/kragniz","html_url":"https://github.com/kragniz","followers_url":"https://api.github.com/users/kragniz/followers","following_url":"https://api.github.com/users/kragniz/following{/other_user}","gists_url":"https://api.github.com/users/kragniz/gists{/gist_id}","starred_url":"https://api.github.com/users/kragniz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/kragniz/subscriptions","organizations_url":"https://api.github.com/users/kragniz/orgs","repos_url":"https://api.github.com/users/kragniz/repos","events_url":"https://api.github.com/users/kragniz/events{/privacy}","received_events_url":"https://api.github.com/users/kragniz/received_events","type":"User","site_admin":false},"repo":{"id":69691394,"name":"python-etcd3","full_name":"kragniz/python-etcd3","owner":{"login":"kragniz","id":735008,"avatar_url":"https://avatars2.githubusercontent.com/u/735008?v=4","gravatar_id":"","url":"https://api.github.com/users/kragniz","html_url":"https://github.com/kragniz","followers_url":"https://api.github.com/users/kragniz/followers","following_url":"https://api.github.com/users/kragniz/following{/other_user}","gists_url":"https://api.github.com/users/kragniz/gists{/gist_id}","starred_url":"https://api.github.com/users/kragniz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/kragniz/subscriptions","organizations_url":"https://api.github.com/users/kragniz/orgs","repos_url":"https://api.github.com/users/kragniz/repos","events_url":"https://api.github.com/users/kragniz/events{/privacy}","received_events_url":"https://api.github.com/users/kragniz/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/kragniz/python-etcd3","description":"Python client for the etcd API v3","fork":false,"url":"https://api.github.com/repos/kragniz/python-etcd3","forks_url":"https://api.github.com/repos/kragniz/python-etcd3/forks","keys_url":"https://api.github.com/repos/kragniz/python-etcd3/keys{/key_id}","collaborators_url":"https://api.github.com/repos/kragniz/python-etcd3/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/kragniz/python-etcd3/teams","hooks_url":"https://api.github.com/repos/kragniz/python-etcd3/hooks","issue_events_url":"https://api.github.com/repos/kragniz/python-etcd3/issues/events{/number}","events_url":"https://api.github.com/repos/kragniz/python-etcd3/events","assignees_url":"https://api.github.com/repos/kragniz/python-etcd3/assignees{/user}","branches_url":"https://api.github.com/repos/kragniz/python-etcd3/branches{/branch}","tags_url":"https://api.github.com/repos/kragniz/python-etcd3/tags","blobs_url":"https://api.github.com/repos/kragniz/python-etcd3/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/kragniz/python-etcd3/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/kragniz/python-etcd3/git/refs{/sha}","trees_url":"https://api.github.com/repos/kragniz/python-etcd3/git/trees{/sha}","statuses_url":"https://api.github.com/repos/kragniz/python-etcd3/statuses/{sha}","languages_url":"https://api.github.com/repos/kragniz/python-etcd3/languages","stargazers_url":"https://api.github.com/repos/kragniz/python-etcd3/stargazers","contributors_url":"https://api.github.com/repos/kragniz/python-etcd3/contributors","subscribers_url":"https://api.github.com/repos/kragniz/python-etcd3/subscribers","subscription_url":"https://api.github.com/repos/kragniz/python-etcd3/subscription","commits_url":"https://api.github.com/repos/kragniz/python-etcd3/commits{/sha}","git_commits_url":"https://api.github.com/repos/kragniz/python-etcd3/git/commits{/sha}","comments_url":"https://api.github.com/repos/kragniz/python-etcd3/comments{/number}","issue_comment_url":"https://api.github.com/repos/kragniz/python-etcd3/issues/comments{/number}","contents_url":"https://api.github.com/repos/kragniz/python-etcd3/contents/{+path}","compare_url":"https://api.github.com/repos/kragniz/python-etcd3/compare/{base}...{head}","merges_url":"https://api.github.com/repos/kragniz/python-etcd3/merges","archive_url":"https://api.github.com/repos/kragniz/python-etcd3/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/kragniz/python-etcd3/downloads","issues_url":"https://api.github.com/repos/kragniz/python-etcd3/issues{/number}","pulls_url":"https://api.github.com/repos/kragniz/python-etcd3/pulls{/number}","milestones_url":"https://api.github.com/repos/kragniz/python-etcd3/milestones{/number}","notifications_url":"https://api.github.com/repos/kragniz/python-etcd3/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/kragniz/python-etcd3/labels{/name}","releases_url":"https://api.github.com/repos/kragniz/python-etcd3/releases{/id}","deployments_url":"https://api.github.com/repos/kragniz/python-etcd3/deployments","created_at":"2016-09-30T18:26:16Z","updated_at":"2018-03-30T23:47:37Z","pushed_at":"2018-04-01T03:30:14Z","git_url":"git://github.com/kragniz/python-etcd3.git","ssh_url":"git@github.com:kragniz/python-etcd3.git","clone_url":"https://github.com/kragniz/python-etcd3.git","svn_url":"https://github.com/kragniz/python-etcd3","homepage":"","size":441,"stargazers_count":79,"watchers_count":79,"language":"Python","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":49,"mirror_url":null,"archived":false,"open_issues_count":40,"license":{"key":"apache-2.0","name":"Apache License 2.0","spdx_id":"Apache-2.0","url":"https://api.github.com/licenses/apache-2.0"},"forks":49,"open_issues":40,"watchers":79,"default_branch":"master"}},"base":{"label":"kragniz:master","ref":"master","sha":"9115ee6b8d18bfc16b18a384f869022982739c99","user":{"login":"kragniz","id":735008,"avatar_url":"https://avatars2.githubusercontent.com/u/735008?v=4","gravatar_id":"","url":"https://api.github.com/users/kragniz","html_url":"https://github.com/kragniz","followers_url":"https://api.github.com/users/kragniz/followers","following_url":"https://api.github.com/users/kragniz/following{/other_user}","gists_url":"https://api.github.com/users/kragniz/gists{/gist_id}","starred_url":"https://api.github.com/users/kragniz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/kragniz/subscriptions","organizations_url":"https://api.github.com/users/kragniz/orgs","repos_url":"https://api.github.com/users/kragniz/repos","events_url":"https://api.github.com/users/kragniz/events{/privacy}","received_events_url":"https://api.github.com/users/kragniz/received_events","type":"User","site_admin":false},"repo":{"id":69691394,"name":"python-etcd3","full_name":"kragniz/python-etcd3","owner":{"login":"kragniz","id":735008,"avatar_url":"https://avatars2.githubusercontent.com/u/735008?v=4","gravatar_id":"","url":"https://api.github.com/users/kragniz","html_url":"https://github.com/kragniz","followers_url":"https://api.github.com/users/kragniz/followers","following_url":"https://api.github.com/users/kragniz/following{/other_user}","gists_url":"https://api.github.com/users/kragniz/gists{/gist_id}","starred_url":"https://api.github.com/users/kragniz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/kragniz/subscriptions","organizations_url":"https://api.github.com/users/kragniz/orgs","repos_url":"https://api.github.com/users/kragniz/repos","events_url":"https://api.github.com/users/kragniz/events{/privacy}","received_events_url":"https://api.github.com/users/kragniz/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/kragniz/python-etcd3","description":"Python client for the etcd API v3","fork":false,"url":"https://api.github.com/repos/kragniz/python-etcd3","forks_url":"https://api.github.com/repos/kragniz/python-etcd3/forks","keys_url":"https://api.github.com/repos/kragniz/python-etcd3/keys{/key_id}","collaborators_url":"https://api.github.com/repos/kragniz/python-etcd3/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/kragniz/python-etcd3/teams","hooks_url":"https://api.github.com/repos/kragniz/python-etcd3/hooks","issue_events_url":"https://api.github.com/repos/kragniz/python-etcd3/issues/events{/number}","events_url":"https://api.github.com/repos/kragniz/python-etcd3/events","assignees_url":"https://api.github.com/repos/kragniz/python-etcd3/assignees{/user}","branches_url":"https://api.github.com/repos/kragniz/python-etcd3/branches{/branch}","tags_url":"https://api.github.com/repos/kragniz/python-etcd3/tags","blobs_url":"https://api.github.com/repos/kragniz/python-etcd3/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/kragniz/python-etcd3/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/kragniz/python-etcd3/git/refs{/sha}","trees_url":"https://api.github.com/repos/kragniz/python-etcd3/git/trees{/sha}","statuses_url":"https://api.github.com/repos/kragniz/python-etcd3/statuses/{sha}","languages_url":"https://api.github.com/repos/kragniz/python-etcd3/languages","stargazers_url":"https://api.github.com/repos/kragniz/python-etcd3/stargazers","contributors_url":"https://api.github.com/repos/kragniz/python-etcd3/contributors","subscribers_url":"https://api.github.com/repos/kragniz/python-etcd3/subscribers","subscription_url":"https://api.github.com/repos/kragniz/python-etcd3/subscription","commits_url":"https://api.github.com/repos/kragniz/python-etcd3/commits{/sha}","git_commits_url":"https://api.github.com/repos/kragniz/python-etcd3/git/commits{/sha}","comments_url":"https://api.github.com/repos/kragniz/python-etcd3/comments{/number}","issue_comment_url":"https://api.github.com/repos/kragniz/python-etcd3/issues/comments{/number}","contents_url":"https://api.github.com/repos/kragniz/python-etcd3/contents/{+path}","compare_url":"https://api.github.com/repos/kragniz/python-etcd3/compare/{base}...{head}","merges_url":"https://api.github.com/repos/kragniz/python-etcd3/merges","archive_url":"https://api.github.com/repos/kragniz/python-etcd3/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/kragniz/python-etcd3/downloads","issues_url":"https://api.github.com/repos/kragniz/python-etcd3/issues{/number}","pulls_url":"https://api.github.com/repos/kragniz/python-etcd3/pulls{/number}","milestones_url":"https://api.github.com/repos/kragniz/python-etcd3/milestones{/number}","notifications_url":"https://api.github.com/repos/kragniz/python-etcd3/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/kragniz/python-etcd3/labels{/name}","releases_url":"https://api.github.com/repos/kragniz/python-etcd3/releases{/id}","deployments_url":"https://api.github.com/repos/kragniz/python-etcd3/deployments","created_at":"2016-09-30T18:26:16Z","updated_at":"2018-03-30T23:47:37Z","pushed_at":"2018-04-01T03:30:14Z","git_url":"git://github.com/kragniz/python-etcd3.git","ssh_url":"git@github.com:kragniz/python-etcd3.git","clone_url":"https://github.com/kragniz/python-etcd3.git","svn_url":"https://github.com/kragniz/python-etcd3","homepage":"","size":441,"stargazers_count":79,"watchers_count":79,"language":"Python","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":49,"mirror_url":null,"archived":false,"open_issues_count":40,"license":{"key":"apache-2.0","name":"Apache License 2.0","spdx_id":"Apache-2.0","url":"https://api.github.com/licenses/apache-2.0"},"forks":49,"open_issues":40,"watchers":79,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/kragniz/python-etcd3/pulls/392"},"html":{"href":"https://github.com/kragniz/python-etcd3/pull/392"},"issue":{"href":"https://api.github.com/repos/kragniz/python-etcd3/issues/392"},"comments":{"href":"https://api.github.com/repos/kragniz/python-etcd3/issues/392/comments"},"review_comments":{"href":"https://api.github.com/repos/kragniz/python-etcd3/pulls/392/comments"},"review_comment":{"href":"https://api.github.com/repos/kragniz/python-etcd3/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/kragniz/python-etcd3/pulls/392/commits"},"statuses":{"href":"https://api.github.com/repos/kragniz/python-etcd3/statuses/b525c911e889fc8234f503aa7bf48745886c4f00"}},"author_association":"CONTRIBUTOR","merged":false,"mergeable":true,"rebaseable":true,"mergeable_state":"unstable","merged_by":null,"comments":1,"review_comments":0,"maintainer_can_modify":false,"commits":1,"additions":1,"deletions":1,"changed_files":1}}
{"actor":{"display_login":"pyup-bot"}}