TST, fix for issue pandas-dev#17978.

moved generic thing to pandas.utils._hypothesis.py.
not sure of what exactly was required to change but still tried to
change the content as per review comments.

Author: sushobhit27

doc/source/contributing.rst

@@ -775,13 +775,13 @@ Tests that we have ``parametrized`` are now accessible via the test name, for ex
    test_cool_feature.py::test_dtypes[int8] PASSED
    test_cool_feature.py::test_series[int8] PASSED
 
-Transitioning to ``hypothesis``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Using ``hypothesis``
+~~~~~~~~~~~~~~~~~~~~
 With the transition to pytest, things have become easier for testing by having reduced boilerplate for test cases and also by utilizing pytest's features like parametizing, skipping and marking test cases.
 
 However, one has to still come up with input data examples which can be tested against the functionality. There is always a possibility to skip testing an example which could have failed the test case.
 
-Imagine if some framework could generate random input examples based on the property/specification of the function being tested. That is exactly what hypothesis does by generating the input data based on some set of specifications provided by the user.
+Hypothesis is a python package which helps in overcoming this issue by generating the input data based on some set of specifications provided by the user.
 e.g suppose we have to test python's sum function for a list of int.
 
 Here is a sample test case using pytest:
@@ -841,6 +841,8 @@ output of test cases:
     ========================== 1 passed in 0.33 seconds ===========================
 
 The main difference in above example is use of a decorator "@given(st.lists(st.integers()))" which if applied to test case function, generates some random list of int, which is then assigned to parameter of test case.
+Above example clearly helps in adding more coverage for our test functions.
+
 For more information about hypothesis or in general about property based testing, check below links:
 
 - https://hypothesis.readthedocs.io/en/latest/quickstart.html

pandas/tests/reshape/test_util.py

@@ -4,105 +4,18 @@
 import pandas.util.testing as tm
 from pandas.core.reshape.util import cartesian_product
 
-from hypothesis import strategies as st
-from hypothesis import given, settings, assume
+import string
 from datetime import date
 from dateutil import relativedelta
-import string
 
+from pandas.util._hypothesis import (st,
+                                     given,
+                                     settings,
+                                     get_seq,
+                                     assume)
 
-NO_OF_EXAMPLES_PER_TEST_CASE = 20
 
-
-def get_elements(elem_type):
-    strategy = st.nothing()
-    if elem_type == bool:
-        strategy = st.booleans()
-    elif elem_type == int:
-        strategy = st.integers()
-    elif elem_type == float:
-        strategy = st.floats()
-    elif elem_type == str:
-        strategy = st.text(string.ascii_letters, max_size=10)
-    return strategy
-
-
-@st.composite
-def get_seq(draw, types, mixed=False, min_size=None, max_size=None,
-            transform_func=None):
-    """
-    Helper function to generate strategy for creating lists.
-    What constitute in the generated list is driven by the different
-    parameters.
-
-    Parameters
-    ----------
-    types: iterable sequence like tuple or list
-        types which can be in the generated list.
-    mixed: bool
-        if True, list will contains elements from all types listed in arg,
-        otherwise it will have elements only from types[0].
-    min_size: int
-        minimum size of the list.
-    max_size: int
-        maximum size of the list.
-    transform_func: callable
-        a callable which can be applied to whole list after it has been
-         generated. It can think of as providing functionality of filter
-         and map function.
-
-    Returns
-    -------
-    hypothesis lists strategy.
-
-    Examples
-    --------
-    seq_strategy = get_seq((int, str, bool),
-                            mixed=True, min_size=1, max_size=5)
-    seq_strategy.example()
-    Out[12]: ['lkYMSn', -2501, 35, 'J']
-    seq_strategy.example()
-    Out[13]: [True]
-    seq_strategy.example()
-    Out[14]: ['dRWgQYrBrW', True, False, 'gmsujJVDBM', 'Z']
-
-    seq_strategy = get_seq((int, bool),
-                            mixed=False,
-                            min_size=1,
-                            max_size=5,
-                            transform_func=lambda seq: [str(x) for x in seq])
-    seq_strategy.example()
-    Out[19]: ['-1892']
-    seq_strategy.example()
-    Out[20]: ['22', '66', '14785', '-26312', '32']
-    seq_strategy.example()
-    Out[21]: ['22890', '-15537', '96']
-    """
-    strategy = st.nothing()
-    if min_size is None:
-        min_size = draw(st.integers(min_value=0, max_value=100))
-
-    if max_size is None:
-        max_size = draw(st.integers(min_value=min_size, max_value=100))
-
-    assert min_size <= max_size, \
-        'max_size must be greater than equal to min_size'
-
-    elem_strategies = []
-    for elem_type in types:
-        elem_strategies.append(get_elements(elem_type))
-        if not mixed:
-            break
-
-    if transform_func:
-        strategy = draw(st.lists(st.one_of(elem_strategies),
-                                 min_size=min_size,
-                                 max_size=max_size).map(transform_func))
-    else:
-        strategy = draw(st.lists(st.one_of(elem_strategies),
-                                 min_size=min_size,
-                                 max_size=max_size))
-    return strategy
+NO_OF_EXAMPLES_PER_TEST_CASE = 20
 
 
 class TestCartesianProduct(object):

pandas/util/_hypothesis.py

@@ -0,0 +1,97 @@
+import string
+from hypothesis import (given,
+                        settings,
+                        assume,
+                        strategies as st,
+                        )
+
+
+def get_elements(elem_type):
+    strategy = st.nothing()
+    if elem_type == bool:
+        strategy = st.booleans()
+    elif elem_type == int:
+        strategy = st.integers()
+    elif elem_type == float:
+        strategy = st.floats()
+    elif elem_type == str:
+        strategy = st.text(string.ascii_letters, max_size=10)
+    return strategy
+
+
+@st.composite
+def get_seq(draw, types, mixed=False, min_size=None, max_size=None,
+            transform_func=None):
+    """
+    Helper function to generate strategy for creating lists.
+    What constitute in the generated list is driven by the different
+    parameters.
+
+    Parameters
+    ----------
+    types: iterable sequence like tuple or list
+        types which can be in the generated list.
+    mixed: bool
+        if True, list will contains elements from all types listed in arg,
+        otherwise it will have elements only from types[0].
+    min_size: int
+        minimum size of the list.
+    max_size: int
+        maximum size of the list.
+    transform_func: callable
+        a callable which can be applied to whole list after it has been
+         generated. It can think of as providing functionality of filter
+         and map function.
+
+    Returns
+    -------
+    hypothesis lists strategy.
+
+    Examples
+    --------
+    seq_strategy = get_seq((int, str, bool),
+                            mixed=True, min_size=1, max_size=5)
+    seq_strategy.example()
+    Out[12]: ['lkYMSn', -2501, 35, 'J']
+    seq_strategy.example()
+    Out[13]: [True]
+    seq_strategy.example()
+    Out[14]: ['dRWgQYrBrW', True, False, 'gmsujJVDBM', 'Z']
+
+    seq_strategy = get_seq((int, bool),
+                            mixed=False,
+                            min_size=1,
+                            max_size=5,
+                            transform_func=lambda seq: [str(x) for x in seq])
+    seq_strategy.example()
+    Out[19]: ['-1892']
+    seq_strategy.example()
+    Out[20]: ['22', '66', '14785', '-26312', '32']
+    seq_strategy.example()
+    Out[21]: ['22890', '-15537', '96']
+    """
+    strategy = st.nothing()
+    if min_size is None:
+        min_size = draw(st.integers(min_value=0, max_value=100))
+
+    if max_size is None:
+        max_size = draw(st.integers(min_value=min_size, max_value=100))
+
+    assert min_size <= max_size, \
+        'max_size must be greater than equal to min_size'
+
+    elem_strategies = []
+    for elem_type in types:
+        elem_strategies.append(get_elements(elem_type))
+        if not mixed:
+            break
+
+    if transform_func:
+        strategy = draw(st.lists(st.one_of(elem_strategies),
+                                 min_size=min_size,
+                                 max_size=max_size).map(transform_func))
+    else:
+        strategy = draw(st.lists(st.one_of(elem_strategies),
+                                 min_size=min_size,
+                                 max_size=max_size))
+    return strategy