MAINT: Make changes for deprecations

Use iloc for clarity with Series
Use setup_method

Author: bashtage

setup.cfg

@@ -78,6 +78,7 @@ filterwarnings =
     error:Parsing dates in:UserWarning
     error:A value is trying to be set on a copy::
     error:Conversion of an array with ndim:DeprecationWarning:
+    error:Series.__getitem__ treating keys:FutureWarning:
 markers =
     example: mark a test that runs example code
     matplotlib: mark a test that requires matplotlib

statsmodels/base/tests/test_predict.py

@@ -38,7 +38,8 @@ def test_1d(self):
 
         pred = res.predict(data.iloc[:1])
         pdt.assert_index_equal(pred.index, data.iloc[:1].index)
-        assert_allclose(pred.values, res.fittedvalues[0], rtol=1e-13)
+        fv = np.asarray(res.fittedvalues)
+        assert_allclose(pred.values, fv[0], rtol=1e-13)
 
         fittedm = res.fittedvalues.mean()
         xmean = data.mean()
@@ -149,5 +150,5 @@ def test_predict_offset(self):
         pred = res.predict(data2, offset=data2['offset'])
         pdt.assert_index_equal(pred.index, fitted.index)
         fitted_nan = fitted.copy()
-        fitted_nan[0] = np.nan
+        fitted_nan.iloc[0] = np.nan
         assert_allclose(pred.values, fitted_nan.values, rtol=1e-13)

statsmodels/discrete/discrete_model.py

@@ -2029,6 +2029,7 @@ def score(self, params):
             return score
 
     def score_factor(self, params, endog=None):
+        params = np.asarray(params)
         if self._transparams:
             alpha = np.exp(params[-1])
         else:
@@ -2182,6 +2183,7 @@ def hessian_factor(self, params):
             parameter.
 
         """
+        params = np.asarray(params)
         if self._transparams:
             alpha = np.exp(params[-1])
         else:
@@ -4018,6 +4020,7 @@ def score_factor(self, params, endog=None):
             The score vector of the model, i.e. the first derivative of the
             loglikelihood function, evaluated at `params`
         """
+        params = np.asarray(params)
         if self._transparams:
             alpha = np.exp(params[-1])
         else:
@@ -4135,6 +4138,7 @@ def hessian_factor(self, params):
         hessian : ndarray, 2-D
             The hessian matrix of the model.
         """
+        params = np.asarray(params)
         if self._transparams:
             alpha = np.exp(params[-1])
         else:

statsmodels/discrete/tests/test_predict.py

@@ -53,8 +53,9 @@ def test_basic(self):
         sl2 = slice(0, -(self.k_infl + 1), None)
         assert_allclose(res1.params[sl1], res2.params[sl2], rtol=self.rtol)
         assert_allclose(res1.bse[sl1], res2.bse[sl2], rtol=30 * self.rtol)
-        assert_allclose(res1.params[-1], np.exp(res2.params[-1]),
-                        rtol=self.rtol)
+        params1 = np.asarray(res1.params)
+        params2 = np.asarray(res2.params)
+        assert_allclose(params1[-1], np.exp(params2[-1]), rtol=self.rtol)
 
     def test_predict(self):
         res1 = self.res1
@@ -64,42 +65,42 @@ def test_predict(self):
         # test for which="mean"
         rdf = res2.results_margins_atmeans
         pred = res1.get_prediction(ex, **self.pred_kwds_mean)
-        assert_allclose(pred.predicted, rdf["b"][0], rtol=1e-4)
-        assert_allclose(pred.se, rdf["se"][0], rtol=1e-4,  atol=1e-4)
+        assert_allclose(pred.predicted, rdf["b"].iloc[0], rtol=1e-4)
+        assert_allclose(pred.se, rdf["se"].iloc[0], rtol=1e-4,  atol=1e-4)
         if isinstance(pred, PredictionResultsMonotonic):
             # default method is endpoint transformation for non-ZI models
             ci = pred.conf_int()[0]
-            assert_allclose(ci[0], rdf["ll"][0], rtol=1e-3,  atol=1e-4)
-            assert_allclose(ci[1], rdf["ul"][0], rtol=1e-3,  atol=1e-4)
+            assert_allclose(ci[0], rdf["ll"].iloc[0], rtol=1e-3,  atol=1e-4)
+            assert_allclose(ci[1], rdf["ul"].iloc[0], rtol=1e-3,  atol=1e-4)
 
             ci = pred.conf_int(method="delta")[0]
-            assert_allclose(ci[0], rdf["ll"][0], rtol=1e-4,  atol=1e-4)
-            assert_allclose(ci[1], rdf["ul"][0], rtol=1e-4,  atol=1e-4)
+            assert_allclose(ci[0], rdf["ll"].iloc[0], rtol=1e-4,  atol=1e-4)
+            assert_allclose(ci[1], rdf["ul"].iloc[0], rtol=1e-4,  atol=1e-4)
         else:
             ci = pred.conf_int()[0]
-            assert_allclose(ci[0], rdf["ll"][0], rtol=1e-4,  atol=1e-4)
-            assert_allclose(ci[1], rdf["ul"][0], rtol=1e-4,  atol=1e-4)
+            assert_allclose(ci[0], rdf["ll"].iloc[0], rtol=1e-4,  atol=1e-4)
+            assert_allclose(ci[1], rdf["ul"].iloc[0], rtol=1e-4,  atol=1e-4)
 
         stat, _ = pred.t_test()
         assert_allclose(stat, pred.tvalues, rtol=1e-4,  atol=1e-4)
 
         rdf = res2.results_margins_mean
         pred = res1.get_prediction(average=True, **self.pred_kwds_mean)
-        assert_allclose(pred.predicted, rdf["b"][0], rtol=3e-4)  # self.rtol)
-        assert_allclose(pred.se, rdf["se"][0], rtol=3e-3,  atol=1e-4)
+        assert_allclose(pred.predicted, rdf["b"].iloc[0], rtol=3e-4)  # self.rtol)
+        assert_allclose(pred.se, rdf["se"].iloc[0], rtol=3e-3,  atol=1e-4)
         if isinstance(pred, PredictionResultsMonotonic):
             # default method is endpoint transformation for non-ZI models
             ci = pred.conf_int()[0]
-            assert_allclose(ci[0], rdf["ll"][0], rtol=1e-3,  atol=1e-4)
-            assert_allclose(ci[1], rdf["ul"][0], rtol=1e-3,  atol=1e-4)
+            assert_allclose(ci[0], rdf["ll"].iloc[0], rtol=1e-3,  atol=1e-4)
+            assert_allclose(ci[1], rdf["ul"].iloc[0], rtol=1e-3,  atol=1e-4)
 
             ci = pred.conf_int(method="delta")[0]
-            assert_allclose(ci[0], rdf["ll"][0], rtol=1e-4,  atol=1e-4)
-            assert_allclose(ci[1], rdf["ul"][0], rtol=1e-4,  atol=1e-4)
+            assert_allclose(ci[0], rdf["ll"].iloc[0], rtol=1e-4,  atol=1e-4)
+            assert_allclose(ci[1], rdf["ul"].iloc[0], rtol=1e-4,  atol=1e-4)
         else:
             ci = pred.conf_int()[0]
-            assert_allclose(ci[0], rdf["ll"][0], rtol=5e-4,  atol=1e-4)
-            assert_allclose(ci[1], rdf["ul"][0], rtol=5e-4,  atol=1e-4)
+            assert_allclose(ci[0], rdf["ll"].iloc[0], rtol=5e-4,  atol=1e-4)
+            assert_allclose(ci[1], rdf["ul"].iloc[0], rtol=5e-4,  atol=1e-4)
 
         stat, _ = pred.t_test()
         assert_allclose(stat, pred.tvalues, rtol=1e-4,  atol=1e-4)
@@ -108,25 +109,25 @@ def test_predict(self):
         rdf = res2.results_margins_atmeans
         pred = res1.get_prediction(ex, which="prob", y_values=np.arange(2),
                                    **self.pred_kwds_mean)
-        assert_allclose(pred.predicted, rdf["b"][1:3], rtol=3e-4)  # self.rtol)
-        assert_allclose(pred.se, rdf["se"][1:3], rtol=3e-3,  atol=1e-4)
+        assert_allclose(pred.predicted, rdf["b"].iloc[1:3], rtol=3e-4)  # self.rtol)
+        assert_allclose(pred.se, rdf["se"].iloc[1:3], rtol=3e-3,  atol=1e-4)
 
         ci = pred.conf_int()
-        assert_allclose(ci[:, 0], rdf["ll"][1:3], rtol=5e-4,  atol=1e-4)
-        assert_allclose(ci[:, 1], rdf["ul"][1:3], rtol=5e-4,  atol=1e-4)
+        assert_allclose(ci[:, 0], rdf["ll"].iloc[1:3], rtol=5e-4,  atol=1e-4)
+        assert_allclose(ci[:, 1], rdf["ul"].iloc[1:3], rtol=5e-4,  atol=1e-4)
 
         stat, _ = pred.t_test()
         assert_allclose(stat, pred.tvalues, rtol=1e-4,  atol=1e-4)
 
         rdf = res2.results_margins_mean
         pred = res1.get_prediction(which="prob", y_values=np.arange(2),
                                    average=True, **self.pred_kwds_mean)
-        assert_allclose(pred.predicted, rdf["b"][1:3], rtol=5e-3)  # self.rtol)
-        assert_allclose(pred.se, rdf["se"][1:3], rtol=3e-3,  atol=5e-4)
+        assert_allclose(pred.predicted, rdf["b"].iloc[1:3], rtol=5e-3)  # self.rtol)
+        assert_allclose(pred.se, rdf["se"].iloc[1:3], rtol=3e-3,  atol=5e-4)
 
         ci = pred.conf_int()
-        assert_allclose(ci[:, 0], rdf["ll"][1:3], rtol=5e-4,  atol=1e-3)
-        assert_allclose(ci[:, 1], rdf["ul"][1:3], rtol=5e-4,  atol=5e-3)
+        assert_allclose(ci[:, 0], rdf["ll"].iloc[1:3], rtol=5e-4,  atol=1e-3)
+        assert_allclose(ci[:, 1], rdf["ul"].iloc[1:3], rtol=5e-4,  atol=5e-3)
 
         stat, _ = pred.t_test()
         assert_allclose(stat, pred.tvalues, rtol=1e-4,  atol=1e-4)

statsmodels/discrete/tests/test_truncated_model.py

@@ -278,8 +278,10 @@ def test_offset(self):
         res1 = self.res1
         reso = self.res_offset
 
-        assert_allclose(reso.params[1:], res1.params[1:], rtol=1e-8)
-        assert_allclose(reso.params[0], res1.params[0] - 1, rtol=1e-8)
+        paramso = np.asarray(reso.params)
+        params1 = np.asarray(res1.params)
+        assert_allclose(paramso[1:], params1[1:], rtol=1e-8)
+        assert_allclose(paramso[0], params1[0] - 1, rtol=1e-8)
         pred1 = res1.predict()
         predo = reso.predict()
         assert_allclose(predo, pred1, rtol=1e-8)
@@ -311,8 +313,10 @@ def test_offset(self):
         res1 = self.res1
         reso = self.res_offset
 
-        assert_allclose(reso.params[1:], res1.params[1:], rtol=1e-8)
-        assert_allclose(reso.params[0], res1.params[0] - 1, rtol=1e-8)
+        paramso = np.asarray(reso.params)
+        params1 = np.asarray(res1.params)
+        assert_allclose(paramso[1:], params1[1:], rtol=1e-8)
+        assert_allclose(paramso[0], params1[0] - 1, rtol=1e-8)
         pred1 = res1.predict()
         predo = reso.predict()
         assert_allclose(predo, pred1, rtol=1e-8)

statsmodels/emplike/originregress.py

@@ -242,11 +242,11 @@ def conf_int_el(self, param_num, upper_bound=None,
         r0 = chi2.ppf(1 - sig, 1)
         param_num = np.array([param_num])
         if upper_bound is None:
-            upper_bound = (np.squeeze(self.model.fit().
-                                      conf_int(.0001)[param_num])[1])
+            ci = np.asarray(self.model.fit().conf_int(.0001))
+            upper_bound = (np.squeeze(ci[param_num])[1])
         if lower_bound is None:
-            lower_bound = (np.squeeze(self.model.fit().conf_int(.00001)
-                                      [param_num])[0])
+            ci = np.asarray(self.model.fit().conf_int(.0001))
+            lower_bound = (np.squeeze(ci[param_num])[0])
         f = lambda b0:  self.el_test(np.array([b0]), param_num,
                                      method=method,
                                  stochastic_exog=stochastic_exog)[0] - r0

statsmodels/gam/smooth_basis.py

@@ -246,14 +246,18 @@ def get_covder2(smoother, k_points=4, integration_points=None,
     integral of the smoother derivative cross-product at knots plus k_points
     in between knots.
     """
-    from scipy.integrate import simps
+    try:
+        from scipy.integrate import simpson
+    except ImportError:
+        # Remove after SciPy 1.7 is the minimum version
+        from scipy.integrate import simps as simpson
     knots = smoother.knots
     x = _get_integration_points(knots, k_points=3)
     if integration_points is None:
         d2 = smoother.transform(x, deriv=deriv, skip_ctransf=skip_ctransf)
     else:
         x = integration_points
-    covd2 = simps(d2[:, :, None] * d2[:, None, :], x, axis=0)
+    covd2 = simpson(d2[:, :, None] * d2[:, None, :], x, axis=0)
     return covd2
 
 

statsmodels/genmod/generalized_estimating_equations.py

@@ -1748,8 +1748,12 @@ def qic(self, params, scale, cov_params, n_step=1000):
             qv[i] = -np.sum(du**2 * (g + 1) / vu)
         qv /= (4 * scale)
 
-        from scipy.integrate import trapz
-        ql = trapz(qv, dx=xv[1] - xv[0])
+        try:
+            from scipy.integrate import trapezoid
+        except ImportError:
+            # Remove after minimum is SciPy 1.7
+            from scipy.integrate import trapz as trapezoid
+        ql = trapezoid(qv, dx=xv[1] - xv[0])
 
         qicu = -2 * ql + 2 * self.exog.shape[1]
         qic = -2 * ql + 2 * np.trace(np.dot(omega, cov_params))

statsmodels/genmod/tests/test_gee.py

@@ -1327,7 +1327,7 @@ def test_predict(self):
         x2_new = np.random.normal(size=10)
         new_exog = pd.DataFrame({"X1": x1_new, "X2": x2_new})
         pred6 = result.predict(exog=new_exog)
-        params = result.params
+        params = np.asarray(result.params)
         pred6_correct = params[0] + params[1] * x1_new + params[2] * x2_new
         assert_allclose(pred6, pred6_correct)
 
@@ -1530,7 +1530,7 @@ def test_sensitivity(self):
                             [0.0, 0.5])
 
         # Regression test
-        assert_almost_equal([x.params[0] for x in ps],
+        assert_almost_equal([np.asarray(x.params)[0] for x in ps],
                             [0.1696214707458818, 0.17836097387799127])
 
     def test_equivalence(self):

statsmodels/graphics/regressionplots.py

@@ -427,7 +427,7 @@ def plot_partregress(endog, exog_i, exog_others, data=None,
         ax.plot(xaxis_resid, yaxis_resid, 'o', **kwargs)
         fitted_line = OLS(yaxis_resid, xaxis_resid).fit()
 
-    fig = abline_plot(0, fitted_line.params[0], color='k', ax=ax)
+    fig = abline_plot(0, np.asarray(fitted_line.params)[0], color='k', ax=ax)
 
     if x_axis_endog_name == 'y':  # for no names regression will just get a y
         x_axis_endog_name = 'x'  # this is misleading, so use x

statsmodels/iolib/summary.py

@@ -423,11 +423,11 @@ def summary_params(results, yname=None, xname=None, alpha=.05, use_t=True,
         #we need to give parameter alpha to conf_int
         results, params, std_err, tvalues, pvalues, conf_int = results
     else:
-        params = results.params
-        std_err = results.bse
-        tvalues = results.tvalues  # is this sometimes called zvalues
-        pvalues = results.pvalues
-        conf_int = results.conf_int(alpha)
+        params = np.asarray(results.params)
+        std_err = np.asarray(results.bse)
+        tvalues = np.asarray(results.tvalues)  # is this sometimes called zvalues
+        pvalues = np.asarray(results.pvalues)
+        conf_int = np.asarray(results.conf_int(alpha))
     if params.size == 0:
         return SimpleTable([['No Model Parameters']])
     # Dictionary to store the header names for the parameter part of the

statsmodels/miscmodels/tests/test_ordinal_model.py

@@ -307,8 +307,10 @@ def test_offset(self):
                                           distr='probit')
         resf2 = modf2.fit(method='bfgs', disp=False)
 
-        assert_allclose(resf2.params[:3], resp.params[:3], atol=2e-4)
-        assert_allclose(resf2.params[3], resp.params[3] + 1, atol=2e-4)
+        resf2_params = np.asarray(resf2.params)
+        resp_params = np.asarray(resp.params)
+        assert_allclose(resf2_params[:3], resp_params[:3], atol=2e-4)
+        assert_allclose(resf2_params[3], resp_params[3] + 1, atol=2e-4)
 
         fitted = resp.predict()
         fitted2 = resf2.predict()
@@ -328,7 +330,7 @@ def test_offset(self):
         assert_allclose(pred_zero1, pred_zero, atol=2e-4)
 
         params_adj = resp.params.copy()
-        params_adj[3] += 1
+        params_adj.iloc[3] += 1
         fitted_zero = resp.model.predict(params_adj)
         assert_allclose(pred_zero1, fitted_zero[:6], atol=2e-4)
 
@@ -464,8 +466,10 @@ def test_attributes(self):
 
         attributes = "bse df_resid llf aic bic llnull".split()
         attributes += "llnull llr llr_pvalue prsquared".split()
-        assert_allclose(resp.params[:3], res_logit.params[:3], rtol=1e-5)
-        assert_allclose(resp.params[3], -res_logit.params[3], rtol=1e-5)
+        params = np.asarray(resp.params)
+        logit_params = np.asarray(res_logit.params)
+        assert_allclose(params[:3], logit_params[:3], rtol=1e-5)
+        assert_allclose(params[3], -logit_params[3], rtol=1e-5)
         for attr in attributes:
             assert_allclose(getattr(resp, attr), getattr(res_logit, attr),
                             rtol=1e-4)

statsmodels/regression/tests/test_recursive_ls.py

@@ -435,8 +435,9 @@ def test_constraints_stata():
 
     # See tests/results/test_rls.do
     desired = [.4699552366, .0005369357, .0005369357]
-    assert_allclose(res.bse[0], desired[0], atol=1e-1)
-    assert_allclose(res.bse[1:], desired[1:], atol=1e-4)
+    bse = np.asarray(res.bse)
+    assert_allclose(bse[0], desired[0], atol=1e-1)
+    assert_allclose(bse[1:], desired[1:], atol=1e-4)
 
     # See tests/results/test_rls.do
     desired = -534.4292052931121
@@ -469,8 +470,9 @@ def test_multiple_constraints():
 
     # See tests/results/test_rls.do
     desired = [.4699552366, .0005369357, .0005369357, 0]
-    assert_allclose(res.bse[0], desired[0], atol=1e-1)
-    assert_allclose(res.bse[1:-1], desired[1:-1], atol=1e-4)
+    bse = np.asarray(res.bse)
+    assert_allclose(bse[0], desired[0], atol=1e-1)
+    assert_allclose(bse[1:-1], desired[1:-1], atol=1e-4)
 
     # See tests/results/test_rls.do
     desired = -534.4292052931121

statsmodels/tools/_testing.py

@@ -69,7 +69,8 @@ def check_ttest_tvalues(results):
 
     tt = res.t_test(mat[0])
     tt.summary()   # smoke test for #1323
-    assert_allclose(tt.pvalue, res.pvalues[0], rtol=5e-10)
+    pvalues = np.asarray(res.pvalues)
+    assert_allclose(tt.pvalue, pvalues[0], rtol=5e-10)
     # TODO: Adapt more of test_generic_methods.test_ttest_values here?
 
 

statsmodels/tools/numdiff.py

@@ -103,7 +103,7 @@ def _get_epsilon(x, s, epsilon, n):
             if h.shape != x.shape:
                 raise ValueError("If h is not a scalar it must have the same"
                                  " shape as x.")
-    return h
+    return np.asarray(h)
 
 
 def approx_fprime(x, f, epsilon=None, args=(), kwargs={}, centered=False):

statsmodels/tools/tests/test_tools.py

@@ -193,22 +193,22 @@ def test_pandas_const_series():
     series = dta.exog["GNP"]
     series = tools.add_constant(series, prepend=False)
     assert_string_equal("const", series.columns[1])
-    assert_equal(series.var(0)[1], 0)
+    assert_equal(series.var(0).iloc[1], 0)
 
 
 def test_pandas_const_series_prepend():
     dta = longley.load_pandas()
     series = dta.exog["GNP"]
     series = tools.add_constant(series, prepend=True)
     assert_string_equal("const", series.columns[0])
-    assert_equal(series.var(0)[0], 0)
+    assert_equal(series.var(0).iloc[0], 0)
 
 
 def test_pandas_const_df():
     dta = longley.load_pandas().exog
     dta = tools.add_constant(dta, prepend=False)
     assert_string_equal("const", dta.columns[-1])
-    assert_equal(dta.var(0)[-1], 0)
+    assert_equal(dta.var(0).iloc[-1], 0)
 
 
 def test_pandas_const_df_prepend():
@@ -217,7 +217,7 @@ def test_pandas_const_df_prepend():
     dta["UNEMP"] /= dta["UNEMP"].std()
     dta = tools.add_constant(dta, prepend=True)
     assert_string_equal("const", dta.columns[0])
-    assert_equal(dta.var(0)[0], 0)
+    assert_equal(dta.var(0).iloc[0], 0)
 
 
 class TestNanDot: