clinicedc 2.0.11__py3-none-any.whl → 2.0.13__py3-none-any.whl

edc_dx/diagnoses.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+from typing import Dict
+
+from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist
+from edc_constants.constants import YES
+from edc_dx_review.utils import (
+    get_clinical_review_baseline_model_cls,
+    get_clinical_review_model_cls,
+    get_initial_review_model_cls,
+)
+
+from .utils import get_diagnosis_labels
+
+
+class InitialReviewRequired(Exception):
+    pass
+
+
+class MultipleInitialReviewsExist(Exception):
+    pass
+
+
+class ClinicalReviewBaselineRequired(Exception):
+    pass
+
+
+class DiagnosesError(Exception):
+    pass
+
+
+class Diagnoses:
+    """
+    Tightly coupled to models
+    """
+
+    def __init__(
+        self,
+        subject_identifier: str = None,
+        report_datetime: datetime = None,
+        subject_visit=None,
+        lte: bool | None = None,
+        limit_to_single_condition_prefix: str | None = None,
+    ) -> None:
+        self.single_condition_prefix = (
+            limit_to_single_condition_prefix.lower()
+            if limit_to_single_condition_prefix
+            else None
+        )
+        if subject_visit:
+            if subject_identifier or report_datetime:
+                raise DiagnosesError(
+                    "Ambiguous parameters provided. Expected either "
+                    "`subject_visit` or `subject_identifier, report_datetime`. Not both."
+                )
+            self.report_datetime = subject_visit.report_datetime
+            self.subject_identifier = subject_visit.appointment.subject_identifier
+        else:
+            self.report_datetime = report_datetime
+            self.subject_identifier = subject_identifier
+        self.lte = lte
+        self.clinical_review_baseline_exists_or_raise()
+
+    @property
+    def diagnosis_labels(self):
+        if self.single_condition_prefix:
+            return {
+                k.lower(): v
+                for k, v in get_diagnosis_labels().items()
+                if k == self.single_condition_prefix
+            }
+        return get_diagnosis_labels()
+
+    def get_dx_by_model(self, instance) -> str:
+        dx = None
+        for prefix in self.diagnosis_labels:
+            if instance.__class__.__name__.lower().startswith(prefix.lower()):
+                dx = self.get_dx(prefix)
+                break
+        if not dx:
+            raise DiagnosesError(
+                f"Invalid. No diagnoses detected. "
+                f"See responses on {self.clinical_review_baseline._meta.verbose_name}."
+            )
+        return dx
+
+    def get_dx_date(self, prefix: str) -> date | None:
+        """Returns a dx date from the initial review for the condition.
+
+        Raises if initial review does not exist."""
+        prefix = prefix.lower()
+        if self.initial_reviews.get(prefix):
+            return self.initial_reviews.get(prefix).get_best_dx_date()
+        return None
+
+    def get_dx(self, prefix: str) -> str | None:
+        """Returns YES if any diagnoses for this condition otherwise None.
+
+        References clinical_review_baseline, clinical_review
+
+        name is `dm`, `hiv` or `htn`.
+        """
+        diagnoses = [
+            getattr(self.clinical_review_baseline, f"{prefix.lower()}_dx", "") == YES,
+            *[
+                (getattr(obj, f"{prefix.lower()}_dx", "") == YES)
+                for obj in self.clinical_reviews
+            ],
+        ]
+        if any(diagnoses):
+            return YES
+        return None
+
+    def clinical_review_baseline_exists_or_raise(self):
+        return self.clinical_review_baseline
+
+    @property
+    def clinical_review_baseline(self):
+        try:
+            obj = get_clinical_review_baseline_model_cls().objects.get(
+                subject_visit__subject_identifier=self.subject_identifier,
+            )
+        except ObjectDoesNotExist:
+            raise ClinicalReviewBaselineRequired(
+                "Please complete "
+                f"{get_clinical_review_baseline_model_cls()._meta.verbose_name}."
+            )
+        return obj
+
+    def report_datetime_opts(
+        self, prefix: str = None, lte: bool = None
+    ) -> Dict[str, datetime]:
+        opts = {}
+        prefix = prefix.lower() or ""
+        if self.report_datetime:
+            if lte or self.lte:
+                opts.update({f"{prefix.lower()}report_datetime__lte": self.report_datetime})
+            else:
+                opts.update({f"{prefix.lower()}report_datetime__lt": self.report_datetime})
+        return opts
+
+    @property
+    def clinical_reviews(self):
+        return get_clinical_review_model_cls().objects.filter(
+            subject_visit__subject_identifier=self.subject_identifier,
+            **self.report_datetime_opts("subject_visit__"),
+        )
+
+    def get_initial_reviews(self):
+        return self.initial_reviews
+
+    @property
+    def initial_reviews(self):
+        """Returns a dict of initial review model instances
+        for each diagnosis.
+
+        If any initial review is expected but does not exist,
+        an expection is raised.
+        """
+        initial_reviews = {}
+
+        options = []
+        for prefix, label in self.diagnosis_labels.items():
+            prefix = prefix.lower()
+            options.append(
+                (
+                    prefix,
+                    self.get_dx(prefix),
+                    get_initial_review_model_cls(prefix),
+                    f"{label.title()} diagnosis",
+                )
+            )
+        for name, diagnosis, initial_review_model_cls, description in options:
+            if diagnosis:
+                extra_msg = description.title()
+                try:
+                    obj = initial_review_model_cls.objects.get(
+                        subject_visit__subject_identifier=self.subject_identifier,
+                        **self.report_datetime_opts("subject_visit__", lte=True),
+                    )
+                except ObjectDoesNotExist:
+                    subject_visit = self.initial_diagnosis_visit(name)
+                    if subject_visit:
+                        visit_label = (
+                            f"{subject_visit.visit_code}."
+                            f"{subject_visit.visit_code_sequence}"
+                        )
+                        extra_msg = f"{description} was reported on visit {visit_label}. "
+                    raise InitialReviewRequired(
+                        f"{extra_msg}. Complete the "
+                        f"`{initial_review_model_cls._meta.verbose_name}` CRF first."
+                    )
+                except MultipleObjectsReturned:
+                    qs = initial_review_model_cls.objects.filter(
+                        subject_visit__subject_identifier=self.subject_identifier,
+                        **self.report_datetime_opts("subject_visit__", lte=True),
+                    ).order_by(
+                        "subject_visit__visit_code",
+                        "subject_visit__visit_code_sequence",
+                    )
+                    visits_str = ", ".join(
+                        [
+                            (
+                                f"{obj.subject_visit.visit_code}."
+                                f"{obj.subject_visit.visit_code_sequence}"
+                            )
+                            for obj in qs
+                        ]
+                    )
+                    raise MultipleInitialReviewsExist(
+                        f"More than one `{initial_review_model_cls._meta.verbose_name}` "
+                        f"has been submitted. "
+                        f"This needs to be corrected. Try removing all but the first "
+                        f"`{initial_review_model_cls._meta.verbose_name}` "
+                        "before continuing. "
+                        f"`{initial_review_model_cls._meta.verbose_name}` "
+                        "CRFs have been submitted "
+                        f"for visits {visits_str}"
+                    )
+
+                else:
+                    initial_reviews.update({name: obj})
+        return initial_reviews
+
+    def initial_diagnosis_visit(self, prefix):
+        related_visit_model_attr = (
+            get_clinical_review_baseline_model_cls().related_visit_model_attr()
+        )
+        opts = {
+            f"{related_visit_model_attr}__subject_identifier": self.subject_identifier,
+            f"{prefix.lower()}_dx": YES,
+        }
+        opts.update(**self.report_datetime_opts(f"{related_visit_model_attr}__", lte=True))
+        try:
+            clinical_review_baseline = get_clinical_review_baseline_model_cls().objects.get(
+                **opts
+            )
+        except ObjectDoesNotExist:
+            subject_visit = None
+        else:
+            subject_visit = clinical_review_baseline.related_visit
+        if not subject_visit:
+            try:
+                clinical_review = get_clinical_review_model_cls().objects.get(**opts)
+            except ObjectDoesNotExist:
+                subject_visit = None
+            else:
+                subject_visit = clinical_review.related_visit
+        return subject_visit

edc_dx/form_validators/__init__.py

@@ -0,0 +1,2 @@
+from .diagnosis_form_validator_mixin import DiagnosisFormValidatorMixin
+from .result_form_validator_mixin import ResultFormValidatorMixin

edc_dx/form_validators/diagnosis_form_validator_mixin.py

@@ -0,0 +1,54 @@
+from django import forms
+from edc_constants.constants import YES
+
+from ..diagnoses import (
+    ClinicalReviewBaselineRequired,
+    Diagnoses,
+    InitialReviewRequired,
+    MultipleInitialReviewsExist,
+)
+
+
+class DiagnosisFormValidatorMixin:
+    def get_diagnoses(self) -> Diagnoses:
+        try:
+            diagnoses = Diagnoses(
+                subject_identifier=self.subject_identifier,
+                report_datetime=self.report_datetime,
+            )
+        except ClinicalReviewBaselineRequired as e:
+            raise forms.ValidationError(e)
+        try:
+            diagnoses.get_initial_reviews()
+        except InitialReviewRequired as e:
+            raise forms.ValidationError(e)
+        except MultipleInitialReviewsExist as e:
+            raise forms.ValidationError(e)
+        return diagnoses
+
+    def applicable_if_not_diagnosed(
+        self, diagnoses=None, prefix=None, field_applicable=None, label=None
+    ) -> bool:
+        diagnoses = diagnoses or self.get_diagnoses()
+        return self.applicable_if_true(
+            diagnoses.get_dx(prefix) != YES,
+            field_applicable=field_applicable,
+            applicable_msg=(
+                f"Patient was not previously diagnosed with {label}. Expected YES or NO."
+            ),
+            not_applicable_msg=f"Patient was previously diagnosed with {label}.",
+        )
+
+    def applicable_if_diagnosed(
+        self, diagnoses=None, prefix=None, field_applicable=None, label=None
+    ) -> bool:
+        diagnoses = diagnoses or self.get_diagnoses()
+        diagnosed = diagnoses.get_dx(prefix) == YES
+        return self.applicable_if_true(
+            diagnosed,
+            field_applicable=field_applicable,
+            applicable_msg=(
+                f"Patient was previously diagnosed with {label}. Expected YES or NO."
+            ),
+            not_applicable_msg=f"Patient was not previously diagnosed with {label}.",
+        )

edc_dx/form_validators/result_form_validator_mixin.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+from django import forms
+from django.conf import settings
+from edc_dx_review.utils import raise_if_clinical_review_does_not_exist
+from edc_form_validators import INVALID_ERROR, FormValidator
+from edc_utils import convert_php_dateformat
+from edc_visit_schedule.utils import raise_if_baseline
+
+from ..diagnoses import ClinicalReviewBaselineRequired, Diagnoses, InitialReviewRequired
+
+
+class ResultFormValidatorMixin(FormValidator):
+    dx: Tuple[str, str]  # e.g. (HIV, "HIV Infection")
+
+    def clean(self):
+        raise_if_baseline(self.cleaned_data.get("subject_visit"))
+        try:
+            raise_if_clinical_review_does_not_exist(self.cleaned_data.get("subject_visit"))
+        except ClinicalReviewBaselineRequired as e:
+            self.raise_validation_error(str(e), INVALID_ERROR)
+        try:
+            self.validate_drawn_date_by_dx_date(*self.dx)
+        except ClinicalReviewBaselineRequired as e:
+            self.raise_validation_error(str(e), INVALID_ERROR)
+
+    def validate_test_date_by_dx_date(
+        self, prefix: str, dx_msg_label: str, test_date_fld: str | None = None
+    ) -> None:
+        return self.validate_drawn_date_by_dx_date(
+            prefix=prefix, dx_msg_label=dx_msg_label, drawn_date_fld=test_date_fld
+        )
+
+    def validate_drawn_date_by_dx_date(
+        self, prefix: str, dx_msg_label: str, drawn_date_fld: str | None = None
+    ):
+        drawn_date_fld = drawn_date_fld or "drawn_date"
+        dx = Diagnoses(
+            subject_visit=self.cleaned_data.get("subject_visit"),
+            lte=True,
+            limit_to_single_condition_prefix=prefix,
+        )
+        try:
+            dx_date = dx.get_dx_date(prefix)
+        except InitialReviewRequired:
+            dx_date = None
+        if not dx_date:
+            raise forms.ValidationError(
+                f"A {dx_msg_label} diagnosis has not been reported for this subject."
+            )
+        else:
+            if dx_date > self.cleaned_data.get(drawn_date_fld):
+                formatted_date = dx_date.strftime(
+                    convert_php_dateformat(settings.SHORT_DATE_FORMAT)
+                )
+                raise forms.ValidationError(
+                    {
+                        "drawn_date": (
+                            "Invalid. Subject was diagnosed with "
+                            f"{dx_msg_label} on {formatted_date}."
+                        )
+                    }
+                )

edc_dx/utils.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.conf import settings
+
+
+class DiagnosisLabelError(Exception):
+    pass
+
+
+def get_diagnosis_labels() -> dict:
+    diagnosis_labels = getattr(
+        settings,
+        "EDC_DX_LABELS",
+        dict(hiv="HIV", dm="Diabetes", htn="Hypertension", chol="High Cholesterol"),
+    )
+    return {k.lower(): v for k, v in diagnosis_labels.items()}
+
+
+def get_diagnosis_labels_prefixes() -> list[str]:
+    return [k for k in get_diagnosis_labels()]
+
+
+def raise_on_unknown_diagnosis_labels(obj: Any, fld_suffix: str, fld_value: Any) -> None:
+    """Raises an exception if a diagnosis field has a response
+    but is not an expected condition.
+
+    See also EDC_DX_LABELS.
+    """
+    labels = [
+        fld.name.split(fld_suffix)[0]
+        for fld in obj._meta.get_fields()
+        if fld.name.endswith(fld_suffix)
+        and fld.name.split(fld_suffix)[0] not in get_diagnosis_labels_prefixes()
+        and getattr(obj, fld.name) == fld_value
+    ]
+    if labels:
+        raise DiagnosisLabelError(
+            "Diagnosis prefix not expected. See settings.EDC_DX_LABELS. "
+            f"Expected one of {get_diagnosis_labels_prefixes()}. Got {labels}."
+        )

edc_dx_review/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig as DjangoAppConfig
+
+
+class AppConfig(DjangoAppConfig):
+    name = "edc_dx_review"

edc_dx_review/auth_objects.py

@@ -0,0 +1,13 @@
+from django.apps import apps as django_apps
+
+EDC_DX_REVIEW = "EDC_DX_REVIEW"
+EDC_DX_REVIEW_SUPER = "EDC_DX_REVIEW_SUPER"
+EDC_DX_REVIEW_VIEW = "EDC_DX_REVIEW_VIEW"
+
+codenames = []
+app_config = django_apps.get_app_config("edc_dx_review")
+for model_cls in app_config.get_models():
+    if "historical" not in model_cls._meta.label_lower:
+        for action in ["view_", "add_", "change_", "delete_", "view_historical"]:
+            codenames.append(f".{action}".join(model_cls._meta.label_lower.split(".")))
+codenames.sort()

edc_dx_review/auths.py

@@ -0,0 +1,12 @@
+from edc_auth.site_auths import site_auths
+
+from .auth_objects import (
+    EDC_DX_REVIEW,
+    EDC_DX_REVIEW_SUPER,
+    EDC_DX_REVIEW_VIEW,
+    codenames,
+)
+
+site_auths.add_group(*codenames, name=EDC_DX_REVIEW_VIEW, view_only=True)
+site_auths.add_group(*codenames, name=EDC_DX_REVIEW, no_delete=True)
+site_auths.add_group(*codenames, name=EDC_DX_REVIEW_SUPER)

edc_dx_review/choices.py

@@ -0,0 +1,24 @@
+from edc_constants.constants import NOT_APPLICABLE, OTHER
+
+from .constants import DIET_LIFESTYLE, DRUGS, INSULIN, THIS_CLINIC
+
+CARE_ACCESS = (
+    (THIS_CLINIC, "Patient comes to this facility for their care"),
+    (OTHER, "Patient goes to a different clinic"),
+    (NOT_APPLICABLE, "Not applicable"),
+)
+
+CHOL_MANAGEMENT = (
+    (DRUGS, "Oral drugs"),
+    (DIET_LIFESTYLE, "Diet and lifestyle alone"),
+)
+DM_MANAGEMENT = (
+    (INSULIN, "Insulin injections"),
+    (DRUGS, "Oral drugs"),
+    (DIET_LIFESTYLE, "Diet and lifestyle alone"),
+)
+
+HTN_MANAGEMENT = (
+    (DRUGS, "Drugs / Medicine"),
+    (DIET_LIFESTYLE, "Diet and lifestyle alone"),
+)

edc_dx_review/constants.py

@@ -0,0 +1,7 @@
+INSULIN = "insulin"
+DIET_LIFESTYLE = "diet_lifestyle"
+DRUGS = "drugs"
+DIABETES_CLINIC = "diabetes_clinic"
+HIV_CLINIC = "hiv_clinic"
+HYPERTENSION_CLINIC = "hypertension_clinic"
+THIS_CLINIC = "this_clinic"

edc_dx_review/fieldsets.py

@@ -0,0 +1,47 @@
+from edc_dx import get_diagnosis_labels
+
+
+def get_clinical_review_baseline_cond_fieldset(
+    cond: str, title: str = None
+) -> tuple[str, dict]:
+    if not title:
+        title = cond.upper()
+    return (
+        title,
+        {"fields": (f"{cond}_dx", f"{cond}_dx_at_screening")},
+    )
+
+
+def get_clinical_review_baseline_cond_fieldsets() -> tuple[tuple]:
+    fieldsets = ()
+    for prefix, label in get_diagnosis_labels().items():
+        fieldsets = fieldsets + (
+            get_clinical_review_baseline_cond_fieldset(cond=prefix.lower(), title=label),
+        )
+    return fieldsets
+
+
+def get_clinical_review_cond_fieldset(cond: str, title: str = None) -> tuple[str, dict]:
+    if not title:
+        title = cond.upper()
+    return (
+        title,
+        {
+            "fields": (
+                f"{cond}_test",
+                f"{cond}_test_date",
+                f"{cond}_reason",
+                f"{cond}_reason_other",
+                f"{cond}_dx",
+            )
+        },
+    )
+
+
+def get_clinical_review_cond_fieldsets() -> tuple[tuple]:
+    fieldsets = ()
+    for prefix, label in get_diagnosis_labels().items():
+        fieldsets = fieldsets + (
+            get_clinical_review_cond_fieldset(cond=prefix.lower(), title=label),
+        )
+    return fieldsets

edc_dx_review/form_mixins/__init__.py

@@ -0,0 +1,3 @@
+from .clinical_review_baseline_required_form_mixin import (
+    ClinicalReviewBaselineRequiredModelFormMixin,
+)

edc_dx_review/form_mixins/clinical_review_baseline_required_form_mixin.py

@@ -0,0 +1,25 @@
+from django import forms
+from django.core.exceptions import ObjectDoesNotExist
+from edc_model.utils import model_exists_or_raise
+
+from ..utils import get_clinical_review_baseline_model_cls
+
+
+class ClinicalReviewBaselineRequiredModelFormMixin:
+    """Asserts Baseline Clinical Review exists or raise"""
+
+    def clean(self) -> dict:
+        cleaned_data = super().clean()
+        model_cls = get_clinical_review_baseline_model_cls()
+        if self._meta.model != model_cls and cleaned_data.get("subject_visit"):
+            try:
+                model_exists_or_raise(
+                    subject_visit=cleaned_data.get("subject_visit"),
+                    model_cls=model_cls,
+                    singleton=True,
+                )
+            except ObjectDoesNotExist:
+                raise forms.ValidationError(
+                    f"Complete the `{model_cls._meta.verbose_name}` CRF first."
+                )
+        return cleaned_data

edc_dx_review/form_validator_mixins/__init__.py

@@ -0,0 +1,6 @@
+from .clinical_review_baseline_form_validator_mixin import (
+    ClinicalReviewBaselineFormValidatorMixin,
+)
+from .clinical_review_followup_form_validator_mixin import (
+    ClinicalReviewFollowupFormValidatorMixin,
+)

edc_dx_review/form_validator_mixins/clinical_review_baseline_form_validator_mixin.py

@@ -0,0 +1,7 @@
+from edc_visit_schedule.utils import raise_if_not_baseline
+
+
+class ClinicalReviewBaselineFormValidatorMixin:
+    def _clean(self):
+        raise_if_not_baseline(self.cleaned_data.get("subject_visit"))
+        super()._clean()

edc_dx_review/form_validator_mixins/clinical_review_followup_form_validator_mixin.py

@@ -0,0 +1,25 @@
+from edc_constants.constants import OTHER, YES
+from edc_dx import get_diagnosis_labels
+from edc_dx.form_validators import DiagnosisFormValidatorMixin
+from edc_visit_schedule.utils import raise_if_baseline
+
+
+class ClinicalReviewFollowupFormValidatorMixin(DiagnosisFormValidatorMixin):
+    def _clean(self):
+        raise_if_baseline(self.cleaned_data.get("subject_visit"))
+        for prefix, label in get_diagnosis_labels().items():
+            cond = prefix.lower()
+            self.applicable_if_not_diagnosed(
+                prefix=cond,
+                field_applicable=f"{cond}_test",
+                label=label,
+            )
+            self.required_if(YES, field=f"{cond}_test", field_required=f"{cond}_test_date")
+            self.m2m_required_if(YES, field=f"{cond}_test", m2m_field=f"{cond}_reason")
+            self.m2m_other_specify(
+                OTHER,
+                m2m_field=f"{cond}_reason",
+                field_other=f"{cond}_reason_other",
+            )
+            self.applicable_if(YES, field=f"{cond}_test", field_applicable=f"{cond}_dx")
+        super()._clean()

edc_dx_review/list_data.py

@@ -0,0 +1,19 @@
+from edc_constants.constants import OTHER, UNKNOWN
+
+list_data = {
+    "edc_dx_review.diagnosislocations": [
+        ("hospital", "Hospital"),
+        ("gov_clinic", "Government clinic"),
+        ("private_clinic", "Private clinic"),
+        ("private_doctor", "Private doctor"),
+        ("study_clinic", "Study clinic"),
+        (UNKNOWN, "Don't recall"),
+        (OTHER, "Other, specify"),
+    ],
+    "edc_dx_review.reasonsfortesting": [
+        ("patient_request", "Patient was well and made a request"),
+        ("patient_complication", "Patient had a clinical complication"),
+        ("signs_symptoms", "Patient had suggestive signs and symptoms"),
+        (OTHER, "Other reason (specify below)"),
+    ],
+}