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

meta_ae/action_items.py

@@ -11,11 +11,11 @@ from edc_adverse_event.constants import (
     DEATH_REPORT_TMG_ACTION,
 )
 from edc_constants.constants import CLOSED, DEAD, HIGH_PRIORITY, NO, YES
-from edc_lab_results import BLOOD_RESULTS_LIPID_ACTION
 from edc_lab_results.constants import (
     BLOOD_RESULTS_FBC_ACTION,
     BLOOD_RESULTS_GLU_ACTION,
     BLOOD_RESULTS_LFT_ACTION,
+    BLOOD_RESULTS_LIPIDS_ACTION,
     BLOOD_RESULTS_RFT_ACTION,
 )
 from edc_ltfu.constants import LOST_TO_FOLLOWUP
@@ -85,7 +85,7 @@ class AeInitialAction(ActionWithNotification):
     display_name = "Submit AE Initial Report"
     notification_display_name = "AE Initial Report"
     parent_action_names = [
-        BLOOD_RESULTS_LIPID_ACTION,
+        BLOOD_RESULTS_LIPIDS_ACTION,
         BLOOD_RESULTS_GLU_ACTION,
         BLOOD_RESULTS_LFT_ACTION,
         BLOOD_RESULTS_RFT_ACTION,

meta_ae/migrations/0017_auto_20221130_2257.py

@@ -1,4 +1,5 @@
 # Generated by Django 4.1.2 on 2022-11-30 19:57
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import migrations
 from edc_constants.constants import NOT_APPLICABLE
 from tqdm import tqdm
@@ -7,13 +8,17 @@ from tqdm import tqdm
 def update_investigator_ae_classification(apps, schema_editor):
     ae_tmg_cls = apps.get_model("meta_ae", "aetmg")
     ae_classification_cls = apps.get_model("edc_adverse_event", "aeclassification")
-    ae_classification = ae_classification_cls.objects.get(name=NOT_APPLICABLE)
-    total = ae_tmg_cls.objects.filter(investigator_ae_classification__isnull=True).count()
-    for obj in tqdm(
-        ae_tmg_cls.objects.filter(investigator_ae_classification__isnull=True), total=total
-    ):
-        obj.investigator_ae_classification = ae_classification
-        obj.save_base(update_fields=["investigator_ae_classification"])
+    try:
+        ae_classification = ae_classification_cls.objects.get(name=NOT_APPLICABLE)
+    except ObjectDoesNotExist:
+        pass
+    else:
+        total = ae_tmg_cls.objects.filter(investigator_ae_classification__isnull=True).count()
+        for obj in tqdm(
+            ae_tmg_cls.objects.filter(investigator_ae_classification__isnull=True), total=total
+        ):
+            obj.investigator_ae_classification = ae_classification
+            obj.save_base(update_fields=["investigator_ae_classification"])
 
 
 class Migration(migrations.Migration):

meta_ae/tests/holidays.csv

@@ -12,4 +12,4 @@
 2019-12-01,Mawlid Day,tanzania
 2019-12-09,Independence Day,tanzania
 2019-12-25,Christmas Day,tanzania
-2019-12-26,Boxing Day,tanzania
+2019-12-26,Boxing Day,tanzania

meta_analytics/README.rst

@@ -0,0 +1,17 @@
+
+
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from django_pandas.io import read_frame
+from dj_notebook import activate
+
+from meta_screening.models import SubjectScreening
+
+plus = activate(dotenv_file="/Users/erikvw/source/edc_source/meta-edc/.env")
+
+qs = SubjectScreening.objects.all()
+
+df = read_frame(qs)

meta_analytics/dataframes/__init__.py

@@ -0,0 +1,19 @@
+from .constants import (
+    CASE_EOS,
+    CASE_FBG_ONLY,
+    CASE_FBGS_WITH_FIRST_OGTT,
+    CASE_FBGS_WITH_SECOND_OGTT,
+    CASE_OGTT,
+    endpoint_cases,
+    endpoint_columns,
+)
+from .get_eos_df import get_eos_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
+from .utils import (
+    get_empty_endpoint_df,
+    get_test_string,
+    get_unique_subject_identifiers,
+    get_unique_visit_codes,
+)

meta_analytics/dataframes/constants.py

@@ -0,0 +1,33 @@
+CASE_EOS = 7
+CASE_FBGS_WITH_FIRST_OGTT = 2
+CASE_FBGS_WITH_SECOND_OGTT = 3
+CASE_FBG_ONLY = 4
+CASE_OGTT = 1
+EOS_DM_MET = "EOS - Patient developed diabetes"
+OGTT_THRESHOLD_MET = "OGTT >= 11.1"
+
+endpoint_columns = [
+    "subject_identifier",
+    "site_id",
+    "baseline_datetime",
+    "visit_datetime",
+    "interval_in_days",
+    "visit_code",
+    "fbg_value",
+    "ogtt_value",
+    "fbg_datetime",
+    "fasting",
+    "endpoint_label",
+    "endpoint_type",
+    "endpoint",
+    "offstudy_datetime",
+    "offstudy_reason",
+]
+
+endpoint_cases = {
+    CASE_OGTT: OGTT_THRESHOLD_MET,
+    CASE_FBGS_WITH_FIRST_OGTT: "FBG >= 7 x 2, first OGTT<=11.1",
+    CASE_FBGS_WITH_SECOND_OGTT: "FBG >= 7 x 2, second OGTT<=11.1",
+    CASE_FBG_ONLY: "FBG >= 7 x 2, OGTT not considered",
+    CASE_EOS: EOS_DM_MET,
+}

meta_analytics/dataframes/enrolled/__init__.py

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

meta_analytics/dataframes/enrolled/get_glucose_df.py

@@ -0,0 +1,122 @@
+import numpy as np
+import pandas as pd
+from django_pandas.io import read_frame
+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:
+    qs_glucose_fbg = GlucoseFbg.objects.all()
+    df_glucose_fbg = read_frame(qs_glucose_fbg)
+    df_glucose_fbg.rename(
+        columns={"fbg_fasting": "fasting", "subject_visit": "subject_visit_id"},
+        inplace=True,
+    )
+
+    df_glucose_fbg.loc[(df_glucose_fbg["fasting"] == "fasting"), "fasting"] = "Yes"
+    df_glucose_fbg.loc[(df_glucose_fbg["fasting"] == "non_fasting"), "fasting"] = "No"
+    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["fasting_hrs"] = df_glucose_fbg["fasting_hrs"].apply(
+        lambda x: 8.05 if not x else x
+    )
+    # df_glucose_fbg = df_glucose_fbg.loc[df_glucose_fbg["fasting_hrs"] >= 8.0]
+    # df_glucose_fbg.reset_index(drop=True, inplace=True)
+    df_glucose_fbg.loc[
+        :,
+        ["ogtt_value", "ogtt_units", "ogtt_datetime"],
+    ] = [np.nan, None, pd.NaT]
+    df_glucose_fbg["source"] = "meta_subject.glucosefbg"
+
+    qs_glucose = Glucose.objects.all()
+    df_glucose = read_frame(qs_glucose)
+    df_glucose.rename(columns={"subject_visit": "subject_visit_id"}, inplace=True)
+    df_glucose.loc[(df_glucose["fasting"] == "fasting"), "fasting"] = "Yes"
+    df_glucose.loc[(df_glucose["fasting"] == "non_fasting"), "fasting"] = "No"
+    df_glucose["fasting_hrs"] = np.nan
+    df_glucose["fasting_hrs"] = df_glucose[df_glucose["fasting"] == "Yes"][
+        "fasting_duration_delta"
+    ].apply(lambda x: x.total_seconds() / 3600)
+    df_glucose["fasting_hrs"] = df_glucose["fasting_hrs"].apply(lambda x: 8.05 if not x else x)
+    # df_glucose = df_glucose.loc[df_glucose["fasting_hrs"] >= 8.0]
+    # df_glucose.reset_index(drop=True, inplace=True)
+    df_glucose["source"] = "meta_subject.glucose"
+
+    keep_cols = [
+        "subject_visit_id",
+        "fasting",
+        "fasting_hrs",
+        "fbg_value",
+        "fbg_units",
+        "fbg_datetime",
+        "ogtt_value",
+        "ogtt_units",
+        "ogtt_datetime",
+        "source",
+        "revision",
+        "report_datetime",
+    ]
+    df_glucose = df_glucose[keep_cols]
+    df_glucose_fbg = df_glucose_fbg[keep_cols]
+    # df = pd.concat([df_glucose_fbg, df_glucose])
+    df = pd.merge(
+        df_glucose,
+        df_glucose_fbg,
+        on="subject_visit_id",
+        how="outer",
+        indicator=True,
+        suffixes=("", "_2"),
+    )
+
+    for suffix in ["", "_2"]:
+        cols = [f"fasting_hrs{suffix}", f"fbg_value{suffix}", f"ogtt_value{suffix}"]
+        df[cols] = df[cols].apply(pd.to_numeric)
+        cols = [f"fbg_datetime{suffix}", f"ogtt_datetime{suffix}"]
+        df[cols] = df[cols].apply(pd.to_datetime)
+        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)"
+        # remove values if not fasted
+        # df.loc[(df[f"fasting{suffix}"] != YES), f"fbg_value{suffix}"] = np.nan
+        # df.loc[(df[f"fasting{suffix}"] != YES), f"ogtt_value{suffix}"] = np.nan
+
+    # reconcile all to single column
+    df.loc[(df["fbg_value"].isna()) & (df["fbg_value_2"].notna()), "fbg_value"] = df[
+        "fbg_value_2"
+    ]
+    df.loc[(df["ogtt_value"].isna()) & (df["ogtt_value_2"].notna()), "ogtt_value"] = df[
+        "ogtt_value_2"
+    ]
+    cols = [col for col in list(df.columns) if col.endswith("_2")]
+    df.drop(columns=cols, inplace=True)
+    cols = [col for col in list(df.columns) if col.endswith("_3")]
+    df.drop(columns=cols, inplace=True)
+
+    df_subject_visit = get_subject_visit("meta_subject.subjectvisit")
+    df_consent = get_subject_consent("meta_consent.subjectconsent")
+    df_eos = get_eos("meta_prn.endofstudy")
+
+    df = pd.merge(df_subject_visit, df, on="subject_visit_id", how="left")
+    df = pd.merge(df, df_consent, on="subject_identifier", how="left")
+    df = pd.merge(df, df_eos, on="subject_identifier", how="left")
+
+    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.sort_values(by=["subject_identifier", "visit_code"])
+    df.reset_index(drop=True, inplace=True)
+    return df

meta_analytics/dataframes/get_eos_df.py

@@ -0,0 +1,26 @@
+import pandas as pd
+from edc_pdutils.dataframes import get_eos, get_subject_visit
+
+
+def get_eos_df() -> pd.DataFrame:
+    """
+    df = get_eos_df()
+
+    # look at transfers and last attended visit
+    df[(df.transfer_reason.notna())]
+
+    """
+    df_eos = get_eos("meta_prn.endofstudy")
+    df_visit = get_subject_visit("meta_subject.subjectvisit")
+    df_last_visit = (
+        df_visit.groupby(["subject_identifier", "site"])
+        .agg({"last_visit_code": "max", "last_visit_datetime": "max"})
+        .reset_index()
+    )
+    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"])
+    return df_eos

meta_analytics/dataframes/get_last_imp_visits_df.py

@@ -0,0 +1,101 @@
+import pandas as pd
+from django.apps import apps as django_apps
+from django.core.exceptions import ObjectDoesNotExist
+from django_pandas.io import read_frame
+from edc_pdutils.dataframes import get_appointments, get_crf
+
+
+class InvalidLotNumber(Exception):
+    pass
+
+
+def site_cond(df, site_id):
+    return (0 == 0) if not site_id else df.site_id == site_id
+
+
+def get_last_imp_visits_df(
+    lot_no: str | None = None,
+    site_id: int | None = None,
+) -> pd.DataFrame:
+    """Returns a dataframe of the last IMP visits based on the last
+    StudyMedication refill report.
+
+    `assignment` col defaults to "*****" unless a valid `lot_no` is
+    provided.
+    """
+    lot_obj = None
+    if lot_no:
+        lot_number_model_cls = django_apps.get_model("meta_pharmacy.lotnumber")
+        try:
+            lot_obj = lot_number_model_cls.objects.get(lot_no=lot_no)
+        except ObjectDoesNotExist:
+            raise ObjectDoesNotExist("The lot number given is invalid")
+
+    df_meds = get_crf(
+        "meta_subject.studymedication", subject_visit_model="meta_subject.subjectvisit"
+    )
+    df_meds = (
+        df_meds[(df_meds.refill == "Yes") & (site_cond(df_meds, site_id))]
+        .groupby(by=["subject_identifier", "site_id"])
+        .agg({"last_visit_code": "max", "last_visit_datetime": "max"})
+        .reset_index()
+    )
+    df_meds = df_meds.rename(
+        columns={"last_visit_code": "imp_visit_code", "last_visit_datetime": "imp_visit_date"}
+    )
+    df_meds.reset_index()
+
+    # merge with OffSchedule
+    opts = {} if not site_id else dict(site_id=site_id)
+    offschedule_model_cls = django_apps.get_model("meta_prn.offschedule")
+    df_off = read_frame(
+        offschedule_model_cls.objects.values(
+            "subject_identifier", "offschedule_datetime"
+        ).filter(**opts),
+        verbose=False,
+    )
+    df_off["offschedule_datetime"] = df_off["offschedule_datetime"].dt.tz_localize(None)
+    df_off["offschedule_datetime"] = df_off["offschedule_datetime"].dt.normalize()
+    df_off = df_off.set_index("subject_identifier")
+
+    df_meds = df_meds.set_index("subject_identifier")
+    df_final = pd.merge(
+        df_meds, df_off, left_index=True, right_index=True, how="outer"
+    ).reset_index()
+
+    # merge with RandomizationList if lot_obj
+    # note: slow to decrypt assignment
+    if lot_obj:
+        rando_model_cls = django_apps.get_model("meta_rando.randomizationlist")
+        qs = rando_model_cls.objects.values("subject_identifier", "assignment").filter(
+            assignment=lot_obj.assignment
+        )
+        df_rando = read_frame(qs, verbose=False)
+        df_final = df_final.merge(df_rando, on="subject_identifier", how="left")
+    else:
+        df_final["assignment"] = "*****"
+
+    # merge in appts
+    df_appt = (
+        get_appointments()
+        .groupby(by=["subject_identifier"])
+        .agg({"next_visit_code": "max", "next_appt_datetime": "max"})
+        .reset_index()
+    )
+    df_final = df_final.merge(
+        df_appt[["subject_identifier", "next_visit_code", "next_appt_datetime"]],
+        on="subject_identifier",
+        how="left",
+    )
+    df_final = df_final[(df_final.offschedule_datetime.isna()) & (df_final.assignment.notna())]
+
+    # Filter out subjects off_schedule.
+    # If lot_obj, filter out those with alternative assignment.
+    df_final = df_final[(df_final.offschedule_datetime.isna()) & (df_final.assignment.notna())]
+    df_final = df_final.drop(columns=["offschedule_datetime"])
+
+    # calculate days since the IMP visit
+    df_final["days_since"] = pd.to_datetime("today").normalize() - df_final.imp_visit_date
+    df_final["days_until"] = df_final.next_appt_datetime - pd.to_datetime("today").normalize()
+    df_final = df_final.reset_index()
+    return df_final

meta_analytics/dataframes/glucose_endpoints/__init__.py

@@ -0,0 +1,2 @@
+from .endpoint_by_date import EndpointByDate
+from .glucose_endpoints_by_date import GlucoseEndpointsByDate

meta_analytics/dataframes/glucose_endpoints/endpoint_by_date.py

@@ -0,0 +1,183 @@
+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
+
+
+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 (fasting=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.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):
+                break
+            elif 3 in self.case_list and self.case_three(index):
+                break
+            elif 4 in self.case_list and self.case_four(index):
+                break
+
+    def endpoint_reached(self, index: int, case: int, next_is_endpoint: bool | None = None):
+        """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)