death-pred 0.1.0__py3-none-any.whl

death_pred/__init__.py

@@ -0,0 +1,3 @@
+"""Run `death-pred-unpack <YOUR_BASE_PATH>` to unpack the codes."""
+
+__version__ = "0.1.0"

death_pred/__main__.py

@@ -0,0 +1,45 @@
+"""Unpack the codes into a folder of your choice.
+
+    death-pred-unpack <YOUR_BASE_PATH>
+    python -m death_pred <YOUR_BASE_PATH>
+"""
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+BUNDLE = Path(__file__).resolve().parent / "bundle"
+FOLDERS = ["BEHRT_external_validation_polars_p312", "SCD"]
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="death-pred-unpack",
+        description="Copy the code and model folders into BASE_PATH.",
+    )
+    parser.add_argument("base_path", nargs="?", default=".",
+                        help="folder to unpack into (created if missing; default: current folder)")
+    args = parser.parse_args(argv)
+
+    base = Path(args.base_path).expanduser().resolve()
+    existing = [str(base / name) for name in FOLDERS if (base / name).exists()]
+    if existing:
+        sys.exit("Not unpacking, because these already exist and would be overwritten:\n  "
+                 + "\n  ".join(existing)
+                 + "\nChoose another folder, or move them out of the way first.")
+
+    base.mkdir(parents=True, exist_ok=True)
+    for name in FOLDERS:
+        # pip compiles the installed scripts; its cache folders are not part of the bundle.
+        shutil.copytree(BUNDLE / name, base / name,
+                        ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+    (base / "SCD" / "predictions").mkdir(exist_ok=True)
+
+    readme = base / "BEHRT_external_validation_polars_p312" / "README_external_validation.md"
+    print(f"Unpacked into {base}\n"
+          f"Next: open {readme}, read 'What may leave this server', then follow it from section 3.\n"
+          "(The Python dependencies were installed by pip, so sections 1 and 2 are already done.)")
+
+
+if __name__ == "__main__":
+    main()

death_pred/bundle/BEHRT_external_validation_polars_p312/CPRD/base/table.py

@@ -0,0 +1,356 @@
+import polars as pl
+from CPRD.config.utils import cvt_str2time, cvt_datestr2time
+from utils.utils import *
+
+try:
+    DICT2KEEP = load_obj('/path/linkage_coverage_dictv')
+except Exception:
+    DICT2KEEP = {
+        'ons_death': ('01/01/1900', '01/01/2100')
+    }
+
+
+class _TableBase:
+    """Base class wrapping a Polars DataFrame. Processing methods return new
+    instances so that the original chaining pattern is preserved."""
+
+    def __init__(self, df):
+        if isinstance(df, _TableBase):
+            self._df = df._df
+        elif isinstance(df, pl.DataFrame):
+            self._df = df
+        else:
+            raise TypeError(f"Expected pl.DataFrame or _TableBase, got {type(df)}")
+
+    @property
+    def df(self):
+        """Access the underlying Polars DataFrame."""
+        return self._df
+
+    @property
+    def columns(self):
+        return self._df.columns
+
+    @property
+    def height(self):
+        return self._df.height
+
+    @property
+    def schema(self):
+        return self._df.schema
+
+    def __len__(self):
+        return self._df.height
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._df.__repr__()})"
+
+
+# ---------------------------------------------------------------------------
+# Patient
+# ---------------------------------------------------------------------------
+class Patient(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def accept_flag(self):
+        return Patient(self._df.filter(pl.col('acceptable') == 1))
+
+    def yob_calibration(self):
+        return Patient(self._df.with_columns(pl.col('yob').cast(pl.Int32)))
+
+    def cvt_tod2date(self):
+        return Patient(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'regenddate').alias('tod')
+            ).drop('regenddate')
+        )
+
+    def cvt_deathdate2date(self):
+        return Patient(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'cprd_ddate').alias('cprd_ddate')
+            )
+        )
+
+    def cvt_crd2date(self):
+        return Patient(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'regstartdate').alias('crd')
+            ).drop('regstartdate')
+        )
+
+    def cvt_pracid(self):
+        return Patient(self._df.with_columns(pl.col('pracid').cast(pl.Int32)))
+
+
+# ---------------------------------------------------------------------------
+# Clinical
+# ---------------------------------------------------------------------------
+class Clinical(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cvtEventDate2Time(self):
+        return Clinical(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'obsdate').alias('eventdate')
+            ).drop('obsdate')
+        )
+
+    def rm_eventdate_medcode_empty(self):
+        return Clinical(
+            self._df.filter(
+                (pl.col('obsdate') != '') & (pl.col('medcodeid') != '')
+            ).rename({'medcodeid': 'medcode'})
+        )
+
+    def filter_byobservation(self):
+        return Clinical(self._df.filter(pl.col('obstypeid') == '7'))
+
+    def filter_byid(self, id_str):
+        return Clinical(self._df.filter(pl.col('obstypeid') == id_str))
+
+    def filter_byidlist(self, id_str):
+        return Clinical(self._df.filter(pl.col('obstypeid').is_in(id_str)))
+
+
+# ---------------------------------------------------------------------------
+# Consultation
+# ---------------------------------------------------------------------------
+class Consultation(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cvtEventDate2Time(self):
+        return Consultation(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'consdate').alias('eventdate')
+            ).drop('consdate')
+        )
+
+    def rm_eventdate_medcode_empty(self):
+        return Consultation(
+            self._df.filter(
+                (pl.col('consdate') != '') & (pl.col('consmedcodeid') != '')
+            ).with_columns(
+                pl.col('consmedcodeid').alias('medcode')
+            ).drop('consmedcodeid')
+        )
+
+
+# ---------------------------------------------------------------------------
+# Practice
+# ---------------------------------------------------------------------------
+class Practice(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cvt_lcd2date(self):
+        return Practice(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'lcd').alias('lcd')
+            )
+        )
+
+    def cvt_uts2date(self):
+        return Practice(
+            self._df.drop('uts').with_columns(
+                pl.lit(None).cast(pl.Date).alias('uts')
+            )
+        )
+
+    def intpracid(self):
+        return Practice(self._df.with_columns(pl.col('pracid').cast(pl.Int32)))
+
+    def rmv_badPract(self):
+        badlist = []
+        if badlist:
+            return Practice(self._df.filter(~pl.col('pracid').is_in(badlist)))
+        return self
+
+
+# ---------------------------------------------------------------------------
+# Diagnosis
+# ---------------------------------------------------------------------------
+class Diagnosis(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cvt_admidate2date(self):
+        return Diagnosis(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'admidate').alias('admidate')
+            )
+        )
+
+    def icd_rm_dot(self):
+        return Diagnosis(
+            self._df.with_columns(
+                pl.col('ICD').str.replace_all(r"\.", "")
+            )
+        )
+
+    def rm_date_icd_empty(self):
+        return Diagnosis(
+            self._df.filter((pl.col('admidate') != '') & (pl.col('ICD') != ''))
+        )
+
+    def hes_apc_timefilter(self):
+        if 'hes_apc' not in DICT2KEEP:
+            return self
+        goodstart = pl.lit(DICT2KEEP['hes_apc'][0]).str.to_date("dd/MM/yyyy", strict=False)
+        goodend = pl.lit(DICT2KEEP['hes_apc'][1]).str.to_date("dd/MM/yyyy", strict=False)
+        return Diagnosis(
+            self._df.filter(
+                (pl.col('admidate') >= goodstart) & (pl.col('admidate') < goodend)
+            )
+        )
+
+
+# ---------------------------------------------------------------------------
+# Hes
+# ---------------------------------------------------------------------------
+class Hes(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cvt_string2date(self, col):
+        # Rearrange dd/MM/yyyy to yyyyMMdd, then parse
+        df = self._df.with_columns(
+            pl.concat_str([
+                pl.col(col).str.slice(6, 4),
+                pl.col(col).str.slice(3, 2),
+                pl.col(col).str.slice(0, 2),
+            ]).str.to_date("%Y%m%d", strict=False).alias(col)
+        )
+        return Hes(df)
+
+    def rm_dot(self, col):
+        return Hes(
+            self._df.with_columns(
+                pl.col(col).str.replace_all(r"\.", "")
+            )
+        )
+
+
+# ---------------------------------------------------------------------------
+# Therapy
+# ---------------------------------------------------------------------------
+class Therapy(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def rm_eventdate_prodcode_empty(self):
+        return Therapy(
+            self._df.filter(
+                (pl.col('issuedate') != '') & (pl.col('prodcodeid') != '')
+            ).rename({'prodcodeid': 'prodcode', 'issuedate': 'eventdate'})
+        )
+
+    def cvtEventDate2Time(self):
+        return Therapy(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'eventdate').alias('eventdate')
+            )
+        )
+
+
+# ---------------------------------------------------------------------------
+# EHR  (used by predictor_extractor for sequence building)
+# ---------------------------------------------------------------------------
+class EHR(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cal_age(self, event_date, yob, year=True, name='age'):
+        """Calculate age from event_date and yob (both Date columns)."""
+        if year:
+            df = self._df.with_columns(
+                (pl.col(event_date).dt.year() - pl.col(yob).dt.year()).alias(name)
+            )
+        else:
+            # Age in months; assume born in January
+            df = self._df.with_columns(
+                (
+                    (pl.col(event_date).dt.year() * 12 + pl.col(event_date).dt.month())
+                    - (pl.col(yob).dt.year() * 12 + 1)
+                ).alias(name)
+            )
+        return EHR(df)
+
+    def cal_year(self, event_date, name='year'):
+        return EHR(
+            self._df.with_columns(
+                pl.col(event_date).dt.year().alias(name)
+            )
+        )
+
+    def set_col_to_str(self, col):
+        return EHR(self._df.with_columns(pl.col(col).cast(pl.Utf8)))
+
+    def array_add_element(self, col, element):
+        """Append a single element to each list in a List[Utf8] column."""
+        dtype = self._df.schema[col]
+        inner = dtype.inner if isinstance(dtype, pl.List) else pl.Utf8
+        return EHR(
+            self._df.with_columns(
+                pl.col(col).map_elements(
+                    lambda lst: list(lst) + [element],
+                    return_dtype=pl.List(inner),
+                )
+            )
+        )
+
+    def array_flatten(self, col):
+        """Flatten a List[List[T]] column into List[T]."""
+        dtype = self._df.schema[col]
+        if isinstance(dtype, pl.List) and isinstance(dtype.inner, pl.List):
+            inner_type = dtype.inner.inner
+            return EHR(
+                self._df.with_columns(
+                    pl.col(col).map_elements(
+                        lambda lst: [item for sublist in lst for item in sublist],
+                        return_dtype=pl.List(inner_type),
+                    )
+                )
+            )
+        return self
+
+
+# ---------------------------------------------------------------------------
+# Proc_HES
+# ---------------------------------------------------------------------------
+class Proc_HES(_TableBase):
+    def __init__(self, df):
+        super().__init__(df)
+
+    def cvt_admidate2date(self):
+        return Proc_HES(
+            self._df.with_columns(
+                cvt_datestr2time(self._df, 'evdate').alias('evdate')
+            )
+        )
+
+    def icd_rm_dot(self):
+        return Proc_HES(
+            self._df.with_columns(
+                pl.col('ICD').str.replace_all(r"\.", "")
+            )
+        )
+
+    def rm_date_opcs_empty(self):
+        return Proc_HES(
+            self._df.filter((pl.col('evdate') != '') & (pl.col('OPCS') != ''))
+        )
+
+    def hes_apc_timefilter(self):
+        if 'hes_apc' not in DICT2KEEP:
+            return self
+        goodstart = pl.lit(DICT2KEEP['hes_apc'][0]).str.to_date("dd/MM/yyyy", strict=False)
+        goodend = pl.lit(DICT2KEEP['hes_apc'][1]).str.to_date("dd/MM/yyyy", strict=False)
+        return Proc_HES(
+            self._df.filter(
+                (pl.col('evdate') >= goodstart) & (pl.col('evdate') < goodend)
+            )
+        )