CLN: Enable more ruff

Author: bashtage

ci/azure_template_posix.yml

@@ -98,6 +98,7 @@ jobs:
      black --check linearmodels
      isort --check linearmodels
      ruff check linearmodels
+     flake8 linearmodels
     displayName: 'Check style and formatting'
 
   - script: |

linearmodels/asset_pricing/model.py

@@ -348,7 +348,7 @@ def fit(
                 kernel=kernel,
             )
             bw = cov_est.bandwidth
-            _cov_config = {k: v for k, v in cov_config.items()}
+            _cov_config = dict(cov_config.items())
             _cov_config["bandwidth"] = bw
             rp_cov_est = KernelCovariance(
                 fe,

linearmodels/iv/absorbing.py

@@ -1089,7 +1089,7 @@ def fit(
                 FutureWarning,
                 stacklevel=2,
             )
-            absorb_options = {k: v for k, v in lsmr_options.items()}
+            absorb_options = dict(lsmr_options.items())
         if self._absorbed_dependent is None:
             self._first_time_fit(use_cache, absorb_options, method)
 
@@ -1104,7 +1104,7 @@ def fit(
         cov_estimator = COVARIANCE_ESTIMATORS[cov_type]
         cov_config["debiased"] = debiased
         cov_config["kappa"] = 0.0
-        cov_config_copy = {k: v for k, v in cov_config.items()}
+        cov_config_copy = dict(cov_config.items())
         cov_config_copy.pop("center", None)
         cov_estimator_inst = cov_estimator(
             exog_resid, dep_resid, exog_resid, params, **cov_config_copy

linearmodels/iv/model.py

@@ -693,7 +693,7 @@ def fit(
         cov_estimator = COVARIANCE_ESTIMATORS[cov_type]
         cov_config["debiased"] = debiased
         cov_config["kappa"] = est_kappa
-        cov_config_copy = {k: v for k, v in cov_config.items()}
+        cov_config_copy = dict(cov_config.items())
         cov_config_copy.pop("center", None)
         cov_estimator_inst = cov_estimator(wx, wy, wz, params, **cov_config_copy)
 

linearmodels/panel/model.py

@@ -763,7 +763,7 @@ def _setup_clusters(
         if not common:
             return cov_config_upd
 
-        cov_config_upd = {k: v for k, v in cov_config.items()}
+        cov_config_upd = dict(cov_config.items())
 
         clusters = get_panel_data_like(cov_config, "clusters")
         clusters_frame: DataFrame | None = None

linearmodels/tests/asset_pricing/test_covariance.py

@@ -20,20 +20,20 @@ def data():
 
 
 def test_kernel_errors(data):
-    with pytest.raises(ValueError, match="Unknown kernel"):
+    with pytest.raises(ValueError, match=r"Unknown kernel"):
         KernelWeight(data.moments, kernel="unknown")
-    with pytest.raises(ValueError, match="bandwidth must be non-negative"):
+    with pytest.raises(ValueError, match=r"bandwidth must be non-negative"):
         KernelWeight(data.moments, bandwidth=-0.5)
-    with pytest.raises(ValueError, match="Unknown kernel"):
+    with pytest.raises(ValueError, match=r"Unknown kernel"):
         KernelCovariance(data.moments, jacobian=data.jacobian, kernel="unknown")
-    with pytest.raises(ValueError, match="bandwidth must be non-negative"):
+    with pytest.raises(ValueError, match=r"bandwidth must be non-negative"):
         KernelCovariance(data.moments, jacobian=data.jacobian, bandwidth=-4)
 
 
 def test_no_jacobian(data):
-    with pytest.raises(ValueError, match="One and only one of jacobian"):
+    with pytest.raises(ValueError, match=r"One and only one of jacobian"):
         KernelCovariance(data.moments)
-    with pytest.raises(ValueError, match="One and only one of jacobian "):
+    with pytest.raises(ValueError, match=r"One and only one of jacobian "):
         KernelCovariance(
             data.moments, jacobian=data.jacobian, inv_jacobian=data.inv_jacobian
         )

linearmodels/tests/asset_pricing/test_formulas.py

@@ -111,7 +111,7 @@ def test_starting_values_options(data):
     res3 = mod2.fit(starting=sv[:, None], opt_options=oo, disp=0)
     assert_frame_equal(res2.params, res3.params)
 
-    with pytest.raises(ValueError, match="tarting values"):
+    with pytest.raises(ValueError, match=r"tarting values"):
         mod2.fit(starting=sv[:-3], opt_options=oo, disp=0)
 
 

linearmodels/tests/asset_pricing/test_linear_factor_model.py

@@ -338,5 +338,5 @@ def test_linear_model_parameters_risk_free_gls(data):
 @pytest.mark.parametrize("output", ["numpy", "pandas"])
 def test_infeasible(output):
     data = generate_data(nfactor=10, nportfolio=20, nobs=10, output=output)
-    with pytest.raises(ValueError, match="Model cannot be estimated"):
+    with pytest.raises(ValueError, match=r"Model cannot be estimated"):
         LinearFactorModel(data.portfolios, data.factors)

linearmodels/tests/asset_pricing/test_model.py

@@ -127,7 +127,7 @@ def test_linear_model_time_series_kernel_smoke(data):
 
 def test_linear_model_time_series_error(data):
     mod = TradedFactorModel(data.portfolios, data.factors)
-    with pytest.raises(ValueError, match="Unknown cov_type"):
+    with pytest.raises(ValueError, match=r"Unknown cov_type"):
         mod.fit(cov_type="unknown")
 
 
@@ -161,19 +161,19 @@ def test_errors(data):
         f2 = np.c_[f, f[:, [0]]]
         f = np.c_[np.ones((f.shape[0], 1)), f]
 
-    with pytest.raises(ValueError, match="portfolios must not contain"):
+    with pytest.raises(ValueError, match=r"portfolios must not contain"):
         TradedFactorModel(p, data.factors)
-    with pytest.raises(ValueError, match="portfolios must not contain"):
+    with pytest.raises(ValueError, match=r"portfolios must not contain"):
         TradedFactorModel(p2, data.factors)
-    with pytest.raises(ValueError, match="The number of observations"):
+    with pytest.raises(ValueError, match=r"The number of observations"):
         TradedFactorModel(p3, data.factors)
-    with pytest.raises(ValueError, match="factors must not contain"):
+    with pytest.raises(ValueError, match=r"factors must not contain"):
         TradedFactorModel(data.portfolios, f)
-    with pytest.raises(ValueError, match="factors must not contain"):
+    with pytest.raises(ValueError, match=r"factors must not contain"):
         TradedFactorModel(data.portfolios, f2)
-    with pytest.raises(ValueError, match="Model cannot be estimated"):
+    with pytest.raises(ValueError, match=r"Model cannot be estimated"):
         TradedFactorModel(p5, f5)
-    with pytest.raises(ValueError, match="The number of test portfolio"):
+    with pytest.raises(ValueError, match=r"The number of test portfolio"):
         LinearFactorModel(p4, data.factors)
 
 
@@ -198,17 +198,17 @@ def test_drop_missing(data):
 
 def test_unknown_kernel(data):
     mod = LinearFactorModel(data.portfolios, data.factors)
-    with pytest.raises(ValueError, match="Unknown weight"):
+    with pytest.raises(ValueError, match=r"Unknown weight"):
         mod.fit(cov_type="unknown")
     mod = LinearFactorModelGMM(data.portfolios, data.factors)
-    with pytest.raises(ValueError, match="Unknown weight"):
+    with pytest.raises(ValueError, match=r"Unknown weight"):
         mod.fit(cov_type="unknown")
 
 
 def test_all_missing():
     p = np.nan * np.ones((1000, 10))
     f = np.nan * np.ones((1000, 3))
-    with pytest.raises(ValueError, match="All observations contain missing data"):
+    with pytest.raises(ValueError, match=r"All observations contain missing data"):
         TradedFactorModel(p, f)
 
 

linearmodels/tests/iv/test_absorbing.py

@@ -265,23 +265,23 @@ def test_smoke(data):
 def test_absorbing_exceptions(random_gen):
     absorbed = random_gen.standard_normal((NOBS, 2))
     assert isinstance(absorbed, np.ndarray)
-    with pytest.raises(TypeError, match="absorb must ba a DataFrame"):
+    with pytest.raises(TypeError, match=r"absorb must ba a DataFrame"):
         AbsorbingLS(
             random_gen.standard_normal(NOBS),
             random_gen.standard_normal((NOBS, 2)),
             absorb=absorbed,
         )
-    with pytest.raises(ValueError, match="ASDF"):
+    with pytest.raises(ValueError, match=r"ASDF"):
         AbsorbingLS(
             random_gen.standard_normal(NOBS), random_gen.standard_normal((NOBS - 1, 2))
         )
-    with pytest.raises(ValueError, match="ASDF"):
+    with pytest.raises(ValueError, match=r"ASDF"):
         AbsorbingLS(
             random_gen.standard_normal(NOBS),
             random_gen.standard_normal((NOBS, 2)),
             absorb=pd.DataFrame(random_gen.standard_normal((NOBS - 1, 1))),
         )
-    with pytest.raises(ValueError, match="ASDF"):
+    with pytest.raises(ValueError, match=r"ASDF"):
         AbsorbingLS(
             random_gen.standard_normal(NOBS),
             random_gen.standard_normal((NOBS, 2)),
@@ -298,7 +298,7 @@ def test_absorbing_exceptions(random_gen):
         assert isinstance(mod.absorbed_exog, pd.DataFrame)
     interactions = random_gen.randint(0, 10, size=(NOBS, 2))
     assert isinstance(interactions, np.ndarray)
-    with pytest.raises(TypeError, match="ASDF"):
+    with pytest.raises(TypeError, match=r"ASDF"):
         AbsorbingLS(
             random_gen.standard_normal(NOBS),
             random_gen.standard_normal((NOBS, 2)),
@@ -346,15 +346,15 @@ def test_category_product_too_large(random_gen):
     for i in range(20):
         dfc[str(i)] = random_cat(10, 1000)
     cat = pd.DataFrame(dfc)
-    with pytest.raises(ValueError, match="There are too many cats"):
+    with pytest.raises(ValueError, match=r"There are too many cats"):
         category_product(cat)
 
 
 def test_category_product_not_cat(random_gen):
     cat = pd.DataFrame(
         {str(i): pd.Series(random_gen.randint(0, 10, 1000)) for i in range(3)}
     )
-    with pytest.raises(TypeError, match="cats must contain only"):
+    with pytest.raises(TypeError, match=r"cats must contain only"):
         category_product(cat)
 
 
@@ -442,9 +442,9 @@ def test_interaction_from_frame(cat, cont):
 
 
 def test_interaction_cat_bad_nobs():
-    with pytest.raises(ValueError, match="nobs must be provided when cat"):
+    with pytest.raises(ValueError, match=r"nobs must be provided when cat"):
         Interaction()
-    with pytest.raises(ValueError, match="ASDF"):
+    with pytest.raises(ValueError, match=r"ASDF"):
         Interaction(cat=np.empty((100, 0)), cont=np.empty((100, 0)))
 
 
@@ -704,7 +704,7 @@ def test_fully_absorb(random_gen):
     y = df.y
     x = pd.get_dummies(df.c, drop_first=False)
     mod = AbsorbingLS(y, x, absorb=df[["c"]], drop_absorbed=True)
-    with pytest.raises(ValueError, match="All columns in exog"):
+    with pytest.raises(ValueError, match=r"All columns in exog"):
         mod.fit()
 
 
@@ -719,9 +719,9 @@ def test_lsmr_options(random_gen):
     y = df.y
     x = df.iloc[:, :3]
     mod = AbsorbingLS(y, x, absorb=df[["c"]], drop_absorbed=True)
-    with pytest.warns(FutureWarning, match="lsmr_options"):
+    with pytest.warns(FutureWarning, match=r"lsmr_options"):
         mod.fit(lsmr_options={})
-    with pytest.raises(ValueError, match="absorb_options cannot"):
+    with pytest.raises(ValueError, match=r"absorb_options cannot"):
         mod.fit(lsmr_options={}, absorb_options={})
 
 
@@ -740,7 +740,7 @@ def test_options(random_gen):
     mod.fit(absorb_options={"atol": 1e-7, "btol": 1e-7}, method="lsmr")
 
     mod = AbsorbingLS(y, x[["x0", "x1"]], absorb=df[["x2", "c"]], drop_absorbed=True)
-    with pytest.raises(RuntimeError, match="HDFE has been"):
+    with pytest.raises(RuntimeError, match=r"HDFE has been"):
         mod.fit(absorb_options={"atol": 1e-7, "btol": 1e-7}, method="hdfe")