pySEQTarget 0.10.0__py3-none-any.whl

pySEQTarget/initialization/_censoring.py

@@ -0,0 +1,53 @@
+def _cense_numerator(self) -> str:
+    trial = (
+        "+".join(["trial", f"trial{self.indicator_squared}"])
+        if self.trial_include
+        else None
+    )
+    followup = (
+        "+".join(["followup", f"followup{self.indicator_squared}"])
+        if self.followup_include
+        else None
+    )
+    time = "+".join([self.time_col, f"{self.time_col}{self.indicator_squared}"])
+    tv_bas = (
+        "+".join([f"{v}{self.indicator_baseline}" for v in self.time_varying_cols])
+        if self.time_varying_cols
+        else None
+    )
+    fixed = "+".join(self.fixed_cols) if self.fixed_cols else None
+
+    if self.weight_preexpansion:
+        out = "+".join(filter(None, ["tx_lag", time, fixed]))
+    else:
+        out = "+".join(filter(None, ["tx_lag", trial, followup, fixed, tv_bas]))
+
+    return out
+
+
+def _cense_denominator(self) -> str:
+    trial = (
+        "+".join(["trial", f"trial{self.indicator_squared}"])
+        if self.trial_include
+        else None
+    )
+    followup = (
+        "+".join(["followup", f"followup{self.indicator_squared}"])
+        if self.followup_include
+        else None
+    )
+    time = "+".join([self.time_col, f"{self.time_col}{self.indicator_squared}"])
+    tv = "+".join(self.time_varying_cols) if self.time_varying_cols else None
+    tv_bas = (
+        "+".join([f"{v}{self.indicator_baseline}" for v in self.time_varying_cols])
+        if self.time_varying_cols
+        else None
+    )
+    fixed = "+".join(self.fixed_cols) if self.fixed_cols else None
+
+    if self.weight_preexpansion:
+        out = "+".join(filter(None, ["tx_lag", time, fixed, tv]))
+    else:
+        out = "+".join(filter(None, ["tx_lag", trial, followup, fixed, tv, tv_bas]))
+
+    return out

pySEQTarget/initialization/_denominator.py

@@ -0,0 +1,39 @@
+def _denominator(self) -> str:
+    if self.method == "ITT":
+        return
+    trial = (
+        "+".join(["trial", f"trial{self.indicator_squared}"])
+        if self.trial_include
+        else None
+    )
+    followup = (
+        "+".join(["followup", f"followup{self.indicator_squared}"])
+        if self.followup_include
+        else None
+    )
+    time = "+".join([self.time_col, f"{self.time_col}{self.indicator_squared}"])
+
+    tv = "+".join(self.time_varying_cols) if self.time_varying_cols else None
+    tv_bas = (
+        "+".join([f"{v}{self.indicator_baseline}" for v in self.time_varying_cols])
+        if self.time_varying_cols
+        else None
+    )
+    fixed = "+".join(self.fixed_cols) if self.fixed_cols else None
+
+    if self.weight_preexpansion:
+        if self.method == "dose-response":
+            out = "+".join(filter(None, [fixed, tv, time]))
+        elif self.method == "censoring" and not self.excused:
+            out = "+".join(filter(None, [fixed, tv, time]))
+        elif self.method == "censoring" and self.excused:
+            out = "+".join(filter(None, [fixed, tv, time]))
+    else:
+        if self.method == "dose-response":
+            out = "+".join(filter(None, [fixed, tv, tv_bas, followup, trial]))
+        elif self.method == "censoring" and not self.excused:
+            out = "+".join(filter(None, [fixed, tv, tv_bas, followup, trial]))
+        elif self.method == "censoring" and self.excused:
+            out = "+".join(filter(None, [fixed, tv, tv_bas, followup, trial]))
+
+    return out

pySEQTarget/initialization/_numerator.py

@@ -0,0 +1,37 @@
+def _numerator(self) -> str:
+    if self.method == "ITT":
+        return
+    trial = (
+        "+".join(["trial", f"trial{self.indicator_squared}"])
+        if self.trial_include
+        else None
+    )
+    followup = (
+        "+".join(["followup", f"followup{self.indicator_squared}"])
+        if self.followup_include
+        else None
+    )
+    time = "+".join([self.time_col, f"{self.time_col}{self.indicator_squared}"])
+
+    tv_bas = (
+        "+".join([f"{v}{self.indicator_baseline}" for v in self.time_varying_cols])
+        if self.time_varying_cols
+        else None
+    )
+    fixed = "+".join(self.fixed_cols) if self.fixed_cols else None
+
+    if self.weight_preexpansion:
+        if self.method == "dose-response":
+            out = "+".join(filter(None, [fixed, time]))
+        elif self.method == "censoring" and not self.excused:
+            out = "+".join(filter(None, [fixed, time]))
+        elif self.method == "censoring" and self.excused:
+            out = None
+    else:
+        if self.method == "dose-response":
+            out = "+".join(filter(None, [fixed, tv_bas, followup, trial]))
+        elif self.method == "censoring" and not self.excused:
+            out = "+".join(filter(None, [fixed, tv_bas, followup, trial]))
+        elif self.method == "censoring" and self.excused:
+            out = "+".join(filter(None, [fixed, tv_bas, followup, trial]))
+    return out

pySEQTarget/initialization/_outcome.py

@@ -0,0 +1,56 @@
+def _outcome(self) -> str:
+    tx_bas = f"{self.treatment_col}{self.indicator_baseline}"
+    dose = "+".join(["dose", f"dose{self.indicator_squared}"])
+    interaction = f"{tx_bas}*followup"
+    interaction_dose = "+".join(
+        ["followup*dose", f"followup*dose{self.indicator_squared}"]
+    )
+
+    if self.hazard or not self.km_curves:
+        interaction = interaction_dose = None
+
+    tv_bas = (
+        "+".join([f"{v}_bas" for v in self.time_varying_cols])
+        if self.time_varying_cols
+        else None
+    )
+    fixed = "+".join(self.fixed_cols) if self.fixed_cols else None
+    trial = (
+        "+".join(["trial", f"trial{self.indicator_squared}"])
+        if self.trial_include
+        else None
+    )
+
+    if self.followup_include:
+        followup = "+".join(["followup", f"followup{self.indicator_squared}"])
+    elif (self.followup_spline or self.followup_class) and not self.followup_include:
+        followup = "followup"
+    else:
+        followup = None
+
+    if self.method == "ITT":
+        parts = [tx_bas, followup, trial, fixed, tv_bas, interaction]
+        return "+".join(filter(None, parts))
+
+    if self.weighted:
+        if self.weight_preexpansion:
+            if self.method == "dose-response":
+                parts = [dose, followup, trial, fixed, interaction_dose]
+            elif self.method == "censoring":
+                if self.excused:
+                    parts = [tx_bas, followup, trial, interaction]
+                else:
+                    parts = [tx_bas, followup, trial, fixed, interaction]
+        else:
+            if self.method == "dose-response":
+                parts = [dose, followup, trial, fixed, tv_bas, interaction_dose]
+            elif self.method == "censoring":
+                parts = [tx_bas, followup, trial, fixed, tv_bas, interaction]
+        return "+".join(filter(None, parts))
+
+    if self.method == "dose-response":
+        parts = [dose, followup, trial, fixed, tv_bas, interaction_dose]
+    elif self.method == "censoring":
+        parts = [tx_bas, followup, trial, fixed, tv_bas, interaction]
+
+    return "+".join(filter(None, parts))

pySEQTarget/plot/__init__.py

@@ -0,0 +1 @@
+from ._survival_plot import _survival_plot as _survival_plot

pySEQTarget/plot/_survival_plot.py

@@ -0,0 +1,104 @@
+import itertools
+
+import matplotlib.pyplot as plt
+import numpy as np
+import polars as pl
+
+
+def _survival_plot(self):
+    if self.plot_type == "risk":
+        plot_data = self.km_data.filter(pl.col("estimate") == "risk")
+    elif self.plot_type == "survival":
+        plot_data = self.km_data.filter(pl.col("estimate") == "survival")
+    else:
+        plot_data = self.km_data.filter(pl.col("estimate") == "incidence")
+
+    if self.subgroup_colname is None:
+        fig = _plot_single(self, plot_data)
+    else:
+        fig = _plot_subgroups(self, plot_data)
+
+    return fig
+
+
+def _plot_single(self, plot_data):
+    fig, ax = plt.subplots(figsize=(10, 6))
+    _plot_data(self, plot_data, ax)
+
+    if self.plot_title is None:
+        self.plot_title = f"Cumulative {self.plot_type.title()}"
+
+    ax.set_xlabel("Followup")
+    ax.set_ylabel(self.plot_type.title())
+    ax.set_title(self.plot_title)
+    ax.legend()
+    ax.grid()
+
+    return fig
+
+
+def _plot_subgroups(self, plot_data):
+    subgroups = sorted(plot_data[self.subgroup_colname].unique().to_list())
+    n_subgroups = len(subgroups)
+    n_cols = min(3, n_subgroups)
+    n_rows = (n_subgroups + n_cols - 1) // n_cols
+
+    fig, axes = plt.subplots(n_rows, n_cols, figsize=(7 * n_cols, 6 * n_rows))
+    axes = np.atleast_1d(axes).flatten()
+
+    for idx, subgroup_val in enumerate(subgroups):
+        ax = axes[idx]
+        subgroup_data = plot_data.filter(pl.col(self.subgroup_colname) == subgroup_val)
+        _plot_data(self, subgroup_data, ax)
+        subgroup_label = (
+            str(subgroup_val).title() if isinstance(subgroup_val, str) else subgroup_val
+        )
+        ax.set_xlabel("Followup")
+        ax.set_ylabel(self.plot_type.title())
+        ax.set_title(
+            f"{self.subgroup_colname.title()}: {subgroup_label}",
+            fontsize=10,
+            style="italic",
+        )
+        ax.legend()
+        ax.grid()
+
+    for idx in range(n_subgroups, len(axes)):
+        axes[idx].set_visible(False)
+
+    if self.plot_title:
+        fig.suptitle(self.plot_title, fontsize=14)
+    else:
+        fig.suptitle(f"Cumulative {self.plot_type.title()}", fontsize=14)
+
+    plt.tight_layout()
+    return fig
+
+
+def _plot_data(self, plot_data, ax):
+    color_cycle = itertools.cycle(self.plot_colors) if self.plot_colors else None
+
+    for idx, i in enumerate(self.treatment_level):
+        subset = plot_data.filter(pl.col(self.treatment_col) == i)
+        if subset.is_empty():
+            continue
+
+        label = f"treatment = {i}"
+        if self.plot_labels and idx < len(self.plot_labels):
+            label = self.plot_labels[idx]
+
+        color = next(color_cycle) if color_cycle else None
+
+        (line,) = ax.plot(
+            subset["followup"], subset["pred"], "-", label=label, color=color
+        )
+
+        if "LCI" in subset.columns and "UCI" in subset.columns:
+            ax.fill_between(
+                subset["followup"],
+                subset["LCI"],
+                subset["UCI"],
+                color=line.get_color(),
+                alpha=0.2,
+                label="_nolegend_",
+            )

pySEQTarget/weighting/__init__.py

@@ -0,0 +1,8 @@
+from ._weight_bind import _weight_bind as _weight_bind
+from ._weight_data import _weight_setup as _weight_setup
+from ._weight_fit import _fit_denominator as _fit_denominator
+from ._weight_fit import _fit_LTFU as _fit_LTFU
+from ._weight_fit import _fit_numerator as _fit_numerator
+from ._weight_fit import _fit_visit as _fit_visit
+from ._weight_pred import _weight_predict as _weight_predict
+from ._weight_stats import _weight_stats as _weight_stats

pySEQTarget/weighting/_weight_bind.py

@@ -0,0 +1,86 @@
+import polars as pl
+
+
+def _weight_bind(self, WDT):
+    if self.weight_preexpansion:
+        join = "inner"
+        on = [self.id_col, "period"]
+        WDT = WDT.rename({self.time_col: "period"})
+    else:
+        join = "left"
+        on = [self.id_col, "trial", "followup"]
+
+    WDT = self.DT.join(WDT, on=on, how=join)
+
+    if self.visit_colname is not None:
+        visit = pl.col(self.visit_colname) == 0
+    else:
+        visit = pl.lit(False)
+
+    if self.weight_preexpansion and self.excused:
+        trial = (pl.col("trial") == 0) & (pl.col("period") == 0)
+        excused = (
+            pl.col("isExcused").fill_null(False).cum_sum().over([self.id_col, "trial"])
+            > 0
+        )
+        override = (
+            trial
+            | excused
+            | visit
+            | pl.col(self.outcome_col).is_null()
+            | (pl.col("denominator") < 1e-7)
+        )
+    elif not self.weight_preexpansion and self.excused:
+        trial = pl.col("followup") == 0
+        excused = (
+            pl.col("isExcused").fill_null(False).cum_sum().over([self.id_col, "trial"])
+            > 0
+        )
+        override = (
+            trial
+            | excused
+            | visit
+            | pl.col(self.outcome_col).is_null()
+            | (pl.col("denominator") < 1e-7)
+            | (pl.col("numerator") < 1e-7)
+        )
+    else:
+        trial = (pl.col("trial") == pl.col("trial").min().over(self.id_col)) & (
+            pl.col("followup") == 0
+        )
+        excused = pl.lit(False)
+        override = (
+            trial
+            | excused
+            | visit
+            | pl.col(self.outcome_col).is_null()
+            | (pl.col("denominator") < 1e-15)
+            | pl.col("numerator").is_null()
+        )
+
+    self.DT = (
+        (
+            WDT.with_columns(
+                pl.when(override)
+                .then(pl.lit(1.0))
+                .otherwise(pl.col("numerator") / pl.col("denominator"))
+                .alias("wt")
+            )
+            .sort([self.id_col, "trial", "followup"])
+            .with_columns(
+                pl.col("wt")
+                .fill_null(1.0)
+                .cum_prod()
+                .over([self.id_col, "trial"])
+                .alias("weight")
+            )
+        )
+        .with_columns(
+            (
+                pl.col("weight")
+                * pl.col("_cense").fill_null(1.0)
+                * pl.col("_visit").fill_null(1.0)
+            ).alias("weight")
+        )
+        .drop(["_cense", "_visit"])
+    )

pySEQTarget/weighting/_weight_data.py

@@ -0,0 +1,47 @@
+import polars as pl
+
+
+def _weight_setup(self):
+    DT = self.DT
+    data = self.data
+    if not self.weight_preexpansion:
+        baseline_lag = (
+            data.select([self.treatment_col, self.id_col, self.time_col])
+            .sort([self.id_col, self.time_col])
+            .with_columns(
+                pl.col(self.treatment_col)
+                .shift(fill_value=self.treatment_level[0])
+                .over(self.id_col)
+                .alias("tx_lag")
+            )
+            .drop(self.treatment_col)
+            .rename({self.time_col: "period"})
+        )
+
+        fup0 = DT.filter(pl.col("followup") == 0).join(
+            baseline_lag, on=[self.id_col, "period"], how="inner"
+        )
+
+        fup = (
+            DT.sort([self.id_col, "trial", "followup"])
+            .with_columns(
+                pl.col(self.treatment_col)
+                .shift(fill_value=self.treatment_level[0])
+                .over([self.id_col, "trial"])
+                .alias("tx_lag")
+            )
+            .filter(pl.col("followup") != 0)
+        )
+
+        WDT = pl.concat([fup0, fup]).sort([self.id_col, "trial", "followup"])
+    else:
+        WDT = data.with_columns(
+            pl.col(self.treatment_col)
+            .shift(fill_value=self.treatment_level[0])
+            .over(self.id_col)
+            .alias("tx_lag"),
+            (pl.col(self.time_col) ** 2).alias(
+                f"{self.time_col}{self.indicator_squared}"
+            ),
+        )
+    return WDT

pySEQTarget/weighting/_weight_fit.py

@@ -0,0 +1,99 @@
+import statsmodels.api as sm
+import statsmodels.formula.api as smf
+
+
+def _fit_pair(
+    self, WDT, outcome_attr, formula_attr, output_attrs, eligible_colname_attr=None
+):
+    outcome = getattr(self, outcome_attr)
+
+    if eligible_colname_attr is not None:
+        _eligible_col = getattr(self, eligible_colname_attr)
+        if _eligible_col is not None:
+            WDT = WDT[WDT[_eligible_col] == 1]
+
+    for rhs, out in zip(formula_attr, output_attrs):
+        formula = f"{outcome}~{rhs}"
+        model = smf.glm(formula, WDT, family=sm.families.Binomial())
+        setattr(self, out, model.fit(disp=0))
+
+
+def _fit_LTFU(self, WDT):
+    if self.cense_colname is None:
+        return
+    _fit_pair(
+        self,
+        WDT,
+        "cense_colname",
+        [self.cense_numerator, self.cense_denominator],
+        ["cense_numerator", "cense_denominator"],
+        "cense_eligible_colname",
+    )
+
+
+def _fit_visit(self, WDT):
+    if self.visit_colname is None:
+        return
+    _fit_pair(
+        self,
+        WDT,
+        "visit_colname",
+        [self.cense_numerator, self.cense_denominator],
+        ["visit_numerator", "visit_denominator"],
+    )
+
+
+def _fit_numerator(self, WDT):
+    if self.weight_preexpansion and self.excused:
+        return
+    if self.method == "ITT":
+        return
+    predictor = "switch" if self.excused else self.treatment_col
+    formula = f"{predictor}~{self.numerator}"
+    tx_bas = (
+        f"{self.treatment_col}{self.indicator_baseline}" if self.excused else "tx_lag"
+    )
+    fits = []
+    for i, level in enumerate(self.treatment_level):
+        if self.excused and self.excused_colnames[i] is not None:
+            DT_subset = WDT[WDT[self.excused_colnames[i]] == 0]
+        else:
+            DT_subset = WDT
+        if self.weight_lag_condition:
+            DT_subset = DT_subset[DT_subset[tx_bas] == level]
+        if self.weight_eligible_colnames[i] is not None:
+            DT_subset = DT_subset[DT_subset[self.weight_eligible_colnames[i]] == 1]
+        model = smf.mnlogit(formula, DT_subset)
+        model_fit = model.fit(disp=0)
+        fits.append(model_fit)
+
+    self.numerator_model = fits
+
+
+def _fit_denominator(self, WDT):
+    if self.method == "ITT":
+        return
+    predictor = (
+        "switch"
+        if self.excused and not self.weight_preexpansion
+        else self.treatment_col
+    )
+    formula = f"{predictor}~{self.denominator}"
+    fits = []
+    for i, level in enumerate(self.treatment_level):
+        if self.excused and self.excused_colnames[i] is not None:
+            DT_subset = WDT[WDT[self.excused_colnames[i]] == 0]
+        else:
+            DT_subset = WDT
+        if self.weight_lag_condition:
+            DT_subset = DT_subset[DT_subset["tx_lag"] == level]
+        if not self.weight_preexpansion:
+            DT_subset = DT_subset[DT_subset["followup"] != 0]
+        if self.weight_eligible_colnames[i] is not None:
+            DT_subset = DT_subset[DT_subset[self.weight_eligible_colnames[i]] == 1]
+
+        model = smf.mnlogit(formula, DT_subset)
+        model_fit = model.fit(disp=0)
+        fits.append(model_fit)
+
+    self.denominator_model = fits