pycomorb 0.4__py3-none-any.whl

pycomorb/CharlsonComorbidityIndex.py

@@ -0,0 +1,262 @@
+# Reference for CCI:
+# 1. Charlson ME, Pompei P, Ales KL, MacKenzie CR.
+#    A new method of classifying prognostic comorbidity in longitudinal studies: development and validation.
+#    J Chronic Dis. 1987;40(5):373-83.
+#    doi: 10.1016/0021-9681(87)90171-8. PMID: 3558716.
+# 2. Charlson M, Szatrowski TP, Peterson J, Gold J.
+#    Validation of a combined comorbidity index.
+#    J Clin Epidemiol. 1994 Nov;47(11):1245-51.
+#    doi: 10.1016/0895-4356(94)90129-5. PMID: 7722560.
+#
+# Reference for ICD-9-CM and ICD-10 Coding Algorithms for Charlson Comorbidities:
+# 3. Deyo RA, Cherkin DC, Ciol MA.
+#    Adapting a clinical comorbidity index for use with ICD-9-CM administrative databases.
+#    J Clin Epidemiol. 1992 Jun;45(6):613-9.
+#    doi: 10.1016/0895-4356(92)90133-8. PMID: 1607900.
+# 4. Romano PS, Roos LL, Jollis JG.
+#    Adapting a clinical comorbidity index for use with ICD-9-CM administrative data: differing perspectives.
+#    J Clin Epidemiol. 1993 Oct;46(10):1075-9; discussion 1081-90.
+#    doi: 10.1016/0895-4356(93)90103-8. PMID: 8410092.
+# 5. Quan H, Sundararajan V, Halfon P, Fong A, Burnand B, Luthi JC, Saunders LD, Beck CA, Feasby TE, Ghali WA.
+#    Coding algorithms for defining comorbidities in ICD-9-CM and ICD-10 administrative data.
+#    Med Care. 2005 Nov;43(11):1130-9.
+#    doi: 10.1097/01.mlr.0000182534.19832.83. PMID: 16224307.
+
+from pathlib import Path
+
+import pandas as pd
+import polars as pl
+
+# Import the generalized function
+from .CustomComorbidityIndex import CustomComorbidityIndex
+
+
+def CharlsonComorbidityIndex(
+    df: pl.DataFrame,
+    id_col: str = "id",
+    code_col: str = "code",
+    age_col: str = "age",
+    icd_version: str = "icd10",
+    icd_version_col: str = None,
+    implementation: str = "quan",
+    return_categories: bool = False,
+):
+    """
+    Calculate the Charlson Comorbidity Index (CCI) using ICD codes and age.
+
+    Args:
+        df (pl.DataFrame): DataFrame with at least columns [id_col, code_col, age_col].
+        id_col (str): Name of the column containing unique identifier. Default: "id".
+        code_col (str): Name of the column containing ICD codes. Default: "code".
+        age_col (str): Name of the column containing patient ages. Default: "age".
+        icd_version (str): ICD version ('icd9', 'icd10', or 'icd9_10'). Default: "icd10".
+        icd_version_col (str, optional): Name of the column with ICD version for 'icd9_10'. Default: None.
+        implementation (str): CCI implementation ('quan', 'deyo', 'romano', 'australia', 'sweden', 'uk_shmi'). Default: "quan".
+        return_categories (bool): If True, also return presence indicators for each CCI category.
+
+    Returns:
+        - DataFrame with [id_col, "Charlson Score"].
+        - DataFrame with category indicators if return_categories is True, else None.
+    """
+
+    # Check if input is pandas DataFrame and convert to polars
+    is_pandas = pd and isinstance(df, pd.DataFrame)
+    if is_pandas:
+        df = pl.from_pandas(df)
+
+    # Change ICD to ICD-9 for Deyo, D'Hoore and Romano
+    if icd_version == "icd10" and implementation in [
+        "deyo",
+        "dhoore",
+        "romano",
+    ]:
+        print(f"Warning: Implementation '{implementation}' only uses ICD-9. Setting ICD version to 'icd9'.") # fmt: skip
+        icd_version = "icd9"
+    # Change ICD to ICD-10 for Australian, Swedish and UK versions
+    elif icd_version == "icd9" and implementation in [
+        "australia",
+        "sweden",
+        "uk_shmi",
+    ]:
+        print(f"Warning: Implementation '{implementation}' only uses ICD-10. Setting ICD version to 'icd10'.") # fmt: skip
+        icd_version = "icd10"
+
+    # Input validation specific to Charlson
+    assert implementation in [
+        "quan",
+        "deyo",
+        "romano",
+        "australia",
+        "sweden",
+        "uk_shmi",
+    ], (
+        "implementation must be one of: "
+        "'quan', 'deyo', 'romano', 'australia', 'sweden', or 'uk_shmi'."
+    )
+    assert (
+        age_col in df.columns
+    ), f"Column '{age_col}' (age) must be present in input DataFrame."
+    assert (
+        id_col in df.columns
+    ), f"Column '{id_col}' (ID) must be present in input DataFrame."
+
+    # STEP 0: select relevant columns and rename diagnosis code column
+    # diagnoses handled by CustomComorbidityIndex
+    patient_ages = df.select(id_col, age_col)
+
+    # STEP 1: Calculate Age Score separately
+    # <= 50: 0
+    # <= 60: 1
+    # <= 70: 2
+    # <= 80: 3
+    #  > 80: 4
+    age_scores = (
+        patient_ages.with_columns(
+            pl.col(age_col)
+            .cut(
+                breaks=[50, 60, 70, 80],
+                labels=["0", "1", "2", "3", "4"],
+                left_closed=False,  # Age > 50 gets score 1, etc.
+            )
+            .fill_null("0")  # Assume age 0 if null
+            .cast(int)
+            .alias("Age Score")
+        )
+        .group_by(id_col)
+        .agg(pl.col("Age Score").max().alias("Age Score"))
+    )
+
+    # STEP 2: Calculate Comorbidity Score using generalized function
+    # Determine definition file based on implementation
+    if implementation == "quan":
+        definition_file = "CHARLSON_QUAN.csv"
+    elif implementation == "deyo":
+        definition_file = "CHARLSON_DEYO.csv"
+    elif implementation == "dhoore":
+        definition_file = "CHARLSON_DHOORE.csv"
+    elif implementation == "romano":
+        definition_file = "CHARLSON_ROMANO.csv"
+    elif implementation == "australia":
+        definition_file = "CHARLSON_AUSTRALIA.csv"
+    elif implementation == "sweden":
+        definition_file = "CHARLSON_SWEDEN.csv"
+    elif implementation == "uk_shmi":
+        definition_file = "CHARLSON_UK_SHMI_v1.55.csv"
+    else:
+        # Should be caught by assert earlier
+        raise ValueError(f"Unsupported implementation: {implementation}")
+
+    definition_file_path = Path(__file__).parent / f"common/{definition_file}"
+    weight_col_name = "weights"
+
+    # Use a temporary score name before adding age score
+    score_col_name = "Charlson Comorbidity Score"
+
+    # Define mutual exclusion rules for Charlson
+    # These category names are common across Quan, Romano, Deyo
+    mutual_exclusion_rules = [
+        (
+            "Diabetes with chronic complication",
+            "Diabetes without chronic complication",
+        ),
+        ("Moderate or severe liver disease", "Mild liver disease"),
+    ]
+    # Adjust rules for specific implementations if category names differ
+    if implementation == "australia" or implementation == "uk_shmi":
+        mutual_exclusion_rules = [
+            ("Diabetes complications", "Diabetes"),
+            ("Severe liver disease", "Liver disease"),
+        ]
+    elif implementation == "sweden":
+        mutual_exclusion_rules = [
+            ("Diabetes with end organ damage", "Diabetes"),
+            # Sweden uses 'Moderate or severe kidney disease' - no specific liver exclusion rule needed based on provided names
+            # Sweden splits Pulmonary disease - no exclusion needed between them
+        ]
+
+    df_charlson = CustomComorbidityIndex(
+        df=df,
+        id_col=id_col,
+        code_col=code_col,
+        icd_version=icd_version,
+        icd_version_col=icd_version_col,
+        definition_data=definition_file_path,
+        weight_col_name=weight_col_name,
+        score_col_name=score_col_name,
+        mutual_exclusion_rules=mutual_exclusion_rules,
+        return_categories=return_categories,
+    )
+
+    # STEP 3: Combine Age Score and Comorbidity Score
+    final_score_col_name = "Charlson Score"
+    df_charlson = df_charlson.join(
+        age_scores, on=id_col, how="left", coalesce=True
+    ).with_columns(
+        (pl.col(score_col_name) + pl.col("Age Score")).alias(
+            final_score_col_name
+        )
+    )
+
+    # Drop Age Score column if not needed
+    if not return_categories:
+        df_charlson = df_charlson.drop("Age Score")
+
+    if is_pandas:
+        return df_charlson.to_pandas()
+
+    return df_charlson
+
+
+# region 10y survival
+def CharlsonComorbidity_10year_survival(
+    df: pl.DataFrame = None,
+    id_col: str = "id",
+    code_col: str = "code",
+    age_col: str = "age",
+    icd_version: str = "icd10",
+    icd_version_col: str = None,
+    implementation: str = "quan",
+    precalculated_df: bool = False,
+) -> pl.DataFrame:
+    """
+    Calculate the 10-year survival probability based on the Charlson Comorbidity Index.
+
+    Args:
+        df (pl.DataFrame): DataFrame with at least columns [id_col, code_col, age_col] or [id_col, "Charlson Score"] if precalculated_df is True.
+        id_col (str): Name of the column containing unique identifier. Default: "id".
+        code_col (str): Name of the column containing ICD codes. Default: "code".
+        age_col (str): Name of the column containing patient ages. Default: "age".
+        icd_version (str): ICD version ('icd9', 'icd10', or 'icd9_10'). Default: "icd10".
+        icd_version_col (str, optional): Name of the column with ICD version for 'icd9_10'. Default: None.
+        implementation (str): The Charlson implementation. Default: "quan".
+        precalculated_df (bool): If True, df is expected to contain a "Charlson Score" column instead of ICD codes and age.
+
+    Returns:
+        pl.DataFrame: DataFrame with columns [id_col, "10-year survival probability"].
+    """
+
+    if not precalculated_df:
+        df, _ = CharlsonComorbidityIndex(
+            df=df,
+            id_col=id_col,
+            code_col=code_col,
+            age_col=age_col,
+            icd_version=icd_version,
+            icd_version_col=icd_version_col,
+            implementation=implementation,
+            return_categories=False,
+        )
+    else:
+        assert (
+            "Charlson Score" in df.columns
+        ), "Input DataFrame must contain column 'Charlson Score'."
+        assert (
+            id_col in df.columns
+        ), f"Input DataFrame must contain column '{id_col}'."
+
+    # Formula: 0.983 ^ (CCI Score * 0.9)
+    return df.with_columns(
+        (pl.lit(0.983) ** (pl.col("Charlson Score").clip(lower_bound=0) * 0.9))
+        .round(3)
+        .alias("10-year survival probability")
+    ).select(id_col, "10-year survival probability")

pycomorb/CustomComorbidityIndex.py

@@ -0,0 +1,255 @@
+from pathlib import Path
+from typing import List, Optional, Tuple, Union
+
+import pandas as pd
+import polars as pl
+
+
+def CustomComorbidityIndex(
+    df: pl.DataFrame,
+    id_col: str = "id",
+    code_col: str = "code",
+    icd_version: str = "icd10",
+    icd_version_col: str = None,
+    definition_data: Union[Path, pl.DataFrame] = None,
+    weight_col_name: str = None,
+    score_col_name: str = None,
+    mutual_exclusion_rules: Optional[List[Tuple[str, str]]] = None,
+    return_categories=False,
+):
+    """
+    Generic comorbidity index calculation from ICD codes.
+
+    Args:
+        df (pl.DataFrame): DataFrame with at least columns [id_col, code_col].
+        id_col (str): Name of the column containing unique identifier. Default: "id".
+        code_col (str): Name of the column containing ICD codes. Default: "code".
+        icd_version (str): ICD version ('icd9', 'icd10', or 'icd9_10'). Default: "icd10".
+        icd_version_col (str, optional): Name of the column with ICD version for 'icd9_10'. Default: None.
+        definition_data (Path or pl.DataFrame): Path to CSV or DataFrame with ICD definitions and weights.
+        weight_col_name (str): Name of the column with weights in definition_data.
+        score_col_name (str): Name for the calculated score column.
+        mutual_exclusion_rules (list of tuple, optional): List of (complicated, uncomplicated) category pairs.
+        return_categories (bool): If True, also return presence indicators for each category.
+
+    Returns:
+        - DataFrame with [id_col, score_col_name].
+        - DataFrame with category indicators if return_categories is True, else None.
+    """
+
+    # Check if input is pandas DataFrame and convert to polars
+    is_pandas = pd and isinstance(df, pd.DataFrame)
+    if is_pandas:
+        df = pl.from_pandas(df)
+
+    # Input validation
+    assert icd_version in [
+        "icd9",
+        "icd10",
+        "icd9_10",
+    ], f"icd_version must be one of: 'icd9', 'icd10', or 'icd9_10'. Got '{icd_version}'."
+    assert (
+        code_col in df.columns
+    ), f"Column '{code_col}' (ICD code) must be present in input DataFrame."
+    assert (
+        id_col in df.columns
+    ), f"Column '{id_col}' (ID) must be present in input DataFrame."
+    if icd_version == "icd9_10":
+        assert (
+            icd_version_col is not None and icd_version_col in df.columns
+        ), f"For icd9_10, '{icd_version_col}' (ICD version) column must be present in input DataFrame."
+
+    # Load definitions
+    if isinstance(definition_data, Path):
+        definitions = pl.read_csv(definition_data, separator=",")
+    else:
+        definitions = definition_data
+
+    assert (
+        "category" in definitions.columns
+    ), "'category' column not found in definition file."
+    assert (
+        weight_col_name in definitions.columns
+    ), f"'{weight_col_name}' column not found in definition file."
+
+    # Drop rows from df with missing codes
+    df = df.filter(pl.col(code_col).is_not_null())
+
+    def process_single_icd(df, icd_col_name):
+        # Prepare mapping DataFrame: code_col, category
+        code_map_rows = []
+        for row in definitions.iter_rows(named=True):
+            if row["category"] is None or row.get(icd_col_name) is None:
+                continue
+            for code in row[icd_col_name].split("|"):
+                code_map_rows.append(
+                    {"prefix": code.strip(), "category": row["category"]}
+                )
+        code_map = pl.DataFrame(code_map_rows)
+
+        # Create dataframe with presence indicators
+        categories = code_map.select("category").unique()
+        categories_list = categories.to_series().to_list()
+        categories_df = categories.with_columns(
+            pl.when(pl.col("category") == category)
+            .then(pl.lit(1))
+            .otherwise(pl.lit(0))
+            .alias(category)
+            for category in categories_list
+        )
+
+        # Get all unique ICD codes in the data
+        code_prefixes = code_map.select("prefix").to_series()
+        unique_codes = df.select(code_col).unique()
+        longest_code = max(unique_codes.to_series().to_list(), key=len)
+
+        # Create a DataFrame with all possible prefixes, then find the best match
+        best_prefix = (
+            unique_codes.with_columns(
+                pl.col(code_col).str.slice(0, n).alias(f"prefix_{n}")
+                for n in range(1, len(longest_code) + 1)
+            )
+            .with_columns(
+                pl.when(pl.col(f"prefix_{n}").is_in(code_prefixes))
+                .then(pl.col(f"prefix_{n}"))
+                .otherwise(None)
+                .alias(f"prefix_{n}")
+                for n in range(1, len(longest_code) + 1)
+            )
+            # Count ICD code as present for each comorbidity it matches
+            .with_columns(
+                pl.concat_list(
+                    pl.col(f"prefix_{n}")
+                    for n in range(1, len(longest_code) + 1)
+                )
+                .list.drop_nulls()
+                .list.unique()
+                .alias("best_prefixes")
+            )
+            .explode("best_prefixes")
+            .rename({"best_prefixes": "best_prefix"})
+            .select(code_col, "best_prefix")
+            .drop_nulls("best_prefix")
+        )
+
+        (
+            unique_codes.with_columns(
+                pl.col(code_col).str.slice(0, n).alias(f"prefix_{n}")
+                for n in range(1, len(longest_code) + 1)
+            )
+            .with_columns(
+                pl.when(pl.col(f"prefix_{n}").is_in(code_prefixes))
+                .then(pl.col(f"prefix_{n}"))
+                .otherwise(None)
+                .alias(f"prefix_{n}")
+                for n in range(1, len(longest_code) + 1)
+            )
+            .with_columns(
+                pl.concat_list(
+                    pl.col(f"prefix_{n}")
+                    for n in range(1, len(longest_code) + 1)
+                )
+                .list.drop_nulls()
+                .list.unique()
+                .list.join(", ")
+                .alias("best_prefixes")
+            )
+            .write_csv("best_prefix.csv")
+        )
+
+        code_to_category = (
+            best_prefix.join(
+                code_map, left_on="best_prefix", right_on="prefix", how="left"
+            )
+            .select(code_col, "category")
+            .join(categories_df, on="category", how="left")
+            .select(code_col, *categories_list)
+        )
+
+        # Join diagnoses with code_to_category to get the best matching category for each diagnosis
+        df_presence_absence = (
+            df.join(code_to_category, on=code_col, how="left")
+            .group_by(id_col)
+            .agg(pl.max(cat).fill_null(0).alias(cat) for cat in categories_list)
+        )
+
+        # Add missing columns
+        for cat in categories_list:
+            if cat not in df_presence_absence.columns:
+                df_presence_absence = df_presence_absence.with_columns(
+                    pl.lit(0).alias(cat)
+                )
+        df_presence_absence = df_presence_absence.select(
+            [id_col] + categories_list
+        )
+        return df_presence_absence, categories_list
+
+    if icd_version == "icd9_10":
+        # Split by icd_version_col
+        df_icd9 = df.filter(pl.col(icd_version_col).cast(str) == "ICD-9")
+        df_icd10 = df.filter(pl.col(icd_version_col).cast(str) != "ICD-9")
+
+        # Process each ICD version separately
+        df9, cats9 = process_single_icd(df_icd9, "icd9_codes")
+        df10, cats10 = process_single_icd(df_icd10, "icd10_codes")
+
+        # Combine: outer join on id_col, take max for each category
+        all_categories = sorted(set(cats9) | set(cats10))
+        df_combined = df9.join(df10, on=id_col, how="outer", suffix="_right")
+        for cat in all_categories:
+            left = cat
+            right = f"{cat}_right"
+            if left in df_combined.columns and right in df_combined.columns:
+                df_combined = df_combined.with_columns(
+                    pl.max_horizontal(pl.col(left), pl.col(right)).alias(cat)
+                )
+            elif right in df_combined.columns:
+                df_combined = df_combined.rename({right: cat})
+        df_presence_absence = df_combined.select([id_col] + all_categories)
+    else:
+        icd_col_name = f"{icd_version}_codes"
+        df_presence_absence, all_categories = process_single_icd(
+            df, icd_col_name
+        )
+
+    # STEP 2: calculate score
+    category_weights = dict(
+        zip(definitions["category"], definitions[weight_col_name])
+    )
+    category_weights = {
+        k: v
+        for k, v in category_weights.items()
+        if k is not None and v is not None
+    }
+
+    # Apply mutual exclusion rules
+    if mutual_exclusion_rules:
+        for complicated, uncomplicated in mutual_exclusion_rules:
+            if (
+                complicated in df_presence_absence.columns
+                and uncomplicated in df_presence_absence.columns
+            ):
+                df_presence_absence = df_presence_absence.with_columns(
+                    pl.when(pl.col(complicated) == 1)
+                    .then(0)
+                    .otherwise(pl.col(uncomplicated))
+                    .alias(uncomplicated)
+                )
+
+    # calculate scores
+    # Ensure weights are applied only to existing category columns that have weights
+    score_expr = pl.sum_horizontal(
+        pl.col(cat) * category_weights.get(cat, 0)
+        for cat in all_categories
+        if cat in df_presence_absence.columns and cat in category_weights
+    ).alias(score_col_name)
+
+    cols = [id_col] + all_categories if return_categories else [id_col]
+    comorbidity_df = df_presence_absence.select(*cols, score_expr).cast(
+        {score_col_name: int}
+    )
+
+    if is_pandas:
+        comorbidity_df = comorbidity_df.to_pandas()
+
+    return comorbidity_df

pycomorb/ElixhauserComorbidityIndex.py

@@ -0,0 +1,153 @@
+# Reference for ECI:
+# 1. van Walraven C, Austin PC, Jennings A, Quan H, Forster AJ.
+#    A modification of the Elixhauser comorbidity measures into a point system for hospital death using administrative data.
+#    Med Care. 2009 Jun;47(6):626-33.
+#    doi: 10.1097/MLR.0b013e31819432e5. PMID: 19433995.
+# 2. Elixhauser A, Steiner C, Harris DR, Coffey RM.
+#    Comorbidity measures for use with administrative data.
+#    Med Care. 1998 Jan;36(1):8-27.
+#    doi: 10.1097/00005650-199801000-00004. PMID: 9431328.
+#
+# Reference for ICD-9-CM and ICD-10 Coding Algorithms for Elixhauser Comorbidities:
+# 3. Quan H, Sundararajan V, Halfon P, Fong A, Burnand B, Luthi JC, Saunders LD, Beck CA, Feasby TE, Ghali WA.
+#    Coding algorithms for defining comorbidities in ICD-9-CM and ICD-10 administrative data.
+#    Med Care. 2005 Nov;43(11):1130-9.
+#    doi: 10.1097/01.mlr.0000182534.19832.83. PMID: 16224307.
+# 4. Original Elixhauser definitions (used when implementation='elixhauser')
+# 5. AHRQ definitions (used when implementation='ahrq_icd9' or 'ahrq_icd10')
+
+from pathlib import Path
+
+import pandas as pd
+import polars as pl
+
+# Import the generalized function
+from .CustomComorbidityIndex import CustomComorbidityIndex
+
+
+def ElixhauserComorbidityIndex(
+    df: pl.DataFrame,
+    id_col: str = "id",
+    code_col: str = "code",
+    icd_version: str = "icd10",
+    icd_version_col: str = None,
+    implementation: str = "quan",
+    weights: str = "van_walraven",
+    return_categories=False,
+):
+    """
+    Calculate the Elixhauser Comorbidity Index (ECI) using ICD codes.
+
+    Args:
+        df (pl.DataFrame): DataFrame with at least columns [id_col, code_col].
+        id_col (str): Name of the column containing unique identifier. Default: "id".
+        code_col (str): Name of the column containing ICD codes. Default: "code".
+        icd_version (str): ICD version ('icd9', 'icd10', or 'icd9_10'). Default: "icd10".
+        icd_version_col (str, optional): Name of the column with ICD version for 'icd9_10'. Default: None.
+        implementation (str): Coding algorithm ('quan' or 'elixhauser'). Default: "quan".
+        weights (str): Weighting scheme ('van_walraven', 'thompson_30', 'thompson_29', 'ahrq'). Default: "van_walraven".
+        return_categories (bool): If True, also return presence indicators for each ECI category.
+
+    Returns:
+        - DataFrame with [id_col, score_col_name].
+        - DataFrame with category indicators if return_categories is True, else None.
+    """
+
+    # Check if input is pandas DataFrame and convert to polars
+    is_pandas = pd and isinstance(df, pd.DataFrame)
+    if is_pandas:
+        df = pl.from_pandas(df)
+
+    # Change ICD to ICD-9 for original Elixhauser and AHRQ ICD-9
+    if icd_version == "icd10" and implementation in [
+        "elixhauser",
+        "ahrq_icd9",
+    ]:
+        print(f"Warning: Implementation '{implementation}' only uses ICD-9. Setting ICD version to 'icd9'.")  # fmt: skip
+        icd_version = "icd9"
+    # Change ICD to ICD-10 for AHRQ ICD-10
+    if icd_version == "icd9" and implementation in ["ahrq_icd10"]:
+        print(f"Warning: Implementation '{implementation}' only uses ICD-10. Setting ICD version to 'icd10'.") # fmt: skip
+        icd_version = "icd10"
+
+    # Input validation specific to Elixhauser
+    assert implementation in [
+        "quan",
+        "elixhauser",
+    ], "implementation must be one of: 'quan', 'elixhauser'."
+    assert weights in [
+        "van_walraven",
+        "thompson_30",
+        "thompson_29",
+        "ahrq",
+    ], "weights must be one of: 'van_walraven', 'thompson_30', 'thompson_29', or 'ahrq'."
+
+    # Determine definition file based on implementation
+    if implementation == "quan":
+        definition_file = "ELIXHAUSER_QUAN.csv"
+    elif implementation == "elixhauser":
+        definition_file = "ELIXHAUSER.csv"
+    else:
+        # Should be caught by assert earlier, but as a safeguard
+        raise ValueError(f"Unsupported implementation: {implementation}")
+
+    # Determine weight column and score column names based on weights argument
+    if weights == "van_walraven":
+        weight_col_name = "van_walraven_weights"
+        score_col_name = "Elixhauser van Walraven Score"
+    elif weights == "thompson_30":
+        weight_col_name = "Thompson_30_weights"
+        score_col_name = "Elixhauser Thompson(30) Score"
+    elif weights == "thompson_29":
+        weight_col_name = "Thompson_29_weights"
+        score_col_name = "Elixhauser Thompson(29) Score"
+    elif weights == "ahrq":
+        weight_col_name = "AHRQ_weights"
+        score_col_name = "Elixhauser AHRQ Score"
+    else:
+        # Should be caught by assert earlier, but as a safeguard
+        raise ValueError(f"Unsupported weights scheme: {weights}")
+
+    # Load definition and weight files
+    base_path = Path(__file__).parent / "common/"
+    definition_file_path = base_path / definition_file
+    weights_file_path = base_path / "ELIXHAUSER_WEIGHTS.csv"
+
+    df_definitions = pl.read_csv(definition_file_path)
+    df_weights = pl.read_csv(weights_file_path).drop("index")
+
+    # Join definitions and weights
+    # Ensure 'category' column exists in both for joining
+    if (
+        "category" not in df_definitions.columns
+        or "category" not in df_weights.columns
+    ):
+        raise ValueError("Both definition and weight files must contain a 'category' column.") # fmt: skip
+
+    # Perform the join
+    df_combined = df_definitions.join(df_weights, on="category", how="left")
+
+    # Define mutual exclusion rules for Elixhauser
+    mutual_exclusion_rules = [
+        ("Diabetes complicated", "Diabetes uncomplicated"),
+        ("Hypertension complicated", "Hypertension uncomplicated"),
+    ]
+
+    # Call the generalized function with the combined DataFrame
+    df_elixhauser = CustomComorbidityIndex(
+        df=df,
+        id_col=id_col,
+        code_col=code_col,
+        icd_version=icd_version,
+        icd_version_col=icd_version_col,
+        definition_data=df_combined,
+        weight_col_name=weight_col_name,
+        score_col_name=score_col_name,
+        mutual_exclusion_rules=mutual_exclusion_rules,
+        return_categories=return_categories,
+    )
+
+    if is_pandas:
+        return df_elixhauser.to_pandas()
+
+    return df_elixhauser