dev-python:pyudev-0.21.0:20180513-142213.log

dev-python:pyudev-0.21.0:20180513-142213.log (text/plain), 366.74 KB, created by Toralf Förster on 2018-05-13 14:29:01 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: xprocess-0.12.1, xdist-1.15.0, mock-1.6.3, localserver-0.3.7, expect-1.1.0, cov-2.5.1, capturelog-0.7, 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 SKIPPED [ 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 PASSED [ 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 PASSED           [ 71%]
tests/test_observer.py::TestPyQt4Observer::test_events_fake_monitor PASSED [ 72%]
tests/test_observer.py::TestPyQt4Observer::test_events_real SKIPPED      [ 72%]
tests/test_observer.py::TestPyQt5Observer::test_monitor ERROR            [ 73%]
tests/test_observer.py::TestPyQt5Observer::test_events_fake_monitor FAILED [ 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 PASSED [ 81%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[add] PASSED [ 81%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[remove] PASSED [ 82%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[change] PASSED [ 82%]
tests/test_observer_deprecated.py::TestDeprecatedPyQt4Observer::test_events_fake_monitor[move] PASSED [ 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%]

==================================== ERRORS ====================================
_______________ ERROR at setup of TestPyQt5Observer.test_monitor _______________

self = <tests.test_observer.TestPyQt5Observer object at 0x7fa1dc615250>
method = <bound method TestPyQt5Observer.test_monitor of <tests.test_observer.TestPyQt5Observer object at 0x7fa1dc615250>>

    def setup_method(self, method):
        self.observer = None
        self.no_emitted_signals = 0
>       self.setup()

tests/test_observer.py:57: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.test_observer.TestPyQt5Observer object at 0x7fa1dc615250>

    def setup(self):
        self.qtcore = pytest.importorskip('{0}.QtCore'.format(
>           self.BINDING_NAME))
E       RuntimeError: the PyQt5.QtCore and PyQt4.QtCore modules both wrap the QObject class

tests/test_observer.py:133: RuntimeError
=================================== FAILURES ===================================
_________________ TestEnumerator.test_match_attribute_nomatch __________________

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

    @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: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.test_enumerate.TestEnumerator object at 0x7fa1dd224510>

    @failed_health_check_wrapper
>   @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
    def test_match_attribute_nomatch(self, context, pair):
        """
            Test that nomatch returns no devices with attribute value match.
E           Flaky: Hypothesis found 2 distinct failures, but 1 of them exhibited some sort of flaky behaviour.

tests/test_enumerate.py:224: Flaky
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_match_attribute_nomatch(self=<tests.test_enumerate.TestEnumerator at 0x7fa1dd224510>, context=<pyudev.core.Context at 0x7fa1e1245b90>, pair=(u'inflight', '       0        0'))
Failed to reproduce exception. Expected: 
Traceback (most recent call last):
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 666, in evaluate_test_data
    result = self.execute(data, collect=True)
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 581, in execute
    result = self.test_runner(data, run)
  File "/usr/lib64/python2.7/site-packages/hypothesis/executors.py", line 58, in default_new_style_executor
    return function(data)
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 577, in run
    return test(*args, **kwargs)
  File "/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_enumerate.py", line 224, in test_match_attribute_nomatch
    @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 520, in test
    result = self.test(*args, **kwargs)
  File "/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_enumerate.py", line 236, in test_match_attribute_nomatch
    lambda d: d.attributes.get(key) != value
  File "/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_enumerate.py", line 66, in _test_direct_and_complement
    assert [device for device in devices if not func(device)] == []
AssertionError: assert [Device(u'/sy...ck/sdb/sdb1')] == []
  Left contains more items, first extra item: Device(u'/sys/devices/pci0000:00/0000:00:1f.2/ata2/host1/target1:0:0/1:0:0:0/block/sdb')
  Full diff:
  + []
  - [Device(u'/sys/devices/pci0000:00/0000:00:1f.2/ata2/host1/target1:0:0/1:0:0:0/block/sdb'),
  -  Device(u'/sys/devices/pci0000:00/0000:00:1f.2/ata2/host1/target1:0:0/1:0:0:0/block/sdb/sdb1')]

Flaky example! Hypothesis test_match_attribute_nomatch(self=<tests.test_enumerate.TestEnumerator at 0x7fa1dd224510>, context=<pyudev.core.Context at 0x7fa1e1245b90>, pair=(u'inflight', '       0        0')) produces unreliable results: Falsified on the first call but did not on a subsequent one

You can reproduce this example by temporarily adding @reproduce_failure('3.50.1', 'AAACAQL/Aw==') as a decorator on your test case
Falsifying example: test_match_attribute_nomatch(self=<tests.test_enumerate.TestEnumerator at 0x7fa1dd224510>, context=<pyudev.core.Context at 0x7fa1e1245b90>, pair=(u'inflight', '       0        0'))
Traceback (most recent call last):
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 820, in run
    falsifying_example.__expected_traceback,
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 581, in execute
    result = self.test_runner(data, run)
  File "/usr/lib64/python2.7/site-packages/hypothesis/executors.py", line 58, in default_new_style_executor
    return function(data)
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 573, in run
    return test(*args, **kwargs)
  File "/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_enumerate.py", line 224, in test_match_attribute_nomatch
    @given(_CONTEXT_STRATEGY, _ATTRIBUTE_STRATEGY)
  File "/usr/lib64/python2.7/site-packages/hypothesis/core.py", line 520, in test
    result = self.test(*args, **kwargs)
  File "/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_enumerate.py", line 236, in test_match_attribute_nomatch
    lambda d: d.attributes.get(key) != value
  File "/var/tmp/portage/dev-python/pyudev-0.21.0/work/pyudev-0.21.0/tests/test_enumerate.py", line 66, in _test_direct_and_complement
    assert [device for device in devices if not func(device)] == []
AssertionError: assert [Device(u'/sy...block/dm-39')] == []
  Left contains more items, first extra item: Device(u'/sys/devices/virtual/block/dm-39')
  Full diff:
  - [Device(u'/sys/devices/virtual/block/dm-39')]
  + []


You can reproduce this example by temporarily adding @reproduce_failure('3.50.1', 'AAACAQL+Aw==') as a decorator on your test case
__________________ TestPyQt5Observer.test_events_fake_monitor __________________

self = <tests.test_observer.TestPyQt5Observer object at 0x7fa1e0b7bb50>
fake_monitor = <tests.plugins.fake_monitor.FakeMonitor object at 0x7fa1dc615a90>
fake_monitor_device = Device(u'/sys/devices/pci0000:3f/0000:3f:13.5')

    def test_events_fake_monitor(self, fake_monitor, fake_monitor_device):
>       self.prepare_test(fake_monitor)

tests/test_observer.py:98: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/test_observer.py:89: in prepare_test
    self.create_event_loop(self_stop_timeout=5000)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.test_observer.TestPyQt5Observer object at 0x7fa1e0b7bb50>
self_stop_timeout = 5000

    def create_event_loop(self, self_stop_timeout=5000):
>       self.app = self.qtcore.QCoreApplication.instance()
E       AttributeError: 'module' object has no attribute 'QCoreApplication'

tests/test_observer.py:144: AttributeError
=============================== warnings summary ===============================
None
  [pytest] section in setup.cfg files is deprecated, use [tool:pytest] instead.
  pytest-capturelog plugin has been merged into the core, please remove it from your requirements.

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 0x7fa1e1245c90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_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 0x7fa1e0d0bed0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 0x7fa1e0dd5050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_nomatch_unfulfillable
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b29b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd3b2f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf2d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf3c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf7d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfaf0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfbe0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfcd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfd70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfc80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfe60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cff00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cffa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2090f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2091e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2092d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2093c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2094b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2095a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_int
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfb40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfd20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cfdc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cff50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2095f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2097d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2410f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2412d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2413c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2416e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2417d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2418c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2419b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2701e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2705a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2707d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2709b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270b90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a8c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15aaa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15abe0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 0x7fa1dd241a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd241820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd68ad70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2702d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd5dbf00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd5db910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15aa50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15a690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15aaf0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15ac80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15adc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15af50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15aeb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27f9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27fa50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27fb90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27fcd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27fdc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27faa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27fc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd27ffa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e90a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e91e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e92d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e94b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e98c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9b90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c90f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c92d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c93c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c95f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c98c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9aa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c99b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0c9c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f0a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f5f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f7d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07fb40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07fc80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07fa50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07fd70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07fe10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07feb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07ffa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_nomatch_complete
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd270370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 247.52ms 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 0x7fa1dd0e9500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd0e9f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd2cf640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07f690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_nomatch
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd15af00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 201.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 0x7fa1dd07f140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd209230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb87d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcfb8eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce6ed20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce6ee10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b3c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce6ec80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b0a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7baa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7bc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7bd70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7be10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7bf00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7beb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd6e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd9b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcdaa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcdc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcdd20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcde60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcdb90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4b0a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4b190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4b230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4b2d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce6ec30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4b820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4ba00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4ba50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4baf0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4bb90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4bc30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4bcd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4bd70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4be10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4beb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4bf50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce640f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce642d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce644b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce645f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce647d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64dc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc840f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc842d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc844b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 0x7fa1dce7bdc0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcd4b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcdcda00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4b320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dd07fa00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcd4bfa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce64f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc841e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc845a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc84c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc46b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcc46d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b7d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb572d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb575a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb579b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcb57f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 208.29ms 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 0x7fa1dcaf4140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf43c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf44b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf45a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4870>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4a50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4f00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcaf4f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac3230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac32d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac3410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac3500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac35f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac3690>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac37d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac38c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcac39b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_string
  hypothesis_temporary_module_8ded927f73d9eab7d1e6331aa53dc4faea77bb76:159: HypothesisDeprecationWarning: Test took 224.52ms 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_enumerate.py::TestEnumerator::()::test_match_subsystem_nomatch_complete
  hypothesis_temporary_module_e0c3aa1027d6ca8f5956f66112519441f37ccade:128: HypothesisDeprecationWarning: Test took 256.98ms 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_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 0x7fa1dc98eb90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98ee10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98ee60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98ef00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993280>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993230>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9932d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9934b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9933c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9935f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9936e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9938c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993910>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993960>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993a00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc9937d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993af0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dce7b1e0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98ea00>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993c80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993d20>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dcbca410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 299.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.

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 0x7fa1dc993b90>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993cd0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993d70>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993e10>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993eb0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc993f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 216.70ms 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 0x7fa1dc993fa0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc8962d0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896370>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896410>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc8964b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc8965f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896500>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc8969b0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896b40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896be0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896730>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896f50>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb050>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb0f0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98e8c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98e640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896e60>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 0x7fa1dc896190>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc896640>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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 234.82ms 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 0x7fa1dc896c30>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98e820>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc98e5a0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb140>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb320>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb460>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb550>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb780>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7eb8c0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7ebb40>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7ebbe0>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when simplifying an example, Hypothesis treats earlier values as simpler.
    values = check_sample(elements)
  /usr/lib64/python2.7/site-packages/hypothesis/strategies.py:483: HypothesisDeprecationWarning: Cannot sample from <generator object available_attributes at 0x7fa1dc7ebc80>, not a sequence.  Hypothesis goes to some length to ensure that sampling an element from a collection (with `sampled_from` or `choices`) is replayable and can be minimised.  To replay a saved example, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomisation.  Most cases can simply use `sorted(values)`, but mixed types or special values 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_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, 150 passed, 39 skipped, 467 warnings, 1 error in 195.18 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 2666:  Called distutils-r1_src_test
 *   environment, line  913:  Called _distutils-r1_run_foreach_impl 'python_test'
 *   environment, line  363:  Called python_foreach_impl 'distutils-r1_run_phase' 'python_test'
 *   environment, line 2192:  Called multibuild_foreach_variant '_python_multibuild_wrapper' 'distutils-r1_run_phase' 'python_test'
 *   environment, line 1567:  Called _multibuild_run '_python_multibuild_wrapper' 'distutils-r1_run_phase' 'python_test'
 *   environment, line 1565:  Called _python_multibuild_wrapper 'distutils-r1_run_phase' 'python_test'
 *   environment, line  587:  Called distutils-r1_run_phase 'python_test'
 *   environment, line  844:  Called python_test
 *   environment, line 2568:  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:20180513-142213.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'