pySEQTarget 0.10.0__py3-none-any.whl

pySEQTarget/weighting/_weight_pred.py

@@ -0,0 +1,192 @@
+import numpy as np
+import polars as pl
+
+from ..helpers import _predict_model
+
+
+def _weight_predict(self, WDT):
+    grouping = [self.id_col]
+    grouping += ["trial"] if not self.weight_preexpansion else []
+    time = self.time_col if self.weight_preexpansion else "followup"
+
+    if self.method == "ITT":
+        WDT = WDT.with_columns(
+            [pl.lit(1.0).alias("numerator"), pl.lit(1.0).alias("denominator")]
+        )
+    else:
+        WDT = WDT.with_columns(
+            [pl.lit(1.0).alias("numerator"), pl.lit(1.0).alias("denominator")]
+        )
+
+        if not self.excused:
+            for i, level in enumerate(self.treatment_level):
+                mask = pl.col("tx_lag") == level
+                lag_mask = (WDT["tx_lag"] == level).to_numpy()
+
+                if self.denominator_model[i] is not None:
+                    pred_denom = np.ones(WDT.height)
+                    if lag_mask.sum() > 0:
+                        subset = WDT.filter(pl.Series(lag_mask))
+                        p = _predict_model(self, self.denominator_model[i], subset)
+                        if p.ndim == 1:
+                            p = p.reshape(-1, 1)
+                        p = p[:, i]
+                        switched_treatment = (
+                            subset[self.treatment_col] != subset["tx_lag"]
+                        ).to_numpy()
+                        pred_denom[lag_mask] = np.where(switched_treatment, 1.0 - p, p)
+                else:
+                    pred_denom = np.ones(WDT.height)
+
+                if self.numerator_model[i] is not None:
+                    pred_num = np.ones(WDT.height)
+                    if lag_mask.sum() > 0:
+                        subset = WDT.filter(pl.Series(lag_mask))
+                        p = _predict_model(self, self.numerator_model[i], subset)
+                        if p.ndim == 1:
+                            p = p.reshape(-1, 1)
+                        p = p[:, i]
+                        switched_treatment = (
+                            subset[self.treatment_col] != subset["tx_lag"]
+                        ).to_numpy()
+                        pred_num[lag_mask] = np.where(switched_treatment, 1.0 - p, p)
+                else:
+                    pred_num = np.ones(WDT.height)
+
+                WDT = WDT.with_columns(
+                    [
+                        pl.when(mask)
+                        .then(pl.Series(pred_num))
+                        .otherwise(pl.col("numerator"))
+                        .alias("numerator"),
+                        pl.when(mask)
+                        .then(pl.Series(pred_denom))
+                        .otherwise(pl.col("denominator"))
+                        .alias("denominator"),
+                    ]
+                )
+
+        else:
+            for i, level in enumerate(self.treatment_level):
+                col = self.excused_colnames[i]
+
+                if col is not None:
+                    denom_mask = ((WDT["tx_lag"] == level) & (WDT[col] != 1)).to_numpy()
+
+                    if self.denominator_model[i] is not None and denom_mask.sum() > 0:
+                        pred_denom = np.ones(WDT.height)
+                        subset = WDT.filter(pl.Series(denom_mask))
+                        p = _predict_model(self, self.denominator_model[i], subset)
+
+                        if p.ndim == 1:
+                            prob_switch = p
+                        else:
+                            prob_switch = p[:, 1] if p.shape[1] > 1 else p.flatten()
+
+                        pred_denom[denom_mask] = prob_switch
+
+                        WDT = WDT.with_columns(
+                            pl.when(pl.Series(denom_mask))
+                            .then(pl.Series(pred_denom))
+                            .otherwise(pl.col("denominator"))
+                            .alias("denominator")
+                        )
+
+                    if i == 0:
+                        flip_mask = (
+                            (WDT["tx_lag"] == level)
+                            & (WDT[col] == 0)
+                            & (WDT[self.treatment_col] == level)
+                        ).to_numpy()
+                    else:
+                        flip_mask = (
+                            (WDT["tx_lag"] == level)
+                            & (WDT[col] == 0)
+                            & (WDT[self.treatment_col] != level)
+                        ).to_numpy()
+
+                    WDT = WDT.with_columns(
+                        pl.when(pl.Series(flip_mask))
+                        .then(1.0 - pl.col("denominator"))
+                        .otherwise(pl.col("denominator"))
+                        .alias("denominator")
+                    )
+
+            if self.weight_preexpansion:
+                WDT = WDT.with_columns(pl.lit(1.0).alias("numerator"))
+            else:
+                for i, level in enumerate(self.treatment_level):
+                    col = self.excused_colnames[i]
+
+                    if col is not None:
+                        num_mask = (
+                            (WDT[self.treatment_col] == level) & (WDT[col] == 0)
+                        ).to_numpy()
+
+                        if self.numerator_model[i] is not None and num_mask.sum() > 0:
+                            pred_num = np.ones(WDT.height)
+                            subset = WDT.filter(pl.Series(num_mask))
+                            p = _predict_model(self, self.numerator_model[i], subset)
+
+                            if p.ndim == 1:
+                                prob_switch = p
+                            else:
+                                prob_switch = p[:, 1] if p.shape[1] > 1 else p.flatten()
+
+                            pred_num[num_mask] = prob_switch
+
+                            WDT = WDT.with_columns(
+                                pl.when(pl.Series(num_mask))
+                                .then(pl.Series(pred_num))
+                                .otherwise(pl.col("numerator"))
+                                .alias("numerator")
+                            )
+
+                first_level = self.treatment_level[0]
+                WDT = WDT.with_columns(
+                    pl.when(pl.col(self.treatment_col) == first_level)
+                    .then(1.0 - pl.col("numerator"))
+                    .otherwise(pl.col("numerator"))
+                    .alias("numerator")
+                )
+    if self.cense_colname is not None:
+        p_num = _predict_model(self, self.cense_numerator, WDT).flatten()
+        p_denom = _predict_model(self, self.cense_denominator, WDT).flatten()
+        WDT = WDT.with_columns(
+            [
+                pl.Series("cense_numerator", p_num),
+                pl.Series("cense_denominator", p_denom),
+            ]
+        ).with_columns(
+            (pl.col("cense_numerator") / pl.col("cense_denominator")).alias("_cense")
+        )
+    else:
+        WDT = WDT.with_columns(pl.lit(1.0).alias("_cense"))
+
+    if self.visit_colname is not None:
+        p_num = _predict_model(self, self.visit_numerator, WDT).flatten()
+        p_denom = _predict_model(self, self.visit_denominator, WDT).flatten()
+
+        WDT = WDT.with_columns(
+            [
+                pl.Series("visit_numerator", p_num),
+                pl.Series("visit_denominator", p_denom),
+            ]
+        ).with_columns(
+            (pl.col("visit_numerator") / pl.col("visit_denominator")).alias("_visit")
+        )
+    else:
+        WDT = WDT.with_columns(pl.lit(1.0).alias("_visit"))
+
+    kept = [
+        "numerator",
+        "denominator",
+        "_cense",
+        "_visit",
+        self.id_col,
+        "trial",
+        time,
+        "tx_lag",
+    ]
+    exists = [col for col in kept if col in WDT.columns]
+    return WDT.select(exists).sort(grouping + [time])

pySEQTarget/weighting/_weight_stats.py

@@ -0,0 +1,23 @@
+import polars as pl
+
+
+def _weight_stats(self):
+    stats = self.DT.select(
+        [
+            pl.col("weight").min().alias("weight_min"),
+            pl.col("weight").max().alias("weight_max"),
+            pl.col("weight").mean().alias("weight_mean"),
+            pl.col("weight").std().alias("weight_std"),
+            pl.col("weight").quantile(0.01).alias("weight_p01"),
+            pl.col("weight").quantile(0.25).alias("weight_p25"),
+            pl.col("weight").quantile(0.50).alias("weight_p50"),
+            pl.col("weight").quantile(0.75).alias("weight_p75"),
+            pl.col("weight").quantile(0.99).alias("weight_p99"),
+        ]
+    )
+
+    if self.weight_p99:
+        self.weight_min = stats.select("weight_p01").item()
+        self.weight_max = stats.select("weight_p99").item()
+
+    return stats

pyseqtarget-0.10.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: pySEQTarget
+Version: 0.10.0
+Summary: Sequentially Nested Target Trial Emulation
+Author-email: Ryan O'Dea <ryan.odea@psi.ch>, Alejandro Szmulewicz <aszmulewicz@hsph.harvard.edu>, Tom Palmer <tom.palmer@bristol.ac.uk>, Miguel Hernan <mhernan@hsph.harvard.edu>
+Maintainer-email: Ryan O'Dea <ryan.odea@psi.ch>
+License: MIT
+Project-URL: Homepage, https://github.com/CausalInference/pySEQTarget
+Project-URL: Repository, https://github.com/CausalInference/pySEQTarget
+Project-URL: Bug Tracker, https://github.com/CausalInference/pySEQTarget/issues
+Project-URL: Ryan O'Dea (ORCID), https://orcid.org/0009-0000-0103-9546
+Project-URL: Alejandro Szmulewicz (ORCID), https://orcid.org/0000-0002-2664-802X
+Project-URL: Tom Palmer (ORCID), https://orcid.org/0000-0003-4655-4511
+Project-URL: Miguel Hernan (ORCID), https://orcid.org/0000-0003-1619-8456
+Project-URL: University of Bristol (ROR), https://ror.org/0524sp257
+Project-URL: Harvard University (ROR), https://ror.org/03vek6s52
+Keywords: causal inference,sequential trial emulation,target trial,observational studies
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: polars
+Requires-Dist: tqdm
+Requires-Dist: statsmodels
+Requires-Dist: matplotlib
+Requires-Dist: pyarrow
+Requires-Dist: lifelines
+Dynamic: license-file
+
+# pySEQTarget - Sequentially Nested Target Trial Emulation
+[![PyPI version](https://badge.fury.io/py/pySEQTarget.svg)](https://pypi.org/project/pySEQTarget) 
+[![Downloads](https://static.pepy.tech/badge/pySEQTarget)](https://pepy.tech/project/pySEQTarget)
+[![codecov](https://codecov.io/gh/CausalInference/pySEQTarget/graph/badge.svg?token=DMOVJJUWXP)](https://codecov.io/gh/CausalInference/pySEQTarget)[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+![versions](https://img.shields.io/pypi/pyversions/pySEQTarget.svg)
+[![Documentation Status](https://readthedocs.org/projects/pySEQTarget/badge/?version=latest)](https://pySEQTarget.readthedocs.io)
+
+Implementation of sequential trial emulation for the analysis of
+observational databases. The `SEQTaRget` software accommodates
+time-varying treatments and confounders, as well as binary and failure
+time outcomes. `SEQTaRget` allows to compare both static and dynamic
+strategies, can be used to estimate observational analogs of
+intention-to-treat and per-protocol effects, and can adjust for
+potential selection bias.
+
+## Installation
+You can install the development version of pySEQTarget from github with:
+```shell
+pip install git+https://github.com/CausalInference/pySEQTarget
+```
+Or from pypi iwth 
+```shell
+pip install pySEQTarget
+```
+
+## Setting up your Analysis
+The primary API, `SEQuential` uses a dataclass system to handle function input. You can then recover elements as they are built by interacting with the `SEQuential` object you create.
+
+From the user side, this amounts to creating a dataclass, `SEQopts`, and then feeding this into `SEQuential`. If you forgot to add something at class instantiation, you can, in some cases, add them when you call their respective class method.
+
+```python
+import polars as pl
+from pySEQTarget import SEQuential, SEQopts
+
+data = pl.from_pandas(SEQdata)
+options = SEQopts(km_curves = True)
+
+# Initiate the class
+model = SEQuential(data, 
+                   id_col = "ID",
+                   time_col = "time",
+                   eligible_col = "eligible",
+                   time_varying_cols = ["N", "L", "P"],
+                   fixed_cols = ["sex"],
+                   method = "ITT",
+                   options = options)
+model.expand()  # Construct the nested structure
+model.bootstrap(bootstrap_nboot = 20) # Run 20 bootstrap samples
+model.fit() # Fit the model
+model.survival() # Create survival curves
+model.plot() # Create and show a plot of the survival curves
+model.collect() # Collection of important information
+
+```
+
+## Assumptions
+There are several key assumptions in this package -
+1. User provided `time_col` begins at 0 per unique `id_col`, we also assume this column contains only integers and continues by 1 for every time step, e.g. (0, 1, 2, 3, 4, ...) is allowed and (0, 1, 2, 2.5, ...) or (0, 1, 4, 5) are not
+    1. Provided `time_col` entries may be out of order at intake as a sort is enforced at expansion.
+2. `eligible_col` and elements of `excused_colnames` are once 1, only 1 (with respect to `time_col`) flag variables.
+

pyseqtarget-0.10.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+pySEQTarget/SEQopts.py,sha256=7AWqwJyQs5I3CkwchpyNwq3oRiQMhOM34l9EnlxZ3L4,8910
+pySEQTarget/SEQoutput.py,sha256=NRXcX6TzuJjiix_I2_PwG18zn83U8cjc3Ihf-UXe-R8,6354
+pySEQTarget/SEQuential.py,sha256=IQ3SpoylyMV28GQCA8cZEhqVZ52MeP6pskpwLadnd2w,12869
+pySEQTarget/__init__.py,sha256=X3BKStCan0QmgpfJqN5ffBKZSDjw6s497N2b2AR3Ilg,147
+pySEQTarget/analysis/__init__.py,sha256=3XOPVKVWeRoCHtuHAIqNOAcGgWmBzXpU2C7_p47xXqo,448
+pySEQTarget/analysis/_hazard.py,sha256=lgluCVm6EpAcGzySRybXlsPrwhgHXW1zwxq47JVdvrg,6795
+pySEQTarget/analysis/_outcome_fit.py,sha256=VR7wF4n0EKIVrm8H2e-PG1-N-Xsu8aJO_VNU8o2O4KI,2199
+pySEQTarget/analysis/_risk_estimates.py,sha256=p40bSvN2wMOpCVq4Rv3ak6ZZVpobaI4zzjjeBKoQvCA,5300
+pySEQTarget/analysis/_subgroup_fit.py,sha256=jeL1LBTtHiSpfiu7-w4LjVWlka8XMPVABGsvV9AFG60,829
+pySEQTarget/analysis/_survival_pred.py,sha256=m_xbbz9awa3WZgaQt2-h4C3kAQLFL3aRB4U69TlsDcw,13993
+pySEQTarget/data/__init__.py,sha256=2q_f_M9LW1R5iO4CaBtoC0y-wwMsFGSd54mHfJDsvJo,682
+pySEQTarget/error/__init__.py,sha256=iC-55PhWIOymSHndMR-1buKE7sOApHw6Zb7W75T1Si0,116
+pySEQTarget/error/_datachecker.py,sha256=h7LDXlA-6OBcpqlF7kymnKQoZ58yLRx9q2461EFcIdQ,1231
+pySEQTarget/error/_param_checker.py,sha256=1d4k75b3qZUveq0S6DvaoGf6dYAKQHOc3q_KRoBie6I,1654
+pySEQTarget/expansion/__init__.py,sha256=Qy-m2NB8AnGX4GOrr9n20GxOCPxf-KaMARjxyFL73yg,241
+pySEQTarget/expansion/_binder.py,sha256=sa6UIcxgBl1uMIOBh-OnxYOMnEzNoceP1GVDiiYU6kM,3019
+pySEQTarget/expansion/_diagnostics.py,sha256=QyQ8HRe2tt8oYfMK1Q_gQAmo_nnaBPHgDo_DDEk2DTM,1507
+pySEQTarget/expansion/_dynamic.py,sha256=_iPJHR5KlCY9A71BfIS-V94hwFldPU17Yd36U7JAlJ0,2406
+pySEQTarget/expansion/_mapper.py,sha256=ROw8EJhok3r_UfY3u6DEe9FtD_eco-IEd_MV72EajlE,1251
+pySEQTarget/expansion/_selection.py,sha256=Ywas9JLBV3TEwm1kLb6CFD2CNza4_5DIDLgEVAobXEI,907
+pySEQTarget/helpers/__init__.py,sha256=Q0H0t6kehgJBkiOaOuB_Truq7kzOKGSiNS-ihX_4sEI,416
+pySEQTarget/helpers/_bootstrap.py,sha256=BiOxYfaf5HBEhoXJcw652JSJbe9BPFvT6GQ9Oq2p6A0,3375
+pySEQTarget/helpers/_col_string.py,sha256=ABMK8vlesY7yIAVKnxN0DRgLZgOCImHxmKphFYRNSv0,213
+pySEQTarget/helpers/_format_time.py,sha256=WGsJDJHxALz0NJSxC8Yht42yOUMju9hJQx8Nitt6bh8,247
+pySEQTarget/helpers/_output_files.py,sha256=dOfgIw1Io0zNjkNexdtdduQcWfBrKK2_W2IPJiVwgDY,5100
+pySEQTarget/helpers/_pad.py,sha256=9ePWswrhqSAVnAu7IBUmkBdI-w1YnBd0ozV9GvQR_dI,194
+pySEQTarget/helpers/_predict_model.py,sha256=dtkMFGMi-ut_HG9Lyp33FUln7E4zitr1ALYC2Ylc8H4,267
+pySEQTarget/helpers/_prepare_data.py,sha256=Nh9TZWlMqohCr4PJ0wlM8ej-w7bGc1rW_4_RVLcErq4,553
+pySEQTarget/initialization/__init__.py,sha256=1ExTDKGsyVLUh6xV6zHda_6WjcD8JMAUyNvHbFVKgD4,273
+pySEQTarget/initialization/_censoring.py,sha256=HkRzbdbTwG9zbX7KRqr9IgNogY3puX0qfClJdD7feo4,1720
+pySEQTarget/initialization/_denominator.py,sha256=Nvqa8EErk-lIxxosm6pqBmr_O6CzpEOEHlI57StlWUg,1534
+pySEQTarget/initialization/_numerator.py,sha256=LjzCVhhch_Ex4nA2el9V0xmwoTf0J2QWjUEfane_E2M,1396
+pySEQTarget/initialization/_outcome.py,sha256=cMhF2KfbInrf7bH6uzngPhWgQEV769Ww578EgIeL_AE,2119
+pySEQTarget/plot/__init__.py,sha256=Wf_4bmD-5gzLUXhSeDDaEIcxNknFjBvDyk55LOXiqOQ,61
+pySEQTarget/plot/_survival_plot.py,sha256=WtHfcpJ5zfa71LjgiHDklxwLmanVorC4hJGJp1-Av5c,3095
+pySEQTarget/weighting/__init__.py,sha256=Gv6zArKhK0many5qgi0ZikwQSCOAelCbuit13SP7DQc,449
+pySEQTarget/weighting/_weight_bind.py,sha256=VP0RO-VIgXqmdp4uhsN78xefxI-Gid4J-QxH0MKDxNs,2508
+pySEQTarget/weighting/_weight_data.py,sha256=P8E_-kOdb-s0Et5PL8b3Q-CnwuW6Ir8hMw_Zw80T0WM,1482
+pySEQTarget/weighting/_weight_fit.py,sha256=o73Lmz-bw58y5JjU9IV584JM-rfSTQXQuJBKOwi7-6k,3143
+pySEQTarget/weighting/_weight_pred.py,sha256=Rw1fQBi54ml62syKKE5xJFtIZJAchOvmnctJ10A82L8,7727
+pySEQTarget/weighting/_weight_stats.py,sha256=pJNH6A9_jQd4WFV1LYMum66VBJHrGsu5CUOPtBKrLD8,815
+pyseqtarget-0.10.0.dist-info/licenses/LICENSE,sha256=4iJQjIiCY2dK-vPGS4ptUlkstcDaS1MaQzv288_SNec,1065
+pyseqtarget-0.10.0.dist-info/METADATA,sha256=q6tzVwxfbNwbJ5qfC367WOGfgJH0hD3ENie4HhXyy7g,4869
+pyseqtarget-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyseqtarget-0.10.0.dist-info/top_level.txt,sha256=deyVmAqpFjyyxotp61jc5zwh0qdSqxCmvn8pWGw3YZo,12
+pyseqtarget-0.10.0.dist-info/RECORD,,

pyseqtarget-0.10.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyseqtarget-0.10.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CAUSALab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyseqtarget-0.10.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pySEQTarget