PyProcessMacro 1.0.14__tar.gz → 2.0.0__tar.gz

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProcessMacro
-Version: 1.0.14
+Version: 2.0.0
 Summary: A Python library for moderation, mediation and conditional process analysis. Based on Andrew F. Hayes' Process Macro.
 Author-email: Quentin André <quentin.andre@insead.edu>
 License-Expression: MIT
@@ -29,6 +29,7 @@ Requires-Dist: matplotlib>=3.7
 Requires-Dist: seaborn>=0.13
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: statsmodels>=0.14; extra == "test"
 Dynamic: license-file
 
 PyProcessMacro: A Python Implementation of Andrew F. Hayes' 'Process' Macro
@@ -68,7 +69,8 @@ In the current version, PyProcessMacro replicates the following features from th
   * All statistics reported by Process: 
     * Variable parameters for outcome models
     * (Conditional) direct and indirect effects
-    * Indices for Partial/Conditional/Moderated Moderated Mediation are always reported if the model supports them.
+    * The index of moderated mediation and, following PROCESS 3, the indices of partial, conditional and
+    moderated moderated mediation, whenever the indirect effect is linear in the moderator(s).
   * Automatic generation of spotlight values for continuous/discrete moderators.
   * Rich set of options to tweak the estimation and display of the different models: (almost) all the options from
   Process exist in PyProcessMacro. Check the doc for more details.
@@ -94,6 +96,38 @@ In the current version, the following features have not yet been ported to PyPro
   * Some options (`normal`, `varorder`, ...). PyProcessMacro will issue a warning to tell you if an option you are 
   trying to use is not implemented.
 
+# Upgrading to 2.0
+
+Version 2.0 corrects several statistics and tightens input handling. Reported numbers change in these ways:
+
+* Confidence intervals of OLS coefficients and of (conditional) direct effects use t critical values with the
+  residual degrees of freedom, as PROCESS does. They were based on z, so they widen slightly; the difference is
+  visible in small samples.
+* Adjusted R² of OLS outcome models is slightly higher: the previous value used one degree of freedom too many.
+* Cox-Snell and Nagelkerke pseudo R² of logistic outcome models are finite for large samples instead of NaN.
+* No index of moderated mediation is reported when a moderator sits on both the X-to-M and the M-to-Y paths
+  (models 58 to 73, 75 and 76), matching PROCESS: the indirect effect is not linear in such a moderator. The
+  `*_index_summary()` methods raise `NotImplementedError` for those models.
+* The sample size reported after listwise deletion is the number of rows kept.
+
+Behaviour that used to be silent now speaks up:
+
+* A misspelled key in `modval`, or a keyword argument that is neither a variable nor an option, raises an error
+  instead of being ignored.
+* Unsupported PROCESS options (`jn`, `effsize`, `mc`, `normal`, ...) raise a visible `UserWarning`.
+* A logistic regression that does not converge raises `pyprocessmacro.ConvergenceError`. Bootstrap resamples
+  that fail are counted, and the bootstrap stops with an error if more resamples fail than were requested.
+
+Removed and added:
+
+* `plot_direct_effects()` and `plot_indirect_effects()` are removed; use `plot_conditional_direct_effects()`
+  and `plot_conditional_indirect_effects()`.
+* `cov_type` selects the OLS covariance estimator (`"standard"`, `"HC0"`, `"HC1"`, `"HC2"` or `"HC3"`);
+  `hc3=True` remains as shorthand for `"HC3"`.
+* `seed=None` draws a different bootstrap sample on every run, and `seed=0` is accepted.
+* `Process.dv` names the outcome variable (`iv` is kept for compatibility).
+* Python 3.11 or newer is required (since 1.0.14).
+
 # Version History
 
 ## Master Versions
@@ -117,7 +151,7 @@ report and for the fix.
 
 ### 1.0.4
 **Bug fix for standard error estimate in all models**
-PyProcessMacro was, by default, using the HC3 estimator for the variance-covariance matrix instead of the HC0 estimator. 
+PyProcessMacro was, by default, using the HC3 estimator for the variance-covariance matrix instead of the standard (non-robust) estimator. 
 This has now been changed. To continue using the HC3 estimator, specify `hc3=True` when initializing the Process instance. 
 Thanks to Zoé Ziani for the bug report.
 
@@ -274,6 +308,17 @@ p = Process(data=df, model=13, x="Effort", y="Success", w="Motivation", z="Skill
 p.summary()
 ````
 
+### F. Choosing the covariance estimator
+
+By default, the standard errors of the OLS outcome models use the standard (homoskedastic) estimator. The
+`cov_type` argument selects a heteroskedasticity-consistent estimator instead: `"HC0"`, `"HC1"`, `"HC2"` or
+`"HC3"`. `hc3=True` is shorthand for `cov_type="HC3"`, which is what the original Process macro uses when
+`hc3=1` is specified. Logistic outcome models always use the inverse of the Hessian.
+
+````python
+p = Process(data=df, model=4, x="Effort", y="Success", m=["MediationSkills"], cov_type="HC3")
+````
+
 ## 2. Accessing the estimation results
 
 After the `Process` object is initialized, you are not limited to printing the summary. PyProcessMacro implements the

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/PyProcessMacro.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProcessMacro
-Version: 1.0.14
+Version: 2.0.0
 Summary: A Python library for moderation, mediation and conditional process analysis. Based on Andrew F. Hayes' Process Macro.
 Author-email: Quentin André <quentin.andre@insead.edu>
 License-Expression: MIT
@@ -29,6 +29,7 @@ Requires-Dist: matplotlib>=3.7
 Requires-Dist: seaborn>=0.13
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: statsmodels>=0.14; extra == "test"
 Dynamic: license-file
 
 PyProcessMacro: A Python Implementation of Andrew F. Hayes' 'Process' Macro
@@ -68,7 +69,8 @@ In the current version, PyProcessMacro replicates the following features from th
   * All statistics reported by Process: 
     * Variable parameters for outcome models
     * (Conditional) direct and indirect effects
-    * Indices for Partial/Conditional/Moderated Moderated Mediation are always reported if the model supports them.
+    * The index of moderated mediation and, following PROCESS 3, the indices of partial, conditional and
+    moderated moderated mediation, whenever the indirect effect is linear in the moderator(s).
   * Automatic generation of spotlight values for continuous/discrete moderators.
   * Rich set of options to tweak the estimation and display of the different models: (almost) all the options from
   Process exist in PyProcessMacro. Check the doc for more details.
@@ -94,6 +96,38 @@ In the current version, the following features have not yet been ported to PyPro
   * Some options (`normal`, `varorder`, ...). PyProcessMacro will issue a warning to tell you if an option you are 
   trying to use is not implemented.
 
+# Upgrading to 2.0
+
+Version 2.0 corrects several statistics and tightens input handling. Reported numbers change in these ways:
+
+* Confidence intervals of OLS coefficients and of (conditional) direct effects use t critical values with the
+  residual degrees of freedom, as PROCESS does. They were based on z, so they widen slightly; the difference is
+  visible in small samples.
+* Adjusted R² of OLS outcome models is slightly higher: the previous value used one degree of freedom too many.
+* Cox-Snell and Nagelkerke pseudo R² of logistic outcome models are finite for large samples instead of NaN.
+* No index of moderated mediation is reported when a moderator sits on both the X-to-M and the M-to-Y paths
+  (models 58 to 73, 75 and 76), matching PROCESS: the indirect effect is not linear in such a moderator. The
+  `*_index_summary()` methods raise `NotImplementedError` for those models.
+* The sample size reported after listwise deletion is the number of rows kept.
+
+Behaviour that used to be silent now speaks up:
+
+* A misspelled key in `modval`, or a keyword argument that is neither a variable nor an option, raises an error
+  instead of being ignored.
+* Unsupported PROCESS options (`jn`, `effsize`, `mc`, `normal`, ...) raise a visible `UserWarning`.
+* A logistic regression that does not converge raises `pyprocessmacro.ConvergenceError`. Bootstrap resamples
+  that fail are counted, and the bootstrap stops with an error if more resamples fail than were requested.
+
+Removed and added:
+
+* `plot_direct_effects()` and `plot_indirect_effects()` are removed; use `plot_conditional_direct_effects()`
+  and `plot_conditional_indirect_effects()`.
+* `cov_type` selects the OLS covariance estimator (`"standard"`, `"HC0"`, `"HC1"`, `"HC2"` or `"HC3"`);
+  `hc3=True` remains as shorthand for `"HC3"`.
+* `seed=None` draws a different bootstrap sample on every run, and `seed=0` is accepted.
+* `Process.dv` names the outcome variable (`iv` is kept for compatibility).
+* Python 3.11 or newer is required (since 1.0.14).
+
 # Version History
 
 ## Master Versions
@@ -117,7 +151,7 @@ report and for the fix.
 
 ### 1.0.4
 **Bug fix for standard error estimate in all models**
-PyProcessMacro was, by default, using the HC3 estimator for the variance-covariance matrix instead of the HC0 estimator. 
+PyProcessMacro was, by default, using the HC3 estimator for the variance-covariance matrix instead of the standard (non-robust) estimator. 
 This has now been changed. To continue using the HC3 estimator, specify `hc3=True` when initializing the Process instance. 
 Thanks to Zoé Ziani for the bug report.
 
@@ -274,6 +308,17 @@ p = Process(data=df, model=13, x="Effort", y="Success", w="Motivation", z="Skill
 p.summary()
 ````
 
+### F. Choosing the covariance estimator
+
+By default, the standard errors of the OLS outcome models use the standard (homoskedastic) estimator. The
+`cov_type` argument selects a heteroskedasticity-consistent estimator instead: `"HC0"`, `"HC1"`, `"HC2"` or
+`"HC3"`. `hc3=True` is shorthand for `cov_type="HC3"`, which is what the original Process macro uses when
+`hc3=1` is specified. Logistic outcome models always use the inverse of the Hessian.
+
+````python
+p = Process(data=df, model=4, x="Effort", y="Success", m=["MediationSkills"], cov_type="HC3")
+````
+
 ## 2. Accessing the estimation results
 
 After the `Process` object is initialized, you are not limited to printing the summary. PyProcessMacro implements the

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/PyProcessMacro.egg-info/SOURCES.txt

@@ -9,8 +9,5 @@ PyProcessMacro.egg-info/requires.txt
 PyProcessMacro.egg-info/top_level.txt
 pyprocessmacro/__init__.py
 pyprocessmacro/models.py
-pyprocessmacro/models.pyi
 pyprocessmacro/process.py
-pyprocessmacro/process.pyi
-pyprocessmacro/utils.py
-pyprocessmacro/utils.pyi
+pyprocessmacro/utils.py

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/PyProcessMacro.egg-info/requires.txt

@@ -6,3 +6,4 @@ seaborn>=0.13
 
 [test]
 pytest>=8
+statsmodels>=0.14

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/README.md

@@ -35,7 +35,8 @@ In the current version, PyProcessMacro replicates the following features from th
   * All statistics reported by Process: 
     * Variable parameters for outcome models
     * (Conditional) direct and indirect effects
-    * Indices for Partial/Conditional/Moderated Moderated Mediation are always reported if the model supports them.
+    * The index of moderated mediation and, following PROCESS 3, the indices of partial, conditional and
+    moderated moderated mediation, whenever the indirect effect is linear in the moderator(s).
   * Automatic generation of spotlight values for continuous/discrete moderators.
   * Rich set of options to tweak the estimation and display of the different models: (almost) all the options from
   Process exist in PyProcessMacro. Check the doc for more details.
@@ -61,6 +62,38 @@ In the current version, the following features have not yet been ported to PyPro
   * Some options (`normal`, `varorder`, ...). PyProcessMacro will issue a warning to tell you if an option you are 
   trying to use is not implemented.
 
+# Upgrading to 2.0
+
+Version 2.0 corrects several statistics and tightens input handling. Reported numbers change in these ways:
+
+* Confidence intervals of OLS coefficients and of (conditional) direct effects use t critical values with the
+  residual degrees of freedom, as PROCESS does. They were based on z, so they widen slightly; the difference is
+  visible in small samples.
+* Adjusted R² of OLS outcome models is slightly higher: the previous value used one degree of freedom too many.
+* Cox-Snell and Nagelkerke pseudo R² of logistic outcome models are finite for large samples instead of NaN.
+* No index of moderated mediation is reported when a moderator sits on both the X-to-M and the M-to-Y paths
+  (models 58 to 73, 75 and 76), matching PROCESS: the indirect effect is not linear in such a moderator. The
+  `*_index_summary()` methods raise `NotImplementedError` for those models.
+* The sample size reported after listwise deletion is the number of rows kept.
+
+Behaviour that used to be silent now speaks up:
+
+* A misspelled key in `modval`, or a keyword argument that is neither a variable nor an option, raises an error
+  instead of being ignored.
+* Unsupported PROCESS options (`jn`, `effsize`, `mc`, `normal`, ...) raise a visible `UserWarning`.
+* A logistic regression that does not converge raises `pyprocessmacro.ConvergenceError`. Bootstrap resamples
+  that fail are counted, and the bootstrap stops with an error if more resamples fail than were requested.
+
+Removed and added:
+
+* `plot_direct_effects()` and `plot_indirect_effects()` are removed; use `plot_conditional_direct_effects()`
+  and `plot_conditional_indirect_effects()`.
+* `cov_type` selects the OLS covariance estimator (`"standard"`, `"HC0"`, `"HC1"`, `"HC2"` or `"HC3"`);
+  `hc3=True` remains as shorthand for `"HC3"`.
+* `seed=None` draws a different bootstrap sample on every run, and `seed=0` is accepted.
+* `Process.dv` names the outcome variable (`iv` is kept for compatibility).
+* Python 3.11 or newer is required (since 1.0.14).
+
 # Version History
 
 ## Master Versions
@@ -84,7 +117,7 @@ report and for the fix.
 
 ### 1.0.4
 **Bug fix for standard error estimate in all models**
-PyProcessMacro was, by default, using the HC3 estimator for the variance-covariance matrix instead of the HC0 estimator. 
+PyProcessMacro was, by default, using the HC3 estimator for the variance-covariance matrix instead of the standard (non-robust) estimator. 
 This has now been changed. To continue using the HC3 estimator, specify `hc3=True` when initializing the Process instance. 
 Thanks to Zoé Ziani for the bug report.
 
@@ -241,6 +274,17 @@ p = Process(data=df, model=13, x="Effort", y="Success", w="Motivation", z="Skill
 p.summary()
 ````
 
+### F. Choosing the covariance estimator
+
+By default, the standard errors of the OLS outcome models use the standard (homoskedastic) estimator. The
+`cov_type` argument selects a heteroskedasticity-consistent estimator instead: `"HC0"`, `"HC1"`, `"HC2"` or
+`"HC3"`. `hc3=True` is shorthand for `cov_type="HC3"`, which is what the original Process macro uses when
+`hc3=1` is specified. Logistic outcome models always use the inverse of the Hessian.
+
+````python
+p = Process(data=df, model=4, x="Effort", y="Success", m=["MediationSkills"], cov_type="HC3")
+````
+
 ## 2. Accessing the estimation results
 
 After the `Process` object is initialized, you are not limited to printing the summary. PyProcessMacro implements the

pyprocessmacro-2.0.0/pyprocessmacro/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+Core module for the PyProcess Macro.
+"""
+from .process import Process
+from .utils import ConvergenceError
+
+__all__ = ["Process", "ConvergenceError"]
+
+__version__ = "2.0.0"

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/pyprocessmacro/models.py

@@ -16,8 +16,10 @@ from .utils import (
     eval_expression,
     bias_corrected_ci,
     z_score,
+    t_score,
     percentile_ci,
     find_significance_region,
+    ConvergenceError,
 )
 
 
@@ -103,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
 
 
@@ -286,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":
@@ -294,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":
@@ -316,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,
@@ -418,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,
@@ -650,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:
@@ -666,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
 
@@ -1585,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-1.0.14 → pyprocessmacro-2.0.0}/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,6 +736,12 @@ 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__}
 
         # _gen_valid_varlist normalizes every variable argument to a list, so the mediator and
@@ -763,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.
@@ -779,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.
@@ -793,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"
@@ -804,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]:
@@ -996,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.)
@@ -1224,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.
@@ -1240,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]
@@ -1269,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()
 
@@ -1350,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):
         """
@@ -1816,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."
-        )

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/pyprocessmacro/utils.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 from numpy import dot
 from numpy.linalg import inv, LinAlgError
-from scipy.stats import norm
+from scipy.stats import norm, t
 from seaborn import FacetGrid
 
 
@@ -16,6 +16,15 @@ def z_score(conf):
     return norm.ppf((100 - (100 - conf) / 2) / 100)
 
 
+def t_score(conf, df):
+    """
+    :param conf: Desired level of confidence
+    :param df: Degrees of freedom of the t distribution
+    :return: The critical t value corresponding to the level of confidence desired.
+    """
+    return t.ppf((100 - (100 - conf) / 2) / 100, df)
+
+
 def bias_corrected_ci(estimate, samples, conf=95):
     """
     Return the bias-corrected bootstrap confidence interval for an estimate
@@ -24,8 +33,10 @@ def bias_corrected_ci(estimate, samples, conf=95):
     :param conf: Level of the desired confidence interval
     :return: Bias-corrected bootstrapped LLCI and ULCI for the estimate.
     """
-    # noinspection PyUnresolvedReferences
     ptilde = ((samples < estimate) * 1).mean()
+    # Every draw on one side of the estimate would make the bias correction infinite; clip to the
+    # resolution of the bootstrap distribution instead (#49).
+    ptilde = min(max(ptilde, 1 / len(samples)), 1 - 1 / len(samples))
     Z = norm.ppf(ptilde)
     Zci = z_score(conf)
     Zlow, Zhigh = -Zci + 2 * Z, Zci + 2 * Z
@@ -47,15 +58,16 @@ def percentile_ci(samples, conf):
     return np.percentile(samples, [lower, upper])
 
 
+class ConvergenceError(RuntimeError):
+    """Raised when the Newton-Raphson estimation of a logistic model does not converge."""
+
+
 def fast_OLS(endog, exog):
     """
     A simple function for (X'X)^(-1)X'Y
     :return: The Kx1 array of estimated coefficients.
     """
-    try:
-        return dot(dot(inv(dot(exog.T, exog)), exog.T), endog).squeeze()
-    except LinAlgError:
-        raise LinAlgError
+    return dot(dot(inv(dot(exog.T, exog)), exog.T), endog).squeeze()
 
 
 def logit_cdf(X):
@@ -109,17 +121,22 @@ def fast_optimize(endog, exog, n_obs=0, n_vars=0, max_iter=10000, tolerance=1e-1
     """
     iterations = 0
     oldparams = np.inf
-    newparams = np.repeat(0, n_vars)
+    newparams = np.zeros(n_vars)
     while iterations < max_iter and np.any(np.abs(newparams - oldparams) > tolerance):
         oldparams = newparams
         try:
             H = logit_hessian(exog, oldparams, n_obs)
-            newparams = oldparams - dot(
-                inv(H), logit_score(endog, exog, oldparams, n_obs)
-            )
+            newparams = oldparams - dot(inv(H), logit_score(endog, exog, oldparams, n_obs))
         except LinAlgError:
-            raise 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
 
 
@@ -130,8 +147,7 @@ def bootstrap_sampler(n_obs, seed=None):
     :param seed: The seed to use for the random number generator
     :return: Bootstrapped indices of size n_obs
     """
-    seeder = np.random.RandomState(seed)
-    seeder.seed(seed)
+    seeder = np.random.RandomState(seed)  # None draws fresh entropy (#45)
     while True:
         yield seeder.randint(n_obs, size=n_obs)
 

{pyprocessmacro-1.0.14 → pyprocessmacro-2.0.0}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-test = ["pytest>=8"]
+test = ["pytest>=8", "statsmodels>=0.14"]
 
 [project.urls]
 Homepage = "https://github.com/QuentinAndre/pyprocessmacro"

pyprocessmacro-1.0.14/pyprocessmacro/__init__.py

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Core module for the PyProcess Macro.
-"""
-from .process import Process
-
-__all__ = ["Process"]
-
-__version__ = "1.0.14"

pyprocessmacro-1.0.14/pyprocessmacro/models.pyi

@@ -1,228 +0,0 @@
-from numpy import ndarray
-from typing import Any, Dict, List, Optional, Tuple, Union, Iterable, Callable
-
-from pandas import DataFrame
-
-class BaseLogit:
-    _endog: ndarray
-    _exog: ndarray
-    _n_obs: int
-    _n_vars: int
-    _options: Dict[str, Any]
-    def __init__(
-        self, endog: ndarray, exog: ndarray, options: Dict[str, Any]
-    ) -> None: ...
-    @staticmethod
-    def _cdf(X: ndarray) -> ndarray: ...
-    def _hessian(self, params: ndarray) -> ndarray: ...
-    def _loglike(self, params: ndarray) -> float: ...
-    def _loglikeobs(self, params: ndarray) -> ndarray: ...
-    def _optimize(self) -> ndarray: ...
-    def _score(self, params: ndarray) -> ndarray: ...
-
-class NullLogitModel(BaseLogit):
-    def __init__(self, endog: ndarray, options: Optional[Dict[str, Any]]) -> None: ...
-
-class BaseOutcomeModel:
-    _data: ndarray
-    _derivative: ndarray
-    _endog: ndarray
-    _endogvar: str
-    _exog: ndarray
-    _exogvars: List[str]
-    _n_obs: int
-    _n_vars: int
-    _options: Dict[Union[None, str], Any]
-    _symb_to_ind: Dict[str, int]
-    _symb_to_var: Dict[str, str]
-    _varnames: List[str]
-    estimation_results: Dict[str, Union[ndarray, float, int, List[str]]]
-    def __init__(
-        self,
-        data: ndarray,
-        endogvar: str,
-        exogvars: List[str],
-        symb_to_ind: Dict[str, int],
-        symb_to_var: Dict[str, str],
-        options: Optional[Dict[str, Any]] = ...,
-    ) -> None: ...
-    def _gen_derivative(self, wrt: str) -> ndarray: ...
-    def coeff_summary(self) -> DataFrame: ...
-    def _estimate(self) -> Dict[str, Union[ndarray, float, int, List[str]]]: ...
-
-class ParallelMediationModel:
-    _analysis_list: List[str]
-    _base_derivs: Dict[str, Union[ndarray, List[ndarray]]]
-    _boot_betas_m: ndarray
-    _boot_betas_y: ndarray
-    _compute_betas_m: Callable[[ndarray, ndarray], ndarray]
-    _compute_betas_y: Callable[[ndarray, ndarray], ndarray]
-    _data: ndarray
-    _endog_vars_m: List[str]
-    _exog_inds_m: List[int]
-    _exog_inds_y: List[int]
-    _exog_terms_m: List[str]
-    _exog_terms_y: List[str]
-    _has_moderation: bool
-    _ind_y: int
-    _inds_m: List[int]
-    _moderators_symb: List[str]
-    _moderators_values: List[List[float]]
-    _n_fail_samples: int
-    _n_meds: int
-    _n_obs: int
-    _options: Dict[Union[None, str], Any]
-    _symb_to_ind: Dict[str, int]
-    _symb_to_var: Dict[str, str]
-    _true_betas_m: ndarray
-    _true_betas_y: ndarray
-    _vars_m: List[str]
-    _vars_y: List[str]
-    estimation_results: Dict[str, ndarray]
-    def __init__(
-        self,
-        data: ndarray,
-        exog_terms_y: List[str],
-        exog_terms_m: List[str],
-        mod_symb: Iterable[str],
-        spot_values: Dict[str, List[float]],
-        n_meds: int,
-        analysis_list: List[str],
-        symb_to_ind: Dict[str, int],
-        symb_to_var: Dict[str, str],
-        options: Optional[Dict[str, Any]] = ...,
-    ) -> None: ...
-    def _simple_ind_effects(self) -> Dict[str, ndarray]: ...
-    def _simple_ind_effects_wrapper(self) -> DataFrame: ...
-    def _MM_index(self) -> Dict[str, ndarray]: ...
-    def _MMM_index(self) -> Dict[str, ndarray]: ...
-    def _CMM_index(self) -> Dict[str, ndarray]: ...
-    def _PMM_index(self) -> Dict[str, ndarray]: ...
-    def _MM_index_wrapper(self) -> DataFrame: ...
-    def _MMM_index_wrapper(self) -> DataFrame: ...
-    def _CMM_index_wrapper(self) -> DataFrame: ...
-    def _PMM_index_wrapper(self) -> DataFrame: ...
-    def MM_index_summary(self) -> DataFrame: ...
-    def MMM_index_summary(self) -> DataFrame: ...
-    def CMM_index_summary(self) -> DataFrame: ...
-    def PMM_index_summary(self) -> DataFrame: ...
-    def _cond_ind_effects(self) -> DataFrame: ...
-    def _cond_ind_effects_wrapper(self) -> DataFrame: ...
-    def _estimate_bootstrapped_params(self) -> Tuple[ndarray, ndarray, int]: ...
-    def _estimate_true_params(self) -> Tuple[ndarray, List[ndarray]]: ...
-    def _floodlight_analysis(
-        self,
-        med_index: int,
-        mod_symb: str,
-        modval_range: List[float],
-        other_modval_symb: Dict[str, int],
-        atol: float,
-        rtol: float,
-    ) -> Union[List[List[float]]]: ...
-    def _gen_derivatives(self) -> Dict[str, Union[ndarray, List[ndarray]]]: ...
-    def _get_conditional_indirect_effects(
-        self,
-        med_index: int,
-        mod_symb: Iterable[str],
-        mod_values: Union[ndarray, List[Iterable[float]]],
-    ) -> Tuple[ndarray, ndarray, ndarray, ndarray, ndarray]: ...
-    def _indirect_effect_at(
-        self, med_index: int, mod_dict: Dict[str, float]
-    ) -> Tuple[float, ndarray, float, float, float]: ...
-    def coeff_summary(self) -> DataFrame: ...
-    def summary(self) -> str: ...
-
-class LogitOutcomeModel(BaseOutcomeModel, BaseLogit):
-    def __init__(
-        self,
-        data: ndarray,
-        endogvar: str,
-        exogvars: List[str],
-        symb_to_ind: Dict[str, int],
-        symb_to_var: Dict[str, str],
-        options: Optional[Dict[str, Any]] = ...,
-    ) -> None: ...
-    def _estimate(self) -> Dict[str, Union[ndarray, float, int, List[str]]]: ...
-
-class OLSOutcomeModel(BaseOutcomeModel):
-    def __init__(
-        self,
-        data: ndarray,
-        endogvar: str,
-        exogvars: List[str],
-        symb_to_ind: Dict[str, int],
-        symb_to_var: Dict[str, str],
-        options: Optional[Dict[str, Any]] = ...,
-    ) -> None: ...
-    def _estimate(self) -> Dict[str, Union[ndarray, float, int, List[str]]]: ...
-
-class DirectEffectModel:
-    _derivative: ndarray
-    _estimation_results: Dict[str, ndarray]
-    _has_mediation: bool
-    _has_moderation: bool
-    _is_logit: bool
-    _model: Union[LogitOutcomeModel, OLSOutcomeModel]
-    _moderators_symb: List[str]
-    _moderators_values: List[List[float]]
-    _options: Dict[Union[None, str], Any]
-    _symb_to_var: Dict[str, str]
-    def __init__(
-        self,
-        model: OLSOutcomeModel,
-        mod_symb: Iterable[str],
-        spot_values: Dict[str, List[float]],
-        has_mediation: bool,
-        symb_to_var: Dict[str, str],
-        options: Optional[Dict[str, Any]] = ...,
-    ) -> None: ...
-    def _direct_effect_at(
-        self, mod_dict: Dict[str, float]
-    ) -> Tuple[float, float, float, float]: ...
-    def _estimate(self) -> Dict[str, ndarray]: ...
-    def _floodlight_analysis(
-        self,
-        mod_symb: str,
-        modval_range: List[float],
-        other_modval_symb: Dict[str, int],
-        atol: float,
-        rtol: float,
-    ) -> List[List[float]]: ...
-    def _get_conditional_direct_effects(
-        self, mod_symb: List[str], mod_values: Union[ndarray, List[Iterable[float]]]
-    ) -> Tuple[ndarray, ndarray, ndarray, ndarray]: ...
-
-class BaseFloodlightAnalysis:
-    sig_regions: List[List[float]]
-    def __init__(
-        self,
-        med_name: Optional[str],
-        mod_name: str,
-        sig_regions: List[List[float]],
-        modval_range: List[float],
-        other_modval_name: Dict[str, float],
-        precision: int,
-    ) -> None: ...
-    def get_significance_regions(self) -> Dict[str, List[float]]: ...
-
-class DirectFloodlightAnalysis(BaseFloodlightAnalysis):
-    def __init__(
-        self,
-        mod_name: str,
-        sig_regions: List[List[float]],
-        modval_range: List[float],
-        other_modval_name: Dict[str, int],
-        precision: int,
-    ) -> None: ...
-
-
-class IndirectFloodlightAnalysis(BaseFloodlightAnalysis):
-    def __init__(
-        self,
-        med_name: str,
-        mod_name: str,
-        sig_regions: List[List[float]],
-        modval_range: List[float],
-        other_modval_name: Dict[str, int],
-        precision: int,
-    ) -> None: ...

pyprocessmacro-1.0.14/pyprocessmacro/process.pyi

@@ -1,163 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Union, Iterable, Dict, List, Any, Set, Tuple, Optional, NoReturn
-
-from numpy import ndarray
-from pandas.core.frame import DataFrame
-from seaborn.axisgrid import FacetGrid
-
-from .models import (
-    OLSOutcomeModel,
-    DirectEffectModel,
-    ParallelMediationModel,
-    LogitOutcomeModel,
-    DirectFloodlightAnalysis,
-    IndirectFloodlightAnalysis,
-)
-
-class Process(object):
-    __var_kws__: Set[str]
-
-    __options_kws__: Set[str]
-
-    __models_vars__: Dict[str, Set[str]]
-
-    __models_eqs__: Dict[str, Dict[List[str]]]
-
-    model_num: int
-    controls: Iterable
-    options = Dict[str, Any]
-    varlist = List[str]
-    mediators = List[str]
-
-    iv: str
-    n_obs: int
-    n_obs_null: int
-    n_meds: int
-    has_mediation: bool
-    outcome_models: Dict[str, Union[OLSOutcomeModel, LogitOutcomeModel]]
-    direct_model: DirectEffectModel
-    indirect_model: Union[None, ParallelMediationModel]
-    centered_vars: Union[List, None]
-
-    _data: DataFrame
-    _moderators: Dict[str, Set[str]]
-    _spotlight_values: Dict[str, List[float]]
-    _var_to_symb: Dict[str, str]
-    _symb_to_var: Dict[str, str]
-    _symb_to_ind: Dict[str, int]
-
-    _equations: List[Tuple[Union[str, List[str]]]]
-    def __init__(
-        self,
-        data: DataFrame,
-        model: int,
-        modval: Optional[Dict[str, List[float]]],
-        cluster: Optional[str],
-        boot: Optional[int],
-        seed: Optional[int],
-        mc: Optional[bool],
-        conf: Optional[int],
-        effsize: Optional[bool],
-        jn: Optional[bool],
-        hc3: Optional[bool],
-        controls: Optional[Iterable[str]],
-        controls_in: str,
-        total: Optional[bool],
-        contrast: Optional[bool],
-        center: Optional[bool],
-        quantile: Optional[bool],
-        detail: Optional[bool],
-        percent: Optional[bool],
-        logit: Optional[bool],
-        iterate: Optional[int],
-        convergence: Optional[float],
-        precision: Optional[int],
-        suppr_init: Optional[bool],
-        **kwargs
-    ) -> None: ...
-    # PRIVATE METHODS
-    def _gen_valid_options(self, argument: Dict[str, Any]) -> Dict[str, Any]: ...
-    def _gen_valid_varlist(
-        self, var_kwargs: Dict[str, Union[str, List]]
-    ) -> List[str]: ...
-    def _gen_analysis_list(self) -> List[str]: ...
-    def _gen_spotlight_values(
-        self, modval: Optional[Dict[str, List[float]]]
-    ) -> Dict[str, Iterable[float]]: ...
-    def _gen_var_mapping(
-        self, var_kwargs: Dict[str, str]
-    ) -> Tuple[Dict[str, str], Dict[str, str]]: ...
-    def _prepare_data(self) -> Tuple[DataFrame, int, int, List[str]]: ...
-    def _gen_equations(
-        self, all_to_y: List[str], x_to_m: List[str], controls_in: str
-    ) -> List[Tuple[str, List[str]]]: ...
-    def _gen_outcome_models(
-        self
-    ) -> Dict[str, Union[OLSOutcomeModel, LogitOutcomeModel]]: ...
-    def _gen_direct_effect_model(self) -> DirectEffectModel: ...
-    def _gen_indirect_effect_model(self) -> ParallelMediationModel: ...
-    def _print_init(self) -> None: ...
-    def _parse_moderator_values(
-        self,
-        x: str,
-        hue: Optional[Union[str, List[str]]],
-        row: Optional[str],
-        col: Optional[str],
-        modval: Optional[Dict[str, Union[ndarray, List[float]]]],
-        path: str,
-    ) -> Dict[str, Union[ndarray, List[float]]]: ...
-    # API METHODS
-    def summary(self) -> None: ...
-    def get_bootstrap_estimates(self) -> DataFrame: ...
-    def floodlight_indirect_effect(
-        self,
-        med_name: str,
-        mod_name: str,
-        other_modval: Optional[Dict[str, float]],
-        atol: Optional[float],
-        rtol: Optional[float],
-    ) -> IndirectFloodlightAnalysis: ...
-    def floodlight_direct_effect(
-        self,
-        mod_name: str,
-        other_modval: Optional[Dict[str, float]],
-        atol: Optional[float],
-        rtol: Optional[float],
-    ) -> DirectFloodlightAnalysis: ...
-    def spotlight_indirect_effect(
-        self, med_name: str, spotval: Optional[Dict[str, Union[ndarray, List[float]]]]
-    ) -> DataFrame: ...
-    def spotlight_direct_effect(
-        self, spotval: Optional[Dict[str, Union[ndarray, List[float]]]]
-    ) -> DataFrame: ...
-    def plot_conditional_direct_effects(
-        self,
-        x: str,
-        hue: Optional[Union[str, List[str]]],
-        row: Optional[str],
-        col: Optional[str],
-        modval: Optional[Dict[str, Union[ndarray, List[float]]]],
-        errstyle: Optional[str],
-        hue_format: Optional[str],
-        facet_kws: Optional[Dict[str, Any]],
-        plot_kws: Optional[Dict[str, Any]],
-        err_kws: Optional[Dict[str, Any]],
-    ) -> FacetGrid: ...
-    def plot_conditional_indirect_effects(
-        self,
-        med_name: str,
-        x: str,
-        hue: Optional[Union[str, List[str]]],
-        row: Optional[str],
-        col: Optional[str],
-        modval: Optional[Dict[str, Union[ndarray, List[float]]]],
-        errstyle: Optional[str],
-        hue_format: Optional[str],
-        facet_kws: Optional[Dict[str, Any]],
-        plot_kws: Optional[Dict[str, Any]],
-        err_kws: Optional[Dict[str, Any]],
-    ) -> FacetGrid: ...
-
-    # DEPRECATED METHODS
-    def plot_indirect_effects(self, *args, **kwargs) -> NoReturn: ...
-    def plot_direct_effects(self, *args, **kwargs) -> NoReturn: ...

pyprocessmacro-1.0.14/pyprocessmacro/utils.pyi

@@ -1,92 +0,0 @@
-from typing import Callable, Union, Iterable, Dict, List, Optional, Any, Set
-
-import numpy as np
-from pandas import DataFrame
-from seaborn import FacetGrid
-
-def z_score(conf: float) -> float: ...
-def bias_corrected_ci(
-    estimate: np.array, samples: np.array, conf: Union[float, int]
-) -> (float, float): ...
-def percentile_ci(samples: np.array, conf: Union[float, int]) -> np.array: ...
-def fast_OLS(endog: np.array, exog: np.array) -> np.array: ...
-def logit_cdf(X: np.array) -> np.array: ...
-def logit_score(
-    endog: np.array, exog: np.array, params: np.array, n_obs: int
-) -> np.array: ...
-def logit_hessian(exog: np.array, params: np.array, n_obs: int) -> np.array: ...
-def fast_optimize(
-    endog: np.array,
-    exog: np.array,
-    n_obs: int,
-    n_vars: int,
-    max_iter: int,
-    tolerance: float = 1e-10,
-) -> np.array: ...
-def bootstrap_sampler(n_obs: int, seed: int) -> np.array: ...
-def eigvals(exog: np.array) -> np.array: ...
-def eval_expression(expr: np.array, values: Dict) -> np.array: ...
-def gen_moderators(
-    raw_equations: Dict[str, List[str]], raw_varlist: List[str]
-) -> Dict[str, Set[str]]: ...
-def plot_errorbars(
-    x: np.array,
-    y: np.array,
-    yerrlow: np.array,
-    yerrhigh: np.array,
-    plot_kws: Optional[Dict[str, Any]],
-    err_kws: Optional[Dict[str, Any]],
-    *args,
-    **kwargs
-) -> None: ...
-def plot_errorbands(
-    x: np.array,
-    y: np.array,
-    llci: np.array,
-    ulci: np.array,
-    plot_kws: Optional[Dict[str, Any]],
-    err_kws: Optional[Dict[str, Any]],
-    *args,
-    **kwargs
-) -> None: ...
-def plot_conditional_effects(
-    df_effects: DataFrame,
-    x: str,
-    hue: Optional[Union[str, List[str]]],
-    row: Optional[str],
-    col: Optional[str],
-    errstyle: Optional[str],
-    hue_format: Optional[str],
-    facet_kws: Optional[Dict[str, Any]],
-    plot_kws: Optional[Dict[str, Any]],
-    err_kws: Optional[Dict[str, Any]],
-) -> FacetGrid: ...
-def find_significance_region(
-    spotlight_func: Callable[[Dict], Iterable],
-    mod_symb: str,
-    modval_min: float,
-    modval_max: float,
-    modval_other_symb: Dict,
-    atol: float,
-    rtol: float,
-) -> List[List[float]]: ...
-def search_mid_range(
-    spotlight_func: Callable[[Dict], Iterable],
-    min_val: float,
-    max_val: float,
-    mod_symb: str,
-    mod_dict: Dict,
-    atol: float,
-    rtol: float,
-) -> List[List[float]]: ...
-def search_critical_values(
-    spotlight_func: Callable[[Dict], Iterable],
-    min_val: float,
-    max_val: float,
-    mod_symb: str,
-    mod_dict: Dict,
-    slope: str,
-    region: str,
-    atol: float,
-    rtol: float,
-) -> float: ...