lifelines 0.27.7__py3-none-any.whl → 0.28.0__py3-none-any.whl

lifelines/plotting.py

@@ -46,26 +46,20 @@ def create_scipy_stats_model_from_lifelines_model(model):
         raise TypeError(
             "Cannot use qq-plot with this model. See notes here: https://lifelines.readthedocs.io/en/latest/Examples.html?highlight=qq_plot#selecting-a-parametric-model-using-qq-plots"
         )
-
     if dist == "weibull":
         scipy_dist = "weibull_min"
         sparams = (model.rho_, 0, model.lambda_)
-
     elif dist == "lognormal":
         scipy_dist = "lognorm"
         sparams = (model.sigma_, 0, np.exp(model.mu_))
-
     elif dist == "loglogistic":
         scipy_dist = "fisk"
         sparams = (model.beta_, 0, model.alpha_)
-
     elif dist == "exponential":
         scipy_dist = "expon"
         sparams = (0, model.lambda_)
-
     else:
         raise NotImplementedError("Distribution not implemented in SciPy")
-
     return getattr(stats, scipy_dist)(*sparams)
 
 
@@ -85,30 +79,44 @@ def cdf_plot(model, timeline=None, ax=None, **plot_kwargs):
 
     if ax is None:
         ax = plt.gca()
-
     if timeline is None:
         timeline = model.timeline
-
     COL_EMP = "empirical CDF"
 
     if CensoringType.is_left_censoring(model):
         empirical_kmf = KaplanMeierFitter().fit_left_censoring(
-            model.durations, model.event_observed, label=COL_EMP, timeline=timeline, weights=model.weights, entry=model.entry
+            model.durations,
+            model.event_observed,
+            label=COL_EMP,
+            timeline=timeline,
+            weights=model.weights,
+            entry=model.entry,
         )
     elif CensoringType.is_right_censoring(model):
         empirical_kmf = KaplanMeierFitter().fit_right_censoring(
-            model.durations, model.event_observed, label=COL_EMP, timeline=timeline, weights=model.weights, entry=model.entry
+            model.durations,
+            model.event_observed,
+            label=COL_EMP,
+            timeline=timeline,
+            weights=model.weights,
+            entry=model.entry,
         )
     elif CensoringType.is_interval_censoring(model):
         empirical_kmf = KaplanMeierFitter().fit_interval_censoring(
-            model.lower_bound, model.upper_bound, label=COL_EMP, timeline=timeline, weights=model.weights, entry=model.entry
+            model.lower_bound,
+            model.upper_bound,
+            label=COL_EMP,
+            timeline=timeline,
+            weights=model.weights,
+            entry=model.entry,
         )
-
     empirical_kmf.plot_cumulative_density(ax=ax, **plot_kwargs)
 
     dist = get_distribution_name_of_lifelines_model(model)
     dist_object = create_scipy_stats_model_from_lifelines_model(model)
-    ax.plot(timeline, dist_object.cdf(timeline), label="fitted %s" % dist, **plot_kwargs)
+    ax.plot(
+        timeline, dist_object.cdf(timeline), label="fitted %s" % dist, **plot_kwargs
+    )
     ax.legend()
     return ax
 
@@ -166,14 +174,12 @@ def rmst_plot(model, model2=None, t=np.inf, ax=None, text_position=None, **plot_
 
     if ax is None:
         ax = plt.gca()
-
     rmst = restricted_mean_survival_time(model, t=t)
     c = ax._get_lines.get_next_color()
     model.plot_survival_function(ax=ax, color=c, ci_show=False, **plot_kwargs)
 
     if text_position is None:
         text_position = (np.percentile(model.timeline, 10), 0.15)
-
     if model2 is not None:
         c2 = ax._get_lines.get_next_color()
         rmst2 = restricted_mean_survival_time(model2, t=t)
@@ -206,14 +212,26 @@ def rmst_plot(model, model2=None, t=np.inf, ax=None, text_position=None, **plot_
         )
 
         ax.text(
-            text_position[0], text_position[1], "RMST(%s) -\n   RMST(%s)=%.3f" % (model._label, model2._label, rmst - rmst2)
+            text_position[0],
+            text_position[1],
+            "RMST(%s) -\n   RMST(%s)=%.3f"
+            % (model._label, model2._label, rmst - rmst2),
         )  # dynamically pick this.
     else:
         rmst = restricted_mean_survival_time(model, t=t)
-        sf_exp_at_limit = model.predict(np.append(model.timeline, t)).sort_index().loc[:t]
-        ax.fill_between(sf_exp_at_limit.index, sf_exp_at_limit.values, step="post", color=c, alpha=0.25)
-        ax.text(text_position[0], text_position[1], "RMST=%.3f" % rmst)  # dynamically pick this.
-
+        sf_exp_at_limit = (
+            model.predict(np.append(model.timeline, t)).sort_index().loc[:t]
+        )
+        ax.fill_between(
+            sf_exp_at_limit.index,
+            sf_exp_at_limit.values,
+            step="post",
+            color=c,
+            alpha=0.25,
+        )
+        ax.text(
+            text_position[0], text_position[1], "RMST=%.3f" % rmst
+        )  # dynamically pick this.
     ax.axvline(t, ls="--", color="k")
     ax.set_ylim(0, 1)
     return ax
@@ -259,7 +277,6 @@ def qq_plot(model, ax=None, scatter_color="k", **plot_kwargs):
 
     if ax is None:
         ax = plt.gca()
-
     dist = get_distribution_name_of_lifelines_model(model)
     dist_object = create_scipy_stats_model_from_lifelines_model(model)
 
@@ -268,21 +285,34 @@ def qq_plot(model, ax=None, scatter_color="k", **plot_kwargs):
 
     if CensoringType.is_left_censoring(model):
         kmf = KaplanMeierFitter().fit_left_censoring(
-            model.durations, model.event_observed, label=COL_EMP, weights=model.weights, entry=model.entry
+            model.durations,
+            model.event_observed,
+            label=COL_EMP,
+            weights=model.weights,
+            entry=model.entry,
         )
         sf, cdf = kmf.survival_function_[COL_EMP], kmf.cumulative_density_[COL_EMP]
     elif CensoringType.is_right_censoring(model):
         kmf = KaplanMeierFitter().fit_right_censoring(
-            model.durations, model.event_observed, label=COL_EMP, weights=model.weights, entry=model.entry
+            model.durations,
+            model.event_observed,
+            label=COL_EMP,
+            weights=model.weights,
+            entry=model.entry,
         )
         sf, cdf = kmf.survival_function_[COL_EMP], kmf.cumulative_density_[COL_EMP]
-
     elif CensoringType.is_interval_censoring(model):
         kmf = KaplanMeierFitter().fit_interval_censoring(
-            model.lower_bound, model.upper_bound, label=COL_EMP, weights=model.weights, entry=model.entry
+            model.lower_bound,
+            model.upper_bound,
+            label=COL_EMP,
+            weights=model.weights,
+            entry=model.entry,
+        )
+        sf, cdf = (
+            kmf.survival_function_.mean(1),
+            kmf.cumulative_density_[COL_EMP + "_lower"],
         )
-        sf, cdf = kmf.survival_function_.mean(1), kmf.cumulative_density_[COL_EMP + "_lower"]
-
     q = np.unique(cdf.values)
 
     quantiles = qth_survival_times(1 - q, sf)
@@ -291,7 +321,9 @@ def qq_plot(model, ax=None, scatter_color="k", **plot_kwargs):
 
     max_, min_ = quantiles[COL_EMP].max(), quantiles[COL_EMP].min()
 
-    quantiles.plot.scatter(COL_THEO, COL_EMP, c="none", edgecolor=scatter_color, lw=0.5, ax=ax)
+    quantiles.plot.scatter(
+        COL_THEO, COL_EMP, c="none", edgecolor=scatter_color, lw=0.5, ax=ax
+    )
     ax.plot([min_, max_], [min_, max_], c="k", ls=":", lw=1.0)
     ax.set_ylim(min_, max_)
     ax.set_xlim(min_, max_)
@@ -446,30 +478,28 @@ def add_at_risk_counts(
 
     if ax is None:
         ax = plt.gca()
-
     fig = kwargs.pop("fig", None)
     if fig is None:
         fig = plt.gcf()
-
     if labels is None:
         labels = [f._label for f in fitters]
     elif labels is False:
         labels = [None] * len(fitters)
-
     if rows_to_show is None:
         rows_to_show = ["At risk", "Censored", "Events"]
     else:
         assert all(
             row in ["At risk", "Censored", "Events"] for row in rows_to_show
         ), 'must be one of ["At risk", "Censored", "Events"]'
-
     n_rows = len(rows_to_show)
 
     # Create another axes where we can put size ticks
     ax2 = plt.twiny(ax=ax)
     # Move the ticks below existing axes
     # Appropriate length scaled for 6 inches. Adjust for figure size.
-    ax_height = (ax.get_position().y1 - ax.get_position().y0) * fig.get_figheight()  # axis height
+    ax_height = (
+        ax.get_position().y1 - ax.get_position().y0
+    ) * fig.get_figheight()  # axis height
     ax2_ypos = ypos / ax_height
 
     move_spines(ax2, ["bottom"], [ax2_ypos])
@@ -502,34 +532,56 @@ def add_at_risk_counts(
             if at_risk_count_from_start_of_period:
                 event_table_slice = f.event_table.assign(at_risk=lambda x: x.at_risk)
             else:
-                event_table_slice = f.event_table.assign(at_risk=lambda x: x.at_risk - x.removed)
-
+                event_table_slice = f.event_table.assign(
+                    at_risk=lambda x: x.at_risk - x.removed
+                )
             if not event_table_slice.loc[:tick].empty:
                 event_table_slice = (
                     event_table_slice.loc[:tick, ["at_risk", "censored", "observed"]]
-                    .agg({"at_risk": lambda x: x.tail(1).values, "censored": "sum", "observed": "sum"})  # see #1385
-                    .rename({"at_risk": "At risk", "censored": "Censored", "observed": "Events"})
+                    .agg(
+                        {
+                            "at_risk": lambda x: x.tail(1).values,
+                            "censored": "sum",
+                            "observed": "sum",
+                        }
+                    )  # see #1385
+                    .rename(
+                        {
+                            "at_risk": "At risk",
+                            "censored": "Censored",
+                            "observed": "Events",
+                        }
+                    )
                     .fillna(0)
                 )
                 counts.extend([int(c) for c in event_table_slice.loc[rows_to_show]])
             else:
                 counts.extend([0 for _ in range(n_rows)])
-
         if n_rows > 1:
             if tick == ax2.get_xticks()[0]:
                 max_length = len(str(max(counts)))
                 for i, c in enumerate(counts):
                     if i % n_rows == 0:
                         if is_latex_enabled():
-                            lbl += ("\n" if i > 0 else "") + r"\textbf{%s}" % labels[int(i / n_rows)] + "\n"
+                            lbl += (
+                                ("\n" if i > 0 else "")
+                                + r"\textbf{%s}" % labels[int(i / n_rows)]
+                                + "\n"
+                            )
                         else:
-                            lbl += ("\n" if i > 0 else "") + r"%s" % labels[int(i / n_rows)] + "\n"
-
+                            lbl += (
+                                ("\n" if i > 0 else "")
+                                + r"%s" % labels[int(i / n_rows)]
+                                + "\n"
+                            )
                     l = rows_to_show[i % n_rows]
-                    s = "{}".format(l.rjust(10, " ")) + (" " * (max_length - len(str(c)) + 3)) + "{{:>{}d}}\n".format(max_length)
+                    s = (
+                        "{}".format(l.rjust(10, " "))
+                        + (" " * (max_length - len(str(c)) + 3))
+                        + "{{:>{}d}}\n".format(max_length)
+                    )
 
                     lbl += s.format(c)
-
             else:
                 # Create tick label
                 lbl += ""
@@ -538,7 +590,6 @@ def add_at_risk_counts(
                         lbl += "\n\n"
                     s = "\n{}"
                     lbl += s.format(c)
-
         else:
             # if only one row to show, show in "condensed" version
             if tick == ax2.get_xticks()[0]:
@@ -553,16 +604,13 @@ def add_at_risk_counts(
                         + "{{:>{}d}}\n".format(max_length)
                     )
                     lbl += s.format(c)
-
             else:
                 # Create tick label
                 lbl += ""
                 for i, c in enumerate(counts):
                     s = "\n{}"
                     lbl += s.format(c)
-
         ticklabels.append(lbl)
-
     # Align labels to the right so numbers can be compared easily
     ax2.set_xticklabels(ticklabels, ha="right", **kwargs)
 
@@ -620,14 +668,16 @@ def plot_interval_censored_lifetimes(
 
     if ax is None:
         ax = plt.gca()
-
     # If lower_bounds is pd.Series with non-default index, then use index values as y-axis labels.
-    label_plot_bars = type(lower_bound) is pd.Series and type(lower_bound.index) is not pd.RangeIndex
+    label_plot_bars = (
+        type(lower_bound) is pd.Series and type(lower_bound.index) is not pd.RangeIndex
+    )
 
     N = lower_bound.shape[0]
     if N > 25:
-        warnings.warn("For less visual clutter, you may want to subsample to less than 25 individuals.")
-
+        warnings.warn(
+            "For less visual clutter, you may want to subsample to less than 25 individuals."
+        )
     assert upper_bound.shape[0] == N
 
     if sort_by_lower_bound:
@@ -636,10 +686,8 @@ def plot_interval_censored_lifetimes(
         lower_bound = _iloc(lower_bound, ix)
         if entry is not None:
             entry = _iloc(entry, ix)
-
     if entry is None:
         entry = np.zeros(N)
-
     for i in range(N):
         if np.isposinf(_iloc(upper_bound, i)):
             c = event_right_censored_color
@@ -652,10 +700,8 @@ def plot_interval_censored_lifetimes(
             else:
                 ax.scatter(_iloc(lower_bound, i), i, color=c, marker=">", s=13)
                 ax.scatter(_iloc(upper_bound, i), i, color=c, marker="<", s=13)
-
         if left_truncated:
             ax.hlines(i, 0, _iloc(entry, i), color=c, lw=1.0, linestyle="--")
-
     if label_plot_bars:
         ax.set_yticks(range(0, N))
         ax.set_yticklabels(lower_bound.index)
@@ -663,7 +709,6 @@ def plot_interval_censored_lifetimes(
         from matplotlib.ticker import MaxNLocator
 
         ax.yaxis.set_major_locator(MaxNLocator(integer=True))
-
     ax.set_xlim(0)
     ax.set_ylim(-0.5, N)
     return ax
@@ -718,20 +763,20 @@ def plot_lifetimes(
 
     if ax is None:
         ax = plt.gca()
-
     # If durations is pd.Series with non-default index, then use index values as y-axis labels.
-    label_plot_bars = type(durations) is pd.Series and type(durations.index) is not pd.RangeIndex
+    label_plot_bars = (
+        type(durations) is pd.Series and type(durations.index) is not pd.RangeIndex
+    )
 
     N = durations.shape[0]
     if N > 25:
-        warnings.warn("For less visual clutter, you may want to subsample to less than 25 individuals.")
-
+        warnings.warn(
+            "For less visual clutter, you may want to subsample to less than 25 individuals."
+        )
     if event_observed is None:
         event_observed = np.ones(N, dtype=bool)
-
     if entry is None:
         entry = np.zeros(N)
-
     assert durations.shape[0] == N
     assert event_observed.shape[0] == N
 
@@ -741,7 +786,6 @@ def plot_lifetimes(
         durations = _iloc(durations, ix)
         event_observed = _iloc(event_observed, ix)
         entry = _iloc(entry, ix)
-
     for i in range(N):
         c = event_observed_color if _iloc(event_observed, i) else event_censored_color
         ax.hlines(i, _iloc(entry, i), _iloc(durations, i), color=c, lw=1.5)
@@ -749,7 +793,6 @@ def plot_lifetimes(
             ax.hlines(i, 0, _iloc(entry, i), color=c, lw=1.0, linestyle="--")
         m = "" if not _iloc(event_observed, i) else "o"
         ax.scatter(_iloc(durations, i), i, color=c, marker=m, s=13)
-
     if label_plot_bars:
         ax.set_yticks(range(0, N))
         ax.set_yticklabels(durations.index)
@@ -757,14 +800,17 @@ def plot_lifetimes(
         from matplotlib.ticker import MaxNLocator
 
         ax.yaxis.set_major_locator(MaxNLocator(integer=True))
-
     ax.set_xlim(0)
     ax.set_ylim(-0.5, N)
     return ax
 
 
 def set_kwargs_color(kwargs):
-    kwargs["color"] = coalesce(kwargs.pop("c", None), kwargs.pop("color", None), kwargs["ax"]._get_lines.get_next_color())
+    kwargs["color"] = coalesce(
+        kwargs.pop("c", None),
+        kwargs.pop("color", None),
+        kwargs["ax"]._get_lines.get_next_color(),
+    )
 
 
 def set_kwargs_drawstyle(kwargs, default="steps-post"):
@@ -778,15 +824,20 @@ def set_kwargs_label(kwargs, cls):
 def create_dataframe_slicer(iloc, loc, timeline):
     if (loc is not None) and (iloc is not None):
         raise ValueError("Cannot set both loc and iloc in call to .plot().")
-
     user_did_not_specify_certain_indexes = (iloc is None) and (loc is None)
-    user_submitted_slice = slice(timeline.min(), timeline.max()) if user_did_not_specify_certain_indexes else coalesce(loc, iloc)
+    user_submitted_slice = (
+        slice(timeline.min(), timeline.max())
+        if user_did_not_specify_certain_indexes
+        else coalesce(loc, iloc)
+    )
 
     get_method = "iloc" if iloc is not None else "loc"
     return lambda df: getattr(df, get_method)[user_submitted_slice]
 
 
-def loglogs_plot(cls, loc=None, iloc=None, show_censors=False, censor_styles=None, ax=None, **kwargs):
+def loglogs_plot(
+    cls, loc=None, iloc=None, show_censors=False, censor_styles=None, ax=None, **kwargs
+):
     """
     Specifies a plot of the log(-log(SV)) versus log(time) where SV is the estimated survival function.
     """
@@ -797,13 +848,10 @@ def loglogs_plot(cls, loc=None, iloc=None, show_censors=False, censor_styles=Non
 
     if (loc is not None) and (iloc is not None):
         raise ValueError("Cannot set both loc and iloc in call to .plot().")
-
     if censor_styles is None:
         censor_styles = {}
-
     if ax is None:
         ax = plt.gca()
-
     kwargs["ax"] = ax
     set_kwargs_color(kwargs)
     set_kwargs_drawstyle(kwargs)
@@ -816,10 +864,11 @@ def loglogs_plot(cls, loc=None, iloc=None, show_censors=False, censor_styles=Non
     if show_censors and cls.event_table["censored"].sum() > 0:
         cs = {"marker": "|", "ms": 12, "mew": 1}
         cs.update(censor_styles)
-        times = dataframe_slicer(cls.event_table.loc[(cls.event_table["censored"] > 0)]).index.values.astype(float)
+        times = dataframe_slicer(
+            cls.event_table.loc[(cls.event_table["censored"] > 0)]
+        ).index.values.astype(float)
         v = cls.predict(times)
         ax.plot(np.log(times), loglog(v), linestyle="None", color=colour, **cs)
-
     # plot estimate
     sliced_estimates = dataframe_slicer(loglog(cls.survival_function_))
     sliced_estimates["log(timeline)"] = np.log(sliced_estimates.index)
@@ -848,7 +897,6 @@ def _plot_estimate(
     ax=None,
     **kwargs
 ):
-
     """
     Plots a pretty figure of estimates
 
@@ -904,21 +952,28 @@ def _plot_estimate(
             DeprecationWarning,
         )
         ci_only_lines = ci_force_lines
-
-    plot_estimate_config = PlotEstimateConfig(cls, estimate, loc, iloc, show_censors, censor_styles, logx, ax, **kwargs)
+    if "point_in_time" in kwargs:  # marker for given point
+        point_in_time = kwargs["point_in_time"]
+        kwargs.pop("point_in_time")
+    plot_estimate_config = PlotEstimateConfig(
+        cls, estimate, loc, iloc, show_censors, censor_styles, logx, ax, **kwargs
+    )
 
     dataframe_slicer = create_dataframe_slicer(iloc, loc, cls.timeline)
 
     if show_censors and cls.event_table["censored"].sum() > 0:
         cs = {"marker": "+", "ms": 12, "mew": 1}
         cs.update(plot_estimate_config.censor_styles)
-        censored_times = dataframe_slicer(cls.event_table.loc[(cls.event_table["censored"] > 0)]).index.values.astype(float)
+        censored_times = dataframe_slicer(
+            cls.event_table.loc[(cls.event_table["censored"] > 0)]
+        ).index.values.astype(float)
         v = plot_estimate_config.predict_at_times(censored_times).values
-        plot_estimate_config.ax.plot(censored_times, v, linestyle="None", color=plot_estimate_config.colour, **cs)
-
-    dataframe_slicer(plot_estimate_config.estimate_).rename(columns=lambda _: plot_estimate_config.kwargs.pop("label")).plot(
-        logx=plot_estimate_config.logx, **plot_estimate_config.kwargs
-    )
+        plot_estimate_config.ax.plot(
+            censored_times, v, linestyle="None", color=plot_estimate_config.colour, **cs
+        )
+    dataframe_slicer(plot_estimate_config.estimate_).rename(
+        columns=lambda _: plot_estimate_config.kwargs.pop("label")
+    ).plot(logx=plot_estimate_config.logx, **plot_estimate_config.kwargs)
 
     # plot confidence intervals
     if ci_show:
@@ -940,15 +995,20 @@ def _plot_estimate(
                     )
                 )
         else:
-            x = dataframe_slicer(plot_estimate_config.confidence_interval_).index.values.astype(float)
-            lower = dataframe_slicer(plot_estimate_config.confidence_interval_.iloc[:, [0]]).values[:, 0]
-            upper = dataframe_slicer(plot_estimate_config.confidence_interval_.iloc[:, [1]]).values[:, 0]
+            x = dataframe_slicer(
+                plot_estimate_config.confidence_interval_
+            ).index.values.astype(float)
+            lower = dataframe_slicer(
+                plot_estimate_config.confidence_interval_.iloc[:, [0]]
+            ).values[:, 0]
+            upper = dataframe_slicer(
+                plot_estimate_config.confidence_interval_.iloc[:, [1]]
+            ).values[:, 0]
 
             if plot_estimate_config.kwargs["drawstyle"] == "default":
                 step = None
             elif plot_estimate_config.kwargs["drawstyle"].startswith("step"):
                 step = plot_estimate_config.kwargs["drawstyle"].replace("steps-", "")
-
             plot_estimate_config.ax.fill_between(
                 x,
                 lower,
@@ -958,23 +1018,35 @@ def _plot_estimate(
                 linewidth=0.0 if ci_no_lines else 1.0,
                 step=step,
             )
-
     if at_risk_counts:
         add_at_risk_counts(cls, ax=plot_estimate_config.ax)
         plt.tight_layout()
-
+    if "point_in_time" in locals():
+        plot_estimate_config.ax.scatter(
+            point_in_time, cls.survival_function_at_times(point_in_time)
+        )
     return plot_estimate_config.ax
 
 
 class PlotEstimateConfig:
-    def __init__(self, cls, estimate: Union[str, pd.DataFrame], loc, iloc, show_censors, censor_styles, logx, ax, **kwargs):
+    def __init__(
+        self,
+        cls,
+        estimate: Union[str, pd.DataFrame],
+        loc,
+        iloc,
+        show_censors,
+        censor_styles,
+        logx,
+        ax,
+        **kwargs
+    ):
         from matplotlib import pyplot as plt
 
         self.censor_styles = coalesce(censor_styles, {})
 
         if ax is None:
             ax = plt.gca()
-
         kwargs["ax"] = ax
         set_kwargs_color(kwargs)
         set_kwargs_drawstyle(kwargs)

lifelines/utils/__init__.py

@@ -311,7 +311,7 @@ def _expected_value_of_survival_squared_up_to_t(
 
     if isinstance(model_or_survival_function, pd.DataFrame):
         sf = model_or_survival_function.loc[:t]
-        sf = sf.append(pd.DataFrame([1], index=[0], columns=sf.columns)).sort_index()
+        sf = pd.concat((sf, pd.DataFrame([1], index=[0], columns=sf.columns))).sort_index()
         sf_tau = sf * sf.index.values[:, None]
         return 2 * trapz(y=sf_tau.values[:, 0], x=sf_tau.index)
     elif isinstance(model_or_survival_function, lifelines.fitters.UnivariateFitter):
@@ -561,7 +561,7 @@ def _group_event_table_by_intervals(event_table, intervals) -> pd.DataFrame:
     )
     # convert columns from multiindex
     event_table.columns = event_table.columns.droplevel(1)
-    return event_table.bfill()
+    return event_table.bfill().fillna(0)
 
 
 def survival_events_from_table(survival_table, observed_deaths_col="observed", censored_col="censored"):
@@ -744,9 +744,6 @@ def k_fold_cross_validation(
     results: list
       (k,1) list of scores for each fold. The scores can be anything.
 
-    See Also
-    ---------
-    lifelines.utils.sklearn_adapter.sklearn_adapter
 
     """
     # Make sure fitters is a list
@@ -884,6 +881,7 @@ def _additive_estimate(events, timeline, _additive_f, _additive_var, reverse):
         population = events["at_risk"] - entrances
 
         estimate_ = np.cumsum(_additive_f(population, deaths))
+
         var_ = np.cumsum(_additive_var(population, deaths))
 
     timeline = sorted(timeline)
@@ -1908,7 +1906,7 @@ class CovariateParameterMappings:
 
         Xs = {}
         for param_name, transform in self.mappings.items():
-            if isinstance(transform, formulaic.formula.Formula):
+            if isinstance(transform, formulaic.ModelSpec):
                 X = transform.get_model_matrix(df)
             elif isinstance(transform, list):
                 if self.force_intercept:
@@ -1954,6 +1952,6 @@ class CovariateParameterMappings:
         if self.force_intercept:
             formula += "+ 1"
 
-        design_info = formulaic.Formula(formula)
+        design_info = formulaic.ModelSpec.from_spec(formulaic.Formula(formula).get_model_matrix(df))
 
         return design_info

lifelines/version.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-__version__ = "0.27.7"
+__version__ = "0.28.0"

{lifelines-0.27.7.dist-info → lifelines-0.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lifelines
-Version: 0.27.7
+Version: 0.28.0
 Summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
 Home-page: https://github.com/CamDavidsonPilon/lifelines
 Author: Cameron Davidson-Pilon
@@ -9,22 +9,20 @@ License: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy (>=1.14.0)
-Requires-Dist: scipy (>=1.2.0)
-Requires-Dist: pandas (>=1.0.0)
-Requires-Dist: matplotlib (>=3.0)
-Requires-Dist: autograd (>=1.5)
-Requires-Dist: autograd-gamma (>=0.3)
-Requires-Dist: formulaic (>=0.2.2)
+Requires-Dist: numpy <2.0,>=1.14.0
+Requires-Dist: scipy >=1.2.0
+Requires-Dist: pandas >=1.2.0
+Requires-Dist: matplotlib >=3.0
+Requires-Dist: autograd >=1.5
+Requires-Dist: autograd-gamma >=0.3
+Requires-Dist: formulaic >=0.2.2
 
 ![](http://i.imgur.com/EOowdSD.png)