PyProcessMacro 1.0.13__py3-none-any.whl → 2.0.0__py3-none-any.whl

pyprocessmacro/__init__.py

@@ -3,7 +3,8 @@
 Core module for the PyProcess Macro.
 """
 from .process import Process
+from .utils import ConvergenceError
 
-__all__ = ["Process"]
+__all__ = ["Process", "ConvergenceError"]
 
-__version__ = "1.0.13"
+__version__ = "2.0.0"

pyprocessmacro/models.py

@@ -16,11 +16,32 @@ from .utils import (
     eval_expression,
     bias_corrected_ci,
     z_score,
+    t_score,
     percentile_ci,
     find_significance_region,
+    ConvergenceError,
 )
 
 
+def _coerce_numeric(df):
+    """
+    Convert the columns of a summary table that hold numbers stored as strings back to numbers.
+
+    The tables are assembled with np.concatenate, which turns every statistic into a string as soon as a
+    column of names sits next to it. pd.to_numeric(errors="ignore") used to undo that but was removed in
+    pandas 3, so this reproduces its behaviour: convert a column when every entry parses as a number, and
+    leave it untouched otherwise.
+    """
+
+    def convert(column):
+        try:
+            return pd.to_numeric(column)
+        except (ValueError, TypeError):
+            return column
+
+    return df.apply(convert)
+
+
 class BaseLogit(object):
     """
     A convenience parent class for the methods used in Logistic models.
@@ -84,14 +105,26 @@ class BaseLogit(object):
             return -self._hessian(params) / self._n_obs
 
         oldparams = np.inf
-        newparams = np.repeat(0, self._n_vars)
+        newparams = np.zeros(self._n_vars)
         while iterations < max_iter and np.any(
                 np.abs(newparams - oldparams) > tolerance
         ):
             oldparams = newparams
-            H = hess(oldparams)
-            newparams = oldparams - dot(inv(H), score(oldparams))
+            try:
+                H = hess(oldparams)
+                newparams = oldparams - dot(inv(H), score(oldparams))
+            except LinAlgError:
+                raise ConvergenceError("The Hessian of the logistic regression is singular.")
             iterations += 1
+            if not np.all(np.isfinite(newparams)):
+                raise ConvergenceError(
+                    "The logistic regression diverged (the outcome may be perfectly separated)."
+                )
+        if np.any(np.abs(newparams - oldparams) > tolerance):
+            raise ConvergenceError(
+                f"The logistic regression did not converge in {max_iter} iterations "
+                "(increase 'iterate', relax 'convergence', or check the outcome for separation)."
+            )
         return newparams
 
 
@@ -267,7 +300,7 @@ class OLSOutcomeModel(BaseOutcomeModel):
         resid = y - dot(x, betas)
         mse = (resid ** 2).sum() / df_e
         sse = dot(resid.T, resid) / df_e
-        errortype = "standard" if self._options["hc3"] is False else "HC3"
+        errortype = self._options.get("cov_type") or ("HC3" if self._options.get("hc3") else "standard")
         if errortype == "standard":
             vcv = np.true_divide(1, n_obs - n_vars) * dot(resid.T, resid) * inv_xx
         elif errortype == "HC0":
@@ -275,7 +308,7 @@ class OLSOutcomeModel(BaseOutcomeModel):
             vcv = dot(dot(dot(inv_xx, x.T) * sq_resid, x), inv_xx)
         elif errortype == "HC1":
             sq_resid = (resid ** 2).squeeze()
-            vcv = np.true_divide(n_obs, n_obs - n_vars - 1) * dot(
+            vcv = np.true_divide(n_obs, n_obs - n_vars) * dot(  # n_vars counts the constant (#52)
                 dot(dot(inv_xx, x.T) * sq_resid, x), inv_xx
             )
         elif errortype == "HC2":
@@ -297,13 +330,13 @@ class OLSOutcomeModel(BaseOutcomeModel):
         t = betas / se
         p = stats.t.sf(np.abs(t), df_e) * 2
         conf = self._options["conf"]
-        zscore = z_score(conf)
+        tcrit = t_score(conf, df_e)  # OLS intervals use the t distribution, as PROCESS does (#40)
         R2 = 1 - resid.var() / y.var()
-        adjR2 = 1 - (1 - R2) * ((n_obs - 1) / (n_obs - n_vars - 1))
+        adjR2 = 1 - (1 - R2) * ((n_obs - 1) / df_e)  # n_vars already counts the constant (#41)
         F = (R2 / df_r) / ((1 - R2) / df_e)
-        F_pval = 1 - stats.f.cdf(F, df_r, df_e)
-        llci = betas - (se * zscore)
-        ulci = betas + (se * zscore)
+        F_pval = stats.f.sf(F, df_r, df_e)
+        llci = betas - (se * tcrit)
+        ulci = betas + (se * tcrit)
         names = [self._symb_to_var.get(x, x) for x in self._exogvars]
         estimation_results = {
             "betas": betas,
@@ -399,19 +432,19 @@ class LogitOutcomeModel(BaseOutcomeModel, BaseLogit):
 
         # GOF statistics
         llmodel = self._loglike(betas)
-        lmodel = np.exp(llmodel)
         minus2ll = -2 * llmodel
 
         null_model = NullLogitModel(self._endog, self._options)
         betas_null = null_model._optimize()
         llnull = null_model._loglike(betas_null)
-        lnull = np.exp(llnull)
 
         d = 2 * (llmodel - llnull)
         pvalue = stats.chi2.sf(d, self._n_vars - 1)
         mcfadden = 1 - llmodel / llnull
-        coxsnell = 1 - (lnull / lmodel) ** (2 / self._n_obs)
-        nagelkerke = coxsnell / (1 - lnull ** (2 / self._n_obs))
+        # Likelihood ratios are taken in log space: exp(llnull) underflows to 0 beyond about a
+        # thousand observations, which turned both pseudo R-squared into NaN (#42).
+        coxsnell = 1 - np.exp(2 * (llnull - llmodel) / self._n_obs)
+        nagelkerke = coxsnell / (1 - np.exp(2 * llnull / self._n_obs))
         names = [self._symb_to_var.get(x, x) for x in self._exogvars]
         estimation_results = {
             "betas": betas,
@@ -631,6 +664,7 @@ class ParallelMediationModel(object):
         boot_betas_y = np.empty((n_boots, len(self._exog_terms_y)))
         boot_betas_m = np.empty((self._n_meds, n_boots, len(self._exog_terms_m)))
         n_fail_samples = 0
+        max_failures = n_boots  # give up once more resamples failed than were requested (#49)
         boot_ind = 0
         sampler = bootstrap_sampler(self._n_obs, seed)
         while boot_ind < n_boots:
@@ -647,8 +681,14 @@ class ParallelMediationModel(object):
                     m_b = self._compute_betas_m(m_e, m_x)
                     boot_betas_m[j][boot_ind] = m_b
                 boot_ind += 1
-            except LinAlgError:  # Hessian (Logit) or X'X (OLS) cannot be inverted
+            except (LinAlgError, ConvergenceError):  # X'X or the Hessian is singular, or the logit diverged
                 n_fail_samples += 1
+                if n_fail_samples > max_failures:
+                    raise RuntimeError(
+                        f"{n_fail_samples} bootstrap samples failed to estimate before {n_boots} succeeded. "
+                        "The model is probably not estimable on resamples of this data (check for separation, "
+                        "collinearity, or a very small sample)."
+                    )
 
         return boot_betas_y, boot_betas_m, n_fail_samples
 
@@ -1184,8 +1224,7 @@ class ParallelMediationModel(object):
         rows = np.concatenate([rows_levels, rows_stats], axis=1)
         cols = cols_levels + cols_stats
         df = pd.DataFrame(rows, columns=cols, index=[""] * rows.shape[0])
-        # noinspection PyTypeChecker
-        return df.apply(lambda s: pd.to_numeric(s, errors='coerce').fillna(s))
+        return _coerce_numeric(df)
 
     def _simple_ind_effects_wrapper(self):
         """
@@ -1218,8 +1257,7 @@ class ParallelMediationModel(object):
         rows = np.concatenate([rows_levels, rows_stats], axis=1)
         cols = ["", "Effect", "Boot SE", "BootLLCI", "BootULCI"]
         df = pd.DataFrame(rows, columns=cols, index=[""] * rows.shape[0])
-        # noinspection PyTypeChecker
-        return df.apply(lambda s: pd.to_numeric(s, errors='coerce').fillna(s))
+        return _coerce_numeric(df)
 
     def _MM_index_wrapper(self):
         """
@@ -1248,8 +1286,7 @@ class ParallelMediationModel(object):
         rows = np.concatenate([rows_levels, rows_stats], axis=1)
         cols = cols_levels + cols_stats
         df = pd.DataFrame(rows, columns=cols, index=[""] * rows.shape[0])
-        # noinspection PyTypeChecker
-        return df.apply(pd.to_numeric, args=["ignore"])
+        return _coerce_numeric(df)
 
     def _PMM_index_wrapper(self):
         """
@@ -1278,8 +1315,7 @@ class ParallelMediationModel(object):
         rows = np.concatenate([rows_levels, rows_stats], axis=1)
         cols = cols_levels + cols_stats
         df = pd.DataFrame(rows, columns=cols, index=[""] * rows.shape[0])
-        # noinspection PyTypeChecker
-        return df.apply(pd.to_numeric, args=["ignore"])
+        return _coerce_numeric(df)
 
     def _CMM_index_wrapper(self):
         """
@@ -1328,8 +1364,7 @@ class ParallelMediationModel(object):
         cols = cols_levels + cols_stats
         df = pd.DataFrame(rows, columns=cols, index=[""] * rows.shape[0])
 
-        # noinspection PyTypeChecker
-        return df.apply(pd.to_numeric, args=["ignore"])
+        return _coerce_numeric(df)
 
     def _MMM_index_wrapper(self):
         """
@@ -1356,8 +1391,7 @@ class ParallelMediationModel(object):
         rows = np.concatenate([rows_levels, rows_stats], axis=1)
         cols = cols_levels + cols_stats
         df = pd.DataFrame(rows, columns=cols, index=[""] * rows.shape[0])
-        # noinspection PyTypeChecker
-        return df.apply(pd.to_numeric, args=["ignore"])
+        return _coerce_numeric(df)
 
     def MM_index_summary(self):
         if "MM" in self._analysis_list:
@@ -1572,9 +1606,12 @@ class DirectEffectModel(object):
             dot(grad, vcv), np.transpose(grad)
         )  # V(Grad(X)) = Grad(X).V(X).Grad'(X)
         se = np.sqrt(var)
-        zscore = z_score(conf)
-        llci = betas - (se * zscore)
-        ulci = betas + (se * zscore)
+        if self._is_logit:
+            crit = z_score(conf)
+        else:  # OLS intervals use the t distribution, as PROCESS does (#40)
+            crit = t_score(conf, self._model.estimation_results["df_e"])
+        llci = betas - (se * crit)
+        ulci = betas + (se * crit)
         return betas, se, llci, ulci
 
     def coeff_summary(self):

pyprocessmacro/process.py

@@ -16,8 +16,6 @@ from .models import (
 )
 from .utils import plot_conditional_effects, gen_moderators
 
-warnings.simplefilter("default")
-
 
 class Process(object):
     __var_kws__ = {"x", "m", "w", "z", "v", "q", "y"}
@@ -31,6 +29,7 @@ class Process(object):
         "effsize",
         "jn",
         "hc3",
+        "cov_type",
         "controls_in",
         "total",
         "center",
@@ -564,6 +563,7 @@ class Process(object):
             effsize=False,
             jn=False,
             hc3=False,
+            cov_type="standard",
             controls=None,
             controls_in="all",
             total=False,
@@ -601,7 +601,8 @@ class Process(object):
         :param boot: int
             The number of bootstrap repetitions for the estimation of the SE and CI in indirect effects.
         :param seed: int
-            The seed to use for bootstrap samples. Specify an integer between 0 and 1e10 for a replicable seed.
+            The seed of the bootstrap sampler: an integer between 0 and 2**32 - 1 for reproducible samples,
+            or None for a different draw on every run.
         :param conf: int
             A value between 51 and 99, representing the desired level of confidence for the confidence intervals
         :param effsize: bool
@@ -610,6 +611,11 @@ class Process(object):
             If True, the Johnson-Neymann region of significance will be reported.
         :param hc3: bool
             If True, the HC3 estimator will be used for the variance/covariance matrix of the parameters.
+            Shorthand for cov_type="HC3".
+        :param cov_type: "standard", "HC0", "HC1", "HC2" or "HC3"
+            The estimator of the variance/covariance matrix of the OLS parameters: the standard homoskedastic
+            estimator, or one of the heteroskedasticity-consistent estimators. Logistic outcome models always
+            use the inverse of the Hessian.
         :param controls: list of string
             A list of control variables to include to the model(s).
         :param controls_in: "all", "x_to_m", "all_to_y"
@@ -642,55 +648,65 @@ class Process(object):
         :param precision:
             The number of decimal places to display in the summary of the model results.
         """
-        if kwargs.pop("mc", None):
+        if mc:
             warnings.warn(
-                "The argument 'mc' for Monte-Carlo simulations is not supported",
-                DeprecationWarning,
+                "The argument 'mc' for Monte-Carlo confidence intervals is not supported; "
+                "bootstrap confidence intervals are used.",
+                UserWarning,
+                stacklevel=2,
             )
         if kwargs.pop("normal", None):
             warnings.warn(
                 "The argument 'normal' for normal theory tests is not supported. "
                 "Bootstrapped CI are recommended.",
-                DeprecationWarning,
+                UserWarning,
+                stacklevel=2,
             )
         if kwargs.pop("varorder", None):
             warnings.warn(
                 "The argument 'varorder' for normal theory tests is not supported. "
                 "Bootstrapped CI are recommended.",
-                DeprecationWarning,
+                UserWarning,
+                stacklevel=2,
             )
         if kwargs.pop("varlist", None):
             warnings.warn(
                 "The 'varlist' is not required. To specify controls, use the 'controls' arguments",
-                DeprecationWarning,
+                UserWarning,
+                stacklevel=2,
             )
         if kwargs.pop("coeffci", None):
             warnings.warn(
-                "The argument 'coeffci' is not supported.", DeprecationWarning
+                "The argument 'coeffci' is not supported.",
+                UserWarning,
+                stacklevel=2,
             )
         if kwargs.pop("plot", None):
             warnings.warn(
                 "The argument 'plot' is not supported. Check the 'plot_conditional_direct_effects() and"
                 "'plot_conditional_indirect_effects()' methods instead.",
-                DeprecationWarning,
+                UserWarning,
+                stacklevel=2,
             )
         if kwargs.pop("save", None):
             warnings.warn(
                 "The argument 'save' is not supported. Call the 'get_bootstrap_estimates() method to recover"
                 "the bootstrap samples instead.",
-                DeprecationWarning,
+                UserWarning,
+                stacklevel=2,
             )
-        if kwargs.pop("effsize", None):
+        if effsize:
             warnings.warn(
-                "The argument 'effsize' for effect sizes is not supported yet."
-                "It is coming in future versions of PyProcessMacro.",
-                SyntaxWarning,
+                "The argument 'effsize' for effect sizes is not supported and is ignored.",
+                UserWarning,
+                stacklevel=2,
             )
-        if kwargs.pop("jn", None):
+        if jn:
             warnings.warn(
-                "The argument 'jn' for the Johnson-Neyman region of significance is not supported."
-                "Call the 'floodlight_direct_effect()' and 'floodlight_indirect_effect()' methods instead.",
-                DeprecationWarning,
+                "The argument 'jn' for the Johnson-Neyman region of significance is not supported and is "
+                "ignored. Call the 'floodlight_direct_effect()' and 'floodlight_indirect_effect()' methods instead.",
+                UserWarning,
+                stacklevel=2,
             )
 
         if model == 6:
@@ -720,13 +736,21 @@ class Process(object):
 
         # Check the congruence between the model specifications, the model number, and the data, and store the final
         # list of variables used
+        unknown_kwargs = set(kwargs) - self.__var_kws__
+        if unknown_kwargs:
+            raise TypeError(
+                f"Process() got unexpected keyword argument(s): {', '.join(sorted(unknown_kwargs))}. "
+                "Variables are x, y, m, w, z, v and q; check the spelling of the options."
+            )
         var_kwargs = {k: v for k, v in kwargs.items() if k in self.__var_kws__}
 
-        self.mediators = var_kwargs.get("m")
-        self.iv = var_kwargs.get("y")
-
+        # _gen_valid_varlist normalizes every variable argument to a list, so the mediator and
+        # outcome names must be read after it runs (#35).
         self.varlist = self._gen_valid_varlist(var_kwargs)
 
+        self.mediators = list(var_kwargs["m"]) if self.model_num > 3 else []
+        self.iv = var_kwargs["y"][0]
+
         # Check the number of mediators supplied to the model:
         if self.model_num > 3:
             self.n_meds = len(self.mediators)
@@ -761,7 +785,8 @@ class Process(object):
         self.outcome_models = self._gen_outcome_models()
 
         # Rename the dictionary of custom spotlight values, and generating the spotlight values.
-        modval_symb = {self._var_to_symb.get(k): v for k, v in modval.items()}
+        self._check_moderator_names(modval, "modval")
+        modval_symb = {self._var_to_symb[k]: v for k, v in modval.items()}
         self._spotlight_values = self._gen_spotlight_values(modval_symb)
 
         # Generate the direct model.
@@ -777,6 +802,20 @@ class Process(object):
         if not suppr_init:
             self._print_init()
 
+    def _check_moderator_names(self, names, argument):
+        """
+        Raise a ValueError if any of the names is not a moderator of the model (#46).
+        :param names: iterable of variable names
+        :param argument: the name of the argument being validated, for the error message
+        """
+        moderators = {self._symb_to_var[s] for s in self._moderators["all"]}
+        unknown = [str(n) for n in names if n not in moderators]
+        if unknown:
+            raise ValueError(
+                f"The variable(s) {', '.join(unknown)} in '{argument}' are not moderators of Model "
+                f"{self.model_num}. Moderators of this model: {', '.join(sorted(moderators)) or 'none'}."
+            )
+
     def _gen_valid_options(self, arguments):
         """
         Validate the arguments specified for the different options used in Process.
@@ -791,8 +830,8 @@ class Process(object):
                 "The option 'conf' must be an integer between 50 and 100, exclusive.\n"
             )
 
-        if not isinstance(seed, int) or ((seed <= 0) or (seed >= 1e9)):
-            errstr += "The option 'seed' must be  an integer between 0 and 1 000 000 000, exclusive.\n"
+        if seed is not None and (not isinstance(seed, (int, np.integer)) or not (0 <= seed <= 2**32 - 1)):
+            errstr += "The option 'seed' must be None or an integer between 0 and 2**32 - 1.\n"
 
         if options["contrast"] not in [True, False]:
             errstr += "The option 'contrast' must be 'True' or 'False'.\n"
@@ -802,6 +841,12 @@ class Process(object):
             errstr += "The option 'jn' must be 'True' or 'False'.\n"
         if options["hc3"] not in [True, False]:
             errstr += "The option 'hc3' must be 'True' or 'False'.\n"
+        if options["cov_type"] not in ["standard", "HC0", "HC1", "HC2", "HC3"]:
+            errstr += "The option 'cov_type' must be one of 'standard', 'HC0', 'HC1', 'HC2' or 'HC3'.\n"
+        elif options["hc3"] is True:
+            if options["cov_type"] not in ["standard", "HC3"]:
+                errstr += "The options hc3=True and cov_type disagree; use one or the other.\n"
+            options["cov_type"] = "HC3"  # hc3 is shorthand for cov_type="HC3" (#52)
         if options["center"] not in [True, False]:
             errstr += "The option 'center' must be 'True' or 'False'.\n"
         if options["quantile"] not in [True, False]:
@@ -810,7 +855,7 @@ class Process(object):
             errstr += "The option 'jn' must be 'True' or 'False'.\n"
         if options["logit"] not in [True, False]:
             errstr += "The option 'logit' must be 'True' or 'False'.\n"
-        if options["controls_in"] not in ["all", "x_to_tm", "all_to_y"]:
+        if options["controls_in"] not in ["all", "x_to_m", "all_to_y"]:
             errstr += "The option 'controls_in' should be one of 'all', 'x_to_m', 'all_to_y'\n"
         if not isinstance(options["modval"], dict):
             errstr += "The option 'modval' must be a dictionary.\n"
@@ -994,9 +1039,9 @@ class Process(object):
         """
         # Subset the data to the columns used in the model
         data = self._data[self.varlist].copy()
-        n_obs_before = self._data.shape[0]
-        data = data.dropna().reset_index()
-        n_obs_after = self._data.shape[0]
+        n_obs_before = data.shape[0]
+        data = data.dropna().reset_index(drop=True)
+        n_obs_after = data.shape[0]  # rows that survived dropna (#44)
         n_obs_null = n_obs_before - n_obs_after
 
         # Map each variable name to a unique variable code, and rename the columns in the data.)
@@ -1222,7 +1267,9 @@ class Process(object):
           1. If the two moderators are on two different paths (X to M, or M to Y): both CMM and MMM are reported.
           2. If the two moderators are on the same path and form a 3-way interaction: both CMM and MMM are reported.
           3. If the two moderators are on the same path and do not form a 3-way: the PMM is reported.
-          4. If at least one of the two moderators is present on both paths: no analysis is reported.
+          4. If a moderator is present on both paths (models 58 to 73, 75 and 76): no index is reported, because
+             the indirect effect is not linear in that moderator and the indices assume it is.
+        MM and PMM match PROCESS 2.16. MMM and CMM follow PROCESS 3 (Hayes, 2018), which 2.16 did not report.
 
         This function returns the list of additional analysis to report. If no additional analysis must be performed,
          this list is empty.
@@ -1238,6 +1285,11 @@ class Process(object):
         if n_mods_ind == 0:  # No moderators on indirect path, so no additional analysis.
             return []
 
+        # Rule 4: a moderator on both the X-to-M and the M-to-Y paths makes the indirect effect quadratic in
+        # that moderator, and every index below assumes linearity. PROCESS reports no index then (#43).
+        if self._moderators["x_indirect"] & self._moderators["m"]:
+            return []
+
         terms = y_exogvars + m_exogvars
         threeway = any(
             [1 if len(term.split("*")) == 3 else 0 for term in terms]
@@ -1267,6 +1319,7 @@ class Process(object):
         :param path:
         :return:
         """
+        self._check_moderator_names(modval, "modval")
         modval_symb = {self._var_to_symb[k]: v for k, v in modval.items()}
         spotlight_values_symb = self._spotlight_values.copy()
 
@@ -1307,17 +1360,28 @@ class Process(object):
                 hue1_values = modval_symb.get(huesymb1,
                                               spotlight_values_symb[huesymb1])
                 hue2_values = [0]
+            else:
+                raise ValueError(
+                    f"'hue' accepts one or two moderator names, got {len(hue)}."
+                )
         else:
             huevar1 = None
             huevar2 = None
             hue1_values = [0]
             hue2_values = [0]
 
-        col_symb = self._var_to_symb[x]
-        col_values = modval_symb.get(col_symb, spotlight_values_symb.get(col_symb, [0]))
+        # Values for the column and row facets (#36)
+        if col is not None:
+            col_symb = self._var_to_symb[col]
+            col_values = modval_symb.get(col_symb, spotlight_values_symb.get(col_symb, [0]))
+        else:
+            col_values = [0]
 
-        row_symb = self._var_to_symb[x]
-        row_values = modval_symb.get(row_symb, spotlight_values_symb.get(row_symb, [0]))
+        if row is not None:
+            row_symb = self._var_to_symb[row]
+            row_values = modval_symb.get(row_symb, spotlight_values_symb.get(row_symb, [0]))
+        else:
+            row_values = [0]
 
         mod_names = [x, huevar1, huevar2, col, row]
         mod_values = [x_values, hue1_values, hue2_values, col_values, row_values]
@@ -1337,13 +1401,19 @@ class Process(object):
             m_var = self._symb_to_var[m]
             if modval_parsed.get(m_var) is None:
                 warnings.warn(
-                    f"The moderator {m_var} exerts an influence on the effect, but is not specified as a factor on\
-                     the graph. Its value has been explicitely set to 0.",
-                    SyntaxWarning,
+                    f"The moderator {m_var} exerts an influence on the effect but is not a factor of the graph; "
+                    "its value has been set to 0.",
+                    UserWarning,
+                    stacklevel=3,
                 )
                 modval_parsed[m_var] = [0]
         return modval_parsed
 
+    @property
+    def dv(self):
+        """The name of the dependent variable (the outcome Y). `iv` holds the same value for compatibility."""
+        return self.iv
+
     # API
     def summary(self):
         """
@@ -1393,17 +1463,18 @@ class Process(object):
         boot_betas_y = iem._boot_betas_y
         boot_betas_m = iem._boot_betas_m
 
-        cols_y = [stv[t] for t in iem._exog_terms_y]
-        df = pd.DataFrame(boot_betas_y, columns=cols_y)
-        df["___"] = stv["y"]
+        frames = []
+        df_y = pd.DataFrame(boot_betas_y, columns=[stv[t] for t in iem._exog_terms_y])
+        df_y.insert(0, "OutcomeName", stv["y"])
+        frames.append(df_y)
+        cols_m = [stv[t] for t in iem._exog_terms_m]
         for i in range(self.n_meds):
-            cols_m = [stv[t] for t in iem._exog_terms_m]
             df_m = pd.DataFrame(boot_betas_m[i], columns=cols_m)
-            df_m["___"] = stv[f"m{i + 1}"]
-            df = df.append(df_m)
+            df_m.insert(0, "OutcomeName", stv[f"m{i + 1}"])
+            frames.append(df_m)
+        # One block per outcome. DataFrame.append was removed in pandas 2.0 (#33).
+        df = pd.concat(frames)
         df.index.name = "BootSample"
-        df.insert(0, "OutcomeName", df["___"].values)
-        del df["___"]
         return df.reset_index()
 
     def floodlight_indirect_effect(
@@ -1432,9 +1503,9 @@ class Process(object):
         if other_modval:
             for k, v in other_modval.items():
                 symb = self._var_to_symb.get(k)
-                if not mod_symb:
+                if not symb:
                     raise ValueError(
-                        f"The variable {mod_name} is not a variable in the model."
+                        f"The variable {k} is not a variable in the model."
                     )
                 if isinstance(v, list):
                     raise ValueError(
@@ -1502,9 +1573,9 @@ class Process(object):
         if other_modval:
             for k, v in other_modval.items():
                 symb = self._var_to_symb.get(k)
-                if not mod_symb:
+                if not symb:
                     raise ValueError(
-                        f"The variable {mod_name} is not a variable in the model."
+                        f"The variable {k} is not a variable in the model."
                     )
                 if isinstance(v, list):
                     raise ValueError(
@@ -1674,14 +1745,15 @@ class Process(object):
                 If 'ci', confidence intervals are drawn at each discrete value of the moderator on the x-axis
                 If 'none', no confidence interval is drawn.
         :param hue_format: string or None
-            By default, the color-code are labeled:
+            By default, the color-codes are labeled:
                 'Mod1 at val1' if there is one moderator for 'hue'.
-                'Mod2 at val1, Mod2 at val2' if there are two moderators for 'hue'.
-            Alternatively, a string that should be formatted can be passed. The string will receive as arguments:
+                'Mod1 at val1, Mod2 at val2' if there are two moderators for 'hue'.
+            Alternatively, a format string can be passed. It receives the keyword arguments:
                 var1 (the name of the first moderator)
                 var2 (the name of the second moderator, if it exists)
                 val1 (the value of the first moderator)
-                val2 (the value of the second moderator)
+                val2 (the value of the second moderator, if it exists)
+            hue1 and hue2 are accepted as aliases of val1 and val2.
             A valid string would for instance look like this: '{var1} = {val1:.4f}, {var2} = {val2:.4f}'
         :param facet_kws: dict
             A dictionary of arguments that should be passed to the FacetGrid object (such as sharex, sharey, size,
@@ -1757,14 +1829,15 @@ class Process(object):
                 If 'ci', confidence intervals are drawn at each discrete value of the moderator on the x-axis
                 If 'none', no confidence interval is drawn.
         :param hue_format: string or None
-            By default, the color-code are labeled:
-                'Mod1 at val1' if there is two moderator for 'hue'.
-                'Mod2 at val1, Mod2 at val2' if there are two moderators for 'hue'.
-            Alternatively, a string that should be formatted can be passed. The string will receive as arguments:
+            By default, the color-codes are labeled:
+                'Mod1 at val1' if there is one moderator for 'hue'.
+                'Mod1 at val1, Mod2 at val2' if there are two moderators for 'hue'.
+            Alternatively, a format string can be passed. It receives the keyword arguments:
                 var1 (the name of the first moderator)
                 var2 (the name of the second moderator, if it exists)
                 val1 (the value of the first moderator)
-                val2 (the value of the second moderator)
+                val2 (the value of the second moderator, if it exists)
+            hue1 and hue2 are accepted as aliases of val1 and val2.
             A valid string would for instance look like this: '{var1} = {val1:.4f}, {var2} = {val2:.4f}'
         :param facet_kws: dict
             A dictionary of arguments that should be passed to the FacetGrid object (such as sharex, sharey, size,
@@ -1800,16 +1873,3 @@ class Process(object):
             plot_kws,
             err_kws,
         )
-
-    # DEPRECATED METHODS
-    def plot_indirect_effects(self, *args, **kwargs):
-        raise DeprecationWarning(
-            "The method 'plot_indirect_effects' has been deprecated. Please use the equivalent method named \
-            'plot_conditional_indirect_effects."
-        )
-
-    def plot_direct_effects(self, *args, **kwargs):
-        raise DeprecationWarning(
-            "The method 'plot_direct_effects' has been deprecated. Please use the equivalent method named \
-            'plot_conditional_direct_effects."
-        )