meta-edc 1.1.8__py3-none-any.whl → 1.1.12__py3-none-any.whl

meta_prn/tests/tests/test_pregnancy_notification.py

@@ -1,93 +0,0 @@
-from dateutil.relativedelta import relativedelta
-from django.core.exceptions import ObjectDoesNotExist
-from django.test import TestCase
-from edc_appointment.models import Appointment
-from edc_constants.constants import FEMALE, NO, YES
-from edc_utils import get_utcnow
-from edc_visit_schedule.constants import MONTH1
-from model_bakery.baker import make_recipe
-
-from meta_prn.models import OffSchedule
-from meta_prn.models.pregnancy_notification import PregnancyNotificationError
-from meta_screening.tests.meta_test_case_mixin import MetaTestCaseMixin
-from meta_visit_schedule.constants import SCHEDULE, SCHEDULE_PREGNANCY
-
-
-class TestPregnancyNotification(MetaTestCaseMixin, TestCase):
-    def setUp(self):
-        super().setUp()
-        self.subject_visit = self.get_subject_visit(gender=FEMALE)
-
-    def test_pregnancy_notification_updates_urine_pregnancy(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        self.assertEqual(subject_visit.visit_code, MONTH1)
-        urine_pregnancy = make_recipe(
-            "meta_subject.urinepregnancy",
-            subject_visit=subject_visit,
-            report_datetime=get_utcnow(),
-            assay_date=get_utcnow().date(),
-        )
-
-        self.assertFalse(urine_pregnancy.notified)
-        self.assertIsNotNone(urine_pregnancy.assay_date)
-        make_recipe(
-            "meta_prn.pregnancynotification",
-            subject_identifier=subject_visit.subject_identifier,
-            report_datetime=get_utcnow(),
-        )
-        urine_pregnancy.refresh_from_db()
-        self.assertTrue(urine_pregnancy.notified)
-        self.assertIsNotNone(urine_pregnancy.notified_datetime)
-
-    def test_pregnancy_notification_unconfirmed_ok(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        self.assertEqual(subject_visit.visit_code, MONTH1)
-        make_recipe(
-            "meta_prn.pregnancynotification",
-            subject_identifier=subject_visit.subject_identifier,
-            report_datetime=get_utcnow(),
-            bhcg_confirmed=NO,
-            unconfirmed_details="blah blah",
-        )
-
-    def test_pregnancy_notification_confirmed_raises(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        self.assertEqual(subject_visit.visit_code, MONTH1)
-        try:
-            make_recipe(
-                "meta_prn.pregnancynotification",
-                subject_identifier=subject_visit.subject_identifier,
-                report_datetime=get_utcnow(),
-                bhcg_confirmed=YES,
-                unconfirmed_details="blah blah",
-            )
-        except PregnancyNotificationError:
-            pass
-        else:
-            self.fail("PregnancyNotificationError unexpectedly NOT raised")
-
-    def test_pregnancy_notification_takes_off_schedule(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        self.assertEqual(subject_visit.visit_code, MONTH1)
-        make_recipe(
-            "meta_prn.pregnancynotification",
-            subject_identifier=subject_visit.subject_identifier,
-            report_datetime=subject_visit.report_datetime,
-            bhcg_confirmed=NO,
-            unconfirmed_details="blah blah",
-            edd=subject_visit.report_datetime + relativedelta(months=6),
-        )
-
-        try:
-            OffSchedule.objects.get(subject_identifier=subject_visit.subject_identifier)
-        except ObjectDoesNotExist:
-            self.fail("OffSchedule unexpectedly does not exist")
-
-        self.assertEqual(Appointment.objects.filter(schedule_name=SCHEDULE).count(), 3)
-        self.assertEqual(
-            Appointment.objects.filter(schedule_name=SCHEDULE_PREGNANCY).count(), 1
-        )

meta_prn/tests/urls.py

@@ -1,10 +0,0 @@
-from django.contrib import admin
-from django.urls.conf import include, path
-
-from meta_prn.admin_site import meta_prn_admin
-
-urlpatterns = [
-    path("meta_prn/", include("meta_prn.urls")),
-    path("admin/", meta_prn_admin.urls),
-    path("admin/", admin.site.urls),
-]

meta_rando/tests/tests/test_randomizers.py

@@ -1,57 +0,0 @@
-from django.core.exceptions import ObjectDoesNotExist
-from django.test import TestCase, override_settings
-from edc_constants.constants import FEMALE, MALE
-from edc_randomization.site_randomizers import site_randomizers
-from edc_registration.models import RegisteredSubject
-
-from meta_edc.meta_version import PHASE_THREE, get_meta_version
-from meta_rando.randomizers import RandomizerPhaseThree
-from meta_screening.tests.meta_test_case_mixin import MetaTestCaseMixin
-
-
-class TestRandomizers(MetaTestCaseMixin, TestCase):
-    import_randomization_list = False
-
-    def test_import(self):
-        RandomizerPhaseThree.import_list(sid_count_for_tests=10)
-        obj = RandomizerPhaseThree.model_cls().objects.all().order_by("sid")[0]
-        self.assertEqual(
-            [1001, "active", "hindu_mandal", "F"],
-            [obj.sid, obj.assignment, obj.site_name, obj.gender],
-        )
-
-    @override_settings(META_PHASE=PHASE_THREE)
-    def test_randomize_phase_three(self):
-        self.assertEqual(get_meta_version(), 3)
-        site_randomizers._registry = {}
-        site_randomizers.loaded = False
-        site_randomizers.register(RandomizerPhaseThree)
-        self.subject_visit = self.get_subject_visit(gender=FEMALE)
-        try:
-            RegisteredSubject.objects.get(
-                sid=1001,
-                subject_identifier=self.subject_visit.subject_identifier,
-                gender=FEMALE,
-            )
-        except ObjectDoesNotExist:
-            self.fail("RegisteredSubject unexpectedly does not exist")
-
-        self.subject_visit = self.get_subject_visit(gender=MALE)
-        try:
-            RegisteredSubject.objects.get(
-                sid=1003,
-                subject_identifier=self.subject_visit.subject_identifier,
-                gender=MALE,
-            )
-        except ObjectDoesNotExist:
-            self.fail("RegisteredSubject unexpectedly does not exist")
-
-        self.subject_visit = self.get_subject_visit(gender=FEMALE)
-        try:
-            RegisteredSubject.objects.get(
-                sid=1002,
-                subject_identifier=self.subject_visit.subject_identifier,
-                gender=FEMALE,
-            )
-        except ObjectDoesNotExist:
-            self.fail("RegisteredSubject unexpectedly does not exist")

meta_reports/tests/test_reports.py

@@ -1,35 +0,0 @@
-from django.contrib.auth.models import User
-from django.test import TestCase
-from django.test.client import RequestFactory
-from edc_adverse_event.models import AeClassification
-from model_bakery import baker
-
-from meta_reports.ae_report import AeReport
-from meta_screening.tests.meta_test_case_mixin import MetaTestCaseMixin
-
-
-class TestReports(MetaTestCaseMixin, TestCase):
-    def setUp(self):
-        self.user = User.objects.create(username="erikvw", is_staff=True, is_active=True)
-        subject_screening = self.get_subject_screening()
-        subject_consent = self.get_subject_consent(subject_screening)
-        self.subject_identifier = subject_consent.subject_identifier
-
-    def test_aereport(self):
-        rf = RequestFactory()
-        request = rf.get("/")
-        request.user = self.user
-        ae_classification = AeClassification.objects.all()[0]
-        ae_initial = baker.make_recipe(
-            "meta_ae.aeinitial",
-            subject_identifier=self.subject_identifier,
-            ae_classification=ae_classification,
-        )
-
-        report = AeReport(
-            ae_initial=ae_initial,
-            subject_identifier=ae_initial.subject_identifier,
-            user=request.user,
-            request=request,
-        )
-        return report.render_to_response()

meta_reports/tests/test_sql_gen.py

@@ -1,5 +0,0 @@
-from django.test import TestCase
-
-
-class TestSqlGen(TestCase):
-    pass

meta_reports/tests/urls.py

@@ -1,4 +0,0 @@
-from django.contrib import admin
-from django.urls import path
-
-urlpatterns = [path("admin/", admin.site.urls)]

meta_screening/offline_models.py

@@ -1,3 +0,0 @@
-from django_collect_offline.site_offline_models import site_offline_models
-
-site_offline_models.register_for_app("meta_screening")

meta_screening/tests/holidays.csv

@@ -1,15 +0,0 @@
-2019-01-01,New Year's Day,tanzania
-2019-01-12,Zanzibar Revolution Day,tanzania
-2019-04-07,The Sheikh Abeid Amani Karume Day,tanzania
-2019-04-17,Easter Monday,tanzania
-2019-04-26,Union Day,tanzania
-2019-05-01,Labour Day,tanzania
-2019-06-26,Eid al-Fitr,tanzania
-2019-07-07,Saba Saba Day,tanzania
-2019-07-14,Good Friday,tanzania
-2019-08-08,Nane Nane Day,tanzania
-2019-10-14,Nyerere Day,tanzania
-2019-12-01,Mawlid Day,tanzania
-2019-12-09,Independence Day,tanzania
-2019-12-25,Christmas Day,tanzania
-2019-12-26,Boxing Day,tanzania

meta_screening/tests/meta_test_case_mixin.py

@@ -1,234 +0,0 @@
-from __future__ import annotations
-
-from copy import deepcopy
-from datetime import date, datetime
-
-from dateutil.relativedelta import relativedelta
-from django.conf import settings
-from django.contrib.sites.models import Site
-from edc_appointment.constants import IN_PROGRESS_APPT, INCOMPLETE_APPT
-from edc_appointment.tests.test_case_mixins import AppointmentTestCaseMixin
-from edc_constants.constants import YES
-from edc_facility.import_holidays import import_holidays
-from edc_list_data.site_list_data import site_list_data
-from edc_metadata import REQUIRED
-from edc_metadata.models import CrfMetadata
-from edc_randomization.site_randomizers import site_randomizers
-from edc_reportable.utils import load_reference_ranges
-from edc_sites.site import sites
-from edc_sites.utils import add_or_update_django_sites
-from edc_visit_tracking.constants import SCHEDULED
-from model_bakery import baker
-
-from meta_consent.models import SubjectConsent, SubjectConsentV1Ext
-from meta_edc.meta_version import PHASE_THREE
-from meta_labs.reportables import reference_range_options
-from meta_pharmacy.prepare_meta_pharmacy import prepare_meta_pharmacy
-from meta_sites.sites import domain_suffix
-from meta_subject.models import SubjectVisit
-from meta_visit_schedule.constants import DAY1
-
-from ..models import (
-    ScreeningPartOne,
-    ScreeningPartThree,
-    ScreeningPartTwo,
-    SubjectScreening,
-)
-from .options import (
-    get_part_one_eligible_options,
-    get_part_three_eligible_options,
-    get_part_two_eligible_options,
-    now,
-)
-
-
-class MetaTestCaseMixin(AppointmentTestCaseMixin):
-    fqdn = domain_suffix
-
-    default_sites = sites.get_by_country("tanzania", aslist=True)
-
-    site_names = [s.name for s in default_sites]
-
-    import_randomization_list = True
-
-    sid_count_for_tests = 5
-
-    @classmethod
-    def setUpTestData(cls):
-        load_reference_ranges(**reference_range_options)
-        import_holidays(test=True)
-        add_or_update_django_sites(single_sites=sites.get_by_country("tanzania", aslist=True))
-        if cls.import_randomization_list:
-            randomizer_cls = site_randomizers.get(PHASE_THREE)
-            randomizer_cls.import_list(
-                verbose=False, sid_count_for_tests=cls.sid_count_for_tests
-            )
-        site_list_data.initialize()
-        site_list_data.autodiscover()
-        prepare_meta_pharmacy()
-
-    def get_subject_screening(
-        self,
-        report_datetime: datetime | None = None,
-        eligibility_datetime: datetime | None = None,
-        gender: str | None = None,
-        ethnicity: str | None = None,
-        age_in_years: int | None = None,
-    ):
-        part_one_eligible_options = deepcopy(get_part_one_eligible_options())
-        part_two_eligible_options = deepcopy(get_part_two_eligible_options())
-        part_three_eligible_options = deepcopy(get_part_three_eligible_options())
-        if report_datetime:
-            part_one_eligible_options.update(report_datetime=report_datetime)
-        part_one_eligible_options["age_in_years"] = (
-            age_in_years or part_one_eligible_options["age_in_years"]
-        )
-        part_one_eligible_options["gender"] = gender or part_one_eligible_options["gender"]
-        part_one_eligible_options["ethnicity"] = (
-            ethnicity or part_one_eligible_options["ethnicity"]
-        )
-        part_one = ScreeningPartOne.objects.create(
-            user_created="erikvw",
-            user_modified="erikvw",
-            **part_one_eligible_options,
-        )
-        screening_identifier = part_one.screening_identifier
-        self.assertEqual(part_one.reasons_ineligible_part_one, None)
-        self.assertEqual(part_one.eligible_part_one, YES)
-
-        screening_part_two = ScreeningPartTwo.objects.get(
-            screening_identifier=screening_identifier
-        )
-        for k, v in part_two_eligible_options.items():
-            setattr(screening_part_two, k, v)
-        screening_part_two.save()
-        self.assertEqual(screening_part_two.reasons_ineligible_part_two, None)
-        self.assertEqual(screening_part_two.eligible_part_two, YES)
-
-        screening_part_three = ScreeningPartThree.objects.get(
-            screening_identifier=screening_identifier
-        )
-        for k, v in part_three_eligible_options.items():
-            setattr(screening_part_three, k, v)
-        screening_part_three.save()
-        self.assertEqual(screening_part_three.reasons_ineligible_part_three, None)
-        self.assertEqual(screening_part_three.eligible_part_three, YES)
-
-        subject_screening = SubjectScreening.objects.get(
-            screening_identifier=screening_identifier
-        )
-
-        self.assertTrue(subject_screening.eligible)
-
-        if eligibility_datetime:
-            screening_part_three.eligibility_datetime = eligibility_datetime
-            screening_part_three.save()
-            subject_screening = SubjectScreening.objects.get(
-                screening_identifier=screening_identifier
-            )
-        return subject_screening
-
-    @staticmethod
-    def get_subject_consent(
-        subject_screening: SubjectScreening,
-        consent_datetime: datetime = None,
-        dob: date = None,
-        site_id: int = None,
-    ):
-        return baker.make_recipe(
-            "meta_consent.subjectconsentv1",
-            user_created="erikvw",
-            user_modified="erikvw",
-            screening_identifier=subject_screening.screening_identifier,
-            initials=subject_screening.initials,
-            gender=subject_screening.gender,
-            dob=dob or (now.date() - relativedelta(years=subject_screening.age_in_years)),
-            site=Site.objects.get(id=site_id or settings.SITE_ID),
-            consent_datetime=consent_datetime or subject_screening.report_datetime,
-        )
-
-    @staticmethod
-    def get_subject_consent_extended(
-        subject_consent: SubjectConsent,
-        consent_datetime: datetime = None,
-    ):
-        return SubjectConsentV1Ext.objects.create(
-            subject_consent=subject_consent,
-            report_datetime=consent_datetime,
-            agrees_to_extension=YES,
-            user_created="erikvw",
-            user_modified="erikvw",
-            site=subject_consent.site,
-        )
-
-    def get_subject_visit(
-        self,
-        visit_code: str | None = None,
-        visit_code_sequence: int | None = None,
-        subject_screening=None,
-        subject_consent=None,
-        reason: str | None = None,
-        appt_datetime: datetime | None = None,
-        gender: str | None = None,
-        ethnicity: str | None = None,
-        age_in_years: int | None = None,
-        screening_datetime: datetime | None = None,
-        eligibility_datetime: datetime | None = None,
-    ):
-        reason = reason or SCHEDULED
-        subject_screening = subject_screening or self.get_subject_screening(
-            gender=gender,
-            ethnicity=ethnicity,
-            age_in_years=age_in_years,
-            report_datetime=screening_datetime,
-            eligibility_datetime=eligibility_datetime,
-        )
-        subject_consent = subject_consent or self.get_subject_consent(subject_screening)
-        options = dict(
-            subject_identifier=subject_consent.subject_identifier,
-            visit_code=visit_code or DAY1,
-            visit_code_sequence=(
-                visit_code_sequence if visit_code_sequence is not None else 0
-            ),
-            reason=reason,
-        )
-        if appt_datetime:
-            options.update(appt_datetime=appt_datetime)
-        appointment = self.get_appointment(**options)
-        subject_visit = SubjectVisit(
-            appointment=appointment,
-            reason=SCHEDULED,
-            report_datetime=appointment.appt_datetime,
-        )
-        subject_visit.save()
-        subject_visit.refresh_from_db()
-        return subject_visit
-
-    @staticmethod
-    def get_next_subject_visit(subject_visit):
-        appointment = subject_visit.appointment
-        appointment.appt_status = INCOMPLETE_APPT
-        appointment.save()
-        appointment.refresh_from_db()
-        next_appointment = appointment.next_by_timepoint
-        next_appointment.appt_status = IN_PROGRESS_APPT
-        next_appointment.save()
-        subject_visit = SubjectVisit(
-            appointment=next_appointment,
-            reason=SCHEDULED,
-            report_datetime=next_appointment.appt_datetime,
-            visit_code=next_appointment.visit_code,
-            visit_code_sequence=next_appointment.visit_code_sequence,
-        )
-        subject_visit.save()
-        subject_visit.refresh_from_db()
-        return subject_visit
-
-    @staticmethod
-    def get_crf_metadata(subject_visit):
-        return CrfMetadata.objects.filter(
-            subject_identifier=subject_visit.subject_identifier,
-            visit_code=subject_visit.visit_code,
-            visit_code_sequence=subject_visit.visit_code_sequence,
-            entry_status=REQUIRED,
-        )

meta_screening/tests/options.py

@@ -1,127 +0,0 @@
-from datetime import datetime
-from random import sample
-from secrets import choice
-from string import ascii_uppercase
-from zoneinfo import ZoneInfo
-
-from dateutil.relativedelta import relativedelta
-from django.conf import settings
-from django.contrib.sites.models import Site
-from edc_constants.constants import (
-    BLACK,
-    FEMALE,
-    NO,
-    NOT_APPLICABLE,
-    RANDOM_SAMPLING,
-    YES,
-)
-from edc_reportable.units import MICROMOLES_PER_LITER, MILLIMOLES_PER_LITER
-from faker import Faker
-
-from meta_edc.meta_version import get_meta_version
-from meta_screening.forms import part_one_fields, part_three_fields, part_two_fields
-
-fake = Faker()
-now = datetime(2019, 5, 1).astimezone(ZoneInfo("UTC"))
-tomorrow = now + relativedelta(days=1)
-
-
-def get_part_one_eligible_options():
-    options = dict(
-        age_in_years=25,
-        art_six_months=YES,
-        continue_part_two=YES,
-        ethnicity=BLACK,
-        gender=FEMALE,
-        hiv_pos=YES,
-        hospital_identifier="".join(map(str, sample(range(0, 10), 10))),  # nosec B311
-        initials=f"{choice(ascii_uppercase)}{choice(ascii_uppercase)}",  # nosec B311
-        lives_nearby=YES,
-        on_rx_stable=YES,
-        pregnant=NOT_APPLICABLE,
-        report_datetime=now,
-        screening_consent=YES,
-        selection_method=RANDOM_SAMPLING,
-        staying_nearby_12=YES,
-        vl_undetectable=YES,
-        meta_phase_two=NO,
-        site=Site.objects.get(id=settings.SITE_ID),
-    )
-    if fld := [f for f in part_one_fields if f not in options]:
-        raise TypeError(
-            f"Missing part one fields for meta phase {get_meta_version()}. Got {fld}."
-        )
-    return options
-
-
-def get_part_two_eligible_options(report_datetime: datetime = None) -> dict:
-    options = dict(
-        acute_condition=NO,
-        acute_metabolic_acidosis=NO,
-        advised_to_fast=YES,
-        alcoholism=NO,
-        already_fasted=NO,
-        appt_datetime=report_datetime or (now + relativedelta(days=10)),
-        congestive_heart_failure=NO,
-        liver_disease=NO,
-        metformin_sensitivity=NO,
-        part_two_report_datetime=report_datetime or now,
-        renal_function_condition=NO,
-        tissue_hypoxia_condition=NO,
-        has_dm=NO,
-        on_dm_medication=NO,
-        agree_to_p3=YES,
-        p3_ltfu=NOT_APPLICABLE,
-        p3_ltfu_date=None,
-        p3_ltfu_comment=None,
-        contact_number=None,
-    )
-    if fld := [f for f in part_two_fields if f not in options]:
-        raise TypeError(
-            f"Missing part two fields for meta phase {get_meta_version()}. Got {fld}."
-        )
-    return options
-
-
-def get_part_three_eligible_options(report_datetime: datetime = None):
-    options = dict(
-        creatinine_performed=YES,
-        creatinine_units=MICROMOLES_PER_LITER,
-        creatinine_value=50,
-        dia_blood_pressure=65,
-        dia_blood_pressure_one=65,
-        dia_blood_pressure_two=65,
-        fasting=YES,
-        fasting_duration_str="8h",
-        hba1c_performed=YES,
-        hba1c_datetime=report_datetime or now,
-        hba1c_value=7.0,
-        height=110,
-        fbg_datetime=tomorrow,
-        fbg_units=MILLIMOLES_PER_LITER,
-        fbg_value=6.9,
-        ogtt_base_datetime=tomorrow + relativedelta(minutes=5),
-        ogtt_datetime=tomorrow + relativedelta(hours=2),
-        ogtt_units=MILLIMOLES_PER_LITER,
-        ogtt_value=7.8,
-        repeat_glucose_opinion=NO,
-        ogtt2_performed=NOT_APPLICABLE,
-        part_three_report_datetime=report_datetime or now,
-        reasons_unsuitable=None,
-        sys_blood_pressure=120,
-        sys_blood_pressure_one=120,
-        sys_blood_pressure_two=120,
-        unsuitable_agreed=NOT_APPLICABLE,
-        unsuitable_for_study=NO,
-        urine_bhcg_date=None,
-        urine_bhcg_performed=NOT_APPLICABLE,
-        urine_bhcg_value=NOT_APPLICABLE,
-        waist_circumference=130,
-        weight=65,
-        severe_htn=NO,
-    )
-    if fld := [f for f in part_three_fields if f not in options]:
-        raise TypeError(
-            f"Missing part three fields for meta phase {get_meta_version()}. Got {fld}."
-        )
-    return options