dev-python:pyudev-0.21.0:20180530-103504.log

dev-python:pyudev-0.21.0:20180530-103504.log (text/plain), 345.56 KB, created by Toralf Förster on 2018-05-30 16:40:10 UTC

 * Package:    dev-python/pyudev-0.21.0
 * Repository: gentoo
 * Maintainer: [e-mail]
 * USE:        abi_x86_64 amd64 elibc_glibc kernel_linux python_targets_python2_7 python_targets_python3_5 qt5 test userland_GNU
 * FEATURES:   network-sandbox preserve-libs sandbox test userpriv usersandbox
>>> Unpacking source...
>>> Unpacking pyudev-0.21.0.tar.gz to /var/tmp/portage/dev-python/pyudev-0.21.0/work
>>> Source unpacked in /var/tmp/portage/dev-python/pyudev-0.21.0/work
>>> Preparing source in /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0 ...
 * If your PORTAGE_TMPDIR is longer in length then '/var/tmp/',
 * change it to /var/tmp to ensure tests will pass.
 * Applying pyudev-0.19.0-skip-non-deterministic-test.patch ...
 [ ok ]
>>> Source prepared.
>>> Configuring source in /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0 ...
>>> Source configured.
>>> Compiling source in /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0 ...
 * python2_7: running distutils-r1_run_phase distutils-r1_python_compile
python2.7 setup.py build
running build
running build_py
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/monitor.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/pyside.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/_compat.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/wx.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/discover.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/_util.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/_qt_base.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/pyqt4.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/version.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/glib.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/pyqt5.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
copying src/pyudev/core.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/device
copying src/pyudev/device/_errors.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/device
copying src/pyudev/device/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/device
copying src/pyudev/device/_device.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/device
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/libudev.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/libc.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/utils.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/_errorcheckers.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_ctypeslib
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_os
copying src/pyudev/_os/poll.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_os
copying src/pyudev/_os/pipe.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_os
copying src/pyudev/_os/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python2_7/lib/pyudev/_os
warning: build_py: byte-compiling is disabled, skipping.

 * python3_5: running distutils-r1_run_phase distutils-r1_python_compile
python3.5 setup.py build
running build
running build_py
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/monitor.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/pyside.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/_compat.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/wx.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/discover.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/_util.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/_qt_base.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/pyqt4.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/version.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/glib.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/pyqt5.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
copying src/pyudev/core.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/device
copying src/pyudev/device/_errors.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/device
copying src/pyudev/device/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/device
copying src/pyudev/device/_device.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/device
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/libudev.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/libc.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/utils.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_ctypeslib
copying src/pyudev/_ctypeslib/_errorcheckers.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_ctypeslib
creating /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_os
copying src/pyudev/_os/poll.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_os
copying src/pyudev/_os/pipe.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_os
copying src/pyudev/_os/__init__.py -> /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0-python3_5/lib/pyudev/_os
warning: build_py: byte-compiling is disabled, skipping.

>>> Source compiled.
>>> Test phase: dev-python/pyudev-0.21.0
 * python2_7: running distutils-r1_run_phase python_test
============================= test session starts ==============================
platform linux2 -- Python 2.7.14, pytest-3.4.1, py-1.5.3, pluggy-0.6.0 -- /usr/bin/python2.7
cachedir: .pytest_cache
rootdir: /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0, inifile: setup.cfg
plugins: virtualenv-1.2.11, shutil-1.2.11, hypothesis-3.50.1, betamax-0.8.0, backports.unittest-mock-1.3
collecting ... collected 192 items

tests/test_core.py::test_udev_version PASSED                             [  0%]
tests/test_core.py::TestContext::test_sys_path PASSED                    [  1%]
tests/test_core.py::TestContext::test_device_path PASSED                 [  1%]
tests/test_core.py::TestContext::test_run_path PASSED                    [  2%]
tests/test_core.py::TestContext::test_log_priority_get PASSED            [  2%]
tests/test_core.py::TestContext::test_log_priority_get_mock PASSED       [  3%]
tests/test_core.py::TestContext::test_log_priority_set_mock PASSED       [  3%]
tests/test_core.py::TestContext::test_log_priority_roundtrip PASSED      [  4%]
tests/test_device.py::TestAttributes::test_getitem <- tests/_device_tests/_attributes_tests.py PASSED [  4%]
tests/test_device.py::TestAttributes::test_getitem_nonexisting <- tests/_device_tests/_attributes_tests.py PASSED [  5%]
tests/test_device.py::TestAttributes::test_non_iterable <- tests/_device_tests/_attributes_tests.py PASSED [  5%]
tests/test_device.py::TestAttributes::test_asstring <- tests/_device_tests/_attributes_tests.py SKIPPED [  6%]
tests/test_device.py::TestAttributes::test_asint <- tests/_device_tests/_attributes_tests.py SKIPPED [  6%]
tests/test_device.py::TestAttributes::test_asbool <- tests/_device_tests/_attributes_tests.py SKIPPED [  7%]
tests/test_device.py::TestAttributes::test_available_attributes <- tests/_device_tests/_attributes_tests.py PASSED [  7%]
tests/test_device.py::TestDevice::test_parent <- tests/_device_tests/_device_tests.py PASSED [  8%]
tests/test_device.py::TestDevice::test_child_of_parent <- tests/_device_tests/_device_tests.py PASSED [  8%]
tests/test_device.py::TestDevice::test_children <- tests/_device_tests/_device_tests.py PASSED [  9%]
tests/test_device.py::TestDevice::test_ancestors <- tests/_device_tests/_device_tests.py PASSED [  9%]
tests/test_device.py::TestDevice::test_find_parent <- tests/_device_tests/_device_tests.py PASSED [ 10%]
tests/test_device.py::TestDevice::test_find_parent_no_devtype_mock <- tests/_device_tests/_device_tests.py PASSED [ 10%]
tests/test_device.py::TestDevice::test_find_parent_with_devtype_mock <- tests/_device_tests/_device_tests.py PASSED [ 11%]
tests/test_device.py::TestDevice::test_traverse <- tests/_device_tests/_device_tests.py PASSED [ 11%]
tests/test_device.py::TestDevice::test_sys_path <- tests/_device_tests/_device_tests.py PASSED [ 12%]
tests/test_device.py::TestDevice::test_device_path <- tests/_device_tests/_device_tests.py PASSED [ 13%]
tests/test_device.py::TestDevice::test_subsystem <- tests/_device_tests/_device_tests.py PASSED [ 13%]
tests/test_device.py::TestDevice::test_device_sys_name <- tests/_device_tests/_device_tests.py PASSED [ 14%]
tests/test_device.py::TestDevice::test_sys_number <- tests/_device_tests/_device_tests.py PASSED [ 14%]
tests/test_device.py::TestDevice::test_type <- tests/_device_tests/_device_tests.py PASSED [ 15%]
tests/test_device.py::TestDevice::test_driver <- tests/_device_tests/_device_tests.py PASSED [ 15%]
tests/test_device.py::TestDevice::test_device_node <- tests/_device_tests/_device_tests.py PASSED [ 16%]
tests/test_device.py::TestDevice::test_device_number <- tests/_device_tests/_device_tests.py PASSED [ 16%]
tests/test_device.py::TestDevice::test_is_initialized <- tests/_device_tests/_device_tests.py PASSED [ 17%]
tests/test_device.py::TestDevice::test_is_initialized_mock <- tests/_device_tests/_device_tests.py PASSED [ 17%]
tests/test_device.py::TestDevice::test_time_since_initialized <- tests/_device_tests/_device_tests.py PASSED [ 18%]
tests/test_device.py::TestDevice::test_time_since_initialized_mock <- tests/_device_tests/_device_tests.py PASSED [ 18%]
tests/test_device.py::TestDevice::test_links <- tests/_device_tests/_device_tests.py PASSED [ 19%]
tests/test_device.py::TestDevice::test_action <- tests/_device_tests/_device_tests.py PASSED [ 19%]
tests/test_device.py::TestDevice::test_action_mock <- tests/_device_tests/_device_tests.py PASSED [ 20%]
tests/test_device.py::TestDevice::test_sequence_number <- tests/_device_tests/_device_tests.py PASSED [ 20%]
tests/test_device.py::TestDevice::test_attributes <- tests/_device_tests/_device_tests.py PASSED [ 21%]
tests/test_device.py::TestDevice::test_no_leak <- tests/_device_tests/_device_tests.py PASSED [ 21%]
tests/test_device.py::TestDevice::test_tags <- tests/_device_tests/_device_tests.py PASSED [ 22%]
tests/test_device.py::TestDevice::test_iteration <- tests/_device_tests/_device_tests.py PASSED [ 22%]
tests/test_device.py::TestDevice::test_length <- tests/_device_tests/_device_tests.py PASSED [ 23%]
tests/test_device.py::TestDevice::test_key_subset <- tests/_device_tests/_device_tests.py PASSED [ 23%]
tests/test_device.py::TestDevice::test_getitem <- tests/_device_tests/_device_tests.py PASSED [ 24%]
tests/test_device.py::TestDevice::test_getitem_devname <- tests/_device_tests/_device_tests.py PASSED [ 25%]
tests/test_device.py::TestDevice::test_getitem_nonexisting <- tests/_device_tests/_device_tests.py PASSED [ 25%]
tests/test_device.py::TestDevice::test_asint <- tests/_device_tests/_device_tests.py SKIPPED [ 26%]
tests/test_device.py::TestDevice::test_asbool <- tests/_device_tests/_device_tests.py SKIPPED [ 26%]
tests/test_device.py::TestDevice::test_hash <- tests/_device_tests/_device_tests.py PASSED [ 27%]
tests/test_device.py::TestDevice::test_equality <- tests/_device_tests/_device_tests.py PASSED [ 27%]
tests/test_device.py::TestDevice::test_inequality <- tests/_device_tests/_device_tests.py PASSED [ 28%]
tests/test_device.py::TestDevice::test_device_ordering <- tests/_device_tests/_device_tests.py PASSED [ 28%]
tests/test_device.py::TestDevice::test_id_wwn_with_extension <- tests/_device_tests/_device_tests.py SKIPPED [ 29%]
tests/test_device.py::TestDevices::test_from_path <- tests/_device_tests/_devices_tests.py PASSED [ 29%]
tests/test_device.py::TestDevices::test_from_path_strips_leading_slash <- tests/_device_tests/_devices_tests.py PASSED [ 30%]
tests/test_device.py::TestDevices::test_from_sys_path <- tests/_device_tests/_devices_tests.py PASSED [ 30%]
tests/test_device.py::TestDevices::test_from_sys_path_device_not_found <- tests/_device_tests/_devices_tests.py PASSED [ 31%]
tests/test_device.py::TestDevices::test_from_name <- tests/_device_tests/_devices_tests.py PASSED [ 31%]
tests/test_device.py::TestDevices::test_from_name_no_device_in_existing_subsystem <- tests/_device_tests/_devices_tests.py PASSED [ 32%]
tests/test_device.py::TestDevices::test_from_name_nonexisting_subsystem <- tests/_device_tests/_devices_tests.py PASSED [ 32%]
tests/test_device.py::TestDevices::test_from_device_number <- tests/_device_tests/_devices_tests.py PASSED [ 33%]
tests/test_device.py::TestDevices::test_from_device_number_wrong_type <- tests/_device_tests/_devices_tests.py PASSED [ 33%]
tests/test_device.py::TestDevices::test_from_device_number_invalid_type <- tests/_device_tests/_devices_tests.py PASSED [ 34%]
tests/test_device.py::TestDevices::test_from_device_file <- tests/_device_tests/_devices_tests.py PASSED [ 34%]
tests/test_device.py::TestDevices::test_from_device_file_links <- tests/_device_tests/_devices_tests.py SKIPPED [ 35%]
tests/test_device.py::TestDevices::test_from_device_file_no_device_file <- tests/_device_tests/_devices_tests.py PASSED [ 35%]
tests/test_device.py::TestDevices::test_from_device_file_non_existing <- tests/_device_tests/_devices_tests.py PASSED [ 36%]
tests/test_device.py::TestDevices::test_from_environment <- tests/_device_tests/_devices_tests.py PASSED [ 36%]
tests/test_device.py::TestTags::test_iteration_and_contains <- tests/_device_tests/_tags_tests.py SKIPPED [ 37%]
tests/test_device.py::TestTags::test_iteration_mock <- tests/_device_tests/_tags_tests.py PASSED [ 38%]
tests/test_device.py::TestTags::test_contains_mock <- tests/_device_tests/_tags_tests.py PASSED [ 38%]
tests/test_device.py::test_garbage PASSED                                [ 39%]
tests/test_discover.py::TestDiscovery::test_device_number PASSED         [ 39%]
tests/test_discover.py::TestDiscovery::test_path PASSED                  [ 40%]
tests/test_discover.py::TestDiscovery::test_name PASSED                  [ 40%]
tests/test_discover.py::TestDiscovery::test_device_file SKIPPED          [ 41%]
tests/test_discover.py::TestDiscovery::test_anything PASSED              [ 41%]
tests/test_enumerate.py::TestEnumerator::test_match_subsystem_nomatch <- tests/utils/misc.py PASSED [ 42%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_nomatch_unfulfillable <- tests/utils/misc.py PASSED [ 42%]
tests/test_enumerate.py::TestEnumerator::test_match_sys_name <- tests/utils/misc.py PASSED [ 43%]
tests/test_enumerate.py::TestEnumerator::test_match_subsystem_nomatch_unfulfillable <- tests/utils/misc.py PASSED [ 43%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_int <- tests/utils/misc.py PASSED [ 44%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_bool <- tests/utils/misc.py PASSED [ 44%]
tests/test_enumerate.py::TestEnumerator::test_match_property_int <- tests/utils/misc.py PASSED [ 45%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_nomatch_complete <- tests/utils/misc.py PASSED [ 45%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_nomatch <- tests/utils/misc.py FAILED [ 46%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_match <- tests/utils/misc.py FAILED [ 46%]
tests/test_enumerate.py::TestEnumerator::test_match_parent <- tests/utils/misc.py PASSED [ 47%]
tests/test_enumerate.py::TestEnumerator::test_match_subsystem <- tests/utils/misc.py PASSED [ 47%]
tests/test_enumerate.py::TestEnumerator::test_match_property_bool <- tests/utils/misc.py SKIPPED [ 48%]
tests/test_enumerate.py::TestEnumerator::test_match_property_string <- tests/utils/misc.py PASSED [ 48%]
tests/test_enumerate.py::TestEnumerator::test_match_subsystem_nomatch_complete <- tests/utils/misc.py PASSED [ 49%]
tests/test_enumerate.py::TestEnumerator::test_match_tag <- tests/utils/misc.py SKIPPED [ 50%]
tests/test_enumerate.py::TestEnumerator::test_match_attribute_string <- tests/utils/misc.py PASSED [ 50%]
tests/test_enumerate.py::TestEnumeratorMatchCombinations::test_combined_property_matches PASSED [ 51%]
tests/test_enumerate.py::TestEnumeratorMatchCombinations::test_combined_attribute_matches PASSED [ 51%]
tests/test_enumerate.py::TestEnumeratorMatchCombinations::test_combined_matches_of_different_types PASSED [ 52%]
tests/test_enumerate.py::TestEnumeratorMatchCombinations::test_match PASSED [ 52%]
tests/test_enumerate.py::TestEnumeratorMatchMethod::test_match_passthrough_subsystem PASSED [ 53%]
tests/test_enumerate.py::TestEnumeratorMatchMethod::test_match_passthrough_sys_name PASSED [ 53%]
tests/test_enumerate.py::TestEnumeratorMatchMethod::test_match_passthrough_tag PASSED [ 54%]
tests/test_enumerate.py::TestEnumeratorMatchMethod::test_match_passthrough_parent PASSED [ 54%]
tests/test_enumerate.py::TestEnumeratorMatchMethod::test_match_passthrough_property PASSED [ 55%]
tests/test_monitor.py::TestMonitor::test_from_netlink_invalid_source PASSED [ 55%]
tests/test_monitor.py::TestMonitor::test_from_netlink_source_udev PASSED [ 56%]
tests/test_monitor.py::TestMonitor::test_from_netlink_source_udev_mock PASSED [ 56%]
tests/test_monitor.py::TestMonitor::test_from_netlink_source_kernel PASSED [ 57%]
tests/test_monitor.py::TestMonitor::test_from_netlink_source_kernel_mock PASSED [ 57%]
tests/test_monitor.py::TestMonitor::test_fileno PASSED                   [ 58%]
tests/test_monitor.py::TestMonitor::test_fileno_mock PASSED              [ 58%]
tests/test_monitor.py::TestMonitor::test_filter_by_no_subsystem PASSED   [ 59%]
tests/test_monitor.py::TestMonitor::test_filter_by_subsystem_no_dev_type PASSED [ 59%]
tests/test_monitor.py::TestMonitor::test_filter_by_subsystem_no_dev_type_mock PASSED [ 60%]
tests/test_monitor.py::TestMonitor::test_filter_by_subsystem_dev_type PASSED [ 60%]
tests/test_monitor.py::TestMonitor::test_filter_by_subsystem_dev_type_mock PASSED [ 61%]
tests/test_monitor.py::TestMonitor::test_filter_by_tag PASSED            [ 61%]
tests/test_monitor.py::TestMonitor::test_filter_by_tag_mock PASSED       [ 62%]
tests/test_monitor.py::TestMonitor::test_remove_filter PASSED            [ 63%]
tests/test_monitor.py::TestMonitor::test_remove_filter_mock PASSED       [ 63%]
tests/test_monitor.py::TestMonitor::test_start_netlink_kernel_source PASSED [ 64%]
tests/test_monitor.py::TestMonitor::test_start_mock PASSED               [ 64%]
tests/test_monitor.py::TestMonitor::test_enable_receiving PASSED         [ 65%]
tests/test_monitor.py::TestMonitor::test_set_receive_buffer_size_mock PASSED [ 65%]
tests/test_monitor.py::TestMonitor::test_poll_timeout PASSED             [ 66%]
tests/test_monitor.py::TestMonitor::test_poll SKIPPED                    [ 66%]
tests/test_monitor.py::TestMonitor::test_receive_device PASSED           [ 67%]
tests/test_monitor.py::TestMonitor::test_iter SKIPPED                    [ 67%]
tests/test_monitor.py::TestMonitorObserver::test_deprecated_handler PASSED [ 68%]
tests/test_monitor.py::TestMonitorObserver::test_fake PASSED             [ 68%]
tests/test_monitor.py::TestMonitorObserver::test_real SKIPPED            [ 69%]
tests/test_observer.py::test_fake_monitor PASSED                         [ 69%]
tests/test_observer.py::TestPysideObserver::test_monitor SKIPPED         [ 70%]
tests/test_observer.py::TestPysideObserver::test_events_fake_monitor SKIPPED [ 70%]
tests/test_observer.py::TestPysideObserver::test_events_real SKIPPED     [ 71%]
tests/test_observer.py::TestPyQt4Observer::test_monitor SKIPPED          [ 71%]
tests/test_observer.py::TestPyQt4Observer::test_events_fake_monitor SKIPPED [ 72%]
tests/test_observer.py::TestPyQt4Observer::test_events_real SKIPPED      [ 72%]
tests/test_observer.py::TestPyQt5Observer::test_monitor PASSED           [ 73%]
tests/test_observer.py::TestPyQt5Observer::test_events_fake_monitor PASSED [ 73%]
tests/test_observer.py::TestPyQt5Observer::test_events_real SKIPPED      [ 74%]
tests/test_observer.py::TestGlibObserver::test_monitor PASSED            [ 75%]
tests/test_observer.py::TestGlibObserver::test_events_fake_monitor PASSED [ 75%]
tests/test_observer.py::TestGlibObserver::test_events_real SKIPPED       [ 76%]
tests/test_observer.py::TestWxObserver::test_monitor SKIPPED             [ 76%]
tests/test_observer.py::TestWxObserver::test_events_fake_monitor SKIPPED [ 77%]
tests/test_observer.py::TestWxObserver::test_events_real SKIPPED         [ 77%]
tests/test_observer_deprecated.py::TestDeprecatedPysideObserver::test_monitor SKIPPED [ 78%]
tests/test_observer_deprecated.py::TestDeprecatedPysideObserver::test_events_fake_monitor[add] SKIPPED [ 78%]
tests/test_observer_deprecated.py::TestDeprecatedPysideObserver::test_events_fake_monitor[remove] SKIPPED [ 79%]
tests/test_observer_deprecated.py::TestDeprecatedPysideObserver::test_events_fake_monitor[change] SKIPPED [ 79%]
tests/test_observer_deprecated.py::TestDeprecatedPysideObserver::test_events_fake_monitor[move] SKIPPED [ 80%]
tests/test_observer_deprecated.py::TestDeprecatedPysideObserver::test_events_real SKIPPED [ 80%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_monitor SKIPPED [ 81%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[add] SKIPPED [ 81%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[remove] SKIPPED [ 82%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[change] SKIPPED [ 82%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[move] SKIPPED [ 83%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_real SKIPPED [ 83%]
tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::test_monitor PASSED [ 84%]
tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::test_events_fake_monitor[add] PASSED [ 84%]
tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::test_events_fake_monitor[remove] PASSED [ 85%]
tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::test_events_fake_monitor[change] PASSED [ 85%]
tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::test_events_fake_monitor[move] PASSED [ 86%]
tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::test_events_real SKIPPED [ 86%]
tests/test_observer_deprecated.py::TestDeprecatedWxObserver::test_monitor SKIPPED [ 87%]
tests/test_observer_deprecated.py::TestDeprecatedWxObserver::test_events_fake_monitor[add] SKIPPED [ 88%]
tests/test_observer_deprecated.py::TestDeprecatedWxObserver::test_events_fake_monitor[remove] SKIPPED [ 88%]
tests/test_observer_deprecated.py::TestDeprecatedWxObserver::test_events_fake_monitor[change] SKIPPED [ 89%]
tests/test_observer_deprecated.py::TestDeprecatedWxObserver::test_events_fake_monitor[move] SKIPPED [ 89%]
tests/test_observer_deprecated.py::TestDeprecatedWxObserver::test_events_real SKIPPED [ 90%]
tests/test_pypi.py::test_manifest_complete SKIPPED                       [ 90%]
tests/test_pypi.py::test_description_rendering PASSED                    [ 91%]
tests/test_util.py::test_ensure_byte_string PASSED                       [ 91%]
tests/test_util.py::test_ensure_byte_string_none PASSED                  [ 92%]
tests/test_util.py::test_ensure_unicode_string PASSED                    [ 92%]
tests/test_util.py::test_ensure_unicode_string_none PASSED               [ 93%]
tests/test_util.py::test_property_value_to_bytes_string PASSED           [ 93%]
tests/test_util.py::test_property_value_to_bytes_int PASSED              [ 94%]
tests/test_util.py::test_property_value_to_bytes_bool PASSED             [ 94%]
tests/test_util.py::test_string_to_bool_true PASSED                      [ 95%]
tests/test_util.py::test_string_to_bool_false PASSED                     [ 95%]
tests/test_util.py::test_string_to_bool_invalid_value PASSED             [ 96%]
tests/test_util.py::test_udev_list_iterate_no_entry PASSED               [ 96%]
tests/test_util.py::test_udev_list_iterate_mock PASSED                   [ 97%]
tests/test_util.py::test_get_device_type_character_device PASSED         [ 97%]
tests/test_util.py::test_get_device_type_block_device PASSED             [ 98%]
tests/test_util.py::test_get_device_type_no_device_file PASSED           [ 98%]
tests/test_util.py::test_get_device_type_not_existing PASSED             [ 99%]
tests/test_util.py::test_eintr_retry_call PASSED                         [100%]

=================================== FAILURES ===================================
_________________ TestEnumerator.test_match_attribute_nomatch __________________

args = (<tests.test_enumerate.TestEnumerator object at 0x7f75cd679bd0>,)

    @wraps(func)
    def the_func(*args):
        """
            Catch a hypothesis FailedHealthCheck exception and log it as a skip.
            """
        try:
>           func(*args)

tests/utils/misc.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/test_enumerate.py:224: in test_match_attribute_nomatch
    @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
/usr/lib64/python2.7/site-packages/hypothesis/core.py:581: in execute
    result = self.test_runner(data, run)
/usr/lib64/python2.7/site-packages/hypothesis/executors.py:58: in default_new_style_executor
    return function(data)
/usr/lib64/python2.7/site-packages/hypothesis/core.py:573: in run
    return test(*args, **kwargs)
tests/test_enumerate.py:224: in test_match_attribute_nomatch
    @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
/usr/lib64/python2.7/site-packages/hypothesis/core.py:520: in test
    result = self.test(*args, **kwargs)
tests/test_enumerate.py:236: in test_match_attribute_nomatch
    lambda d: d.attributes.get(key) != value
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

context = <pyudev.core.Context object at 0x7f75d0d49cd0>
devices = frozenset([Device(u'/sys/devices/pci0000:00/0000:00:1f.2/ata1/host0/target0:0:0/0:0:0:0/block/sda'), Device(u'/sys/dev...evices/pnp0/00:01/rtc/rtc0'), Device(u'/sys/devices/system/cpu/cpu10'), Device(u'/sys/devices/system/cpu/cpu11'), ...])
func = <function <lambda> at 0x7f75cd60dc80>

    def _test_direct_and_complement(context, devices, func):
        """
        Test that results are correct and that complement holds.
    
        :param Context context: the libudev context
        :param devices: the devices that match
        :type devices: frozenset of Device
        :param func: the property to test
        :type func: device -> bool
        """
>       assert [device for device in devices if not func(device)] == []
E       AssertionError: assert [Device(u'/sy...0/device:01')] == []
E         Left contains more items, first extra item: Device(u'/sys/devices/LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:01')
E         Full diff:
E         - [Device(u'/sys/devices/LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:01')]
E         + []

tests/test_enumerate.py:66: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_match_attribute_nomatch(self=<tests.test_enumerate.TestEnumerator at 0x7f75cd679bd0>, context=<pyudev.core.Context at 0x7f75d0d49cd0>, pair=(u'path', '\\_SB_.PCI0.P32_'))

You can reproduce this example by temporarily adding @reproduce_failure('3.50.1', 'AAAtAQ==') as a decorator on your test case
__________________ TestEnumerator.test_match_attribute_match ___________________

args = (<tests.test_enumerate.TestEnumerator object at 0x7f75cd70d8d0>,)

    @wraps(func)
    def the_func(*args):
        """
            Catch a hypothesis FailedHealthCheck exception and log it as a skip.
            """
        try:
>           func(*args)

tests/utils/misc.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/test_enumerate.py:211: in test_match_attribute_match
    @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
/usr/lib64/python2.7/site-packages/hypothesis/core.py:581: in execute
    result = self.test_runner(data, run)
/usr/lib64/python2.7/site-packages/hypothesis/executors.py:58: in default_new_style_executor
    return function(data)
/usr/lib64/python2.7/site-packages/hypothesis/core.py:573: in run
    return test(*args, **kwargs)
tests/test_enumerate.py:211: in test_match_attribute_match
    @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
/usr/lib64/python2.7/site-packages/hypothesis/core.py:520: in test
    result = self.test(*args, **kwargs)
tests/test_enumerate.py:220: in test_match_attribute_match
    lambda d: d.attributes.get(key) == value
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

context = <pyudev.core.Context object at 0x7f75d0d49cd0>
devices = frozenset([]), func = <function <lambda> at 0x7f75cd12b7d0>

    def _test_direct_and_complement(context, devices, func):
        """
        Test that results are correct and that complement holds.
    
        :param Context context: the libudev context
        :param devices: the devices that match
        :type devices: frozenset of Device
        :param func: the property to test
        :type func: device -> bool
        """
        assert [device for device in devices if not func(device)] == []
        complement = frozenset(context.list_devices()) - devices
>       assert [device for device in complement if func(device)] == []
E       AssertionError: assert [Device(u'/sy...LNXSYSTM:00')] == []
E         Left contains more items, first extra item: Device(u'/sys/devices/LNXSYSTM:00')
E         Full diff:
E         - [Device(u'/sys/devices/LNXSYSTM:00')]
E         + []

tests/test_enumerate.py:68: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_match_attribute_match(self=<tests.test_enumerate.TestEnumerator at 0x7f75cd70d8d0>, context=<pyudev.core.Context at 0x7f75d0d49cd0>, pair=(u'path', '\\'))

You can reproduce this example by temporarily adding @reproduce_failure('3.50.1', 'AAAAAg==') as a decorator on your test case
=============================== warnings summary ===============================
None
  [pytest] section in setup.cfg files is deprecated, use [tool:pytest] instead.

tests/test_device.py::TestAttributes::()::test_getitem
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <tests.utils.udev.DeviceDatabase object at 0x7f75d0d49c90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_device.py::TestDevice::()::test_getitem
  hypothesis_temporary_module_c1c33a3dcff510661568e4e44b25574a60bfc0f9:361: HypothesisDeprecationWarning: Test took 212.40ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 300 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_discover.py::TestDiscovery::()::test_device_number
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <pyudev.core.Enumerator object at 0x7f75d0cbaad0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumerator::()::test_match_subsystem_nomatch
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <pyudev.core.Enumerator object at 0x7f75d0c842d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_77109e94108e45c6efae8cddec61f59a2abeedc8:101: HypothesisDeprecationWarning: Test took 691.87ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 700 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_nomatch_unfulfillable
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_a00c14637674e6b4bb6bc365350f3c50bad2092e:240: HypothesisDeprecationWarning: Test took 260.87ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 300 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7135a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7136e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7137d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7750a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumerator::()::test_match_sys_name
  hypothesis_temporary_module_43461005ec4251f0d2212edf2c9b33b4a42aa833:146: HypothesisDeprecationWarning: Test took 377.48ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 400 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_int
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7135f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7138c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_a60f0293a124bc0b0c9128c018ca5cabb8d46049:281: HypothesisDeprecationWarning: Test took 271.80ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 300 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd713780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7750f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7753c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7754b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7755a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7756e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7758c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d54b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d52d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d56e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d59b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f01e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f02d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f03c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f04b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f05f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f06e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b70a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b72d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b73c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b78c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b79b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c3c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c5a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62ca00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c7d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62caf0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62cb90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62ccd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62cc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62cdc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62cfa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f30f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62ce60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62ce10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f31e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f32d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f34b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f36e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3b90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_bool
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd775dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d51e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_bcc5c363bfdefbdab8d9f2c5a67fe27f9e12027e:299: HypothesisDeprecationWarning: Test took 327.03ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 400 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d58c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6d5dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd8944b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd894a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b74b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b76e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd894320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6b7d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62c820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd62cc80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7e5e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f38c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f39b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5f3e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b7d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55ba50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55baf0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55bbe0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55bc80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55be10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55bcd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55beb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55bf50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5190f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5192d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5193c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5194b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5195f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd5198c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519b90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f00a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd519dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f01e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f05f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f06e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f07d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f09b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c71e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c70f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c75a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c76e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumerator::()::test_match_property_int
  hypothesis_temporary_module_9df60ffce3d01aa8705e0c6c02e21b112ba77eec:173: HypothesisDeprecationWarning: Test took 313.16ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 400 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_nomatch_complete
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd7751e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_6ce7b66708270a94045696ab5708eac7e5bcd143:253: HypothesisDeprecationWarning: Test took 983.93ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 1000 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b2d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55bc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55bf00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6f0a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd55b820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4f0230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4c7690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/core.py:1049: HypothesisDeprecationWarning: Your tests are hitting the settings timeout (60.00s). This functionality will go away in a future release and you should not rely on it. Instead, try setting max_examples to be some value lower than 49 (the number of examples your test successfully ran here). Or, if you would prefer your tests to run to completion, regardless of how long they take, you can set the timeout value to hypothesis.unlimited.
    state.run()

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_nomatch
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6bcf00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_66761eabec6311ba69e3dd50ee5da0696ac414f8:224: HypothesisDeprecationWarning: Test took 1007.81ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 1100 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4940a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4945f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd4948c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b31e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b3640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b36e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b3a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b3aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b3f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd494af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b3e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25b2d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25b460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25b730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25b8c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25b9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25baa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25bc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_match
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd25b500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_bd8653928ca49a2bcefe7862c6d09fe263955a75:211: HypothesisDeprecationWarning: Test took 794.41ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 800 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c7a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c7b90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c79b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c7e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c7fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd114230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3b33c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c7be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd1c7f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd114780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd6bcfa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd114c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd114cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd114fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3013c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3017d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd3018c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd301f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd0220a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd0226e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd022230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumerator::()::test_match_subsystem
  hypothesis_temporary_module_368e6de2bb5c862688075379a3e7b7978bda7cd5:88: HypothesisDeprecationWarning: Test took 610.00ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 700 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumerator::()::test_match_property_string
  hypothesis_temporary_module_8ded927f73d9eab7d1e6331aa53dc4faea77bb76:159: HypothesisDeprecationWarning: Test took 765.39ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 800 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumerator::()::test_match_subsystem_nomatch_complete
  hypothesis_temporary_module_e0c3aa1027d6ca8f5956f66112519441f37ccade:128: HypothesisDeprecationWarning: Test took 694.81ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 700 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumerator::()::test_match_attribute_string
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_bc15ad2cb75d1fe905f31aca10824ada641beae7:270: HypothesisDeprecationWarning: Test took 274.03ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 300 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd03ae10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75cd0697d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf0a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf7d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf8c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumeratorMatchCombinations::()::test_combined_property_matches
  hypothesis_temporary_module_9665b4d63047daf1ca08e12d47aebad8e8d5f957:363: HypothesisDeprecationWarning: Test took 750.79ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 800 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_enumerate.py::TestEnumeratorMatchCombinations::()::test_combined_attribute_matches
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf03370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccf035f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_3eb2ad5a799315264a5ac26e5fcffe6a9c57013d:393: HypothesisDeprecationWarning: Test took 770.33ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 800 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf3c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebfaa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebfbe0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebfd70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebfe60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebff00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca0a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca3c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca8c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdcaa50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumeratorMatchCombinations::()::test_combined_matches_of_different_types
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebf190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  hypothesis_temporary_module_9728d3e610389c4248e4bd996b4580c46a1ed212:423: HypothesisDeprecationWarning: Test took 772.32ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 800 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccebfc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdca9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdcabe0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdcad20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccdcae10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccd1f190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7f75ccd1f320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)

tests/test_enumerate.py::TestEnumeratorMatchCombinations::()::test_match
  hypothesis_temporary_module_bd33746b1a17a342ebccbe37f8c6ed29145fddb8:459: HypothesisDeprecationWarning: Test took 368.24ms to run. In future the default deadline setting will be 200ms, which will make this an error. You can set deadline to an explicit value of e.g. 400 to turn tests slower than this into an error, or you can set it to None to disable this check entirely.

tests/test_observer.py::TestGlibObserver::()::test_monitor
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer.py:179: Warning: Source ID 6 was not found when attempting to remove it
    self.glib.source_remove(source)

tests/test_observer.py::TestGlibObserver::()::test_events_fake_monitor
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer.py:179: Warning: Source ID 11 was not found when attempting to remove it
    self.glib.source_remove(source)
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer.py:179: Warning: Source ID 9 was not found when attempting to remove it
    self.glib.source_remove(source)

tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::()::test_monitor
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 13 was not found when attempting to remove it
    self.glib.source_remove(source)

tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::()::test_events_fake_monitor[add]
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 18 was not found when attempting to remove it
    self.glib.source_remove(source)
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 16 was not found when attempting to remove it
    self.glib.source_remove(source)

tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::()::test_events_fake_monitor[remove]
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 22 was not found when attempting to remove it
    self.glib.source_remove(source)
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 20 was not found when attempting to remove it
    self.glib.source_remove(source)

tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::()::test_events_fake_monitor[change]
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 26 was not found when attempting to remove it
    self.glib.source_remove(source)
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 24 was not found when attempting to remove it
    self.glib.source_remove(source)

tests/test_observer_deprecated.py::TestDeprecatedGlibObserver::()::test_events_fake_monitor[move]
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 30 was not found when attempting to remove it
    self.glib.source_remove(source)
  /var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_observer_deprecated.py:205: Warning: Source ID 28 was not found when attempting to remove it
    self.glib.source_remove(source)

-- Docs: http://doc.pytest.org/en/latest/warnings.html
======= 2 failed, 145 passed, 45 skipped, 444 warnings in 463.85 seconds =======
 * ERROR: dev-python/pyudev-0.21.0::gentoo failed (test phase):
 *   Tests fail with python2.7
 * 
 * Call stack:
 *     ebuild.sh, line  124:  Called src_test
 *   environment, line 2658:  Called distutils-r1_src_test
 *   environment, line  905:  Called _distutils-r1_run_foreach_impl 'python_test'
 *   environment, line  355:  Called python_foreach_impl 'distutils-r1_run_phase' 'python_test'
 *   environment, line 2184:  Called multibuild_foreach_variant '_python_multibuild_wrapper' 'distutils-r1_run_phase' 'python_test'
 *   environment, line 1559:  Called _multibuild_run '_python_multibuild_wrapper' 'distutils-r1_run_phase' 'python_test'
 *   environment, line 1557:  Called _python_multibuild_wrapper 'distutils-r1_run_phase' 'python_test'
 *   environment, line  579:  Called distutils-r1_run_phase 'python_test'
 *   environment, line  836:  Called python_test
 *   environment, line 2560:  Called die
 * The specific snippet of code:
 *       py.test -v || die "Tests fail with ${EPYTHON}"
 * 
 * If you need support, post the output of `emerge --info '=dev-python/pyudev-0.21.0::gentoo'`,
 * the complete build log and the output of `emerge -pqv '=dev-python/pyudev-0.21.0::gentoo'`.
 * The complete build log is located at '/var/log/portage/dev-python:pyudev-0.21.0:20180530-103504.log'.
 * For convenience, a symlink to the build log is located at '/var/tmp/portage/dev-python/pyudev-0.21.0/temp/build.log'.
 * The ebuild environment file is located at '/var/tmp/portage/dev-python/pyudev-0.21.0/temp/environment'.
 * Working directory: '/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0'
 * S: '/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0'