meta-edc 0.3.15__py3-none-any.whl → 0.3.50__py3-none-any.whl

meta_analytics/dataframes/screening/get_screening_df.py

@@ -0,0 +1,163 @@
+import numpy as np
+import pandas as pd
+from django_pandas.io import read_frame
+
+from meta_screening.models import SubjectScreening
+from meta_subject.models import PhysicalExam, SubjectVisit
+
+
+def get_screening_df(df: pd.DataFrame | None = None) -> pd.DataFrame:
+    df = pd.DataFrame() if not hasattr(df, "empty") else df
+    if df.empty:
+        cols = [
+            f.name
+            for f in SubjectScreening._meta.get_fields()
+            if f.name
+            not in [
+                "contact_number",
+                "initials",
+                "hospital_identifier",
+                "modified",
+                "user_created",
+                "user_modified",
+                "hostname_created",
+                "hostname_modified",
+                "device_created",
+                "device_modified",
+                "locale_created",
+                "locale_modified",
+                "slug",
+            ]
+        ]
+        qs_screening = SubjectScreening.objects.values(*cols).all()
+        df = read_frame(qs_screening, verbose=False)
+        df = df.drop(df[df["hiv_pos"] == "No"].index)  # removes 2 rows
+        df = df.reset_index(drop=True)
+
+    # convert all to float
+    num_cols = [
+        "age_in_years",
+        "calculated_bmi_value",
+        "converted_fbg2_value",
+        "converted_fbg_value",
+        "converted_ogtt2_value",
+        "converted_ogtt_value",
+        "dia_blood_pressure_avg",
+        "fbg2_value",
+        "fbg_value",
+        "hba1c_value",
+        "ogtt2_value",
+        "ogtt_value",
+        "sys_blood_pressure_avg",
+        "waist_circumference",
+    ]
+    df[num_cols] = df[num_cols].apply(pd.to_numeric)
+
+    df["reasons_ineligible_part_one"] = df["reasons_ineligible_part_one"].apply(
+        lambda x: None if x == "" else x
+    )
+    df["reasons_ineligible_part_two"] = df["reasons_ineligible_part_two"].apply(
+        lambda x: None if x == "" else x
+    )
+    df["reasons_ineligible_part_two"] = df["reasons_ineligible_part_two"].str.replace(
+        "Has Dm", "Diabetes"
+    )
+    df["reasons_ineligible_part_two"] = df["reasons_ineligible_part_two"].str.replace(
+        "On Dm Medication", "taking anti-diabetic medications"
+    )
+    df["reasons_ineligible_part_three"] = df["reasons_ineligible_part_three"].apply(
+        lambda x: None if x == "" else x
+    )
+
+    # condition to include any glucose test
+
+    # has_dm fillna with unk
+    df["has_dm"] = df["has_dm"].apply(lambda x: "unk" if not x else x)
+
+    na = "Not applicable, subject is not eligible based on the criteria above"
+    df["already_fasted"] = df["already_fasted"].apply(lambda x: "N/A" if x == na else x)
+
+    # create a column that summarizes lives_nearby and staying_nearby_12
+    df["in_catchment"] = (df["lives_nearby"] == "Yes") & (df["staying_nearby_12"] == "Yes")
+
+    # create ogtt column
+    df["ogtt"] = df["converted_ogtt_value"]
+    df.loc[df["ogtt"].notna() & df["converted_ogtt2_value"].notna(), "ogtt"] = df[
+        "converted_ogtt2_value"
+    ]
+
+    # create fbg column
+    df["fbg"] = df["converted_fbg_value"]
+    df.loc[df["fbg"].notna() & df["converted_fbg2_value"].notna(), "fbg"] = df[
+        "converted_fbg2_value"
+    ]
+
+    # fasting columns
+    df["fasting_fbg_hrs"] = np.nan
+    df["fasting_fbg_hrs"] = df["fasting_duration_delta"].apply(
+        lambda x: x.total_seconds() / 3600
+    )
+    df.loc[df["fbg"].notna() & df["converted_fbg2_value"].notna(), "fasting_fbg_hrs"] = df[
+        "repeat_fasting_duration_delta"
+    ].apply(lambda x: x.total_seconds() / 3600)
+    df["fasting_ogtt_hrs"] = np.nan
+    df["fasting_ogtt_hrs"] = df["fasting_duration_delta"].apply(
+        lambda x: x.total_seconds() / 3600
+    )
+    df.loc[df["ogtt"].notna() & df["converted_ogtt2_value"].notna(), "fasting_ogtt_hrs"] = df[
+        "repeat_fasting_duration_delta"
+    ].apply(lambda x: x.total_seconds() / 3600)
+
+    # bmi
+    # subject SR9E8B4D has eligible part two == No but subject has a glucose value
+    df.loc[(df["screening_identifier"] == "SR9E8B4D"), "eligible_part_two"] = "Yes"
+
+    # merge with physical exam to get waist circumference if taken at baseline
+    subject_identifiers = list(df["subject_identifier"])
+    qs_subject_visit = SubjectVisit.objects.filter(subject_identifier__in=subject_identifiers)
+    df_subject_visit = read_frame(qs_subject_visit)
+    df_subject_visit.rename(columns={"id": "subject_visit"}, inplace=True)
+    qs_physical_exam = PhysicalExam.objects.filter(
+        subject_visit__subject_identifier__in=subject_identifiers
+    )
+    df_physical_exam = read_frame(qs_physical_exam)
+    # merge w/ subject visit to get subject_identifier
+    df_physical_exam = pd.merge(
+        df_physical_exam,
+        df_subject_visit[
+            ["subject_visit", "subject_identifier", "visit_code", "visit_code_sequence"]
+        ],
+        on="subject_visit",
+        how="left",
+    )
+    df_physical_exam = df_physical_exam[
+        ["subject_identifier", "visit_code", "visit_code_sequence", "waist_circumference"]
+    ]
+    df_physical_exam[["waist_circumference"]] = df_physical_exam[
+        ["waist_circumference"]
+    ].apply(pd.to_numeric)
+    # rename column to waist_circumference_baseline
+    df_physical_exam["waist_circumference_baseline"] = df_physical_exam["waist_circumference"]
+    df_physical_exam.drop(columns=["waist_circumference"])
+    df_physical_exam[["waist_circumference_baseline"]] = df_physical_exam[
+        ["waist_circumference_baseline"]
+    ].apply(pd.to_numeric)
+    # merge on subject_identifier with main DF
+    df = pd.merge(
+        df,
+        df_physical_exam[["subject_identifier", "waist_circumference_baseline"]],
+        on="subject_identifier",
+        how="left",
+    )
+    df.reset_index(drop=True, inplace=True)
+    # set waist_circumference=waist_circumference_baseline
+    # if `waist_circumference` is none and `waist_circumference_baseline` is not
+    df.loc[
+        (df["waist_circumference"].isna()) & (df["waist_circumference_baseline"].notna()),
+        "waist_circumference",
+    ] = df["waist_circumference_baseline"]
+
+    # drop waist_circumference_baseline
+    df.drop(columns=["waist_circumference_baseline"], inplace=True)
+
+    return df

meta_analytics/dataframes/utils.py

@@ -0,0 +1,65 @@
+import pandas as pd
+
+from .constants import endpoint_columns
+
+
+def get_test_string(s):
+    if pd.notna(s["fbg_value"]) and pd.notna(s["ogtt_value"]):
+        return "fbg_ogtt"
+    if pd.notna(s["fbg_value"]) and pd.isna(s["ogtt_value"]):
+        return "fbg_only"
+    if pd.isna(s["fbg_value"]) and pd.notna(s["ogtt_value"]):
+        return "ogtt_only"
+    if pd.isna(s["fbg_value"]) and pd.isna(s["ogtt_value"]):
+        return "not_tested"
+    return "???"
+
+
+def get_empty_endpoint_df() -> pd.DataFrame:
+    endpoint_df = pd.DataFrame(columns=endpoint_columns)
+    endpoint_df[
+        [
+            "visit_code",
+            "interval_in_days",
+            "fbg_value",
+            "ogtt_value",
+            "endpoint",
+            "endpoint_type",
+        ]
+    ] = endpoint_df[
+        [
+            "visit_code",
+            "interval_in_days",
+            "fbg_value",
+            "ogtt_value",
+            "endpoint",
+            "endpoint_type",
+        ]
+    ].apply(
+        pd.to_numeric
+    )
+    endpoint_df[
+        ["baseline_datetime", "visit_datetime", "fbg_datetime", "offstudy_datetime"]
+    ] = endpoint_df[
+        ["baseline_datetime", "visit_datetime", "fbg_datetime", "offstudy_datetime"]
+    ].apply(
+        pd.to_datetime
+    )
+    endpoint_df["visit_code"] = endpoint_df["visit_code"].astype(float)
+    return endpoint_df
+
+
+def get_unique_visit_codes(df: pd.DataFrame) -> pd.DataFrame:
+    stats_df = df[df["visit_code"] % 1 == 0]["visit_code"].value_counts().to_frame()
+    stats_df = stats_df.reset_index()
+    stats_df["visit_code"] = stats_df["visit_code"].astype(float)
+    stats_df = stats_df.sort_values(["visit_code"])
+    stats_df = stats_df.reset_index(drop=True)
+    return stats_df
+
+
+def get_unique_subject_identifiers(df: pd.DataFrame) -> pd.DataFrame:
+    values_df = pd.DataFrame(df["subject_identifier"].unique(), columns=["subject_identifier"])
+    values_df = values_df.sort_values(["subject_identifier"])
+    values_df = values_df.reset_index()
+    return values_df

meta_analytics/get_tables.py

@@ -0,0 +1,81 @@
+import pandas as pd
+from edc_analytics.custom_tables import (
+    AgeTable,
+    ArtTable,
+    BmiTable,
+    BpTable,
+    FastingTable,
+    FbgOgttTable,
+    FbgTable,
+    GenderTable,
+    HbA1cTable,
+    OgttTable,
+    WaistCircumferenceTable,
+)
+from edc_analytics.data import Data
+
+from .dataframes import get_glucose_tested_only_df, get_screening_df
+from .tables import EligibleP12Table, HasDmTable
+
+
+def get_tables() -> dict[str, Data]:
+    """
+    results = get_table()
+    results.get("fbg").to_csv(folder="/Users/erikvw/Documents/")
+    """
+    df_screening = get_screening_df()
+    df_has_dm = df_screening[(df_screening["has_dm"] == "Yes")]
+    df_no_dm = df_screening[(df_screening["has_dm"] == "No")]
+    df_fbg = get_glucose_tested_only_df(df_screening)
+
+    df_not_tested = df_no_dm.copy()
+    df_not_eligible_p1p2 = df_not_tested[
+        ~(
+            (df_not_tested["eligible_part_one"] == "Yes")
+            & (df_not_tested["eligible_part_two"] == "Yes")
+        )
+    ]
+    df_not_tested.drop(df_not_eligible_p1p2.index, inplace=True)
+    df_not_tested.drop(df_fbg.index, inplace=True)
+
+    df_stats = pd.DataFrame(
+        {
+            "df": ["df_screening", "df_has_dm", "df_no_dm", "df_not_tested", "df_fbg"],
+            "count": [
+                len(df_screening),
+                len(df_has_dm),
+                len(df_no_dm),
+                len(df_not_tested),
+                len(df_fbg),
+            ],
+        }
+    )
+
+    results = {"stats": df_stats}
+    for key, df in {
+        "screening": df_screening,
+        "has_dm": df_has_dm,
+        "no_dm": df_no_dm,
+        "not_tested": df_not_tested,
+        "fbg": df_fbg,
+    }.items():
+        dfs = []
+        for tbl_cls in [
+            GenderTable,
+            AgeTable,
+            WaistCircumferenceTable,
+            BmiTable,
+            BpTable,
+            ArtTable,
+            FastingTable,
+            FbgTable,
+            OgttTable,
+            FbgOgttTable,
+            HbA1cTable,
+            EligibleP12Table,
+            HasDmTable,
+        ]:
+            tbl = tbl_cls(main_df=df)
+            dfs.append(tbl.table_df)
+        results.update({key: Data(key, pd.concat(list(dfs)), df, "meta3")})
+    return results

meta_analytics/tables/__init__.py

@@ -0,0 +1,2 @@
+from .eligible import EligibleP12Table
+from .has_dm import HasDmTable

meta_analytics/tables/eligible.py

@@ -0,0 +1,106 @@
+import pandas as pd
+from edc_analytics.constants import N_ONLY, N_WITH_COL_PROP, N_WITH_ROW_PROP
+from edc_analytics.row import RowDefinition, RowDefinitions
+from edc_analytics.table import Table
+
+
+class EligibleP12Table(Table):
+    def __init__(self, main_df: pd.DataFrame = None):
+        super().__init__(colname="", main_df=main_df, title="Eligible by Part 1/2")
+
+    @property
+    def row_definitions(self) -> RowDefinitions:
+        df_tmp = self.main_df.copy()
+        row_defs = RowDefinitions(reverse_rows=False)
+        row0 = RowDefinition(
+            title=self.title,
+            label=self.default_sublabel,
+            condition=(df_tmp["gender"].notna()),
+            columns={
+                "F": (N_ONLY, 2),
+                "M": (N_ONLY, 2),
+                "All": (N_ONLY, 2),
+            },
+            drop=False,
+        )
+        row_defs.add(row0)
+        columns = {
+            "F": (N_WITH_COL_PROP, 2),
+            "M": (N_WITH_COL_PROP, 2),
+            "All": (N_WITH_ROW_PROP, 2),
+        }
+        row_defs.add(
+            RowDefinition(
+                label="Eligible P1",
+                condition=(df_tmp["eligible_part_one"] == "Yes"),
+                columns=columns,
+                drop=False,
+            )
+        )
+        row_defs.add(
+            RowDefinition(
+                label="Eligible P2",
+                condition=(df_tmp["eligible_part_two"] == "Yes"),
+                columns=columns,
+                drop=False,
+            )
+        )
+
+        row_defs.add(
+            RowDefinition(
+                label="Eligible P1 & P2",
+                condition=(df_tmp["eligible_part_one"] == "Yes")
+                & (df_tmp["eligible_part_two"] == "Yes"),
+                columns=columns,
+                drop=False,
+            )
+        )
+        # note already_fasted accepts Y/N/NA
+        row_defs.add(
+            RowDefinition(
+                label="Glucose tested (fasted on day)",
+                condition=(
+                    (df_tmp["already_fasted"] == "Yes")
+                    & ((df_tmp["fbg"].notna()) | (df_tmp["ogtt"].notna()))
+                ),
+                columns=columns,
+                drop=True,
+            )
+        )
+
+        row_defs.add(
+            RowDefinition(
+                label="Glucose tested (returned fasted)",
+                condition=(
+                    (df_tmp["already_fasted"] == "No")
+                    & ((df_tmp["fbg"].notna()) | (df_tmp["ogtt"].notna()))
+                ),
+                columns=columns,
+                drop=True,
+            )
+        )
+
+        row_defs.add(
+            RowDefinition(
+                label="Glucose tested (N/A)",
+                condition=(df_tmp["already_fasted"] == "N/A")
+                & ((df_tmp["fbg"].notna()) | (df_tmp["ogtt"].notna())),
+                columns=columns,
+                drop=True,
+            )
+        )
+
+        row_defs.add(
+            RowDefinition(
+                label="No glucose test (not fasted on day and did not return)",
+                condition=(
+                    (df_tmp["eligible_part_one"] == "Yes")
+                    & (df_tmp["eligible_part_two"] == "Yes")
+                    & (df_tmp["fbg"].isna())
+                    & (df_tmp["ogtt"].isna())
+                ),
+                columns=columns,
+                drop=False,
+            )
+        )
+        return row_defs

meta_analytics/tables/enrolled/glucose.py

@@ -0,0 +1,28 @@
+import pandas as pd
+from edc_analytics.custom_tables import AgeTable, GenderTable
+from edc_analytics.table import Table
+
+
+class GlucoseTable(Table):
+    """
+    gender
+    age
+    fasting
+    fbg mean
+    ogtt mean
+    fbg + ogtt count
+    """
+
+    def __init__(self, main_df: pd.DataFrame = None):
+        super().__init__(colname="", main_df=main_df, title="Glucose (enrolled)")
+
+    def build_table_df(self) -> None:
+        super().build_table_df()
+        df = self.main_df
+        s = df.groupby("subject_identifier")[["age_in_years", "gender"]].value_counts()
+        df_tmp = s.to_frame()
+        df_tmp = df_tmp.reset_index()
+        gender_tbl = GenderTable(main_df=df_tmp).table_df
+        age_tbl = AgeTable(main_df=df_tmp).table_df
+        self.table_df = pd.concat([self.table_df, gender_tbl, age_tbl])
+        self.table_df.reset_index(drop=True, inplace=True)

meta_analytics/tables/has_dm.py

@@ -0,0 +1,61 @@
+import pandas as pd
+from edc_analytics.constants import N_ONLY, N_WITH_COL_PROP, N_WITH_ROW_PROP
+from edc_analytics.row import RowDefinition, RowDefinitions
+from edc_analytics.table import Table
+
+
+class HasDmTable(Table):
+    def __init__(self, main_df: pd.DataFrame = None):
+        super().__init__(
+            colname="", main_df=main_df, title="Subjects reporting having Diabetes"
+        )
+
+    @property
+    def row_definitions(self) -> RowDefinitions:
+        df_tmp = self.main_df.copy()
+        row_defs = RowDefinitions(reverse_rows=False)
+        row0 = RowDefinition(
+            title=self.title,
+            label=self.default_sublabel,
+            condition=(df_tmp["gender"].notna()),
+            columns={
+                "F": (N_ONLY, 2),
+                "M": (N_ONLY, 2),
+                "All": (N_ONLY, 2),
+            },
+            drop=False,
+        )
+        row_defs.add(row0)
+        columns = {
+            "F": (N_WITH_COL_PROP, 2),
+            "M": (N_WITH_COL_PROP, 2),
+            "All": (N_WITH_ROW_PROP, 2),
+        }
+        row_defs.add(
+            RowDefinition(
+                label="Yes",
+                condition=(df_tmp["has_dm"] == "Yes"),
+                columns=columns,
+                drop=True,
+            )
+        )
+
+        row_defs.add(
+            RowDefinition(
+                label="No",
+                condition=(df_tmp["has_dm"] == "No"),
+                columns=columns,
+                drop=True,
+            )
+        )
+
+        row_defs.add(
+            RowDefinition(
+                label="Not evaluated",
+                condition=(df_tmp["has_dm"] == "unk"),
+                columns=columns,
+                drop=True,
+            )
+        )
+
+        return row_defs

meta_analytics/tests/test_endpoints_by_date.py

@@ -0,0 +1,94 @@
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+from dateutil.relativedelta import relativedelta
+from django.test import TestCase
+from edc_constants.constants import YES
+
+from meta_analytics.dataframes import EndpointByDate
+
+
+class TestEndpointsByDate(TestCase):
+    def test_case_one(self):
+        def d(m: int, w: int | None = None):
+            if w:
+                return datetime.now() - relativedelta(months=m, weeks=w)
+            return datetime.now() - relativedelta(months=m)
+
+        def append_to(subject_df, endpoint_df):
+            if endpoint_df.empty:
+                endpoint_df = subject_df.copy()
+            elif subject_df.empty:
+                pass
+            else:
+                endpoint_df = pd.concat([endpoint_df, subject_df])
+                endpoint_df = self.endpoint_df.sort_values(
+                    by=["subject_identifier", "visit_code"]
+                )
+                endpoint_df.reset_index(drop=True, inplace=True)
+
+        subject_identifier = "101-1"
+        data = {
+            "subject_identifier": [subject_identifier] * 10,
+            "visit_code": [
+                1000.0,
+                1005.0,
+                1010.0,
+                1030.0,
+                1060.0,
+                1090.0,
+                1120.0,
+                1115.0,
+                1118.0,
+                1210.0,
+            ],
+            "fasting": [YES] * 10,
+            "fbg_datetime": [
+                d(0),
+                d(0, 2),
+                d(1),
+                d(3),
+                d(6),
+                d(9),
+                d(12),
+                d(15),
+                d(18),
+                d(21),
+            ],
+            "fbg_value": [np.nan, 6.9, 6.9, 7.1, 7.1, 6.4, 7.0, np.nan, 8.1, np.nan],
+            "ogtt_value": [
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                7.9,
+                np.nan,
+            ],
+        }
+
+        fbgs = [np.nan, 6.9, 6.9, 7.1, 7.1, 6.4, 7.0, np.nan, 8.1, np.nan]
+        ogtts = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 7.9, np.nan]
+
+        fbgs = [np.nan, 6.9, 6.9, 7.1, 7.1, 6.4, 7.0, 8.1, np.nan, np.nan]
+        ogtts = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 7.9, np.nan, np.nan]
+
+        data.update(fbg_values=fbgs, ogtt_values=ogtts)
+        subject_df = pd.DataFrame(data)
+        subject_df["fasting"] = subject_df.apply(
+            lambda r: np.nan if pd.isna(r.fbg_value) else r.fbg_value, axis=1
+        )
+        subject_df["fbg_datetime"] = subject_df.apply(
+            lambda r: np.nan if pd.isna(r.fbg_value) else r.fbg_datetime, axis=1
+        )
+
+        endpoint_df = pd.DataFrame()
+        for index, row in subject_df.iterrows():
+            cls = EndpointByDate(index, row, fbg_threshhold=7.0, ogtt_threshhold=11.1)
+            append_to(cls.subject_df, endpoint_df)
+
+        endpoint_df

meta_auth/auth_objects.py

@@ -1,10 +1,32 @@
 from django.conf import settings
 from edc_auth.get_app_codenames import get_app_codenames
 
+META_REPORTS = "META_REPORTS"
+META_REPORTS_AUDIT = "META_REPORTS_AUDIT"
+META_PHARMACIST = "META_PHARMACIST"
+
+
 clinic_codenames = get_app_codenames(
     "meta_prn", "meta_subject", "meta_consent", list_app="meta_lists"
 )
 
+reports_codenames = get_app_codenames("meta_reports")
+reports_codenames.remove("meta_reports.view_impsubstitutions")
+
+meta_pharmacy_codenames = get_app_codenames("meta_pharmacy")
+meta_pharmacy_codenames.extend(get_app_codenames("django_pylabels"))
+meta_pharmacy_codenames.append("meta_reports.view_impsubstitutions")
+meta_pharmacy_codenames.append("meta_reports.viewallsites_impsubstitutions")
+excluded_meta_pharmacy_codenames = [
+    "meta_pharmacy.add_rx",
+    "meta_pharmacy.change_rx",
+    "meta_pharmacy.delete_rx",
+]
+
+meta_pharmacy_codenames = [
+    c for c in meta_pharmacy_codenames if c not in excluded_meta_pharmacy_codenames
+]
+
 add_perms = []
 if not settings.LIVE_SYSTEM:
     add_perms = [

meta_auth/auths.py

@@ -20,13 +20,26 @@ from edc_pharmacy.auth_objects import (
     PHARMACY_PRESCRIBER,
     SITE_PHARMACIST_ROLE,
 )
+from edc_qareports.auth_objects import QA_REPORTS_AUDIT_ROLE, QA_REPORTS_ROLE
 from edc_qol.auth_objects import QOL, QOL_SUPER, QOL_VIEW
 from edc_randomization.auth_objects import RANDO_BLINDED, RANDO_UNBLINDED
 from edc_screening.auth_objects import SCREENING, SCREENING_SUPER, SCREENING_VIEW
 from edc_subject_dashboard.auths import SUBJECT_VIEW
 from edc_unblinding.auth_objects import UNBLINDING_REQUESTORS
 
-from .auth_objects import clinic_codenames, screening_codenames
+from .auth_objects import (
+    META_PHARMACIST,
+    META_REPORTS,
+    META_REPORTS_AUDIT,
+    clinic_codenames,
+    meta_pharmacy_codenames,
+    reports_codenames,
+    screening_codenames,
+)
+
+site_auths.add_group(*reports_codenames, name=META_REPORTS)
+site_auths.add_group(*reports_codenames, name=META_REPORTS_AUDIT, view_only=True)
+site_auths.add_group(*meta_pharmacy_codenames, name=META_PHARMACIST)
 
 # update edc_auth default groups
 site_auths.update_group(*clinic_codenames, name=AUDITOR, view_only=True)
@@ -59,9 +72,11 @@ site_auths.update_role(
     DATA_MANAGER_EXPORT,
     name=DATA_EXPORTER_ROLE,
 )
-site_auths.update_role(RANDO_UNBLINDED, PII, name=PHARMACIST_ROLE)
-site_auths.update_role(RANDO_BLINDED, PII, name=SITE_PHARMACIST_ROLE)
+site_auths.update_role(RANDO_UNBLINDED, PII, META_PHARMACIST, name=PHARMACIST_ROLE)
+site_auths.update_role(RANDO_BLINDED, PII, META_PHARMACIST, name=SITE_PHARMACIST_ROLE)
 site_auths.update_role(SUBJECT_VIEW, SCREENING_VIEW, name=DATA_MANAGER_ROLE)
 site_auths.update_role(
     SUBJECT_VIEW, SCREENING_VIEW, ACTION_ITEM, UNBLINDING_REQUESTORS, name=TMG_ROLE
 )
+site_auths.update_role(META_REPORTS, name=QA_REPORTS_ROLE)
+site_auths.update_role(META_REPORTS_AUDIT, name=QA_REPORTS_AUDIT_ROLE)