meta-edc 1.0.5__tar.gz → 1.0.7__tar.gz

meta_edc-1.0.7/AUTHORS.rst

@@ -0,0 +1,8 @@
+Maintainers
+===========
+- Erik van Widenfelt (`erikvw <https://github.com/erikvw>`__)
+
+Authors
+=======
+- Erik van Widenfelt (`erikvw <https://github.com/erikvw>`_)
+- Jonathan Willitts (`JonathanWillitts <https://github.com/JonathanWillitts>`_)

{meta_edc-1.0.5 → meta_edc-1.0.7}/CHANGES

@@ -1,6 +1,10 @@
 Changes
 -------
 
+1.0.6
+-----
+- bump edc=1.0.9
+
 1.0.5
 -----
 - bump edc-pharmacy, edc=1.0.7

{meta_edc-1.0.5 → meta_edc-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: meta-edc
-Version: 1.0.5
+Version: 1.0.7
 Summary: META Trial EDC (http://www.isrctn.com/ISRCTN76157257)
 Home-page: https://github.com/meta-trial/meta-edc
 Author: Erik van Widenfelt
@@ -692,12 +692,13 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Requires-Python: >=3.12
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-License-File: AUTHORS
-Requires-Dist: edc==1.0.8
+License-File: AUTHORS.rst
+Requires-Dist: edc==1.0.9
 Requires-Dist: edc-microscopy
 Requires-Dist: beautifulsoup4
 Requires-Dist: celery[redis]
 Requires-Dist: django-pylabels
+Dynamic: license-file
 
 |pypi| |actions| |codecov| |downloads|
 

{meta_edc-1.0.5 → meta_edc-1.0.7}/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_edc-1.0.5 → meta_edc-1.0.7}/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_edc-1.0.5 → meta_edc-1.0.7}/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_edc-1.0.5 → meta_edc-1.0.7}/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_edc-1.0.7/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_edc-1.0.7/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_edc-1.0.7/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_edc-1.0.7/meta_analytics/dataframes/glucose_endpoints/endpoint_by_date.py

@@ -0,0 +1,169 @@
+from dataclasses import dataclass, field
+
+import numpy as np
+import pandas as pd
+from edc_constants.constants import YES
+
+from ..constants import endpoint_cases
+
+
+class EndpointTdeltaError(Exception):
+    pass
+
+
+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.
+
+    IMPORTANT: Remove case one before passing to this class
+        * case 1. any OGTT >= 11.1
+
+    Evaluation is done in order
+
+    Order of protocol endpoint evaluation:
+      * case 2. FBG >= 7 x 2, first OGTT<11.1
+      * case 3.  FBG >= 7 x 2, second OGTT<11.1
+
+    Additional criteria considered:
+      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.
+    """
+
+    def __init__(
+        self,
+        subject_df: pd.DataFrame = None,
+        fbg_threshhold: float = None,
+        ogtt_threshhold: float = None,
+    ):
+        self.row = None
+        self.index = None
+        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.evaluate()
+
+    def evaluate(self):
+        for index, _ in self.subject_df.iterrows():
+            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 case_data.case_three():
+                self.endpoint_reached(index, case=3, fbg_datetime=case_data.next_fbg_datetime)
+                break
+            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, fbg_datetime: pd.Timestamp):
+        """Update the subject_df"""
+        self.subject_df.loc[self.subject_df["fbg_datetime"] == fbg_datetime, "endpoint"] = 1
+        self.subject_df["interval_in_days"] = np.nan
+        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"
+        ] = endpoint_cases[case]