meta-edc 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

meta_ae/admin/modeladmin_mixins.py

@@ -70,7 +70,6 @@ class AeReviewModelAdminMixin(
 
     search_fields: Tuple[str, ...] = (
         "action_identifier",
-        "ae_initial__tracking_identifier",
         "ae_initial__subject_identifier",
         "ae_initial__action_identifier",
     )

meta_analytics/dataframes/__init__.py

@@ -8,6 +8,9 @@ from .constants import (
     endpoint_columns,
 )
 from .get_eos_df import get_eos_df
+from .get_glucose_df import get_glucose_df
+from .get_glucose_fbg_df import get_glucose_fbg_df
+from .get_glucose_fbg_ogtt_df import get_glucose_fbg_ogtt_df
 from .get_last_imp_visits_df import get_last_imp_visits_df
 from .glucose_endpoints import EndpointByDate, GlucoseEndpointsByDate
 from .screening import get_glucose_tested_only_df, get_screening_df

meta_analytics/dataframes/constants.py

@@ -16,7 +16,7 @@ endpoint_columns = [
     "fbg_value",
     "ogtt_value",
     "fbg_datetime",
-    "fasting",
+    "fasted",
     "endpoint_label",
     "endpoint_type",
     "endpoint",

meta_analytics/dataframes/enrolled/__init__.py

@@ -1 +0,0 @@
-from .get_glucose_df import get_glucose_df

meta_analytics/dataframes/get_eos_df.py

@@ -13,14 +13,27 @@ def get_eos_df() -> pd.DataFrame:
     df_eos = get_eos("meta_prn.endofstudy")
     df_visit = get_subject_visit("meta_subject.subjectvisit")
     df_last_visit = (
-        df_visit.groupby(["subject_identifier", "site"])
+        df_visit.groupby(["subject_identifier", "site_id"])
         .agg({"endline_visit_code": "max", "endline_visit_datetime": "max"})
         .reset_index()
     )
-    df_last_visit = df_last_visit.rename(columns={"site": "site_id"})
+    # df_last_visit = df_last_visit.rename(columns={"site": "site_id"})
 
     df_eos = df_eos.merge(
         df_last_visit, on="subject_identifier", how="left", suffixes=("", "_y")
     )
     df_eos = df_eos.drop(columns=["site_id_y"])
+    df_visit_grp = (
+        df_visit.groupby(by=["subject_identifier"])[["baseline_datetime", "visit_datetime"]]
+        .max()
+        .reset_index()
+    )
+    df_visit_grp["followup_days"] = (
+        df_visit_grp["visit_datetime"] - df_visit_grp["baseline_datetime"]
+    ).dt.days
+    df_eos = df_eos.merge(
+        df_visit_grp[["subject_identifier", "followup_days"]],
+        on="subject_identifier",
+        how="left",
+    ).reset_index(drop=True)
     return df_eos

meta_analytics/dataframes/get_glucose_df.py

@@ -0,0 +1,149 @@
+import numpy as np
+import pandas as pd
+from django_pandas.io import read_frame
+from edc_appointment.constants import MISSED_APPT  # noqa
+from edc_pdutils.dataframes import get_eos, get_subject_consent, get_subject_visit
+
+from meta_subject.models import Glucose, GlucoseFbg
+
+
+def get_glucose_df() -> pd.DataFrame:
+    subject_visit_df = (
+        get_subject_visit("meta_subject.subjectvisit")
+        .rename(columns={"id": "subject_visit_id"})
+        .query("appt_timing!=@MISSED_APPT")
+    )
+    df_glucose_fbg = read_frame(GlucoseFbg.objects.all(), verbose=False).rename(
+        columns={"fasting": "fasted", "subject_visit": "subject_visit_id"},
+    )
+    df_glucose_fbg["fasting_hrs"] = np.nan
+    df_glucose_fbg["fasting_hrs"] = df_glucose_fbg["fasting_duration_delta"].apply(
+        lambda x: x.total_seconds() / 3600
+    )
+    df_glucose_fbg.loc[
+        :,
+        ["ogtt_value", "ogtt_units", "ogtt_datetime"],
+    ] = [np.nan, None, pd.NaT]
+    df_glucose_fbg["source"] = "meta_subject.glucosefbg"
+    df_glucose_fbg = pd.merge(
+        subject_visit_df[
+            [
+                "subject_identifier",
+                "site_id",
+                "visit_code",
+                "visit_datetime",
+                "baseline_datetime",
+                "subject_visit_id",
+            ]
+        ],
+        df_glucose_fbg[[col for col in df_glucose_fbg.columns if "site_id" not in col]],
+        on="subject_visit_id",
+        how="left",
+    )
+
+    df_glucose = read_frame(Glucose.objects.all(), verbose=False).rename(
+        columns={"subject_visit": "subject_visit_id", "fasting": "fasted"}
+    )
+    df_glucose["fasting_hrs"] = np.nan
+    df_glucose["fasting_hrs"] = df_glucose["fasting_duration_delta"].apply(
+        lambda x: x.total_seconds() / 3600
+    )
+    df_glucose["source"] = "meta_subject.glucose"
+
+    df_glucose = pd.merge(
+        subject_visit_df[
+            [
+                "subject_identifier",
+                "site_id",
+                "visit_code",
+                "visit_datetime",
+                "baseline_datetime",
+                "subject_visit_id",
+            ]
+        ],
+        df_glucose[[col for col in df_glucose.columns if "site_id" not in col]],
+        on="subject_visit_id",
+        how="left",
+    )
+
+    keep_cols = [
+        "subject_identifier",
+        "site_id",
+        "visit_code",
+        "visit_datetime",
+        "baseline_datetime",
+        "subject_visit_id",
+        "fasted",
+        "fasting_hrs",
+        "fbg_value",
+        "fbg_units",
+        "fbg_datetime",
+        "ogtt_value",
+        "ogtt_units",
+        "ogtt_datetime",
+        "source",
+        "revision",
+        "report_datetime",
+    ]
+    df = pd.merge(
+        df_glucose[keep_cols],
+        df_glucose_fbg[keep_cols],
+        on="subject_visit_id",
+        how="outer",
+        # indicator=True,
+        suffixes=("", "_2"),
+    )
+
+    for suffix in ["", "_2"]:
+        df[[f"fasting_hrs{suffix}", f"fbg_value{suffix}", f"ogtt_value{suffix}"]] = df[
+            [f"fasting_hrs{suffix}", f"fbg_value{suffix}", f"ogtt_value{suffix}"]
+        ].apply(pd.to_numeric)
+        df.loc[
+            (df[f"fbg_units{suffix}"] != "mmol/L (millimoles/L)")
+            & (df[f"fbg_value{suffix}"] >= 0),
+            f"fbg_units{suffix}",
+        ] = "mmol/L (millimoles/L)"
+        df.loc[
+            (df[f"ogtt_units{suffix}"] != "mmol/L (millimoles/L)")
+            & (df[f"ogtt_value{suffix}"] >= 0),
+            f"ogtt_units{suffix}",
+        ] = "mmol/L (millimoles/L)"
+
+    # reconcile all to single column
+    for col in ["fasted", "fbg_value", "ogtt_value", "fbg_datetime", "ogtt_datetime"]:
+        df.loc[(df[col].isna()) & (df[f"{col}_2"].notna()), col] = df[f"{col}_2"]
+
+    df_consent = get_subject_consent("meta_consent.subjectconsent")
+    df_eos = get_eos("meta_prn.endofstudy")
+    df = df.merge(
+        df_consent[["subject_identifier", "gender", "consent_datetime", "dob"]],
+        on="subject_identifier",
+        how="left",
+    ).merge(
+        df_eos[["subject_identifier", "offstudy_datetime", "offstudy_reason"]],
+        on="subject_identifier",
+        how="left",
+    )
+
+    df[[col for col in df.columns if "datetime" in col]] = df[
+        [col for col in df.columns if "datetime" in col]
+    ].apply(lambda x: x.dt.tz_localize(None) if x.dtype == "datetime64[ns, UTC]" else x)
+
+    df["visit_days"] = df["baseline_datetime"].rsub(df["visit_datetime"]).dt.days
+    df["fgb_days"] = df["baseline_datetime"].rsub(df["fbg_datetime"]).dt.days
+    df["ogtt_days"] = df["baseline_datetime"].rsub(df["ogtt_datetime"]).dt.days
+    df["visit_days"] = pd.to_numeric(df["visit_days"], downcast="integer")
+    df["fgb_days"] = pd.to_numeric(df["fgb_days"], downcast="integer")
+    df["ogtt_days"] = pd.to_numeric(df["ogtt_days"], downcast="integer")
+
+    df = (
+        df.query(
+            "offstudy_reason != 'Patient fulfilled late exclusion criteria "
+            "(due to abnormal blood values or raised blood pressure at enrolment'"
+        )
+        .copy()
+        .drop(columns=[col for col in df.columns if "_2" in col])
+        .sort_values(by=["subject_identifier", "visit_code"])
+        .reset_index(drop=True)
+    )
+    return df

meta_analytics/dataframes/get_glucose_fbg_df.py

@@ -0,0 +1,27 @@
+import pandas as pd
+from edc_constants.constants import NO, YES
+from edc_pdutils.dataframes import get_crf
+
+from meta_analytics.dataframes.utils import calculate_fasting_hrs
+
+__all__ = ["get_glucose_fbg_df"]
+
+
+def get_glucose_fbg_df(subject_identifiers: list[str] | None = None) -> pd.DataFrame:
+    """Returns a prepared Dataframe of CRF
+    meta_subject.glucosefbg.
+
+    Note: meta_subject.glucosefbg has only FBG measures.
+    """
+    df = get_crf(
+        model="meta_subject.glucosefbg",
+        subject_identifiers=subject_identifiers or [],
+        subject_visit_model="meta_subject.subjectvisit",
+    )
+    df["source"] = "meta_subject.glucosefbg"
+    df.rename(columns={"fbg_fasting": "fasting"}, inplace=True)
+    df.loc[(df["fasting"] == "fasting"), "fasting"] = YES
+    df.loc[(df["fasting"] == "non_fasting"), "fasting"] = NO
+    df = calculate_fasting_hrs(df)
+    df = df.reset_index(drop=True)
+    return df

meta_analytics/dataframes/get_glucose_fbg_ogtt_df.py

@@ -0,0 +1,22 @@
+import pandas as pd
+from edc_pdutils.dataframes import get_crf
+
+from .utils import calculate_fasting_hrs
+
+__all__ = ["get_glucose_fbg_ogtt_df"]
+
+
+def get_glucose_fbg_ogtt_df(subject_identifiers: list[str] | None = None) -> pd.DataFrame:
+    """Returns a prepared Dataframe of CRF meta_subject.glucose.
+
+    Note: meta_subject.glucose has FBG and OGTT measures.
+    """
+    df = get_crf(
+        model="meta_subject.glucose",
+        subject_identifiers=subject_identifiers or [],
+        subject_visit_model="meta_subject.subjectvisit",
+    )
+    df["source"] = "meta_subject.glucose"
+    df = calculate_fasting_hrs(df)
+    df = df.reset_index(drop=True)
+    return df

meta_analytics/dataframes/glucose_endpoints/endpoint_by_date.py

@@ -1,3 +1,5 @@
+from dataclasses import dataclass, field
+
 import numpy as np
 import pandas as pd
 from edc_constants.constants import YES
@@ -13,6 +15,97 @@ class InvalidCaseList(Exception):
     pass
 
 
+@dataclass(kw_only=True)
+class CaseData:
+    df: pd.DataFrame
+    index: int
+    fbg_value: float | None = field(default=None, init=False)
+    fbg_datetime: pd.Timestamp | None = field(default=None, init=False)
+    fasted: str | None = field(default=None, init=False)
+    ogtt_value: float | None = field(default=None, init=False)
+    next_fbg_value: float | None = field(default=None, init=False)
+    next_fbg_datetime: pd.Timestamp | None = field(default=None, init=False)
+    next_fasted: str | None = field(default=None, init=False)
+    next_ogtt_value: float | None = field(default=None, init=False)
+
+    previous_fbg_value: float | None = field(default=None, init=False)
+    previous_fbg_datetime: pd.Timestamp | None = field(default=None, init=False)
+    previous_fasted: str | None = field(default=None, init=False)
+    previous_ogtt_value: float | None = field(default=None, init=False)
+
+    fbg_threshold: float = field(default=7.0, init=False)
+    ogtt_threshold: float = field(default=11.1, init=False)
+
+    def __post_init__(self):
+        self.fbg_value = self.df.loc[self.index, "fbg_value"]
+        self.fbg_datetime = self.df.loc[self.index, "fbg_datetime"]
+        self.ogtt_value = self.df.loc[self.index, "ogtt_value"]
+        self.fasted = self.df.loc[self.index, "fasted"]
+
+        try:
+            self.next_fbg_value = self.df.loc[self.index + 1, "fbg_value"]
+        except KeyError:
+            self.next_fbg_value = np.nan
+            self.next_fbg_datetime = pd.NaT
+            self.next_ogtt_value = np.nan
+            self.next_fasted = np.nan
+        else:
+            self.next_fbg_datetime = self.df.loc[self.index + 1, "fbg_datetime"]
+            self.next_ogtt_value = self.df.loc[self.index + 1, "ogtt_value"]
+            self.next_fasted = self.df.loc[self.index + 1, "fasted"]
+
+        try:
+            self.previous_fbg_value = self.df.loc[self.index - 1, "fbg_value"]
+        except KeyError:
+            self.previous_fbg_value = np.nan
+            self.previous_fbg_datetime = pd.NaT
+            self.previous_ogtt_value = np.nan
+            self.previous_fasted = np.nan
+        else:
+            self.previous_fbg_datetime = self.df.loc[self.index - 1, "fbg_datetime"]
+            self.previous_ogtt_value = self.df.loc[self.index - 1, "ogtt_value"]
+            self.previous_fasted = self.df.loc[self.index - 1, "fasted"]
+
+    def case_two(self) -> bool:
+        """ "FBG >= 7 x 2, first OGTT<=11.1"""
+        if (
+            self.fbg_value >= self.fbg_threshold
+            and self.next_fbg_value >= self.fbg_threshold
+            and 0.0 < self.ogtt_value < self.ogtt_threshold
+            and self.fasted == YES
+            and self.next_fasted == YES
+            and (self.next_fbg_datetime.date() - self.fbg_datetime.date()).days > 6
+        ):
+            return True
+        return False
+
+    def case_three(self) -> bool:
+        """ "FBG >= 7 x 2, second OGTT<=11.1"""
+        if (
+            self.fbg_value >= self.fbg_threshold
+            and self.next_fbg_value >= self.fbg_threshold
+            and 0.0 < self.next_ogtt_value < self.ogtt_threshold
+            and self.fasted == YES
+            and self.next_fasted == YES
+            and (self.next_fbg_datetime.date() - self.fbg_datetime.date()).days > 6
+        ):
+            return True
+        return False
+
+    def case_two_reversed(self) -> bool:
+        """Same as case 2, but with the previous FBG reading."""
+        if (
+            self.fbg_value >= self.fbg_threshold
+            and self.previous_fbg_value >= self.fbg_threshold
+            and 0.0 < self.previous_ogtt_value < self.ogtt_threshold
+            and self.fasted == YES
+            and self.previous_fasted == YES
+            and (self.fbg_datetime.date() - self.previous_fbg_datetime.date()).days > 6
+        ):
+            return True
+        return False
+
+
 class EndpointByDate:
     """Given all timepoints for a subject, flag the first timepoint
     where the protocol endpoint is reached.
@@ -27,157 +120,50 @@ class EndpointByDate:
       * case 3.  FBG >= 7 x 2, second OGTT<11.1
 
     Additional criteria considered:
-      1. any threshhold FBG must be taken while fasted (fasting=YES)
+      1. any threshhold FBG must be taken while fasted (fasted=YES)
       2. threshhold FBG readings must be consecutive (no
          readings below threshold in the sequence regardless
          of fasting)
       3. at least 7 days between threshhold FBG readings.
       4. at least one of the two threshold FBG readings must be taken
          with an OGTT at the same timepoint.
-
-    Note:
-        case 4 is not a protocol endpoint. It considers only FBG and fasting.
-        It looks for two consecutive fasted threshold FBG readings.
     """
 
-    valid_case_list = [2, 3, 4]
-
     def __init__(
         self,
         subject_df: pd.DataFrame = None,
         fbg_threshhold: float = None,
         ogtt_threshhold: float = None,
-        case_list: list[int] | None = None,
     ):
         self.row = None
         self.index = None
-        self.subject_df = subject_df[subject_df["fbg_value"].notna()]
-        self.subject_df = self.subject_df.reset_index(drop=True)
+        self.subject_df = subject_df.sort_values(by=["visit_code"]).reset_index(drop=True)
         self.fbg_threshhold = fbg_threshhold
         self.ogtt_threshhold = ogtt_threshhold
-        self.case_list = case_list or [2, 3]
-        if [x for x in self.case_list if x not in self.valid_case_list]:
-            raise InvalidCaseList(f"Expected any of {self.valid_case_list}. Got {case_list}.")
-        self.endpoint_cases = {k: v for k, v in endpoint_cases.items() if k in self.case_list}
         self.evaluate()
 
     def evaluate(self):
         for index, _ in self.subject_df.iterrows():
-            if 2 in self.case_list and self.case_two(index):
+            case_data = CaseData(df=self.subject_df, index=index)
+            if case_data.case_two():
+                self.endpoint_reached(index, case=2, fbg_datetime=case_data.next_fbg_datetime)
                 break
-            elif 3 in self.case_list and self.case_three(index):
+            elif case_data.case_three():
+                self.endpoint_reached(index, case=3, fbg_datetime=case_data.next_fbg_datetime)
                 break
-            elif 4 in self.case_list and self.case_four(index):
+            elif case_data.case_two_reversed():
+                self.endpoint_reached(index, case=2, fbg_datetime=case_data.fbg_datetime)
                 break
+            else:
+                pass
 
-    def endpoint_reached(self, index: int, case: int, next_is_endpoint: bool | None = None):
+    def endpoint_reached(self, index: int, case: int, fbg_datetime: pd.Timestamp):
         """Update the subject_df"""
-        fbg_datetime = (
-            self.get_next("fbg_datetime", index)
-            if next_is_endpoint
-            else self.get("fbg_datetime", index)
-        )
         self.subject_df.loc[self.subject_df["fbg_datetime"] == fbg_datetime, "endpoint"] = 1
         self.subject_df["interval_in_days"] = np.nan
-        try:
-            self.subject_df.loc[
-                self.subject_df["fbg_datetime"] == fbg_datetime, "interval_in_days"
-            ] = self.sequential_assessments_in_days(index)
-        except EndpointTdeltaError:
-            pass
-        self.subject_df["interval_in_days"] = pd.to_numeric(
-            self.subject_df["interval_in_days"]
-        )
         self.subject_df.loc[
             self.subject_df["fbg_datetime"] == fbg_datetime, "endpoint_type"
         ] = case
         self.subject_df.loc[
             self.subject_df["fbg_datetime"] == fbg_datetime, "endpoint_label"
-        ] = self.endpoint_cases[case]
-
-    def case_two(self, index: int):
-        """FBG >= 7 x 2, first OGTT<11.1.
-
-        First FBG must be done with corresponding OGTT.
-        """
-        reached = (
-            self.get_next("fbg_datetime", index)
-            and self.get("fbg_value", index)
-            and self.get("ogtt_value", index)
-            and self.get("fasting", index)
-            and self.get_next("fbg_value", index)
-            and self.get_next("fasting", index)
-            and self.get("fbg_value", index) >= self.fbg_threshhold
-            and self.get("ogtt_value", index) < self.ogtt_threshhold
-            and self.get("fasting", index) == YES
-            and self.get_next("fbg_value", index) >= self.fbg_threshhold
-            and self.get_next("fasting", index) == YES
-            and (self.get_next("fbg_datetime", index) - self.get("fbg_datetime", index)).days
-            >= 7
-        )
-        if reached:
-            self.endpoint_reached(index, case=2, next_is_endpoint=True)
-        return reached
-
-    def case_three(self, index: int):
-        """FBG >= 7 x 2, second OGTT<11.1.
-
-        Second FBG must be done with corresponding OGTT.
-        """
-        reached = (
-            self.get_next("fbg_datetime", index)
-            and self.get("fbg_value", index)
-            and self.get("fasting", index)
-            and self.get_next("fbg_value", index)
-            and self.get_next("ogtt_value", index)
-            and self.get_next("fasting", index)
-            and self.get("fbg_value", index) >= self.fbg_threshhold
-            and self.get("fasting", index) == YES
-            and self.get_next("fbg_value", index) >= self.fbg_threshhold
-            and self.get_next("ogtt_value", index) < self.ogtt_threshhold
-            and self.get_next("fasting", index) == YES
-            and (self.get_next("fbg_datetime", index) - self.get("fbg_datetime", index)).days
-            >= 7
-        )
-        if reached:
-            self.endpoint_reached(index, case=3, next_is_endpoint=True)
-        return reached
-
-    def case_four(self, index: int):
-        """FBG >= 7 x 2, OGTT not considered
-
-        This is not a protocol endpoint.
-        """
-        reached = (
-            self.get("fbg_value", index)
-            and self.get("fbg_datetime", index)
-            and self.get("fasting", index)
-            and self.get_next("fbg_value", index)
-            and self.get_next("ogtt_value", index)
-            and self.get_next("fbg_datetime", index)
-            and self.get_next("fasting", index)
-            and self.get("fbg_value", index) >= self.fbg_threshhold
-            and self.get("fasting", index) == YES
-            and self.get_next("fbg_value", index) >= self.fbg_threshhold
-            and self.get_next("fasting", index) == YES
-            and (self.get_next("fbg_datetime", index) - self.get("fbg_datetime", index)).days
-            >= 7
-        )
-        if reached:
-            self.endpoint_reached(index, case=4, next_is_endpoint=True)
-        return reached
-
-    def sequential_assessments_in_days(self, index) -> int:
-        if not self.get_next("fbg_value", index):
-            raise EndpointTdeltaError
-        return (self.get_next("fbg_datetime", index) - self.get("visit_datetime", index)).days
-
-    def get(self, col: str, index: int) -> float | None:
-        try:
-            next_value = self.subject_df.iloc[index : index + 1][col].item()
-        except ValueError:
-            next_value = None
-        return next_value
-
-    def get_next(self, col: str, index: int) -> float | None:
-        return self.get(col, index + 1)
+        ] = endpoint_cases[case]