pySEQTarget 0.10.0__py3-none-any.whl

pySEQTarget/analysis/_risk_estimates.py

@@ -0,0 +1,136 @@
+import polars as pl
+from scipy import stats
+
+
+def _risk_estimates(self):
+    last_followup = self.km_data["followup"].max()
+    risk = self.km_data.filter(
+        (pl.col("followup") == last_followup) & (pl.col("estimate") == "risk")
+    )
+
+    group_cols = [self.subgroup_colname] if self.subgroup_colname else []
+    rd_comparisons = []
+    rr_comparisons = []
+
+    if self.bootstrap_nboot > 0:
+        alpha = 1 - self.bootstrap_CI
+        z = stats.norm.ppf(1 - alpha / 2)
+
+    for tx_x in self.treatment_level:
+        for tx_y in self.treatment_level:
+            if tx_x == tx_y:
+                continue
+
+            risk_x = (
+                risk.filter(pl.col("tx_init") == tx_x)
+                .select(group_cols + ["pred"])
+                .rename({"pred": "risk_x"})
+            )
+
+            risk_y = (
+                risk.filter(pl.col("tx_init") == tx_y)
+                .select(group_cols + ["pred"])
+                .rename({"pred": "risk_y"})
+            )
+
+            if group_cols:
+                comp = risk_x.join(risk_y, on=group_cols, how="left")
+            else:
+                comp = risk_x.join(risk_y, how="cross")
+
+            comp = comp.with_columns(
+                [pl.lit(tx_x).alias("A_x"), pl.lit(tx_y).alias("A_y")]
+            )
+
+            if self.bootstrap_nboot > 0:
+                se_x = (
+                    risk.filter(pl.col("tx_init") == tx_x)
+                    .select(group_cols + ["SE"])
+                    .rename({"SE": "se_x"})
+                )
+
+                se_y = (
+                    risk.filter(pl.col("tx_init") == tx_y)
+                    .select(group_cols + ["SE"])
+                    .rename({"SE": "se_y"})
+                )
+
+                if group_cols:
+                    comp = comp.join(se_x, on=group_cols, how="left")
+                    comp = comp.join(se_y, on=group_cols, how="left")
+                else:
+                    comp = comp.join(se_x, how="cross")
+                    comp = comp.join(se_y, how="cross")
+
+                rd_se = (pl.col("se_x").pow(2) + pl.col("se_y").pow(2)).sqrt()
+                rd_comp = comp.with_columns(
+                    [
+                        (pl.col("risk_x") - pl.col("risk_y")).alias("Risk Difference"),
+                        (pl.col("risk_x") - pl.col("risk_y") - z * rd_se).alias(
+                            "RD 95% LCI"
+                        ),
+                        (pl.col("risk_x") - pl.col("risk_y") + z * rd_se).alias(
+                            "RD 95% UCI"
+                        ),
+                    ]
+                )
+                rd_comp = rd_comp.drop(["risk_x", "risk_y", "se_x", "se_y"])
+                col_order = group_cols + [
+                    "A_x",
+                    "A_y",
+                    "Risk Difference",
+                    "RD 95% LCI",
+                    "RD 95% UCI",
+                ]
+                rd_comp = rd_comp.select([c for c in col_order if c in rd_comp.columns])
+                rd_comparisons.append(rd_comp)
+
+                rr_log_se = (
+                    (pl.col("se_x") / pl.col("risk_x")).pow(2)
+                    + (pl.col("se_y") / pl.col("risk_y")).pow(2)
+                ).sqrt()
+                rr_comp = comp.with_columns(
+                    [
+                        (pl.col("risk_x") / pl.col("risk_y")).alias("Risk Ratio"),
+                        (
+                            (pl.col("risk_x") / pl.col("risk_y"))
+                            * (-z * rr_log_se).exp()
+                        ).alias("RR 95% LCI"),
+                        (
+                            (pl.col("risk_x") / pl.col("risk_y"))
+                            * (z * rr_log_se).exp()
+                        ).alias("RR 95% UCI"),
+                    ]
+                )
+                rr_comp = rr_comp.drop(["risk_x", "risk_y", "se_x", "se_y"])
+                col_order = group_cols + [
+                    "A_x",
+                    "A_y",
+                    "Risk Ratio",
+                    "RR 95% LCI",
+                    "RR 95% UCI",
+                ]
+                rr_comp = rr_comp.select([c for c in col_order if c in rr_comp.columns])
+                rr_comparisons.append(rr_comp)
+
+            else:
+                rd_comp = comp.with_columns(
+                    (pl.col("risk_x") - pl.col("risk_y")).alias("Risk Difference")
+                )
+                rd_comp = rd_comp.drop(["risk_x", "risk_y"])
+                col_order = group_cols + ["A_x", "A_y", "Risk Difference"]
+                rd_comp = rd_comp.select([c for c in col_order if c in rd_comp.columns])
+                rd_comparisons.append(rd_comp)
+
+                rr_comp = comp.with_columns(
+                    (pl.col("risk_x") / pl.col("risk_y")).alias("Risk Ratio")
+                )
+                rr_comp = rr_comp.drop(["risk_x", "risk_y"])
+                col_order = group_cols + ["A_x", "A_y", "Risk Ratio"]
+                rr_comp = rr_comp.select([c for c in col_order if c in rr_comp.columns])
+                rr_comparisons.append(rr_comp)
+
+    risk_difference = pl.concat(rd_comparisons) if rd_comparisons else pl.DataFrame()
+    risk_ratio = pl.concat(rr_comparisons) if rr_comparisons else pl.DataFrame()
+
+    return {"risk_difference": risk_difference, "risk_ratio": risk_ratio}

pySEQTarget/analysis/_subgroup_fit.py

@@ -0,0 +1,30 @@
+import polars as pl
+
+from ._outcome_fit import _outcome_fit
+
+
+def _subgroup_fit(self):
+    subgroups = sorted(self.DT[self.subgroup_colname].unique().to_list())
+    self._unique_subgroups = subgroups
+
+    models_list = []
+    for val in subgroups:
+        subDT = self.DT.filter(pl.col(self.subgroup_colname) == val)
+
+        models = {
+            "outcome": _outcome_fit(
+                self, subDT, self.outcome_col, self.covariates, self.weighted, "weight"
+            )
+        }
+
+        if self.compevent_colname is not None:
+            models["compevent"] = _outcome_fit(
+                self,
+                subDT,
+                self.compevent_colname,
+                self.covariates,
+                self.weighted,
+                "weight",
+            )
+        models_list.append(models)
+    return models_list

pySEQTarget/analysis/_survival_pred.py

@@ -0,0 +1,372 @@
+import polars as pl
+
+
+def _get_outcome_predictions(self, TxDT, idx=None):
+    data = TxDT.to_pandas()
+    predictions = {"outcome": []}
+    if self.compevent_colname is not None:
+        predictions["compevent"] = []
+
+    for boot_model in self.outcome_model:
+        model_dict = boot_model[idx] if idx is not None else boot_model
+        predictions["outcome"].append(model_dict["outcome"].predict(data))
+        if self.compevent_colname is not None:
+            predictions["compevent"].append(model_dict["compevent"].predict(data))
+
+    return predictions
+
+
+def _pred_risk(self):
+    has_subgroups = (
+        isinstance(self.outcome_model[0], list) if self.outcome_model else False
+    )
+
+    if not has_subgroups:
+        return _calculate_risk(self, self.DT, idx=None, val=None)
+
+    all_risks = []
+    original_DT = self.DT
+
+    for i, val in enumerate(self._unique_subgroups):
+        subgroup_DT = original_DT.filter(pl.col(self.subgroup_colname) == val)
+        risk = _calculate_risk(self, subgroup_DT, i, val)
+        all_risks.append(risk)
+
+    self.DT = original_DT
+    return pl.concat(all_risks)
+
+
+def _calculate_risk(self, data, idx=None, val=None):
+    a = 1 - self.bootstrap_CI
+    lci = a / 2
+    uci = 1 - lci
+
+    SDT = (
+        data.with_columns(
+            [
+                (
+                    pl.col(self.id_col).cast(pl.Utf8) + pl.col("trial").cast(pl.Utf8)
+                ).alias("TID")
+            ]
+        )
+        .group_by("TID")
+        .first()
+        .drop(["followup", f"followup{self.indicator_squared}"])
+        .with_columns([pl.lit(list(range(self.followup_max))).alias("followup")])
+        .explode("followup")
+        .with_columns(
+            [
+                (pl.col("followup") + 1).alias("followup"),
+                (pl.col("followup") ** 2).alias(f"followup{self.indicator_squared}"),
+            ]
+        )
+    ).sort([self.id_col, "trial", "followup"])
+
+    risks = []
+    for treatment_val in self.treatment_level:
+        TxDT = SDT.with_columns(
+            [
+                pl.lit(treatment_val).alias(
+                    f"{self.treatment_col}{self.indicator_baseline}"
+                )
+            ]
+        )
+
+        if self.method == "dose-response":
+            if treatment_val == self.treatment_level[0]:
+                TxDT = TxDT.with_columns(
+                    [pl.lit(0.0).alias("dose"), pl.lit(0.0).alias("dose_sq")]
+                )
+            else:
+                TxDT = TxDT.with_columns(
+                    [
+                        pl.col("followup").alias("dose"),
+                        pl.col(f"followup{self.indicator_squared}").alias("dose_sq"),
+                    ]
+                )
+
+        preds = _get_outcome_predictions(self, TxDT, idx=idx)
+        pred_series = [pl.Series("pred_outcome", preds["outcome"][0])]
+
+        if self.bootstrap_nboot > 0:
+            for boot_idx, pred in enumerate(preds["outcome"][1:], start=1):
+                pred_series.append(pl.Series(f"pred_outcome_{boot_idx}", pred))
+
+        if self.compevent_colname is not None:
+            pred_series.append(pl.Series("pred_ce", preds["compevent"][0]))
+            if self.bootstrap_nboot > 0:
+                for boot_idx, pred in enumerate(preds["compevent"][1:], start=1):
+                    pred_series.append(pl.Series(f"pred_ce_{boot_idx}", pred))
+
+        outcome_names = [s.name for s in pred_series if "outcome" in s.name]
+        ce_names = [s.name for s in pred_series if "ce" in s.name]
+
+        TxDT = TxDT.with_columns(pred_series)
+
+        if self.compevent_colname is not None:
+            for out_col, ce_col in zip(outcome_names, ce_names):
+                surv_col = out_col.replace("pred_outcome", "surv")
+                cce_col = out_col.replace("pred_outcome", "cce")
+                inc_col = out_col.replace("pred_outcome", "inc")
+
+                TxDT = TxDT.with_columns(
+                    [
+                        (1 - pl.col(out_col)).cum_prod().over("TID").alias(surv_col),
+                        ((1 - pl.col(out_col)) * (1 - pl.col(ce_col)))
+                        .cum_prod()
+                        .over("TID")
+                        .alias(cce_col),
+                    ]
+                ).with_columns(
+                    [
+                        (pl.col(out_col) * (1 - pl.col(ce_col)) * pl.col(cce_col))
+                        .cum_sum()
+                        .over("TID")
+                        .alias(inc_col)
+                    ]
+                )
+
+            surv_names = [n.replace("pred_outcome", "surv") for n in outcome_names]
+            inc_names = [n.replace("pred_outcome", "inc") for n in outcome_names]
+            TxDT = (
+                TxDT.group_by("followup")
+                .agg([pl.col(col).mean() for col in surv_names + inc_names])
+                .sort("followup")
+            )
+            main_col = "surv"
+            boot_cols = [col for col in surv_names if col != "surv"]
+        else:
+            TxDT = (
+                TxDT.with_columns(
+                    [
+                        (1 - pl.col(col)).cum_prod().over("TID").alias(col)
+                        for col in outcome_names
+                    ]
+                )
+                .group_by("followup")
+                .agg([pl.col(col).mean() for col in outcome_names])
+                .sort("followup")
+                .with_columns([(1 - pl.col(col)).alias(col) for col in outcome_names])
+            )
+            main_col = "pred_outcome"
+            boot_cols = [col for col in outcome_names if col != "pred_outcome"]
+
+        if boot_cols:
+            risk = (
+                TxDT.select(["followup"] + boot_cols)
+                .unpivot(
+                    index="followup",
+                    on=boot_cols,
+                    variable_name="bootID",
+                    value_name="risk",
+                )
+                .group_by("followup")
+                .agg(
+                    [
+                        pl.col("risk").std().cast(pl.Float64).alias("SE"),
+                        pl.col("risk").quantile(lci).cast(pl.Float64).alias("LCI"),
+                        pl.col("risk").quantile(uci).cast(pl.Float64).alias("UCI"),
+                    ]
+                )
+                .join(TxDT.select(["followup", main_col]), on="followup")
+            )
+
+            if self.bootstrap_CI_method == "se":
+                from scipy.stats import norm
+
+                z = norm.ppf(1 - a / 2)
+                risk = risk.with_columns(
+                    [
+                        (pl.col(main_col) - z * pl.col("SE")).alias("LCI"),
+                        (pl.col(main_col) + z * pl.col("SE")).alias("UCI"),
+                    ]
+                )
+
+            fup0_val = 1.0 if self.compevent_colname else 0.0
+
+            if self.compevent_colname is not None:
+                inc_boot_cols = [col for col in inc_names if col != "inc"]
+                if inc_boot_cols:
+                    inc_risk = (
+                        TxDT.select(["followup"] + inc_boot_cols)
+                        .unpivot(
+                            index="followup",
+                            on=inc_boot_cols,
+                            variable_name="bootID",
+                            value_name="inc_val",
+                        )
+                        .group_by("followup")
+                        .agg(
+                            [
+                                pl.col("inc_val")
+                                .std()
+                                .cast(pl.Float64)
+                                .alias("inc_SE"),
+                                pl.col("inc_val")
+                                .quantile(lci)
+                                .cast(pl.Float64)
+                                .alias("inc_LCI"),
+                                pl.col("inc_val")
+                                .quantile(uci)
+                                .cast(pl.Float64)
+                                .alias("inc_UCI"),
+                            ]
+                        )
+                        .join(TxDT.select(["followup", "inc"]), on="followup")
+                    )
+                    risk = risk.join(inc_risk, on="followup")
+                    final_cols = [
+                        "followup",
+                        main_col,
+                        "SE",
+                        "LCI",
+                        "UCI",
+                        "inc",
+                        "inc_SE",
+                        "inc_LCI",
+                        "inc_UCI",
+                    ]
+                    risk = risk.select(final_cols).with_columns(
+                        pl.lit(treatment_val).alias(self.treatment_col)
+                    )
+
+                    fup0 = pl.DataFrame(
+                        {
+                            "followup": [0],
+                            main_col: [fup0_val],
+                            "SE": [0.0],
+                            "LCI": [fup0_val],
+                            "UCI": [fup0_val],
+                            "inc": [0.0],
+                            "inc_SE": [0.0],
+                            "inc_LCI": [0.0],
+                            "inc_UCI": [0.0],
+                            self.treatment_col: [treatment_val],
+                        }
+                    ).with_columns(
+                        [
+                            pl.col("followup").cast(pl.Int64),
+                            pl.col(self.treatment_col).cast(pl.Int32),
+                        ]
+                    )
+                else:
+                    risk = risk.select(
+                        ["followup", main_col, "SE", "LCI", "UCI"]
+                    ).with_columns(pl.lit(treatment_val).alias(self.treatment_col))
+                    fup0 = pl.DataFrame(
+                        {
+                            "followup": [0],
+                            main_col: [fup0_val],
+                            "SE": [0.0],
+                            "LCI": [fup0_val],
+                            "UCI": [fup0_val],
+                            self.treatment_col: [treatment_val],
+                        }
+                    ).with_columns(
+                        [
+                            pl.col("followup").cast(pl.Int64),
+                            pl.col(self.treatment_col).cast(pl.Int32),
+                        ]
+                    )
+            else:
+                risk = risk.select(
+                    ["followup", main_col, "SE", "LCI", "UCI"]
+                ).with_columns(pl.lit(treatment_val).alias(self.treatment_col))
+                fup0 = pl.DataFrame(
+                    {
+                        "followup": [0],
+                        main_col: [fup0_val],
+                        "SE": [0.0],
+                        "LCI": [fup0_val],
+                        "UCI": [fup0_val],
+                        self.treatment_col: [treatment_val],
+                    }
+                ).with_columns(
+                    [
+                        pl.col("followup").cast(pl.Int64),
+                        pl.col(self.treatment_col).cast(pl.Int32),
+                    ]
+                )
+        else:
+            fup0_val = 1.0 if self.compevent_colname else 0.0
+            risk = TxDT.select(["followup", main_col]).with_columns(
+                pl.lit(treatment_val).alias(self.treatment_col)
+            )
+            fup0 = pl.DataFrame(
+                {
+                    "followup": [0],
+                    main_col: [fup0_val],
+                    self.treatment_col: [treatment_val],
+                }
+            ).with_columns(
+                [
+                    pl.col("followup").cast(pl.Int64),
+                    pl.col(self.treatment_col).cast(pl.Int32),
+                ]
+            )
+
+            if self.compevent_colname is not None:
+                risk = risk.join(TxDT.select(["followup", "inc"]), on="followup")
+                fup0 = fup0.with_columns([pl.lit(0.0).alias("inc")])
+
+        risks.append(pl.concat([fup0, risk]))
+    out = pl.concat(risks)
+
+    if self.compevent_colname is not None:
+        has_ci = "SE" in out.columns
+
+        surv_cols = ["followup", self.treatment_col, "surv"]
+        if has_ci:
+            surv_cols.extend(["SE", "LCI", "UCI"])
+        surv_out = (
+            out.select(surv_cols)
+            .rename({"surv": "pred"})
+            .with_columns(pl.lit("survival").alias("estimate"))
+        )
+
+        risk_cols = ["followup", self.treatment_col, (1 - pl.col("surv")).alias("pred")]
+        if has_ci:
+            risk_cols.extend(
+                [
+                    pl.col("SE"),
+                    (1 - pl.col("UCI")).alias("LCI"),
+                    (1 - pl.col("LCI")).alias("UCI"),
+                ]
+            )
+        risk_out = out.select(risk_cols).with_columns(pl.lit("risk").alias("estimate"))
+
+        inc_cols = ["followup", self.treatment_col, pl.col("inc").alias("pred")]
+        if has_ci:
+            inc_cols.extend(
+                [
+                    pl.col("inc_SE").alias("SE"),
+                    pl.col("inc_LCI").alias("LCI"),
+                    pl.col("inc_UCI").alias("UCI"),
+                ]
+            )
+        inc_out = out.select(inc_cols).with_columns(
+            pl.lit("incidence").alias("estimate")
+        )
+
+        out = pl.concat([surv_out, risk_out, inc_out])
+    else:
+        out = out.rename({"pred_outcome": "pred"}).with_columns(
+            pl.lit("risk").alias("estimate")
+        )
+
+    if val is not None:
+        out = out.with_columns(pl.lit(val).alias(self.subgroup_colname))
+
+    return out
+
+
+def _calculate_survival(self, risk_data):
+    if self.bootstrap_nboot > 0:
+        surv = risk_data.with_columns(
+            [(1 - pl.col(col)).alias(col) for col in ["pred", "LCI", "UCI"]]
+        ).with_columns(pl.lit("survival").alias("estimate"))
+    else:
+        surv = risk_data.with_columns(
+            [(1 - pl.col("pred")).alias("pred"), pl.lit("survival").alias("estimate")]
+        )
+    return surv

pySEQTarget/data/__init__.py

@@ -0,0 +1,19 @@
+from importlib.resources import files
+
+import polars as pl
+
+
+def load_data(name: str = "SEQdata") -> pl.DataFrame:
+    loc = files("pySEQTarget.data")
+    if name in ["SEQdata", "SEQdata_multitreatment", "SEQdata_LTFU"]:
+        if name == "SEQdata":
+            data_path = loc.joinpath("SEQdata.csv")
+        elif name == "SEQdata_multitreatment":
+            data_path = loc.joinpath("SEQdata_multitreatment.csv")
+        else:
+            data_path = loc.joinpath("SEQdata_LTFU.csv")
+        return pl.read_csv(data_path)
+    else:
+        raise ValueError(
+            f"Dataset '{name}' not available. Options: ['SEQdata', 'SEQdata_multitreatment', 'SEQdata_LTFU']"
+        )

pySEQTarget/error/__init__.py

@@ -0,0 +1,2 @@
+from ._datachecker import _datachecker as _datachecker
+from ._param_checker import _param_checker as _param_checker

pySEQTarget/error/_datachecker.py

@@ -0,0 +1,38 @@
+import polars as pl
+
+
+def _datachecker(self):
+    check = self.data.group_by(self.id_col).agg(
+        [pl.len().alias("row_count"), pl.col(self.time_col).max().alias("max_time")]
+    )
+
+    invalid = check.filter(pl.col("row_count") != pl.col("max_time") + 1)
+    if len(invalid) > 0:
+        raise ValueError(
+            f"Data validation failed: {len(invalid)} ID(s) have mismatched "
+            f"This suggests invalid times"
+            f"Invalid IDs:\n{invalid}"
+        )
+
+    for col in self.excused_colnames:
+        violations = (
+            self.data.sort([self.id_col, self.time_col])
+            .group_by(self.id_col)
+            .agg(
+                [
+                    (
+                        (pl.col(col).cum_sum().shift(1, fill_value=0) > 0)
+                        & (pl.col(col) == 0)
+                    )
+                    .any()
+                    .alias("has_violation")
+                ]
+            )
+            .filter(pl.col("has_violation"))
+        )
+
+        if len(violations) > 0:
+            raise ValueError(
+                f"Column '{col}' violates 'once one, always one' rule for excusing treatment "
+                f"{len(violations)} ID(s) have zeros after ones."
+            )

pySEQTarget/error/_param_checker.py

@@ -0,0 +1,50 @@
+from ..helpers import _pad
+
+
+def _param_checker(self):
+    if (
+        self.subgroup_colname is not None
+        and self.subgroup_colname not in self.fixed_cols
+    ):
+        raise ValueError("subgroup_colname must be included in fixed_cols.")
+
+    if self.followup_max is None:
+        self.followup_max = self.data.select(self.time_col).to_series().max()
+
+    if len(self.excused_colnames) == 0 and self.excused:
+        self.excused = False
+        raise Warning(
+            "Excused column names not provided but excused is set to True. Automatically set excused to False"
+        )
+
+    if len(self.excused_colnames) > 0 and not self.excused:
+        self.excused = True
+        raise Warning(
+            "Excused column names provided but excused is set to False. Automatically set excused to True"
+        )
+
+    if self.km_curves and self.hazard_estimate:
+        raise ValueError("km_curves and hazard cannot both be set to True.")
+
+    if sum([self.followup_class, self.followup_include, self.followup_spline]) > 1:
+        raise ValueError(
+            "Only one of followup_class or followup_include can be set to True."
+        )
+
+    if (
+        self.weighted
+        and self.method == "ITT"
+        and self.cense_colname is None
+        and self.visit_colname is None
+    ):
+        raise ValueError(
+            "For weighted ITT analyses, cense_colname or visit_colname must be provided."
+        )
+
+    if self.excused:
+        _, self.excused_colnames = _pad(self.treatment_level, self.excused_colnames)
+    _, self.weight_eligible_colnames = _pad(
+        self.treatment_level, self.weight_eligible_colnames
+    )
+
+    return

pySEQTarget/expansion/__init__.py

@@ -0,0 +1,5 @@
+from ._binder import _binder as _binder
+from ._diagnostics import _diagnostics as _diagnostics
+from ._dynamic import _dynamic as _dynamic
+from ._mapper import _mapper as _mapper
+from ._selection import _random_selection as _random_selection