File python-patsy-remove-nose.patch of Package python-patsy

Overview Repositories Revisions Requests Users Attributes Meta

File python-patsy-remove-nose.patch of Package python-patsy (Revision 76618946444d6c5fa1abda9986c9f8c4)

Currently displaying revision 76618946444d6c5fa1abda9986c9f8c4 , Show latest

Index: patsy-0.5.1/patsy/build.py
===================================================================
--- patsy-0.5.1.orig/patsy/build.py	2015-06-14 02:45:14.000000000 +0200
+++ patsy-0.5.1/patsy/build.py	2020-09-08 14:02:18.683103765 +0200
@@ -47,16 +47,16 @@ def _max_allowed_dim(dim, arr, factor):
         raise PatsyError(msg, factor)
 
 def test__max_allowed_dim():
-    from nose.tools import assert_raises
+    from pytest import raises
     f = _MockFactor()
     _max_allowed_dim(1, np.array(1), f)
     _max_allowed_dim(1, np.array([1]), f)
-    assert_raises(PatsyError, _max_allowed_dim, 1, np.array([[1]]), f)
-    assert_raises(PatsyError, _max_allowed_dim, 1, np.array([[[1]]]), f)
+    raises(PatsyError, _max_allowed_dim, 1, np.array([[1]]), f)
+    raises(PatsyError, _max_allowed_dim, 1, np.array([[[1]]]), f)
     _max_allowed_dim(2, np.array(1), f)
     _max_allowed_dim(2, np.array([1]), f)
     _max_allowed_dim(2, np.array([[1]]), f)
-    assert_raises(PatsyError, _max_allowed_dim, 2, np.array([[[1]]]), f)
+    raises(PatsyError, _max_allowed_dim, 2, np.array([[[1]]]), f)
 
 def _eval_factor(factor_info, data, NA_action):
     factor = factor_info.factor
@@ -87,7 +87,7 @@ def _eval_factor(factor_info, data, NA_a
         return result, np.asarray(result == -1)
 
 def test__eval_factor_numerical():
-    from nose.tools import assert_raises
+    from pytest import raises
     naa = NAAction()
     f = _MockFactor()
 
@@ -99,10 +99,10 @@ def test__eval_factor_numerical():
     assert np.all(eval123 == [[1], [2], [3]])
     assert is_NA.shape == (3,)
     assert np.all(~is_NA)
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": [[[1]]]}, naa)
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": [[1, 2]]}, naa)
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": ["a", "b"]}, naa)
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": [True, False]}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": [[[1]]]}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": [[1, 2]]}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": ["a", "b"]}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": [True, False]}, naa)
     fi2 = FactorInfo(_MockFactor(), "numerical",
                      {}, num_columns=2, categories=None)
     eval123321, is_NA = _eval_factor(fi2,
@@ -112,8 +112,8 @@ def test__eval_factor_numerical():
     assert np.all(eval123321 == [[1, 3], [2, 2], [3, 1]])
     assert is_NA.shape == (3,)
     assert np.all(~is_NA)
-    assert_raises(PatsyError, _eval_factor, fi2, {"mock": [1, 2, 3]}, naa)
-    assert_raises(PatsyError, _eval_factor, fi2, {"mock": [[1, 2, 3]]}, naa)
+    raises(PatsyError, _eval_factor, fi2, {"mock": [1, 2, 3]}, naa)
+    raises(PatsyError, _eval_factor, fi2, {"mock": [[1, 2, 3]]}, naa)
 
     ev_nan, is_NA = _eval_factor(fi1, {"mock": [1, 2, np.nan]},
                                  NAAction(NA_types=["NaN"]))
@@ -148,11 +148,11 @@ def test__eval_factor_numerical():
         assert np.array_equal(eval_df2, [[2, 3], [1, 4], [3, -1]])
         assert np.array_equal(eval_df2.index, [20, 30, 10])
 
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       _eval_factor, fi2,
                       {"mock": pandas.Series([1, 2, 3], index=[10, 20, 30])},
                       naa)
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       _eval_factor, fi1,
                       {"mock":
                        pandas.DataFrame([[2, 3], [1, 4], [3, -1]],
@@ -160,7 +160,7 @@ def test__eval_factor_numerical():
                       naa)
 
 def test__eval_factor_categorical():
-    from nose.tools import assert_raises
+    from pytest import raises
     from patsy.categorical import C
     naa = NAAction()
     f = _MockFactor()
@@ -170,20 +170,20 @@ def test__eval_factor_categorical():
     cat1, _ = _eval_factor(fi1, {"mock": ["b", "a", "b"]}, naa)
     assert cat1.shape == (3,)
     assert np.all(cat1 == [1, 0, 1])
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": ["c"]}, naa)
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": C(["a", "c"])}, naa)
-    assert_raises(PatsyError, _eval_factor, fi1,
+    raises(PatsyError, _eval_factor, fi1, {"mock": ["c"]}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": C(["a", "c"])}, naa)
+    raises(PatsyError, _eval_factor, fi1,
                   {"mock": C(["a", "b"], levels=["b", "a"])}, naa)
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": [1, 0, 1]}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": [1, 0, 1]}, naa)
     bad_cat = np.asarray(["b", "a", "a", "b"])
     bad_cat.resize((2, 2))
-    assert_raises(PatsyError, _eval_factor, fi1, {"mock": bad_cat}, naa)
+    raises(PatsyError, _eval_factor, fi1, {"mock": bad_cat}, naa)
 
     cat1_NA, is_NA = _eval_factor(fi1, {"mock": ["a", None, "b"]},
                                   NAAction(NA_types=["None"]))
     assert np.array_equal(is_NA, [False, True, False])
     assert np.array_equal(cat1_NA, [0, -1, 1])
-    assert_raises(PatsyError, _eval_factor, fi1,
+    raises(PatsyError, _eval_factor, fi1,
                   {"mock": ["a", None, "b"]}, NAAction(NA_types=[]))
 
     fi2 = FactorInfo(_MockFactor(), "categorical", {},
@@ -276,7 +276,7 @@ def _build_subterm(subterm, factor_infos
                 out[:, i] *= factor_values[factor][:, column_idx]
 
 def test__subterm_column_names_iter_and__build_subterm():
-    from nose.tools import assert_raises
+    from pytest import raises
     from patsy.contrasts import ContrastMatrix
     from patsy.categorical import C
     f1 = _MockFactor("f1")
@@ -308,7 +308,7 @@ def test__subterm_column_names_iter_and_
                              [0, 0.5 * 2 * 2],
                              [3 * 3 * -12, 0]])
     # Check that missing categorical values blow up
-    assert_raises(PatsyError, _build_subterm, subterm1, factor_infos1,
+    raises(PatsyError, _build_subterm, subterm1, factor_infos1,
                   {f1: atleast_2d_column_default([1, 2, 3]),
                    f2: np.asarray([0, -1, 1]),
                    f3: atleast_2d_column_default([7.5, 2, -12])},
@@ -557,7 +557,7 @@ def test__examine_factor_types():
         string_3col: ([["a", "b", "c"]], [["b", "c", "a"]]),
         object_3col: ([[[object()]]], [[[object()]]]),
         }
-    from nose.tools import assert_raises
+    from pytest import raises
     for illegal_factor in illegal_factor_states:
         it = DataIterMaker()
         try:
Index: patsy-0.5.1/patsy/builtins.py
===================================================================
--- patsy-0.5.1.orig/patsy/builtins.py	2014-07-16 22:27:10.000000000 +0200
+++ patsy-0.5.1/patsy/builtins.py	2020-09-08 14:02:18.683103765 +0200
@@ -92,6 +92,6 @@ def test_Q():
     a = 1
     assert Q("a") == 1
     assert Q("Q") is Q
-    from nose.tools import assert_raises
-    assert_raises(NameError, Q, "asdfsadfdsad")
+    from pytest import raises
+    raises(NameError, Q, "asdfsadfdsad")
     
Index: patsy-0.5.1/patsy/categorical.py
===================================================================
--- patsy-0.5.1.orig/patsy/categorical.py	2018-05-30 08:53:45.000000000 +0200
+++ patsy-0.5.1/patsy/categorical.py	2020-09-08 14:02:18.683103765 +0200
@@ -295,14 +295,14 @@ def test_CategoricalSniffer():
     # 0d
     t([], ["b"], False, ("b",))
 
-    from nose.tools import assert_raises
+    from pytest import raises
 
     # unhashable level error:
     sniffer = CategoricalSniffer(NAAction())
-    assert_raises(PatsyError, sniffer.sniff, [{}])
+    raises(PatsyError, sniffer.sniff, [{}])
 
     # >1d is illegal
-    assert_raises(PatsyError, sniffer.sniff, np.asarray([["b"]]))
+    raises(PatsyError, sniffer.sniff, np.asarray([["b"]]))
 
 # returns either a 1d ndarray or a pandas.Series
 def categorical_to_int(data, levels, NA_action, origin=None):
@@ -369,7 +369,7 @@ def categorical_to_int(data, levels, NA_
     return out
 
 def test_categorical_to_int():
-    from nose.tools import assert_raises
+    from pytest import raises
     from patsy.missing import NAAction
     if have_pandas:
         s = pandas.Series(["a", "b", "c"], index=[10, 20, 30])
@@ -377,7 +377,7 @@ def test_categorical_to_int():
         assert np.all(c_pandas == [0, 1, 2])
         assert np.all(c_pandas.index == [10, 20, 30])
         # Input must be 1-dimensional
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       categorical_to_int,
                       pandas.DataFrame({10: s}), ("a", "b", "c"), NAAction())
     if have_pandas_categorical:
@@ -397,12 +397,12 @@ def test_categorical_to_int():
                                        NAAction(NA_types=["None"]))
             assert np.all(conv2 == [1, 0, -1])
             # But levels must match
-            assert_raises(PatsyError,
+            raises(PatsyError,
                           categorical_to_int,
                           con([1, 0], ("a", "b")),
                           ("a", "c"),
                           NAAction())
-            assert_raises(PatsyError,
+            raises(PatsyError,
                           categorical_to_int,
                           con([1, 0], ("a", "b")),
                           ("b", "a"),
@@ -422,14 +422,14 @@ def test_categorical_to_int():
     t(["a", "b", "a"], ("a", "d", "z", "b"), [0, 3, 0])
     t([("a", 1), ("b", 0), ("a", 1)], (("a", 1), ("b", 0)), [0, 1, 0])
 
-    assert_raises(PatsyError, categorical_to_int,
+    raises(PatsyError, categorical_to_int,
                   ["a", "b", "a"], ("a", "c"), NAAction())
 
     t(C(["a", "b", "a"]), ("a", "b"), [0, 1, 0])
     t(C(["a", "b", "a"]), ("b", "a"), [1, 0, 1])
     t(C(["a", "b", "a"], levels=["b", "a"]), ("b", "a"), [1, 0, 1])
     # Mismatch between C() levels and expected levels
-    assert_raises(PatsyError, categorical_to_int,
+    raises(PatsyError, categorical_to_int,
                   C(["a", "b", "a"], levels=["a", "b"]),
                   ("b", "a"), NAAction())
 
@@ -439,14 +439,14 @@ def test_categorical_to_int():
     t(True, (False, True), [1])
 
     # ndim == 2 is disallowed
-    assert_raises(PatsyError, categorical_to_int,
+    raises(PatsyError, categorical_to_int,
                   np.asarray([["a", "b"], ["b", "a"]]),
                   ("a", "b"), NAAction())
 
     # levels must be hashable
-    assert_raises(PatsyError, categorical_to_int,
+    raises(PatsyError, categorical_to_int,
                   ["a", "b"], ("a", "b", {}), NAAction())
-    assert_raises(PatsyError, categorical_to_int,
+    raises(PatsyError, categorical_to_int,
                   ["a", "b", {}], ("a", "b"), NAAction())
 
     t(["b", None, np.nan, "a"], ("a", "b"), [1, -1, -1, 0],
@@ -458,7 +458,7 @@ def test_categorical_to_int():
 
     # Smoke test for the branch that formats the ellipsized list of levels in
     # the error message:
-    assert_raises(PatsyError, categorical_to_int,
+    raises(PatsyError, categorical_to_int,
                   ["a", "b", "q"],
                   ("a", "b", "c", "d", "e", "f", "g", "h"),
                   NAAction())
Index: patsy-0.5.1/patsy/constraint.py
===================================================================
--- patsy-0.5.1.orig/patsy/constraint.py	2018-10-28 03:34:36.000000000 +0100
+++ patsy-0.5.1/patsy/constraint.py	2020-09-08 14:02:18.687103790 +0200
@@ -112,14 +112,14 @@ def test_LinearConstraint():
     lc = LinearConstraint(["a"], [[0]])
     assert_equal(lc.coefs, [[0]])
 
-    from nose.tools import assert_raises
-    assert_raises(ValueError, LinearConstraint, ["a"], [[1, 2]])
-    assert_raises(ValueError, LinearConstraint, ["a"], [[[1]]])
-    assert_raises(ValueError, LinearConstraint, ["a"], [[1, 2]], [3, 4])
-    assert_raises(ValueError, LinearConstraint, ["a", "b"], [[1, 2]], [3, 4])
-    assert_raises(ValueError, LinearConstraint, ["a"], [[1]], [[]])
-    assert_raises(ValueError, LinearConstraint, ["a", "b"], [])
-    assert_raises(ValueError, LinearConstraint, ["a", "b"],
+    from pytest import raises
+    raises(ValueError, LinearConstraint, ["a"], [[1, 2]])
+    raises(ValueError, LinearConstraint, ["a"], [[[1]]])
+    raises(ValueError, LinearConstraint, ["a"], [[1, 2]], [3, 4])
+    raises(ValueError, LinearConstraint, ["a", "b"], [[1, 2]], [3, 4])
+    raises(ValueError, LinearConstraint, ["a"], [[1]], [[]])
+    raises(ValueError, LinearConstraint, ["a", "b"], [])
+    raises(ValueError, LinearConstraint, ["a", "b"],
                   np.zeros((0, 2)))
 
     assert_no_pickling(lc)
@@ -135,9 +135,9 @@ def test_LinearConstraint_combine():
     assert_equal(comb.coefs, [[1, 0], [0, 1]])
     assert_equal(comb.constants, [[0], [1]])
 
-    from nose.tools import assert_raises
-    assert_raises(ValueError, LinearConstraint.combine, [])
-    assert_raises(ValueError, LinearConstraint.combine,
+    from pytest import raises
+    raises(ValueError, LinearConstraint.combine, [])
+    raises(ValueError, LinearConstraint.combine,
                   [LinearConstraint(["a"], [1]), LinearConstraint(["b"], [1])])
 
 
@@ -215,8 +215,8 @@ def test__tokenize_constraint():
         assert got.origin == Origin(code, expected[1], expected[2])
         assert got.extra == expected[3]
 
-    from nose.tools import assert_raises
-    assert_raises(PatsyError, _tokenize_constraint, "1 + @b", ["b"])
+    from pytest import raises
+    raises(PatsyError, _tokenize_constraint, "1 + @b", ["b"])
     # Shouldn't raise an error:
     _tokenize_constraint("1 + @b", ["@b"])
 
@@ -433,12 +433,12 @@ def _check_lincon(input, varnames, coefs
 
 
 def test_linear_constraint():
-    from nose.tools import assert_raises
+    from pytest import raises
     from patsy.compat import OrderedDict
     t = _check_lincon
 
     t(LinearConstraint(["a", "b"], [2, 3]), ["a", "b"], [[2, 3]], [[0]])
-    assert_raises(ValueError, linear_constraint,
+    raises(ValueError, linear_constraint,
                   LinearConstraint(["b", "a"], [2, 3]),
                   ["a", "b"])
 
@@ -454,8 +454,8 @@ def test_linear_constraint():
     t(OrderedDict([("a", 2), (1, 3)]),
       ["a", "b"], [[1, 0], [0, 1]], [[2], [3]])
 
-    assert_raises(ValueError, linear_constraint, {"q": 1}, ["a", "b"])
-    assert_raises(ValueError, linear_constraint, {"a": 1, 0: 2}, ["a", "b"])
+    raises(ValueError, linear_constraint, {"q": 1}, ["a", "b"])
+    raises(ValueError, linear_constraint, {"a": 1, 0: 2}, ["a", "b"])
 
     t(np.array([2, 3]), ["a", "b"], [[2, 3]], [[0]])
     t(np.array([[2, 3], [4, 5]]), ["a", "b"], [[2, 3], [4, 5]], [[0], [0]])
@@ -469,7 +469,7 @@ def test_linear_constraint():
 
     t(["a = 2", "b = 3"], ["a", "b"], [[1, 0], [0, 1]], [[2], [3]])
 
-    assert_raises(ValueError, linear_constraint, ["a", {"b": 0}], ["a", "b"])
+    raises(ValueError, linear_constraint, ["a", {"b": 0}], ["a", "b"])
 
     # Actual evaluator tests
     t("2 * (a + b/3) + b + 2*3/4 = 1 + 2*3", ["a", "b"],
@@ -494,9 +494,9 @@ def test_linear_constraint():
     t(([[10, 20], [20, 40]], [[30], [35]]), ["a", "b"],
       [[10, 20], [20, 40]], [[30], [35]])
     # wrong-length tuple
-    assert_raises(ValueError, linear_constraint,
+    raises(ValueError, linear_constraint,
                   ([1, 0], [0], [0]), ["a", "b"])
-    assert_raises(ValueError, linear_constraint, ([1, 0],), ["a", "b"])
+    raises(ValueError, linear_constraint, ([1, 0],), ["a", "b"])
 
     t([10, 20], ["a", "b"], [[10, 20]], [[0]])
     t([[10, 20], [20, 40]], ["a", "b"], [[10, 20], [20, 40]], [[0], [0]])
@@ -505,7 +505,7 @@ def test_linear_constraint():
       [[10, 20], [20, 40]], [[0], [0]])
 
     # unknown object type
-    assert_raises(ValueError, linear_constraint, None, ["a", "b"])
+    raises(ValueError, linear_constraint, None, ["a", "b"])
 
 
 _parse_eval_error_tests = [
Index: patsy-0.5.1/patsy/contrasts.py
===================================================================
--- patsy-0.5.1.orig/patsy/contrasts.py	2018-05-30 08:53:45.000000000 +0200
+++ patsy-0.5.1/patsy/contrasts.py	2020-09-08 14:02:18.687103790 +0200
@@ -56,8 +56,8 @@ def test_ContrastMatrix():
     # smoke test
     repr(cm)
 
-    from nose.tools import assert_raises
-    assert_raises(PatsyError, ContrastMatrix, [[1], [0]], ["a", "b"])
+    from pytest import raises
+    raises(PatsyError, ContrastMatrix, [[1], [0]], ["a", "b"])
 
     assert_no_pickling(cm)
 
@@ -128,10 +128,10 @@ def test__get_level():
     assert _get_level(["a", "b", "c"], "b") == 1
     # For integer levels, we check identity before treating it as an index
     assert _get_level([2, 1, 0], 0) == 2
-    from nose.tools import assert_raises
-    assert_raises(PatsyError, _get_level, ["a", "b"], 2)
-    assert_raises(PatsyError, _get_level, ["a", "b"], -3)
-    assert_raises(PatsyError, _get_level, ["a", "b"], "c")
+    from pytest import raises
+    raises(PatsyError, _get_level, ["a", "b"], 2)
+    raises(PatsyError, _get_level, ["a", "b"], -3)
+    raises(PatsyError, _get_level, ["a", "b"], "c")
 
     if not six.PY3:
         assert _get_level(["a", "b", "c"], long(0)) == 0
@@ -326,8 +326,8 @@ def test_Poly():
                         [1, 0.293294230042706, -0.762000762001143],
                         [1, 0.513264902574736, 0.635000635000952]])
 
-    from nose.tools import assert_raises
-    assert_raises(PatsyError,
+    from pytest import raises
+    raises(PatsyError,
                   Poly(scores=[0, 1]).code_with_intercept,
                   ["a", "b", "c"])
 
Index: patsy-0.5.1/patsy/design_info.py
===================================================================
--- patsy-0.5.1.orig/patsy/design_info.py	2018-05-30 08:53:45.000000000 +0200
+++ patsy-0.5.1/patsy/design_info.py	2020-09-08 14:02:18.687103790 +0200
@@ -143,19 +143,19 @@ def test_FactorInfo():
     # smoke test
     repr(fi2)
 
-    from nose.tools import assert_raises
-    assert_raises(ValueError, FactorInfo, "asdf", "non-numerical", {})
-    assert_raises(ValueError, FactorInfo, "asdf", "numerical", {})
+    from pytest import raises
+    raises(ValueError, FactorInfo, "asdf", "non-numerical", {})
+    raises(ValueError, FactorInfo, "asdf", "numerical", {})
 
-    assert_raises(ValueError, FactorInfo, "asdf", "numerical", {},
+    raises(ValueError, FactorInfo, "asdf", "numerical", {},
                   num_columns="asdf")
-    assert_raises(ValueError, FactorInfo, "asdf", "numerical", {},
+    raises(ValueError, FactorInfo, "asdf", "numerical", {},
                   num_columns=1, categories=1)
 
-    assert_raises(TypeError, FactorInfo, "asdf", "categorical", {})
-    assert_raises(ValueError, FactorInfo, "asdf", "categorical", {},
+    raises(TypeError, FactorInfo, "asdf", "categorical", {})
+    raises(ValueError, FactorInfo, "asdf", "categorical", {},
                   num_columns=1)
-    assert_raises(TypeError, FactorInfo, "asdf", "categorical", {},
+    raises(TypeError, FactorInfo, "asdf", "categorical", {},
                   categories=1)
 
     # Make sure longs are legal for num_columns
@@ -251,12 +251,12 @@ def test_SubtermInfo():
     # smoke test
     repr(s)
 
-    from nose.tools import assert_raises
-    assert_raises(TypeError, SubtermInfo, 1, {}, 1)
-    assert_raises(ValueError, SubtermInfo, ["a", "x"], 1, 1)
-    assert_raises(ValueError, SubtermInfo, ["a", "x"], {"z": cm}, 1)
-    assert_raises(ValueError, SubtermInfo, ["a", "x"], {"a": 1}, 1)
-    assert_raises(ValueError, SubtermInfo, ["a", "x"], {}, 1.5)
+    from pytest import raises
+    raises(TypeError, SubtermInfo, 1, {}, 1)
+    raises(ValueError, SubtermInfo, ["a", "x"], 1, 1)
+    raises(ValueError, SubtermInfo, ["a", "x"], {"z": cm}, 1)
+    raises(ValueError, SubtermInfo, ["a", "x"], {"a": 1}, 1)
+    raises(ValueError, SubtermInfo, ["a", "x"], {}, 1.5)
 
 class DesignInfo(object):
     """A DesignInfo object holds metadata about a design matrix.
@@ -694,7 +694,7 @@ class DesignInfo(object):
     __getstate__ = no_pickling
 
 def test_DesignInfo():
-    from nose.tools import assert_raises
+    from pytest import raises
     class _MockFactor(object):
         def __init__(self, name):
             self._name = name
@@ -730,7 +730,7 @@ def test_DesignInfo():
     assert di.slice("y") == slice(3, 4)
     assert di.slice(t_y) == slice(3, 4)
     assert di.slice(slice(2, 4)) == slice(2, 4)
-    assert_raises(PatsyError, di.slice, "asdf")
+    raises(PatsyError, di.slice, "asdf")
 
     # smoke test
     repr(di)
@@ -761,29 +761,29 @@ def test_DesignInfo():
 
     # Failure modes
     # must specify either both or neither of factor_infos and term_codings:
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], factor_infos=factor_infos)
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], term_codings=term_codings)
     # factor_infos must be a dict
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], list(factor_infos), term_codings)
     # wrong number of column names:
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y1", "y2"], factor_infos, term_codings)
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3"], factor_infos, term_codings)
     # name overlap problems
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "y", "y2"], factor_infos, term_codings)
     # duplicate name
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x1", "x1", "y"], factor_infos, term_codings)
 
     # f_y is in factor_infos, but not mentioned in any term
     term_codings_x_only = OrderedDict(term_codings)
     del term_codings_x_only[t_y]
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3"], factor_infos, term_codings_x_only)
 
     # f_a is in a term, but not in factor_infos
@@ -791,44 +791,44 @@ def test_DesignInfo():
     t_a = Term([f_a])
     term_codings_with_a = OrderedDict(term_codings)
     term_codings_with_a[t_a] = [SubtermInfo([f_a], {}, 1)]
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y", "a"],
                   factor_infos, term_codings_with_a)
 
     # bad factor_infos
     not_factor_infos = dict(factor_infos)
     not_factor_infos[f_x] = "what is this I don't even"
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], not_factor_infos, term_codings)
 
     mismatch_factor_infos = dict(factor_infos)
     mismatch_factor_infos[f_x] = FactorInfo(f_a, "numerical", {}, num_columns=3)
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], mismatch_factor_infos, term_codings)
 
     # bad term_codings
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], factor_infos, dict(term_codings))
 
     not_term_codings = OrderedDict(term_codings)
     not_term_codings["this is a string"] = term_codings[t_x]
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], factor_infos, not_term_codings)
 
     non_list_term_codings = OrderedDict(term_codings)
     non_list_term_codings[t_y] = tuple(term_codings[t_y])
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], factor_infos, non_list_term_codings)
 
     non_subterm_term_codings = OrderedDict(term_codings)
     non_subterm_term_codings[t_y][0] = "not a SubtermInfo"
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], factor_infos, non_subterm_term_codings)
 
     bad_subterm = OrderedDict(term_codings)
     # f_x is a factor in this model, but it is not a factor in t_y
     term_codings[t_y][0] = SubtermInfo([f_x], {}, 1)
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["x1", "x2", "x3", "y"], factor_infos, bad_subterm)
 
     # contrast matrix has wrong number of rows
@@ -841,7 +841,7 @@ def test_DesignInfo():
                       {f_a: ContrastMatrix(np.ones((3, 2)),
                                            ["[1]", "[2]"])},
                       2)])])
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["a[1]", "a[2]"],
                   factor_codings_a,
                   term_codings_a_bad_rows)
@@ -860,7 +860,7 @@ def test_DesignInfo():
                       {f_a: ContrastMatrix(np.ones((2, 2)), ["[1]", "[2]"]),
                        f_x: ContrastMatrix(np.ones((2, 2)), ["[1]", "[2]"])},
                       4)])])
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["a[1]:x[1]", "a[2]:x[1]", "a[1]:x[2]", "a[2]:x[2]"],
                   factor_codings_ax,
                   term_codings_ax_extra_cm)
@@ -873,7 +873,7 @@ def test_DesignInfo():
                       4)])])
     # This actually fails before it hits the relevant check with a KeyError,
     # but that's okay... the previous test still exercises the check.
-    assert_raises((ValueError, KeyError), DesignInfo,
+    raises((ValueError, KeyError), DesignInfo,
                   ["a[1]:x[1]", "a[2]:x[1]", "a[1]:x[2]", "a[2]:x[2]"],
                   factor_codings_ax,
                   term_codings_ax_missing_cm)
@@ -887,7 +887,7 @@ def test_DesignInfo():
                                            ["[1]", "[2]", "[3]"])},
                       # should be 2 * 3 = 6
                       5)])])
-    assert_raises(ValueError, DesignInfo,
+    raises(ValueError, DesignInfo,
                   ["a[1]:x[1]", "a[2]:x[1]", "a[3]:x[1]",
                    "a[1]:x[2]", "a[2]:x[2]", "a[3]:x[2]"],
                   factor_codings_ax,
@@ -910,8 +910,8 @@ def test_DesignInfo_from_array():
     di_weird = DesignInfo.from_array(m)
     assert di_weird.column_names == ["column0"]
 
-    from nose.tools import assert_raises
-    assert_raises(ValueError, DesignInfo.from_array, np.ones((2, 2, 2)))
+    from pytest import raises
+    raises(ValueError, DesignInfo.from_array, np.ones((2, 2, 2)))
 
     from patsy.util import have_pandas
     if have_pandas:
@@ -1149,14 +1149,14 @@ class DesignMatrix(np.ndarray):
     __reduce__ = no_pickling
 
 def test_design_matrix():
-    from nose.tools import assert_raises
+    from pytest import raises
 
     di = DesignInfo(["a1", "a2", "a3", "b"])
     mm = DesignMatrix([[12, 14, 16, 18]], di)
     assert mm.design_info.column_names == ["a1", "a2", "a3", "b"]
 
     bad_di = DesignInfo(["a1"])
-    assert_raises(ValueError, DesignMatrix, [[12, 14, 16, 18]], bad_di)
+    raises(ValueError, DesignMatrix, [[12, 14, 16, 18]], bad_di)
 
     mm2 = DesignMatrix([[12, 14, 16, 18]])
     assert mm2.design_info.column_names == ["column0", "column1", "column2",
@@ -1166,7 +1166,7 @@ def test_design_matrix():
     assert mm3.shape == (4, 1)
 
     # DesignMatrix always has exactly 2 dimensions
-    assert_raises(ValueError, DesignMatrix, [[[1]]])
+    raises(ValueError, DesignMatrix, [[[1]]])
 
     # DesignMatrix constructor passes through existing DesignMatrixes
     mm4 = DesignMatrix(mm)
@@ -1181,9 +1181,9 @@ def test_design_matrix():
     assert_no_pickling(mm6)
 
     # Only real-valued matrices can be DesignMatrixs
-    assert_raises(ValueError, DesignMatrix, [1, 2, 3j])
-    assert_raises(ValueError, DesignMatrix, ["a", "b", "c"])
-    assert_raises(ValueError, DesignMatrix, [1, 2, object()])
+    raises(ValueError, DesignMatrix, [1, 2, 3j])
+    raises(ValueError, DesignMatrix, ["a", "b", "c"])
+    raises(ValueError, DesignMatrix, [1, 2, object()])
 
     # Just smoke tests
     repr(mm)
Index: patsy-0.5.1/patsy/eval.py
===================================================================
--- patsy-0.5.1.orig/patsy/eval.py	2015-10-28 02:31:11.000000000 +0100
+++ patsy-0.5.1/patsy/eval.py	2020-09-08 14:02:18.687103790 +0200
@@ -81,8 +81,8 @@ def test_VarLookupDict():
     assert ds["b"] == 3
     assert "a" in ds
     assert "c" not in ds
-    from nose.tools import assert_raises
-    assert_raises(KeyError, ds.__getitem__, "c")
+    from pytest import raises
+    raises(KeyError, ds.__getitem__, "c")
     ds["a"] = 10
     assert ds["a"] == 10
     assert d1["a"] == 1
@@ -118,15 +118,15 @@ def test_ast_names():
         assert set(ast_names(code)) == set(expected)
 
 def test_ast_names_disallowed_nodes():
-    from nose.tools import assert_raises
+    from pytest import raises
     def list_ast_names(code):
         return list(ast_names(code))
-    assert_raises(PatsyError, list_ast_names, "lambda x: x + y")
-    assert_raises(PatsyError, list_ast_names, "[x + 1 for x in range(10)]")
-    assert_raises(PatsyError, list_ast_names, "(x + 1 for x in range(10))")
+    raises(PatsyError, list_ast_names, "lambda x: x + y")
+    raises(PatsyError, list_ast_names, "[x + 1 for x in range(10)]")
+    raises(PatsyError, list_ast_names, "(x + 1 for x in range(10))")
     if sys.version_info >= (2, 7):
-        assert_raises(PatsyError, list_ast_names, "{x: True for x in range(10)}")
-        assert_raises(PatsyError, list_ast_names, "{x + 1 for x in range(10)}")
+        raises(PatsyError, list_ast_names, "{x: True for x in range(10)}")
+        raises(PatsyError, list_ast_names, "{x + 1 for x in range(10)}")
 
 class EvalEnvironment(object):
     """Represents a Python execution environment.
@@ -292,12 +292,12 @@ def test_EvalEnvironment_capture_namespa
     assert a2.namespace["_a"] == 1
     assert b1.namespace["_c"] is _c
     assert b2.namespace["_c"] is _c
-    from nose.tools import assert_raises
-    assert_raises(ValueError, EvalEnvironment.capture, 10 ** 6)
+    from pytest import raises
+    raises(ValueError, EvalEnvironment.capture, 10 ** 6)
 
     assert EvalEnvironment.capture(b1) is b1
 
-    assert_raises(TypeError, EvalEnvironment.capture, 1.2)
+    raises(TypeError, EvalEnvironment.capture, 1.2)
 
     assert_no_pickling(EvalEnvironment.capture())
 
@@ -346,8 +346,8 @@ def test_EvalEnvironment_eval_namespace(
     env = EvalEnvironment([{"a": 1}])
     assert env.eval("2 * a") == 2
     assert env.eval("2 * a", inner_namespace={"a": 2}) == 4
-    from nose.tools import assert_raises
-    assert_raises(NameError, env.eval, "2 * b")
+    from pytest import raises
+    raises(NameError, env.eval, "2 * b")
     a = 3
     env2 = EvalEnvironment.capture(0)
     assert env2.eval("2 * a") == 6
@@ -357,7 +357,7 @@ def test_EvalEnvironment_eval_namespace(
     assert env3.eval("2 * b") == 6
 
 def test_EvalEnvironment_eval_flags():
-    from nose.tools import assert_raises
+    from pytest import raises
     if sys.version_info >= (3,):
         # This joke __future__ statement replaces "!=" with "<>":
         #   http://www.python.org/dev/peps/pep-0401/
@@ -366,13 +366,13 @@ def test_EvalEnvironment_eval_flags():
 
         env = EvalEnvironment([{"a": 11}], flags=0)
         assert env.eval("a != 0") == True
-        assert_raises(SyntaxError, env.eval, "a <> 0")
+        raises(SyntaxError, env.eval, "a <> 0")
         assert env.subset(["a"]).flags == 0
         assert env.with_outer_namespace({"b": 10}).flags == 0
 
         env2 = EvalEnvironment([{"a": 11}], flags=test_flag)
         assert env2.eval("a <> 0") == True
-        assert_raises(SyntaxError, env2.eval, "a != 0")
+        raises(SyntaxError, env2.eval, "a != 0")
         assert env2.subset(["a"]).flags == test_flag
         assert env2.with_outer_namespace({"b": 10}).flags == test_flag
     else:
@@ -394,13 +394,13 @@ def test_EvalEnvironment_subset():
 
     subset_a = env.subset(["a"])
     assert subset_a.eval("a") == 1
-    from nose.tools import assert_raises
-    assert_raises(NameError, subset_a.eval, "b")
-    assert_raises(NameError, subset_a.eval, "c")
+    from pytest import raises
+    raises(NameError, subset_a.eval, "b")
+    raises(NameError, subset_a.eval, "c")
 
     subset_bc = env.subset(["b", "c"])
     assert subset_bc.eval("b * c") == 6
-    assert_raises(NameError, subset_bc.eval, "a")
+    raises(NameError, subset_bc.eval, "a")
 
 def test_EvalEnvironment_eq():
     # Two environments are eq only if they refer to exactly the same
Index: patsy-0.5.1/patsy/infix_parser.py
===================================================================
--- patsy-0.5.1.orig/patsy/infix_parser.py	2015-06-14 04:06:58.000000000 +0200
+++ patsy-0.5.1/patsy/infix_parser.py	2020-09-08 14:02:18.687103790 +0200
@@ -262,9 +262,9 @@ def test_infix_parse():
     te(tree.args[1].args[1].args[0], "ATOM1", "c")
     te(tree.args[1].args[1].args[1], "ATOM2", "d")
 
-    from nose.tools import assert_raises
+    from pytest import raises
     # No ternary ops
-    assert_raises(ValueError,
+    raises(ValueError,
                   infix_parse, [], [Operator("+", 3, 10)], ["ATOMIC"])
 
     # smoke test just to make sure there are no egregious bugs in 'trace'
Index: patsy-0.5.1/patsy/mgcv_cubic_splines.py
===================================================================
--- patsy-0.5.1.orig/patsy/mgcv_cubic_splines.py	2015-10-28 02:31:11.000000000 +0100
+++ patsy-0.5.1/patsy/mgcv_cubic_splines.py	2020-09-08 14:02:18.691103814 +0200
@@ -85,10 +85,10 @@ def test__map_cyclic():
 
 
 def test__map_cyclic_errors():
-    from nose.tools import assert_raises
+    from pytest import raises
     x = np.linspace(0.2, 5.7, 10)
-    assert_raises(ValueError, _map_cyclic, x, 4.5, 3.6)
-    assert_raises(ValueError, _map_cyclic, x, 4.5, 4.5)
+    raises(ValueError, _map_cyclic, x, 4.5, 3.6)
+    raises(ValueError, _map_cyclic, x, 4.5, 4.5)
 
 
 def _get_cyclic_f(knots):
@@ -172,12 +172,12 @@ def _row_tensor_product(dms):
 
 
 def test__row_tensor_product_errors():
-    from nose.tools import assert_raises
-    assert_raises(ValueError, _row_tensor_product, [])
-    assert_raises(ValueError, _row_tensor_product, [np.arange(1, 5)])
-    assert_raises(ValueError, _row_tensor_product,
+    from pytest import raises
+    raises(ValueError, _row_tensor_product, [])
+    raises(ValueError, _row_tensor_product, [np.arange(1, 5)])
+    raises(ValueError, _row_tensor_product,
                   [np.arange(1, 5), np.arange(1, 5)])
-    assert_raises(ValueError, _row_tensor_product,
+    raises(ValueError, _row_tensor_product,
                   [np.arange(1, 13).reshape((3, 4)),
                    np.arange(1, 13).reshape((4, 3))])
 
@@ -473,24 +473,24 @@ def _get_all_sorted_knots(x, n_inner_kno
 
 
 def test__get_all_sorted_knots():
-    from nose.tools import assert_raises
-    assert_raises(ValueError, _get_all_sorted_knots,
+    from pytest import raises
+    raises(ValueError, _get_all_sorted_knots,
                   np.array([]), -1)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   np.array([]), 0)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   np.array([]), 0, lower_bound=1)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   np.array([]), 0, upper_bound=5)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   np.array([]), 0, lower_bound=3, upper_bound=1)
     assert np.array_equal(
         _get_all_sorted_knots(np.array([]), 0, lower_bound=1, upper_bound=5),
         [1, 5])
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   np.array([]), 0, lower_bound=1, upper_bound=1)
     x = np.arange(6) * 2
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, -2)
     assert np.array_equal(
         _get_all_sorted_knots(x, 0),
@@ -501,18 +501,18 @@ def test__get_all_sorted_knots():
     assert np.array_equal(
         _get_all_sorted_knots(x, 2, lower_bound=1, upper_bound=9),
         [1, 4, 6, 9])
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, 2, lower_bound=1, upper_bound=3)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, 1, lower_bound=1.3, upper_bound=1.4)
     assert np.array_equal(
         _get_all_sorted_knots(x, 1, lower_bound=1, upper_bound=3),
         [1, 2, 3])
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, 1, lower_bound=2, upper_bound=3)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, 1, inner_knots=[2, 3])
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, lower_bound=2, upper_bound=3)
     assert np.array_equal(
         _get_all_sorted_knots(x, inner_knots=[3, 7]),
@@ -520,9 +520,9 @@ def test__get_all_sorted_knots():
     assert np.array_equal(
         _get_all_sorted_knots(x, inner_knots=[3, 7], lower_bound=2),
         [2, 3, 7, 10])
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, inner_knots=[3, 7], lower_bound=4)
-    assert_raises(ValueError, _get_all_sorted_knots,
+    raises(ValueError, _get_all_sorted_knots,
                   x, inner_knots=[3, 7], upper_bound=6)
 
 
@@ -750,24 +750,24 @@ cc = stateful_transform(CC)
 
 
 def test_crs_errors():
-    from nose.tools import assert_raises
+    from pytest import raises
     # Invalid 'x' shape
-    assert_raises(ValueError, cr, np.arange(16).reshape((4, 4)), df=4)
-    assert_raises(ValueError, CR().transform,
+    raises(ValueError, cr, np.arange(16).reshape((4, 4)), df=4)
+    raises(ValueError, CR().transform,
                   np.arange(16).reshape((4, 4)), df=4)
     # Should provide at least 'df' or 'knots'
-    assert_raises(ValueError, cr, np.arange(50))
+    raises(ValueError, cr, np.arange(50))
     # Invalid constraints shape
-    assert_raises(ValueError, cr, np.arange(50), df=4,
+    raises(ValueError, cr, np.arange(50), df=4,
                   constraints=np.arange(27).reshape((3, 3, 3)))
     # Invalid nb of columns in constraints
     # (should have df + 1 = 5, but 6 provided)
-    assert_raises(ValueError, cr, np.arange(50), df=4,
+    raises(ValueError, cr, np.arange(50), df=4,
                   constraints=np.arange(6))
     # Too small 'df' for natural cubic spline
-    assert_raises(ValueError, cr, np.arange(50), df=1)
+    raises(ValueError, cr, np.arange(50), df=1)
     # Too small 'df' for cyclic cubic spline
-    assert_raises(ValueError, cc, np.arange(50), df=0)
+    raises(ValueError, cc, np.arange(50), df=0)
 
 
 def test_crs_compat():
@@ -946,13 +946,13 @@ te = stateful_transform(TE)
 
 
 def test_te_errors():
-    from nose.tools import assert_raises
+    from pytest import raises
     x = np.arange(27)
     # Invalid input shape
-    assert_raises(ValueError, te, x.reshape((3, 3, 3)))
-    assert_raises(ValueError, te, x.reshape((3, 3, 3)), constraints='center')
+    raises(ValueError, te, x.reshape((3, 3, 3)))
+    raises(ValueError, te, x.reshape((3, 3, 3)), constraints='center')
     # Invalid constraints shape
-    assert_raises(ValueError, te, x,
+    raises(ValueError, te, x,
                   constraints=np.arange(8).reshape((2, 2, 2)))
 
 
Index: patsy-0.5.1/patsy/missing.py
===================================================================
--- patsy-0.5.1.orig/patsy/missing.py	2015-06-14 03:18:57.000000000 +0200
+++ patsy-0.5.1/patsy/missing.py	2020-09-08 14:02:18.691103814 +0200
@@ -183,10 +183,10 @@ class NAAction(object):
     __getstate__ = no_pickling
 
 def test_NAAction_basic():
-    from nose.tools import assert_raises
-    assert_raises(ValueError, NAAction, on_NA="pord")
-    assert_raises(ValueError, NAAction, NA_types=("NaN", "asdf"))
-    assert_raises(ValueError, NAAction, NA_types="NaN")
+    from pytest import raises
+    raises(ValueError, NAAction, on_NA="pord")
+    raises(ValueError, NAAction, NA_types=("NaN", "asdf"))
+    raises(ValueError, NAAction, NA_types="NaN")
 
     assert_no_pickling(NAAction())
 
Index: patsy-0.5.1/patsy/splines.py
===================================================================
--- patsy-0.5.1.orig/patsy/splines.py	2018-01-10 03:33:02.000000000 +0100
+++ patsy-0.5.1/patsy/splines.py	2020-09-08 14:02:18.691103814 +0200
@@ -326,14 +326,14 @@ def test_bs_0degree():
     assert np.array_equal(result_int[:, 1:], result_no_int)
 
 def test_bs_errors():
-    from nose.tools import assert_raises
+    from pytest import raises
     x = np.linspace(-10, 10, 20)
     # error checks:
     # out of bounds
-    assert_raises(NotImplementedError, bs, x, 3, lower_bound=0)
-    assert_raises(NotImplementedError, bs, x, 3, upper_bound=0)
+    raises(NotImplementedError, bs, x, 3, lower_bound=0)
+    raises(NotImplementedError, bs, x, 3, upper_bound=0)
     # must specify df or knots
-    assert_raises(ValueError, bs, x)
+    raises(ValueError, bs, x)
     # df/knots match/mismatch (with and without intercept)
     #   match:
     bs(x, df=10, include_intercept=False, knots=[0] * 7)
@@ -341,57 +341,57 @@ def test_bs_errors():
     bs(x, df=10, include_intercept=False, knots=[0] * 9, degree=1)
     bs(x, df=10, include_intercept=True, knots=[0] * 8, degree=1)
     #   too many knots:
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=False, knots=[0] * 8)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=True, knots=[0] * 7)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=False, knots=[0] * 10,
                   degree=1)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=True, knots=[0] * 9,
                   degree=1)
     #   too few knots:
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=False, knots=[0] * 6)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=True, knots=[0] * 5)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=False, knots=[0] * 8,
                   degree=1)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, include_intercept=True, knots=[0] * 7,
                   degree=1)
     # df too small
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=1, degree=3)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=3, degree=5)
     # bad degree
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, degree=-1)
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, df=10, degree=1.5)
     # upper_bound < lower_bound
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, 3, lower_bound=1, upper_bound=-1)
     # multidimensional input
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, np.column_stack((x, x)), 3)
     # unsorted knots are okay, and get sorted
     assert np.array_equal(bs(x, knots=[1, 4]), bs(x, knots=[4, 1]))
     # 2d knots
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, knots=[[0], [20]])
     # knots > upper_bound
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, knots=[0, 20])
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, knots=[0, 4], upper_bound=3)
     # knots < lower_bound
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, knots=[-20, 0])
-    assert_raises(ValueError,
+    raises(ValueError,
                   bs, x, knots=[-4, 0], lower_bound=-3)
 
 
Index: patsy-0.5.1/patsy/test_build.py
===================================================================
--- patsy-0.5.1.orig/patsy/test_build.py	2018-05-30 08:53:45.000000000 +0200
+++ patsy-0.5.1/patsy/test_build.py	2020-09-08 14:02:18.691103814 +0200
@@ -11,7 +11,7 @@ from __future__ import print_function
 
 import six
 import numpy as np
-from nose.tools import assert_raises
+from pytest import raises
 from patsy import PatsyError
 from patsy.util import (atleast_2d_column_default,
                         have_pandas, have_pandas_categorical)
@@ -35,14 +35,14 @@ def assert_full_rank(m):
 def test_assert_full_rank():
     assert_full_rank(np.eye(10))
     assert_full_rank([[1, 0], [1, 0], [1, 0], [1, 1]])
-    assert_raises(AssertionError,
+    raises(AssertionError,
                   assert_full_rank, [[1, 0], [2, 0]])
-    assert_raises(AssertionError,
+    raises(AssertionError,
                   assert_full_rank, [[1, 2], [2, 4]])
-    assert_raises(AssertionError,
+    raises(AssertionError,
                   assert_full_rank, [[1, 2, 3], [1, 10, 100]])
     # col1 + col2 = col3
-    assert_raises(AssertionError,
+    raises(AssertionError,
                   assert_full_rank, [[1, 2, 3], [1, 5, 6], [1, 6, 7]])
     
 def make_termlist(*entries):
@@ -185,7 +185,7 @@ def test_redundancy_thoroughly():
             expected_rank = len(expanded_terms)
             if termlist_template in [(), ((),)]:
                 # No data dependence, should fail
-                assert_raises(PatsyError,
+                raises(PatsyError,
                               make_matrix,
                               data, expected_rank, termlist_template)
             else:
@@ -259,7 +259,7 @@ def test_return_type():
     assert isinstance(mat, DesignMatrix)
 
     # Check that nonsense is detected
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   build_design_matrices, [builder], data,
                   return_type="asdfsadf")
 
@@ -300,7 +300,7 @@ def test_NA_action():
     np.testing.assert_array_equal(mat, [[1.0, 0.0, 10.0], [0.0, 1.0, np.nan]])
     
     # NA_action="raise"
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   build_design_matrices,
                   [builder],
                   {"x": [10.0, np.nan, 20.0],
@@ -347,10 +347,10 @@ def test_return_type_pandas():
                                             eval_env=0)
     # Index compatibility is always checked for pandas input, regardless of
     # whether we're producing pandas output
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   build_design_matrices,
                   [x_a_builder], {"x": data["x"], "a": data["a"][::-1]})
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   build_design_matrices,
                   [y_builder, x_builder],
                   {"x": data["x"], "y": data["y"][::-1]})
@@ -364,7 +364,7 @@ def test_return_type_pandas():
                 return pandas.DataFrame.__getitem__(self, key)[::-1]
             else:
                 return pandas.DataFrame.__getitem__(self, key)
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   build_design_matrices,
                   [x_builder],
                   CheatingDataFrame(data))
@@ -436,7 +436,7 @@ def test_return_type_pandas():
     try:
         patsy.build.have_pandas = False
         # return_type="dataframe" gives a nice error if pandas is not available
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       build_design_matrices,
                       [x_builder], {"x": [1, 2, 3]}, return_type="dataframe")
     finally:
@@ -489,7 +489,7 @@ def test_data_mismatch():
         def iter_maker():
             yield {"x": data1}
         builders = design_matrix_builders([termlist], iter_maker, 0)
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       build_design_matrices, builders, {"x": data2})
     for (a, b) in test_cases_twoway:
         t_incremental(a, b)
@@ -503,7 +503,7 @@ def test_data_mismatch():
         t_setup_predict(a, b)
         t_setup_predict(b, a)
 
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   make_matrix, {"x": [1, 2, 3], "y": [1, 2, 3, 4]},
                   2, [["x"], ["y"]])
 
@@ -518,14 +518,14 @@ def test_data_independent_builder():
     # - the data is not a DataFrame
     # - there are no other matrices
     null_builder = design_matrix_builders([make_termlist()], iter_maker, 0)[0]
-    assert_raises(PatsyError, build_design_matrices, [null_builder], data)
+    raises(PatsyError, build_design_matrices, [null_builder], data)
 
     intercept_builder = design_matrix_builders([make_termlist([])],
                                                iter_maker,
                                                eval_env=0)[0]
-    assert_raises(PatsyError, build_design_matrices, [intercept_builder], data)
+    raises(PatsyError, build_design_matrices, [intercept_builder], data)
 
-    assert_raises(PatsyError,
+    raises(PatsyError,
                   build_design_matrices,
                   [null_builder, intercept_builder], data)
 
@@ -573,7 +573,7 @@ def test_eval_env_type_builder():
     data = {"x": [1, 2, 3]}
     def iter_maker():
         yield data
-    assert_raises(TypeError, design_matrix_builders, [make_termlist("x")], iter_maker, "foo")
+    raises(TypeError, design_matrix_builders, [make_termlist("x")], iter_maker, "foo")
 
 def test_categorical():
     data_strings = {"a": ["a1", "a2", "a1"]}
@@ -728,11 +728,11 @@ def test_DesignInfo_subset():
     t([all_terms[1]], ["y"], [1, 2])
 
     # Formula can't have a LHS
-    assert_raises(PatsyError, all_builder.subset, "a ~ a")
+    raises(PatsyError, all_builder.subset, "a ~ a")
     # Term must exist
-    assert_raises(KeyError, all_builder.subset, "~ asdf")
-    assert_raises(KeyError, all_builder.subset, ["asdf"])
-    assert_raises(KeyError,
+    raises(KeyError, all_builder.subset, "~ asdf")
+    raises(KeyError, all_builder.subset, ["asdf"])
+    raises(KeyError,
                   all_builder.subset, [Term(["asdf"])])
 
     # Also check for a minimal DesignInfo (column names only)
Index: patsy-0.5.1/patsy/test_highlevel.py
===================================================================
--- patsy-0.5.1.orig/patsy/test_highlevel.py	2018-05-30 08:53:45.000000000 +0200
+++ patsy-0.5.1/patsy/test_highlevel.py	2020-09-08 14:02:18.691103814 +0200
@@ -8,7 +8,7 @@ import sys
 import __future__
 import six
 import numpy as np
-from nose.tools import assert_raises
+from pytest import raises
 from patsy import PatsyError
 from patsy.design_info import DesignMatrix, DesignInfo
 from patsy.eval import EvalEnvironment
@@ -90,9 +90,9 @@ def t(formula_like, data, depth,
                      expected_rhs_values, expected_rhs_names,
                      expected_lhs_values, expected_lhs_names)
     else:
-        assert_raises(PatsyError, incr_dbuilders,
+        raises(PatsyError, incr_dbuilders,
                       formula_like, data_iter_maker)
-        assert_raises(PatsyError, incr_dbuilder,
+        raises(PatsyError, incr_dbuilder,
                       formula_like, data_iter_maker)
     one_mat_fs = [dmatrix]
     two_mat_fs = [dmatrices]
@@ -106,7 +106,7 @@ def t(formula_like, data, depth,
                          expected_rhs_values, expected_rhs_names,
                          expected_lhs_values, expected_lhs_names)
 
-        # We inline assert_raises here to avoid complications with the
+        # We inline raises here to avoid complications with the
         # depth argument.
         for f in two_mat_fs:
             try:
@@ -272,7 +272,7 @@ def test_formula_likes():
         # restrict variable naming rules)
         eacute = "\xc3\xa9".decode("utf-8")
         assert isinstance(eacute, unicode)
-        assert_raises(PatsyError, dmatrix, eacute, data={eacute: [1, 2]})
+        raises(PatsyError, dmatrix, eacute, data={eacute: [1, 2]})
 
     # ModelDesc
     desc = ModelDesc([], [Term([LookupFactor("x")])])
@@ -387,9 +387,9 @@ def test_return_pandas():
     had_pandas = patsy.highlevel.have_pandas
     try:
         patsy.highlevel.have_pandas = False
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       dmatrix, "x", {"x": [1]}, 0, return_type="dataframe")
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       dmatrices, "y ~ x", {"x": [1], "y": [2]}, 0,
                       return_type="dataframe")
     finally:
@@ -536,8 +536,8 @@ def test_incremental():
                                              [1, 1, 0],
                                              x_col[3:])))
 
-    assert_raises(PatsyError, incr_dbuilder, "x ~ x", data_iter_maker)
-    assert_raises(PatsyError, incr_dbuilders, "x", data_iter_maker)
+    raises(PatsyError, incr_dbuilder, "x ~ x", data_iter_maker)
+    raises(PatsyError, incr_dbuilders, "x", data_iter_maker)
 
 def test_env_transform():
     t("~ np.sin(x)", {"x": [1, 2, 3]}, 0,
@@ -673,7 +673,7 @@ def test_dmatrix_NA_action():
                                     [1, 3, 30]])
         if return_type == "dataframe":
             assert mat.index.equals(pandas.Index([1, 2]))
-        assert_raises(PatsyError, dmatrix, "x + y", data=data,
+        raises(PatsyError, dmatrix, "x + y", data=data,
                       return_type=return_type,
                       NA_action="raise")
 
@@ -683,7 +683,7 @@ def test_dmatrix_NA_action():
         if return_type == "dataframe":
             assert lmat.index.equals(pandas.Index([1, 2]))
             assert rmat.index.equals(pandas.Index([1, 2]))
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       dmatrices, "y ~ x", data=data, return_type=return_type,
                       NA_action="raise")
 
@@ -695,7 +695,7 @@ def test_dmatrix_NA_action():
         if return_type == "dataframe":
             assert lmat.index.equals(pandas.Index([1, 2, 3]))
             assert rmat.index.equals(pandas.Index([1, 2, 3]))
-        assert_raises(PatsyError,
+        raises(PatsyError,
                       dmatrices, "y ~ 1", data=data, return_type=return_type,
                       NA_action="raise")
 
Index: patsy-0.5.1/patsy/tokens.py
===================================================================
--- patsy-0.5.1.orig/patsy/tokens.py	2018-10-28 03:34:36.000000000 +0100
+++ patsy-0.5.1/patsy/tokens.py	2020-09-08 14:02:18.695103837 +0200
@@ -78,11 +78,11 @@ def test_python_tokenize():
                  (tokenize.NAME, "b", Origin(code2, 5, 6))]
     assert tokens2 == expected2
 
-    from nose.tools import assert_raises
-    assert_raises(PatsyError, list, python_tokenize("a b # c"))
+    from pytest import raises
+    raises(PatsyError, list, python_tokenize("a b # c"))
 
-    from nose.tools import assert_raises
-    assert_raises(PatsyError, list, python_tokenize("a b \"c"))
+    from pytest import raises
+    raises(PatsyError, list, python_tokenize("a b \"c"))
 
 _python_space_both = (list("+-*/%&^|<>")
                       + ["==", "<>", "!=", "<=", ">=",
Index: patsy-0.5.1/patsy/user_util.py
===================================================================
--- patsy-0.5.1.orig/patsy/user_util.py	2015-06-14 03:59:26.000000000 +0200
+++ patsy-0.5.1/patsy/user_util.py	2020-09-08 14:02:18.695103837 +0200
@@ -135,9 +135,9 @@ def test_demo_data():
     assert len(demo_data("a", "b", "x", min_rows=10)["x"]) == 12
     assert len(demo_data("a", "b", "x", min_rows=10, nlevels=3)["x"]) == 18
 
-    from nose.tools import assert_raises
-    assert_raises(PatsyError, demo_data, "a", "b", "__123")
-    assert_raises(TypeError, demo_data, "a", "b", asdfasdf=123)
+    from pytest import raises
+    raises(PatsyError, demo_data, "a", "b", "__123")
+    raises(TypeError, demo_data, "a", "b", asdfasdf=123)
 
 class LookupFactor(object):
     """A simple factor class that simply looks up a named entry in the given
@@ -238,8 +238,8 @@ def test_LookupFactor():
     assert box.contrast == "CONTRAST"
     assert box.levels == (1, 2)
 
-    from nose.tools import assert_raises
-    assert_raises(ValueError, LookupFactor, "nc", contrast="CONTRAST")
-    assert_raises(ValueError, LookupFactor, "nc", levels=(1, 2))
+    from pytest import raises
+    raises(ValueError, LookupFactor, "nc", contrast="CONTRAST")
+    raises(ValueError, LookupFactor, "nc", levels=(1, 2))
 
     assert_no_pickling(LookupFactor("a"))
Index: patsy-0.5.1/patsy/util.py
===================================================================
--- patsy-0.5.1.orig/patsy/util.py	2018-10-28 03:34:36.000000000 +0100
+++ patsy-0.5.1/patsy/util.py	2020-09-08 14:02:18.695103837 +0200
@@ -252,7 +252,7 @@ def pandas_friendly_reshape(a, new_shape
                      % (a.shape, new_shape))
 
 def test_pandas_friendly_reshape():
-    from nose.tools import assert_raises
+    from pytest import raises
     global have_pandas
     assert np.allclose(pandas_friendly_reshape(np.arange(10).reshape(5, 2),
                                                (2, 5)),
@@ -268,16 +268,16 @@ def test_pandas_friendly_reshape():
         assert np.array_equal(squozen.index, ["a", "b", "c"])
         assert squozen.name == "x"
 
-        assert_raises(ValueError, pandas_friendly_reshape, df, (4,))
-        assert_raises(ValueError, pandas_friendly_reshape, df, (1, 3))
-        assert_raises(ValueError, pandas_friendly_reshape, df, (3, 3))
+        raises(ValueError, pandas_friendly_reshape, df, (4,))
+        raises(ValueError, pandas_friendly_reshape, df, (1, 3))
+        raises(ValueError, pandas_friendly_reshape, df, (3, 3))
 
         had_pandas = have_pandas
         try:
             have_pandas = False
             # this will try to do a reshape directly, and DataFrames *have* no
             # reshape method
-            assert_raises(AttributeError, pandas_friendly_reshape, df, (3,))
+            raises(AttributeError, pandas_friendly_reshape, df, (3,))
         finally:
             have_pandas = had_pandas
 
@@ -327,8 +327,8 @@ def test_wide_dtype_for_and_widen():
     assert widen([1.0, 2.0, 3.0]).dtype == widest_float
     assert np.allclose(widen([1+0j, 2, 3]), [1, 2, 3])
     assert widen([1+0j, 2, 3]).dtype == widest_complex
-    from nose.tools import assert_raises
-    assert_raises(ValueError, widen, ["hi"])
+    from pytest import raises
+    raises(ValueError, widen, ["hi"])
 
 class PushbackAdapter(object):
     def __init__(self, it):
@@ -727,8 +727,8 @@ def no_pickling(*args, **kwargs):
 
 def assert_no_pickling(obj):
     import pickle
-    from nose.tools import assert_raises
-    assert_raises(NotImplementedError, pickle.dumps, obj)
+    from pytest import raises
+    raises(NotImplementedError, pickle.dumps, obj)
 
 # Use like:
 #   if safe_string_eq(constraints, "center"):
Index: patsy-0.5.1/pytest.ini
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ patsy-0.5.1/pytest.ini	2020-09-08 14:53:07.429151511 +0200
@@ -0,0 +1,3 @@
+[pytest]
+python_files = *.py
+testpaths = patsy

Places

File python-patsy-remove-nose.patch of Package python-patsy (Revision 76618946444d6c5fa1abda9986c9f8c4)

Places