clinicedc 2.0.33__py3-none-any.whl → 2.0.35__py3-none-any.whl

edc_appointment/view_mixins/appointment_view_mixin.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from typing import TYPE_CHECKING, Any
 
 from django.apps import apps as django_apps
@@ -50,7 +51,7 @@ class AppointmentViewMixin:
             if self.appointment.related_visit:
                 report_datetime = self.appointment.related_visit.report_datetime
                 kwargs.update(report_datetime=report_datetime)
-        has_call_manager = True if django_apps.app_configs.get("edc_call_manager") else False
+        has_call_manager = bool(django_apps.app_configs.get("edc_call_manager"))
         kwargs.update(
             appointment=self.appointment,
             appointments=self.appointments,
@@ -92,18 +93,15 @@ class AppointmentViewMixin:
 
     @property
     def appointment(self) -> Appointment:
-        if not self._appointment:
-            if self.appointment_id:
-                try:
-                    self._appointment = self.appointment_model_cls.objects.get(
-                        id=self.appointment_id
-                    )
-                except ObjectDoesNotExist:
-                    if opts := self.appointment_options:
-                        try:
-                            self._appointment = self.appointment_model_cls.objects.get(**opts)
-                        except ObjectDoesNotExist:
-                            pass
+        if not self._appointment and self.appointment_id:
+            try:
+                self._appointment = self.appointment_model_cls.objects.get(
+                    id=self.appointment_id
+                )
+            except ObjectDoesNotExist:
+                if opts := self.appointment_options:
+                    with contextlib.suppress(ObjectDoesNotExist):
+                        self._appointment = self.appointment_model_cls.objects.get(**opts)
         return self._appointment
 
     @property

edc_appointment/views/unscheduled_appointment_view.py

@@ -3,7 +3,6 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.http.response import HttpResponseRedirect
 from django.urls.base import reverse
 from django.utils.html import format_html
-from django.utils.safestring import mark_safe
 from django.views.generic.base import View
 
 from ..creators import UnscheduledAppointmentCreator
@@ -30,7 +29,7 @@ class UnscheduledAppointmentView(View):
     unscheduled_appointment_cls = UnscheduledAppointmentCreator
     dashboard_template = "subject_dashboard_template"
 
-    def get(self, request, *args, **kwargs):
+    def get(self, request, *args, **kwargs):  # noqa: ARG002
         kwargs["suggested_visit_code_sequence"] = int(kwargs["visit_code_sequence"])
         kw = dict(
             subject_identifier=kwargs.get("subject_identifier"),
@@ -61,15 +60,15 @@ class UnscheduledAppointmentView(View):
             messages.success(
                 self.request,
                 format_html(
-                    "Appointment {} was created successfully.",
-                    mark_safe(creator.appointment),  # nosec B308, B703
+                    "Appointment {appt} was created successfully.",
+                    appt=creator.appointment,  # nosec B308, B703
                 ),
             )
             messages.warning(
                 self.request,
                 format_html(
-                    "Remember to adjust the appointment date and time on appointment {}.",
-                    mark_safe(creator.appointment),  # nosec B308, B703
+                    "Remember to adjust the appointment date and time on appointment {appt}.",
+                    appt=creator.appointment,  # nosec B308, B703
                 ),
             )
         return HttpResponseRedirect(

edc_consent/consent_definition.py

@@ -82,16 +82,8 @@ class ConsentDefinition:
             raise ConsentDefinitionError(f"Invalid gender. Got {self.gender}.")
         if not self.start.tzinfo:
             raise ConsentDefinitionError(f"Naive datetime not allowed. Got {self.start}.")
-        if str(self.start.tzinfo).upper() != "UTC":
-            raise ConsentDefinitionError(
-                f"Start date must be UTC. Got {self.start} / {self.start.tzinfo}."
-            )
         if not self.end.tzinfo:
-            raise ConsentDefinitionError(f"Naive datetime not allowed Got {self.end}.")
-        if str(self.end.tzinfo).upper() != "UTC":
-            raise ConsentDefinitionError(
-                f"End date must be UTC. Got {self.end} / {self.start.tzinfo}."
-            )
+            raise ConsentDefinitionError(f"Naive datetime not allowed. Got {self.end}.")
         self.check_date_within_study_period()
 
     def model_create(self, **kwargs) -> ConsentLikeModel:
@@ -147,7 +139,7 @@ class ConsentDefinition:
 
     def get_consent_for(
         self,
-        subject_identifier: str = None,
+        subject_identifier: str,
         site_id: int | None = None,
         raise_if_not_consented: bool | None = None,
     ) -> ConsentLikeModel | None:
@@ -209,9 +201,9 @@ class ConsentDefinition:
                 <= getattr(self, attr)
                 <= ceil_secs(study_close_datetime)
             ):
-                open_date_string = formatted_datetime(study_open_datetime)
-                close_date_string = formatted_datetime(study_close_datetime)
-                attr_date_string = formatted_datetime(getattr(self, attr))
+                open_date_string = formatted_datetime(to_local(study_open_datetime))
+                close_date_string = formatted_datetime(to_local(study_close_datetime))
+                attr_date_string = formatted_datetime(to_local(getattr(self, attr)))
                 raise ConsentDefinitionError(
                     f"Invalid {attr} date. "
                     f"Must be within the opening and closing dates of the protocol. "

edc_consent/consent_definition_extension.py

@@ -72,8 +72,6 @@ class ConsentDefinitionExtension:
         self.sort_index = self.name
         if not self.start.tzinfo:
             raise ConsentDefinitionError(f"Naive datetime not allowed. Got {self.start}.")
-        if str(self.start.tzinfo) != "UTC":
-            raise ConsentDefinitionError(f"Start date must be UTC. Got {self.start}.")
         self.extends.check_date_within_study_period()
 
     def update_visit_collection(

edc_consent/form_validators/consent_definition_form_validator_mixin.py

@@ -13,15 +13,15 @@ from edc_consent.exceptions import (
     SiteConsentError,
 )
 from edc_consent.site_consents import site_consents
+from edc_consent.stubs import ConsentLikeModel
 from edc_form_validators import INVALID_ERROR
 from edc_sites.site import sites as site_sites
 
 if TYPE_CHECKING:
-    from django.contrib.sites.models import Site
+    pass
 
 
 class ConsentDefinitionFormValidatorMixin:
-
     @property
     def subject_consent(self):
         cdef = self.get_consent_definition()
@@ -29,48 +29,48 @@ class ConsentDefinitionFormValidatorMixin:
 
     def get_consent_datetime_or_raise(
         self,
-        report_datetime: datetime = None,
-        site: Site = None,
-        fldname: str = None,
-        error_code: str = None,
+        reference_datetime: datetime | None = None,
+        reference_datetime_field: str | None = None,
+        error_code: str | None = None,
     ) -> datetime:
         """Returns the consent_datetime of this subject"""
         consent_obj = self.get_consent_or_raise(
-            report_datetime=report_datetime,
-            site=site,
-            fldname=fldname,
+            reference_datetime=reference_datetime,
+            reference_datetime_field=reference_datetime_field,
             error_code=error_code,
         )
         return consent_obj.consent_datetime
 
     def get_consent_or_raise(
         self,
-        report_datetime: datetime = None,
-        site: Site = None,
-        fldname: str | None = None,
+        reference_datetime: datetime | None = None,
+        reference_datetime_field: str | None = None,
         error_code: str | None = None,
-    ) -> datetime:
+    ) -> ConsentLikeModel:
         """Returns the consent_datetime of this subject.
 
         Wraps func `consent_datetime_or_raise` to re-raise exceptions
         as ValidationError.
         """
 
-        fldname = fldname or "report_datetime"
         error_code = error_code or INVALID_ERROR
         try:
             consent_obj = site_consents.get_consent_or_raise(
                 subject_identifier=self.subject_identifier,
-                report_datetime=report_datetime,
-                site_id=getattr(site, "id", None),
+                report_datetime=reference_datetime or self.report_datetime,
+                site_id=getattr(self.site, "id", None),
             )
         except (NotConsentedError, ConsentDefinitionNotConfiguredForUpdate) as e:
-            self.raise_validation_error({fldname: str(e)}, error_code)
+            self.raise_validation_error(
+                {reference_datetime_field or self.report_datetime_field_attr: str(e)},
+                error_code,
+                exc=e,
+            )
         return consent_obj
 
     def get_consent_definition(
         self,
-        report_datetime: datetime = None,
+        report_datetime: datetime,
         fldname: str = None,
         error_code: str = None,
     ) -> ConsentDefinition:
@@ -84,19 +84,15 @@ class ConsentDefinitionFormValidatorMixin:
                 report_datetime=report_datetime,
             )
         except ConsentDefinitionDoesNotExist as e:
-            self.raise_validation_error({fldname: str(e)}, error_code)
-        except SiteConsentError:
+            self.raise_validation_error({fldname: str(e)}, error_code, exc=e)
+        except SiteConsentError as e:
             possible_consents = "', '".join(
                 [cdef.display_name for cdef in site_consents.consent_definitions]
             )
-            self.raise_validation_error(
-                {
-                    fldname: _(
-                        "Date does not fall within a valid consent period. "
-                        "Possible consents are '%(possible_consents)s'. "
-                        % {"possible_consents": possible_consents}
-                    )
-                },
-                error_code,
-            )
+            msg = _(
+                "Date does not fall within a valid consent period. "
+                "Possible consents are '%(possible_consents)s'. "
+            ) % {"possible_consents": possible_consents}
+
+            self.raise_validation_error({fldname: msg}, error_code, exc=e)
         return consent_definition

edc_consent/form_validators/subject_consent_form_validator.py

@@ -9,7 +9,7 @@ from edc_form_validators import INVALID_ERROR
 from edc_screening.form_validator_mixins import SubjectScreeningFormValidatorMixin
 from edc_sites.site import sites
 from edc_utils import AgeValueError, age
-from edc_utils.date import to_local, to_utc
+from edc_utils.date import to_local
 from edc_utils.text import convert_php_dateformat
 
 from ..site_consents import site_consents
@@ -63,7 +63,7 @@ class SubjectConsentFormValidatorMixin(SubjectScreeningFormValidatorMixin):
                     self.raise_validation_error(
                         {"consent_datetime": "This field is required."}, INVALID_ERROR
                     )
-                self._consent_datetime = to_utc(self.cleaned_data.get("consent_datetime"))
+                self._consent_datetime = self.cleaned_data.get("consent_datetime")
             else:
                 self._consent_datetime = self.instance.consent_datetime
         return self._consent_datetime
@@ -75,7 +75,7 @@ class SubjectConsentFormValidatorMixin(SubjectScreeningFormValidatorMixin):
         try:
             rdelta = age(self.dob, self.subject_screening.report_datetime.date())
         except AgeValueError as e:
-            self.raise_validation_error(str(e), INVALID_ERROR)
+            self.raise_validation_error(str(e), INVALID_ERROR, exc=e)
         return rdelta.years
 
     def validate_age(self) -> None:

edc_consent/modelform_mixins/consent_modelform_mixin/consent_modelform_validation_mixin.py

@@ -8,7 +8,7 @@ from django import forms
 
 from edc_constants.constants import NO, YES
 from edc_model_form.utils import get_field_or_raise
-from edc_utils import AgeValueError, age, formatted_age
+from edc_utils.age import AgeValueError, age, formatted_age
 
 from ...exceptions import ConsentDefinitionValidityPeriodError
 from ...site_consents import site_consents

edc_consent/modelform_mixins/requires_consent_modelform_mixin.py

@@ -5,8 +5,7 @@ from typing import TYPE_CHECKING
 from django import forms
 
 from edc_sites import site_sites
-from edc_utils import formatted_date
-from edc_utils.date import to_utc
+from edc_utils import formatted_date, to_local
 
 from ..consent_definition import ConsentDefinition
 from ..exceptions import (
@@ -36,7 +35,7 @@ class RequiresConsentModelFormMixin:
         return cleaned_data
 
     def validate_against_dob(self, consent_obj):
-        if consent_obj and to_utc(self.report_datetime).date() < consent_obj.dob:
+        if consent_obj and to_local(self.report_datetime).date() < consent_obj.dob:
             dte_str = formatted_date(consent_obj.dob)
             raise forms.ValidationError(f"Report datetime cannot be before DOB. Got {dte_str}")
 
@@ -53,7 +52,7 @@ class RequiresConsentModelFormMixin:
                     site_id=self.site.id,
                 )
             except (NotConsentedError, ConsentDefinitionNotConfiguredForUpdate) as e:
-                raise forms.ValidationError({"__all__": str(e)})
+                raise forms.ValidationError({"__all__": str(e)}) from e
         return consent_obj
 
     @property
@@ -66,5 +65,5 @@ class RequiresConsentModelFormMixin:
                 report_datetime=self.report_datetime,
             )
         except ConsentDefinitionDoesNotExist as e:
-            raise forms.ValidationError(e)
+            raise forms.ValidationError(e) from e
         return cdef

edc_consent/site_consents.py

@@ -10,7 +10,7 @@ from django.core.management.color import color_style
 from django.utils.module_loading import import_module, module_has_submodule
 
 from edc_sites.site import sites as site_sites
-from edc_utils import ceil_secs, floor_secs, formatted_date, to_utc
+from edc_utils import ceil_secs, floor_secs, formatted_date, to_local
 
 from .exceptions import (
     AlreadyRegistered,
@@ -154,9 +154,9 @@ class SiteConsents:
             raise_if_not_consented=raise_if_not_consented,
         )
 
-        if consent_obj and to_utc(report_datetime) < consent_obj.consent_datetime:
+        if consent_obj and report_datetime < consent_obj.consent_datetime:
             if not consent_definition.updates:
-                dte = formatted_date(report_datetime)
+                dte = formatted_date(to_local(report_datetime))
                 raise ConsentDefinitionNotConfiguredForUpdate(
                     f"Consent not configured to update any previous versions. "
                     f"Got '{consent_definition.version}'. "
@@ -164,12 +164,12 @@ class SiteConsents:
                     f"'{consent_definition.version}' "
                     f"of consent on or after report_datetime='{dte}'?"
                 )
-            if consent_definition.start <= to_utc(report_datetime) <= consent_definition.end:
+            if consent_definition.start <= report_datetime <= consent_definition.end:
                 # ensures the higher version is returned if there is overlap
                 pass
             elif (
                 consent_definition.updates.start
-                <= to_utc(report_datetime)
+                <= report_datetime
                 <= consent_definition.updates.end
             ):
                 # return the previous version consent (updated_by)
@@ -245,19 +245,19 @@ class SiteConsents:
 
         # filter cdefs to try to get just one.
         # by model, report_datetime, version, site
-        cdefs, error_msg = self._filter_cdefs_by_model_or_raise(model, cdefs, error_messages)
-        cdefs, error_msg = self._filter_cdefs_by_report_datetime_or_raise(
+        cdefs, error_messages = self._filter_cdefs_by_model_or_raise(
+            model, cdefs, error_messages
+        )
+        cdefs, error_messages = self._filter_cdefs_by_report_datetime_or_raise(
             report_datetime, cdefs, error_messages
         )
-        cdefs, error_msg = self._filter_cdefs_by_version_or_raise(
+        cdefs, error_messages = self._filter_cdefs_by_version_or_raise(
             version, cdefs, error_messages
         )
         cdefs = self.filter_cdefs_by_site_or_raise(site, cdefs, error_messages)
-
-        cdefs, error_msg = self._filter_cdefs_by_screening_model_or_raise(
+        cdefs, _ = self._filter_cdefs_by_screening_model_or_raise(
             screening_model, cdefs, error_messages
         )
-
         # apply additional criteria
         for k, v in kwargs.items():
             if v is not None:
@@ -324,17 +324,16 @@ class SiteConsents:
             cdefs = [
                 cdef
                 for cdef in cdefs
-                if floor_secs(cdef.start) <= to_utc(report_datetime) <= ceil_secs(cdef.end)
+                if floor_secs(cdef.start) <= report_datetime <= ceil_secs(cdef.end)
             ]
+            date_string = formatted_date(to_local(report_datetime))
             if not cdefs:
-                date_string = formatted_date(report_datetime)
                 using_msg = "Using " + " and ".join(errror_messages)
                 raise ConsentDefinitionDoesNotExist(
                     "Date does not fall within the validity period of any "
                     f"consent definition. Got {date_string}. {using_msg}. "
                     f"Possible consent definitions are: {consent_definitions}. "
                 )
-            date_string = formatted_date(report_datetime)
             errror_messages.append(f"report_datetime={date_string}")
         return cdefs, errror_messages
 

edc_crf/crf_form_validator.py

@@ -10,7 +10,7 @@ from edc_appointment.form_validator_mixins import WindowPeriodFormValidatorMixin
 from edc_form_validators import INVALID_ERROR, FormValidator
 from edc_registration import get_registered_subject_model_cls
 from edc_sites.form_validator_mixin import SiteFormValidatorMixin
-from edc_utils import floor_secs, formatted_datetime, to_utc
+from edc_utils import floor_secs, formatted_datetime
 from edc_utils.date import to_local
 from edc_visit_tracking.modelform_mixins import get_related_visit
 
@@ -65,13 +65,8 @@ class CrfFormValidator(
             # falls within appointment's window period
             self.validate_crf_datetime_in_window_period()
             # not before consent date
-            report_datetime = to_utc(self.report_datetime)
-            consent_datetime = self.get_consent_datetime_or_raise(
-                report_datetime=report_datetime,
-                site=self.site,
-                fldname="report_datetime",
-            )
-            if floor_secs(report_datetime) < floor_secs(consent_datetime):
+            consent_datetime = self.get_consent_datetime_or_raise()
+            if floor_secs(self.report_datetime) < floor_secs(consent_datetime):
                 msg = _("Invalid. Cannot be before date of consent. Participant consented on")
                 formatted_date = formatted_datetime(to_local(consent_datetime))
                 err_message = format_lazy(
@@ -83,24 +78,25 @@ class CrfFormValidator(
                 )
 
     def validate_crf_datetime_in_window_period(self) -> None:
-        opts = [
+        self.datetime_in_window_or_raise(
             self.appointment,
             self.report_datetime,
             self.report_datetime_field_attr,
-        ]
-        self.datetime_in_window_or_raise(*opts)
+        )
 
     @property
     def appointment(self) -> Appointment:
         try:
-            return self.related_visit.appointment
-        except AttributeError:
+            appointment = self.related_visit.appointment
+        except AttributeError as e:
             msg = _("is required")
             verbose_name = self.related_visit._meta.verbose_name
             self.raise_validation_error(
                 format_lazy("{verbose_name} {msg}.", msg=msg, verbose_name=verbose_name),
                 INVALID_ERROR,
+                exc=e,
             )
+        return appointment
 
     @property
     def related_visit_model_attr(self) -> str:
@@ -127,19 +123,17 @@ class CrfFormValidator(
                 self, related_visit_model_attr=self.related_visit_model_attr
             )
         except AttributeError as e:
-            raise CrfFormValidatorError(f"{e}. See {self.__class__}")
+            raise CrfFormValidatorError(f"{e}. See {self.__class__}") from e
 
     def validate_datetime_against_report_datetime(self, field: str) -> None:
         """Datetime cannot be after report_datetime"""
         if (
             self.cleaned_data.get(field)
             and floor_secs(self.report_datetime)
-            and floor_secs(to_utc(self.cleaned_data.get(field)))
-            > floor_secs(self.report_datetime)
+            and floor_secs(self.cleaned_data.get(field)) > floor_secs(self.report_datetime)
         ):
-            self.raise_validation_error(
-                {field: _("Cannot be after report datetime")}, INVALID_ERROR
-            )
+            msg = _("Cannot be after report datetime")
+            self.raise_validation_error({field: msg}, INVALID_ERROR)
 
     def validate_date_against_report_datetime(self, field: str) -> None:
         """Date cannot be after report_datetime"""

edc_crf/crf_form_validator_mixins.py

@@ -7,7 +7,7 @@ from django.core.exceptions import ObjectDoesNotExist
 
 from edc_consent.form_validators import ConsentDefinitionFormValidatorMixin
 from edc_form_validators import ReportDatetimeFormValidatorMixin
-from edc_utils import age, to_utc
+from edc_utils import age, to_local
 from edc_visit_schedule.schedule import Schedule
 from edc_visit_schedule.visit_schedule import VisitSchedule
 from edc_visit_tracking.modelform_mixins import get_related_visit
@@ -43,7 +43,7 @@ class BaseFormValidatorMixin(
     @property
     def age_in_years(self) -> int | None:
         if self.report_datetime and self.subject_consent.dob:
-            return age(self.subject_consent.dob, to_utc(self.report_datetime)).years
+            return age(self.subject_consent.dob, to_local(self.report_datetime)).years
         return None
 
 
@@ -58,21 +58,6 @@ class CrfFormValidatorMixin(BaseFormValidatorMixin):
         """Always returns the subject_identifier from related_visit"""
         return self.related_visit.subject_identifier
 
-    @property
-    def report_datetime(self) -> datetime:
-        """Returns report_datetime or raises.
-
-        Report datetime is always a required field on a CRF model,
-        Django will raise a field ValidationError before getting
-        here if report_datetime is None.
-        """
-        report_datetime = None
-        if self.report_datetime_field_attr in self.cleaned_data:
-            report_datetime = self.cleaned_data.get(self.report_datetime_field_attr)
-        elif self.instance:
-            report_datetime = self.instance.report_datetime
-        return report_datetime
-
     @property
     def related_visit_model_attr(self) -> str:
         return self.model.related_visit_model_attr()

edc_data_manager/admin/actions.py

@@ -9,7 +9,7 @@ from django.utils.html import format_html
 from django.utils.safestring import mark_safe
 
 from edc_constants.constants import CLOSED, OPEN
-from edc_utils import formatted_datetime
+from edc_utils.text import formatted_datetime
 
 from ..models import QueryRule
 from ..rule import update_query_rules

edc_data_manager/admin/data_query_admin.py

@@ -24,7 +24,7 @@ from edc_constants.constants import (
 from edc_model_admin.dashboard import ModelAdminSubjectDashboardMixin
 from edc_model_admin.history import SimpleHistoryAdmin
 from edc_sites.admin import SiteModelAdminMixin
-from edc_utils import formatted_datetime
+from edc_utils.text import formatted_datetime
 
 from ..admin_site import edc_data_manager_admin
 from ..auth_objects import DATA_MANAGER

edc_dx/form_validators/result_form_validator_mixin.py

@@ -5,7 +5,7 @@ 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_utils.text import convert_php_dateformat
 from edc_visit_schedule.utils import raise_if_baseline
 
 from ..diagnoses import ClinicalReviewBaselineRequired, Diagnoses, InitialReviewRequired

edc_dx_review/medical_date.py

@@ -7,7 +7,7 @@ from django.core.exceptions import ValidationError
 
 from edc_constants.constants import GT, GTE, LT, LTE
 from edc_model import estimated_date_from_ago
-from edc_utils import convert_php_dateformat
+from edc_utils.text import convert_php_dateformat
 
 FAILED_COMPARISON = "FAILED_COMPARISON"
 BEFORE_AFTER_BOTH_TRUE = "BEFORE_AFTER_BOTH_TRUE"

edc_egfr/egfr.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from datetime import date, datetime
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any
-from zoneinfo import ZoneInfo
 
 from dateutil.relativedelta import relativedelta
 from django.core.exceptions import ObjectDoesNotExist
@@ -89,13 +88,10 @@ class Egfr:
         if self.dob:
             self.age_in_years = age(
                 born=self.dob,
-                reference_dt=self.report_datetime.astimezone(ZoneInfo("UTC")),
+                reference_dt=self.report_datetime,
             ).years
         elif not self.dob and self.age_in_years:
-            self.dob = (
-                self.report_datetime.astimezone(ZoneInfo("UTC"))
-                - relativedelta(years=self.age_in_years)
-            ).date()
+            self.dob = (self.report_datetime - relativedelta(years=self.age_in_years)).date()
         else:
             raise EgfrError("Expected `age_in_years` or `dob`. Got None for both.")
 
@@ -105,7 +101,7 @@ class Egfr:
             self.percent_drop_threshold = calling_crf.percent_drop_threshold
             self.related_visit = calling_crf.related_visit
             self.report_datetime = calling_crf.report_datetime
-            self.assay_date = calling_crf.assay_datetime.astimezone(ZoneInfo("UTC")).date()
+            self.assay_date = calling_crf.assay_datetime.date()
         else:
             self.creatinine_units = creatinine_units
             self.creatinine_value = creatinine_value
@@ -113,7 +109,7 @@ class Egfr:
             self.related_visit = related_visit
             self.report_datetime = report_datetime
             if assay_datetime:
-                self.assay_date = assay_datetime.astimezone(ZoneInfo("UTC")).date()
+                self.assay_date = assay_datetime.date()
 
         if self.percent_drop_threshold is not None and self.percent_drop_threshold < 1.0:
             raise EgfrError(

edc_egfr/form_validator_mixins/egfr_form_validator_mixins.py

@@ -28,7 +28,7 @@ class EgfrCkdEpiFormValidatorMixin:
         try:
             value = EgfrCkdEpi(**opts).value
         except (EgfrCalculatorError, CalculatorError, ConversionNotHandled) as e:
-            raise forms.ValidationError(e)
+            raise forms.ValidationError(e) from e
         return value
 
 
@@ -52,5 +52,5 @@ class EgfrCockcroftGaultFormValidatorMixin:
         try:
             value = EgfrCockcroftGault(**opts).value
         except (EgfrCalculatorError, CalculatorError, ConversionNotHandled) as e:
-            self.raise_validation_error({"__all__": str(e)}, INVALID_ERROR)
+            self.raise_validation_error({"__all__": str(e)}, INVALID_ERROR, exc=e)
         return value