python-hypothesis/python-hypothesis.changes

-------------------------------------------------------------------
Mon May  9 17:57:36 UTC 2016 - toddrme2178@gmail.com

- Update to 3.1.3
  + Single bug fix release
    * Another charmap problem. In 3.1.2 text/characters would break on systems
      which had /tmp/ mounted on a different partition than the Hypothesis
      storage directory (usually in home). This fixes that.
- Update to 3.1.2
  + Single bug fix release:
    * Anything which used a text() or 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.
- Update to 3.1.1
  + Minor bug fix release.
    * Fix concurrency issue when running tests that use text() from multiple 
      processes at once (Bug #302, thanks to Alex Chan).
    * Improve performance of code using lists with max_size (thanks to Cristi 
      Cobzarenco).
    * Fix install on Python 2 with ancient versions of pip so that it installs 
      the 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.
- Update to 3.1.0
  * Add a ‘nothing’ strategy that never successfully generates values.
  * sampled_from() and one_of() can both now be called with an empty argument 
    list, in which case they also never generate any values.
  * one_of may now be called with a single argument that is a collection of 
    strategies as well as as varargs.
  * Add a ‘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.
  * As 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).
- Update to 3.0.5
  * Fix a bug where Hypothesis would now error on py.test development versions.
- Update to 3.0.4
  * Fix a bug where Hypothesis would error when running on Python 2.7.3 or 
    earlier because it was trying to pass a bytearray object to struct.unpack 
    (which is only supported since 2.7.4).
- Update to 3.0.3
  * Fix version parsing of py.test to work with py.test 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.
- Update to 3.0.2
  * Under certain circumstances, strategies involving 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.
- Update to 3.0.1
  * 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 binary(min_size=n, max_size=n) 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.
- Update to 3.0.0
  + 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 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 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.
- Update to 2.0.0
  + 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.
- Update to 1.19.0
  + 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.
- Update to 1.18.1
  + 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 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.
- Update to 1.18.0
  + 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.
- Update to 1.17.1
  * 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.
- Update to 1.17.0
  + 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
      caued the test to  fail but would cause e.g. degraded performance or
      confusing results.
- Update to 1.16.1
  * 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.

-------------------------------------------------------------------
Wed Dec  9 10:06:43 UTC 2015 - dmueller@suse.com

- update to 1.16.0:
  * Functions from hypothesis.strategies will no longer raise InvalidArgument on bad arguments
  * Errors caused by accidentally invoking the legacy API are now much less confusing
  * hypothesis.extra.django is 1.9 compatible.
  * When tests are run with max_shrinks=0 this will now still rerun the test on failure

-------------------------------------------------------------------
Tue Nov 24 12:48:51 UTC 2015 - toddrme2178@gmail.com

- Fix license naming.

-------------------------------------------------------------------
Tue Nov 10 07:38:36 UTC 2015 - tbechtold@suse.com

- Initial packaging (version 1.14.0)