Merge pull request #133 from thequackdaddy/fix_travis

MAINT: Travis fixes

Author: njsmith

.travis.yml

@@ -40,9 +40,10 @@ before_install:
   - conda config --set always_yes yes --set changeps1 no
   - conda update -q conda
   - conda info -a
-  - conda create -q -n testenv python=$TRAVIS_PYTHON_VERSION numpy scipy coverage nose pip
+  - export PKGS="numpy scipy coverage nose pip"
+  - if [ "$PANDAS_VERSION_STR" != "NONE" ]; then export PKGS="${PKGS} pandas${PANDAS_VERSION_STR}"; fi
+  - conda create -q -n testenv python=$TRAVIS_PYTHON_VERSION ${PKGS}
   - source activate testenv
-  - if [ "$PANDAS_VERSION_STR" != "NONE" ]; then conda install pandas${PANDAS_VERSION_STR}; fi
 install:
   - python setup.py sdist
   - pip install dist/*

patsy/constraint.py

@@ -17,9 +17,10 @@
 from patsy.origin import Origin
 from patsy.util import (atleast_2d_column_default,
                         repr_pretty_delegate, repr_pretty_impl,
-                        SortAnythingKey,
                         no_pickling, assert_no_pickling)
-from patsy.infix_parser import Token, Operator, ParseNode, infix_parse
+from patsy.infix_parser import Token, Operator, infix_parse
+from patsy.parse_formula import _parsing_error_test
+
 
 class LinearConstraint(object):
     """A linear constraint in matrix form.
@@ -87,7 +88,10 @@ def combine(cls, constraints):
         return cls(variable_names, coefs, constants)
 
 def test_LinearConstraint():
-    from numpy.testing.utils import assert_equal
+    try:
+        from numpy.testing import assert_equal
+    except ImportError:
+        from numpy.testing.utils import assert_equal
     lc = LinearConstraint(["foo", "bar"], [1, 1])
     assert lc.variable_names == ["foo", "bar"]
     assert_equal(lc.coefs, [[1, 1]])
@@ -96,7 +100,7 @@ def test_LinearConstraint():
     lc = LinearConstraint(["foo", "bar"], [[1, 1], [2, 3]], [10, 20])
     assert_equal(lc.coefs, [[1, 1], [2, 3]])
     assert_equal(lc.constants, [[10], [20]])
-    
+
     assert lc.coefs.dtype == np.dtype(float)
     assert lc.constants.dtype == np.dtype(float)
 
@@ -124,21 +128,24 @@ def test_LinearConstraint_combine():
     comb = LinearConstraint.combine([LinearConstraint(["a", "b"], [1, 0]),
                                      LinearConstraint(["a", "b"], [0, 1], [1])])
     assert comb.variable_names == ["a", "b"]
-    from numpy.testing.utils import assert_equal
+    try:
+        from numpy.testing import assert_equal
+    except ImportError:
+        from numpy.testing.utils import assert_equal
     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,
                   [LinearConstraint(["a"], [1]), LinearConstraint(["b"], [1])])
-    
+
 
 _ops = [
     Operator(",", 2, -100),
 
     Operator("=", 2, 0),
-    
+
     Operator("+", 1, 100),
     Operator("-", 1, 100),
     Operator("+", 2, 100),
@@ -408,8 +415,12 @@ def linear_constraint(constraint_like, variable_names):
     coefs = np.asarray(constraint_like, dtype=float)
     return LinearConstraint(variable_names, coefs)
 
+
 def _check_lincon(input, varnames, coefs, constants):
-    from numpy.testing.utils import assert_equal
+    try:
+        from numpy.testing import assert_equal
+    except ImportError:
+        from numpy.testing.utils import assert_equal
     got = linear_constraint(input, varnames)
     print("got", got)
     expected = LinearConstraint(varnames, coefs, constants)
@@ -420,6 +431,7 @@ def _check_lincon(input, varnames, coefs, constants):
     assert_equal(got.coefs.dtype, np.dtype(float))
     assert_equal(got.constants.dtype, np.dtype(float))
 
+
 def test_linear_constraint():
     from nose.tools import assert_raises
     from patsy.compat import OrderedDict
@@ -495,6 +507,7 @@ def test_linear_constraint():
     # unknown object type
     assert_raises(ValueError, linear_constraint, None, ["a", "b"])
 
+
 _parse_eval_error_tests = [
     # Bad token
     "a + <f>oo",
@@ -512,7 +525,7 @@ def test_linear_constraint():
     "a = 1, <(a, b)> + 2, c",
 ]
 
-from patsy.parse_formula import _parsing_error_test
+
 def test_eval_errors():
     def doit(bad_code):
         return linear_constraint(bad_code, ["a", "b", "c"])

patsy/util.py

@@ -55,6 +55,7 @@
         have_pandas_categorical_dtype = (_pandas_is_categorical_dtype
                                          is not None)
 
+
 # Passes through Series and DataFrames, call np.asarray() on everything else
 def asarray_or_pandas(a, copy=False, dtype=None, subok=False):
     if have_pandas:
@@ -68,10 +69,17 @@ def asarray_or_pandas(a, copy=False, dtype=None, subok=False):
             return a.__class__(a, copy=copy, dtype=dtype, **extra_args)
     return np.array(a, copy=copy, dtype=dtype, subok=subok)
 
+
 def test_asarray_or_pandas():
+    import warnings
     assert type(asarray_or_pandas([1, 2, 3])) is np.ndarray
-    assert type(asarray_or_pandas(np.matrix([[1, 2, 3]]))) is np.ndarray
-    assert type(asarray_or_pandas(np.matrix([[1, 2, 3]]), subok=True)) is np.matrix
+    with warnings.catch_warnings() as w:
+        warnings.filterwarnings('ignore', 'the matrix subclass',
+                                PendingDeprecationWarning)
+        assert type(asarray_or_pandas(np.matrix([[1, 2, 3]]))) is np.ndarray
+        assert type(asarray_or_pandas(
+            np.matrix([[1, 2, 3]]), subok=True)) is np.matrix
+        assert w is None
     a = np.array([1, 2, 3])
     assert asarray_or_pandas(a) is a
     a_copy = asarray_or_pandas(a, copy=True)
@@ -147,7 +155,7 @@ def test_asarray_or_pandas():
 # instead of rows. It also converts ndarray subclasses into basic ndarrays,
 # which makes it easier to guarantee correctness. However, there are many
 # places in the code where we want to preserve pandas indexing information if
-# present, so there is also an option 
+# present, so there is also an option
 def atleast_2d_column_default(a, preserve_pandas=False):
     if preserve_pandas and have_pandas:
         if isinstance(a, pandas.Series):
@@ -162,7 +170,9 @@ def atleast_2d_column_default(a, preserve_pandas=False):
     assert a.ndim >= 2
     return a
 
+
 def test_atleast_2d_column_default():
+    import warnings
     assert np.all(atleast_2d_column_default([1, 2, 3]) == [[1], [2], [3]])
 
     assert atleast_2d_column_default(1).shape == (1, 1)
@@ -173,7 +183,11 @@ def test_atleast_2d_column_default():
     assert atleast_2d_column_default([1, 2, 3]).shape == (3, 1)
     assert atleast_2d_column_default([[1], [2], [3]]).shape == (3, 1)
 
-    assert type(atleast_2d_column_default(np.matrix(1))) == np.ndarray
+    with warnings.catch_warnings() as w:
+        warnings.filterwarnings('ignore', 'the matrix subclass',
+                                PendingDeprecationWarning)
+        assert type(atleast_2d_column_default(np.matrix(1))) == np.ndarray
+        assert w is None
 
     global have_pandas
     if have_pandas:
@@ -187,18 +201,21 @@ def test_atleast_2d_column_default():
         assert (type(atleast_2d_column_default(pandas.DataFrame([[1], [2]]),
                                                preserve_pandas=True))
                 == pandas.DataFrame)
-        s = pandas.Series([10, 11,12], name="hi", index=["a", "b", "c"])
+        s = pandas.Series([10, 11, 12], name="hi", index=["a", "b", "c"])
         df = atleast_2d_column_default(s, preserve_pandas=True)
         assert isinstance(df, pandas.DataFrame)
         assert np.all(df.columns == ["hi"])
         assert np.all(df.index == ["a", "b", "c"])
-    assert (type(atleast_2d_column_default(np.matrix(1),
-                                           preserve_pandas=True))
-            == np.ndarray)
-    assert (type(atleast_2d_column_default([1, 2, 3],
-                                           preserve_pandas=True))
+    with warnings.catch_warnings() as w:
+        warnings.filterwarnings('ignore', 'the matrix subclass',
+                                PendingDeprecationWarning)
+        assert (type(atleast_2d_column_default(np.matrix(1),
+                                               preserve_pandas=True))
+                == np.ndarray)
+        assert w is None
+    assert (type(atleast_2d_column_default([1, 2, 3], preserve_pandas=True))
             == np.ndarray)
-        
+
     if have_pandas:
         had_pandas = have_pandas
         try:
@@ -367,15 +384,15 @@ def test_PushbackAdapter():
 # The IPython pretty-printer gives very nice output that is difficult to get
 # otherwise, e.g., look how much more readable this is than if it were all
 # smooshed onto one line:
-# 
+#
 #    ModelDesc(input_code='y ~ x*asdf',
 #              lhs_terms=[Term([EvalFactor('y')])],
 #              rhs_terms=[Term([]),
 #                         Term([EvalFactor('x')]),
 #                         Term([EvalFactor('asdf')]),
 #                         Term([EvalFactor('x'), EvalFactor('asdf')])],
 #              )
-#              
+#
 # But, we don't want to assume it always exists; nor do we want to be
 # re-writing every repr function twice, once for regular repr and once for
 # the pretty printer. So, here's an ugly fallback implementation that can be
@@ -562,7 +579,7 @@ def test_safe_isnan():
     assert not safe_isnan(None)
     # raw isnan raises a *different* error for strings than for objects:
     assert not safe_isnan("asdf")
-    
+
 def iterable(obj):
     try:
         iter(obj)