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

edc_facility/facility.py

@@ -11,7 +11,7 @@ from dateutil.relativedelta import relativedelta, weekday
 from django.conf import settings
 from django.utils import timezone
 
-from edc_utils import convert_php_dateformat, to_utc
+from edc_utils.text import convert_php_dateformat
 
 from .exceptions import FacilityError
 from .holidays import Holidays
@@ -67,10 +67,6 @@ class Facility:
             slots_per_day = 0
         return slots_per_day
 
-    # @property
-    # def weekdays(self) -> list[int]:
-    #     return [d.weekday for d in self.days]
-
     @staticmethod
     def open_slot_on(arr) -> Arrow:
         """Hook for handling load balance by day.
@@ -80,8 +76,8 @@ class Facility:
         """
         return arr
 
-    def is_holiday(self, dt: datetime) -> bool:
-        return self.holidays.is_holiday(utc_datetime=to_utc(dt))
+    def is_holiday(self, dte: datetime) -> bool:
+        return self.holidays.is_holiday(dte=dte)
 
     def available_datetime(self, **kwargs) -> datetime:
         return self.available_arr(**kwargs).datetime
@@ -95,11 +91,11 @@ class Facility:
         """
         # min_arw = self.to_arrow_utc(suggested_arr.datetime - reverse_delta)
         min_arr = Arrow.fromdate(
-            suggested_arr.datetime - reverse_delta, tzinfo=ZoneInfo("UTC")
+            suggested_arr.datetime - reverse_delta, tzinfo=ZoneInfo(settings.TIME_ZONE)
         )
         # max_arw = self.to_arrow_utc(suggested_arw.datetime + forward_delta)
         max_arr = Arrow.fromdate(
-            suggested_arr.datetime + forward_delta, tzinfo=ZoneInfo("UTC")
+            suggested_arr.datetime + forward_delta, tzinfo=ZoneInfo(settings.TIME_ZONE)
         )
         span = [arw[0] for arw in Arrow.span_range("day", min_arr.datetime, max_arr.datetime)]
         span_lt = [arw for arw in span if arw.date() < suggested_arr.date()]
@@ -136,13 +132,13 @@ class Facility:
         close to the suggested datetime.
 
         To exclude datetimes other than holidays, pass a list of
-        datetimes in UTC to `taken_datetimes`.
+        datetimes to `taken_datetimes`.
         """
         available_arr = None
         forward_delta = forward_delta or relativedelta(months=1)
         reverse_delta = reverse_delta or relativedelta(months=0)
         taken_arr = [
-            arrow.Arrow.fromdatetime(dt, tzinfo=ZoneInfo("UTC")).to("utc")
+            arrow.Arrow.fromdatetime(dt, tzinfo=ZoneInfo(settings.TIME_ZONE))
             for dt in taken_datetimes or []
         ]
         if suggested_datetime:

edc_facility/holidays.py

@@ -85,9 +85,9 @@ class Holidays:
             self._holidays = self.model_cls.objects.filter(country=self.country)
         return self._holidays
 
-    def is_holiday(self, utc_datetime=None) -> bool:
-        """Returns True if the UTC datetime is a holiday."""
-        local_date = to_local(utc_datetime).date()
+    def is_holiday(self, dte=None) -> bool:
+        """Returns True if the datetime is a holiday."""
+        local_date = to_local(dte).date()
         try:
             self.model_cls.objects.get(country=self.country, local_date=local_date)
         except ObjectDoesNotExist:

edc_facility/models/holiday.py

@@ -3,7 +3,7 @@ from django.db import models
 from django.db.models import Index, UniqueConstraint
 from django.utils.translation import gettext as _
 
-from edc_utils import convert_php_dateformat
+from edc_utils.text import convert_php_dateformat
 
 
 class Holiday(models.Model):

edc_form_runners/form_runner.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import html
+import sys
 import uuid
 from typing import TYPE_CHECKING, Any
 
@@ -25,8 +26,8 @@ class FormRunner:
 
     model_name: str | None = None
     issue_model = "edc_form_runners.issue"
-    extra_formfields: list[str] | None = None
-    exclude_formfields: list[str] | None = None
+    extra_formfields: tuple[str] | None = None
+    exclude_formfields: tuple[str] | None = None
 
     def __init__(
         self,
@@ -68,7 +69,7 @@ class FormRunner:
             self.issue_model_cls.objects.filter(**self.unique_opts(src_obj)).delete()
             self.run_one(src_obj=src_obj, skip_delete=True)
         for k, v in self.messages.items():
-            print(f"Warning: {k}: {v}")
+            sys.stdout.write(f"Warning: {k}: {v}\n")
 
     def run_one(self, src_obj: Model, skip_delete: bool | None = None) -> None:
         if not skip_delete:
@@ -87,17 +88,17 @@ class FormRunner:
                         self.print(str(issue_obj))
 
     @property
-    def issue_model_cls(self) -> Issue:
+    def issue_model_cls(self) -> type[Issue]:
         return django_apps.get_model(self.issue_model)
 
     @property
-    def fieldset_fields(self) -> list[str]:
-        fields = []
+    def fieldset_fields(self) -> tuple[str]:
+        fields = ()
         if self.modeladmin_cls.form != ModelForm:
             if getattr(self.modeladmin_cls, "fieldsets", None):
                 for fieldset in self.modeladmin_cls.fieldsets:
                     _, data = fieldset
-                    fields.extend(data.get("fields"))
+                    fields = {*fields, *data.get("fields")}
             else:
                 self.messages.update(
                     {
@@ -107,10 +108,8 @@ class FormRunner:
                     }
                 )
 
-                fields = [
-                    k for k, v in getattr(self.modeladmin_cls.form(), "fields", {}).items()
-                ]
-        fields = list(set(fields))
+                fields = {k for k in getattr(self.modeladmin_cls.form(), "fields", {})}
+            fields = tuple(fields)
         return fields
 
     def write_to_db(self, fldname: str, errmsg: Any, src_obj: Any) -> Issue:
@@ -208,12 +207,12 @@ class FormRunner:
     def get_src_filter_options(self) -> dict[str, Any]:
         return self.src_filter_options
 
-    def get_extra_formfields(self) -> list[str]:
-        return self.extra_formfields or []
+    def get_extra_formfields(self) -> tuple[str]:
+        return self.extra_formfields or ()
 
-    def get_exclude_formfields(self) -> list[str]:
-        return self.exclude_formfields or []
+    def get_exclude_formfields(self) -> tuple[str]:
+        return self.exclude_formfields or ()
 
     def print(self, msg: str) -> None:
         if self.verbose:
-            print(msg)
+            sys.stdout.write(f"{msg}\n")

edc_form_validators/base_form_validator.py

@@ -96,11 +96,15 @@ class BaseFormValidator:
                 field_value = self.cleaned_data.get(field)
         return field_value
 
-    def raise_validation_error(self, message: dict[str, str] | str, error_code: str) -> None:
+    def raise_validation_error(
+        self, message: dict[str, str] | str, error_code: str, exc: Exception | None = None
+    ) -> None:
         if isinstance(message, str):
             message = {NON_FIELD_ERRORS: message}
         self._errors.update(message)
         self._error_codes.append(error_code)
+        if exc:
+            raise ValidationError(message, code=error_code or INVALID_ERROR) from exc
         raise ValidationError(message, code=error_code or INVALID_ERROR)
 
     def validate(self) -> dict:

edc_form_validators/date_range_validator.py

@@ -1,24 +1,21 @@
 from __future__ import annotations
 
+import contextlib
 from datetime import date
 
 from django import forms
+from django.utils.translation import gettext as _
 
-from edc_utils.date import to_utc
-from edc_utils.text import formatted_datetime
+from edc_utils.date import to_local
 
 from .base_form_validator import BaseFormValidator
 
 
 def convert_any_to_date(date1, date2) -> tuple[date, date]:
-    try:
-        date1 = date1.date()
-    except AttributeError:
-        pass
-    try:
-        date2 = date2.date()
-    except AttributeError:
-        pass
+    with contextlib.suppress(AttributeError):
+        date1 = to_local(date1).date()
+    with contextlib.suppress(AttributeError):
+        date2 = to_local(date2).date()
     return date1, date2
 
 
@@ -36,10 +33,9 @@ class DateRangeFieldValidator(BaseFormValidator):
         date2 = self.cleaned_data.get(date_field2)
         if convert_to_date:
             date1, date2 = convert_any_to_date(date1, date2)
-        msg = msg or f"Invalid. Cannot be before {date_field1} "
-        if date1 and date2:
-            if date1 > date2:
-                raise forms.ValidationError({message_on_field or date_field2: f"{msg}."})
+        if date1 and date2 and (date2 < date1):
+            msg = msg or _("Invalid. Cannot be before %(field)s.") % {"field": date_field1}
+            raise forms.ValidationError({message_on_field or date_field2: msg})
 
     def date_not_after(
         self,
@@ -48,14 +44,14 @@ class DateRangeFieldValidator(BaseFormValidator):
         msg: str | None = None,
         convert_to_date: bool | None = None,
     ) -> None:
+        """Asserts date_field2 is not after date_field1"""
         date1 = self.cleaned_data.get(date_field1)
         date2 = self.cleaned_data.get(date_field2)
         if convert_to_date:
             date1, date2 = convert_any_to_date(date1, date2)
-        msg = msg or f"Invalid. Cannot be after {date_field1} "
-        if date1 and date2:
-            if date1 < date2:
-                raise forms.ValidationError({date_field2: f"{msg}"})
+        if date1 and date2 and (date2 > date1):
+            msg = msg or _("Invalid. Cannot be after %(field)s.") % {"field": date_field1}
+            raise forms.ValidationError({date_field2: msg})
 
     def date_equal(
         self,
@@ -65,15 +61,17 @@ class DateRangeFieldValidator(BaseFormValidator):
         message_on_field=None,
         convert_to_date: bool | None = None,
     ) -> None:
-        """Asserts date1 and date2 are equal"""
+        """Asserts date2 and date1 are equal"""
         date1 = self.cleaned_data.get(date_field1)
         date2 = self.cleaned_data.get(date_field2)
         if convert_to_date:
             date1, date2 = convert_any_to_date(date1, date2)
-        msg = msg or f"Invalid. Expected {date_field2} to be the same as {date_field1}."
-        if date1 and date2:
-            if date1 != date2:
-                raise forms.ValidationError({message_on_field or date_field2: f"{msg}"})
+        if date1 and date2 and (date1 != date2):
+            msg = msg or _("Invalid. Expected %(field2)s to be the same as %(field1)s.") % {
+                "field1": date_field1,
+                "field2": date_field2,
+            }
+            raise forms.ValidationError({message_on_field or date_field2: msg})
 
     def date_not_equal(
         self,
@@ -83,50 +81,40 @@ class DateRangeFieldValidator(BaseFormValidator):
         message_on_field=None,
         convert_to_date: bool | None = None,
     ) -> None:
-        """Asserts date1 and date2 are equal"""
-        date1 = self.cleaned_data.get(date_field1)
-        date2 = self.cleaned_data.get(date_field2)
+        """Asserts date2 and date1 are not equal"""
+        dte1 = self.cleaned_data.get(date_field1)
+        dte2 = self.cleaned_data.get(date_field2)
         if convert_to_date:
-            date1, date2 = convert_any_to_date(date1, date2)
-        msg = msg or f"Invalid. Expected {date_field2} to be the same as {date_field1}."
-        if date1 and date2:
-            if date1 == date2:
-                raise forms.ValidationError({message_on_field or date_field2: f"{msg}"})
+            dte1, dte2 = convert_any_to_date(dte1, dte2)
+        if dte1 and dte2 and (dte1 == dte2):
+            msg = msg or _("Invalid. Expected %(field2)s to be different from %(field1)s.") % {
+                "field1": date_field1,
+                "field2": date_field2,
+            }
+            raise forms.ValidationError({message_on_field or date_field2: msg})
 
     def datetime_not_before(
         self, datetime_field1: str, datetime_field2: str, msg=None
     ) -> None:
-        datetime1 = self.cleaned_data.get(datetime_field1)
-        datetime2 = self.cleaned_data.get(datetime_field2)
-        if datetime1:
-            datetime1 = to_utc(datetime1)
-        if datetime2:
-            datetime2 = to_utc(datetime2)
-        msg = msg or f"Invalid. Cannot be before {datetime_field2} "
-        if datetime1 and datetime2:
-            if datetime1 < datetime2:
-                raise forms.ValidationError(
-                    {datetime_field1: f"{msg}. Got {formatted_datetime(datetime2)}."}
-                )
+        """Asserts datetime_field2 is not before datetime_field1"""
+        dte1 = self.cleaned_data.get(datetime_field1)
+        dte2 = self.cleaned_data.get(datetime_field2)
+        if dte1 and dte2 and (dte2 < dte1):
+            msg = msg or _("Invalid. Cannot be before %(field)s") % {"field": datetime_field1}
+            raise forms.ValidationError({datetime_field2: msg})
 
     def datetime_not_after(self, datetime_field1: str, datetime_field2: str, msg=None) -> None:
-        datetime_field1 = self.cleaned_data.get(datetime_field1)
-        datetime_field2 = self.cleaned_data.get(datetime_field2)
-        msg = msg or f"Invalid. Cannot be before date of {datetime_field2} "
-        if datetime_field1:
-            datetime_field1 = to_utc(datetime_field1)
-            datetime_field2 = to_utc(datetime_field2)
-            if datetime_field1 > datetime_field2:
-                raise forms.ValidationError({datetime_field1: f"{msg}"})
+        """Asserts datetime_field2 is not after datetime_field1"""
+        dte1 = self.cleaned_data.get(datetime_field1)
+        dte2 = self.cleaned_data.get(datetime_field2)
+        if dte1 and dte2 and (dte2 > dte1):
+            msg = msg or _("Invalid. Cannot be after %(field)s") % {"field": datetime_field1}
+            raise forms.ValidationError({datetime_field2: msg})
 
     def datetime_equal(self, datetime_field1: str, datetime_field2: str, msg=None) -> None:
-        datetime_field1 = self.cleaned_data.get(datetime_field1)
-        datetime_field2 = self.cleaned_data.get(datetime_field2)
-        msg = msg or f"Invalid. Cannot be before date of {datetime_field2} "
-        if datetime_field1:
-            datetime_field1 = to_utc(datetime_field1)
-            datetime_field2 = to_utc(datetime_field2)
-            if datetime_field1 == datetime_field2:
-                raise forms.ValidationError(
-                    {datetime_field1: f"{msg}. Got {formatted_datetime(datetime_field2)}."}
-                )
+        """Asserts datetime_field2 is not equal to datetime_field1"""
+        dte1 = self.cleaned_data.get(datetime_field1)
+        dte2 = self.cleaned_data.get(datetime_field2)
+        if dte1 and dte2 and (dte1 == dte2):
+            msg = msg or _("Invalid. Cannot be same as %(field)s") % {"field": datetime_field1}
+            raise forms.ValidationError({datetime_field2: msg})

edc_form_validators/date_validator.py

@@ -6,8 +6,8 @@ from django.conf import settings
 
 from edc_constants.constants import EQ, GT, GTE, LT, LTE
 from edc_model import estimated_date_from_ago
-from edc_utils import convert_php_dateformat
 from edc_utils.date import to_local
+from edc_utils.text import convert_php_dateformat
 
 from .base_form_validator import INVALID_ERROR, BaseFormValidator
 

edc_form_validators/extra_mixins/study_day_form_validator.py

@@ -5,7 +5,7 @@ from django.apps import apps as django_apps
 from django.conf import settings
 
 from edc_crf.crf_form_validator import CrfFormValidator
-from edc_utils import convert_php_dateformat
+from edc_utils.text import convert_php_dateformat
 
 from ..base_form_validator import INVALID_ERROR
 

edc_lab/form_validators/crf_requisition_form_validator_mixin.py

@@ -4,7 +4,8 @@ from typing import TYPE_CHECKING
 
 from django import forms
 
-from edc_utils import formatted_datetime, to_utc
+from edc_utils.date import to_local
+from edc_utils.text import formatted_datetime
 
 if TYPE_CHECKING:
     from ..model_mixins import RequisitionModelMixin
@@ -65,17 +66,22 @@ class CrfRequisitionFormValidatorMixin:
         requisition: RequisitionModelMixin,
         assay_datetime_field: str | None = None,
     ) -> None:
-        assay_datetime_field = assay_datetime_field or self.assay_datetime_field
-        assay_datetime = self.cleaned_data.get(assay_datetime_field)
-        if assay_datetime:
-            assay_datetime = to_utc(assay_datetime)
-            requisition_datetime = to_utc(requisition.requisition_datetime)
-            if assay_datetime < requisition_datetime:
-                raise forms.ValidationError(
-                    {
-                        assay_datetime_field: (
-                            f"Invalid. Cannot be before date of requisition "
-                            f"{formatted_datetime(requisition_datetime)}."
-                        )
-                    }
-                )
+        """Validate assay datetime is on or after requisition
+        datetime.
+        """
+        assay_datetime = self.cleaned_data.get(
+            assay_datetime_field or self.assay_datetime_field
+        )
+        if assay_datetime > self.report_datetime:
+            raise forms.ValidationError(
+                {assay_datetime_field: "Invalid. Cannot be after report datetime."}
+            )
+        if assay_datetime < requisition.requisition_datetime:
+            raise forms.ValidationError(
+                {
+                    assay_datetime_field: (
+                        "Invalid. Cannot be before requisition date. Requisition date is "
+                        f"{formatted_datetime(to_local(requisition.requisition_datetime))}."
+                    )
+                }
+            )

edc_lab/form_validators/requisition_form_validator_mixin.py

@@ -7,7 +7,7 @@ from django import forms
 from django.apps import apps as django_apps
 
 from edc_constants.constants import NO, YES
-from edc_utils import to_utc
+from edc_utils.date import to_local
 
 if TYPE_CHECKING:
     from ..models import Aliquot
@@ -77,8 +77,8 @@ class RequisitionFormValidatorMixin:
         if (
             self.requisition_datetime
             and self.cleaned_data.get("drawn_datetime")
-            and to_utc(self.cleaned_data.get("drawn_datetime")).date()
-            > to_utc(self.requisition_datetime).date()
+            and to_local(self.cleaned_data.get("drawn_datetime")).date()
+            > to_local(self.requisition_datetime).date()
         ):
             raise forms.ValidationError(
                 {"drawn_datetime": "Invalid. Cannot be after requisition date."}

edc_lab_results/form_validator_mixins/blood_results_form_validator_mixin.py

@@ -105,7 +105,7 @@ class BloodResultsFormValidatorMixin(
         for panel in self.panel_list:
             for utest_id in panel.utest_ids:
                 with contextlib.suppress(ValueError):
-                    utest_id, _ = utest_id
+                    utest_id, _ = utest_id  # noqa: PLW2901
                 utest_ids.append(utest_id)
         return tuple(utest_ids)
 

edc_ltfu/modelform_mixins.py

@@ -5,7 +5,7 @@ from django.core.exceptions import ObjectDoesNotExist
 
 from edc_constants.constants import NO, YES
 from edc_form_validators import FormValidator
-from edc_utils import convert_php_dateformat
+from edc_utils.text import convert_php_dateformat
 from edc_visit_tracking.constants import MISSED_VISIT
 from edc_visit_tracking.utils import get_related_visit_model_cls
 

edc_metadata/metadata/metadata.py

@@ -7,6 +7,7 @@ from django.contrib.admin.sites import all_sites
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import IntegrityError, transaction
 
+from edc_visit_schedule.exceptions import MissedVisitError, UnScheduledVisitError
 from edc_visit_schedule.visit import CrfCollection, RequisitionCollection
 from edc_visit_tracking.constants import MISSED_VISIT
 
@@ -206,17 +207,29 @@ class Creator:
         if self.related_visit.reason == MISSED_VISIT:
             # missed visit CRFs only
             crfs = self.related_visit.visit.crfs_missed.forms
+            if not crfs:
+                raise MissedVisitError(
+                    "Visit not configured for missed visit. "
+                    f"visit.crfs_missed=None. Got {self.related_visit.visit}"
+                )
         elif self.related_visit.visit_code_sequence != 0:
             # unscheduled + prn CRFs only
-            models = [crf.model for crf in self.related_visit.visit.crfs_unscheduled]
-            crfs = self.related_visit.visit.crfs_unscheduled.forms + tuple(
-                [f for f in self.related_visit.visit.crfs_prn if f.model not in models]
+            models = (crf.model for crf in self.related_visit.visit.crfs_unscheduled)
+            crfs = (
+                *self.related_visit.visit.crfs_unscheduled.forms,
+                *{f for f in self.related_visit.visit.crfs_prn if f.model not in models},
             )
+            if not crfs:
+                raise UnScheduledVisitError(
+                    "Visit not configured for unscheduled visit. "
+                    f"visit.crfs_unscheduled=None. Got {self.related_visit.visit}"
+                )
         else:
             # scheduled + prn CRFs only
-            models = [crf.model for crf in self.related_visit.visit.crfs]
-            crfs = self.related_visit.visit.crfs.forms + tuple(
-                [f for f in self.related_visit.visit.crfs_prn if f.model not in models]
+            models = (crf.model for crf in self.related_visit.visit.crfs)
+            crfs = (
+                *self.related_visit.visit.crfs.forms,
+                *{f for f in self.related_visit.visit.crfs_prn if f.model not in models},
             )
         return CrfCollection(*crfs, name="crfs")
 
@@ -278,7 +291,7 @@ class Destroyer:
     def metadata_requisition_model_cls(self) -> RequisitionMetadata:
         return django_apps.get_model(self.metadata_requisition_model)
 
-    def delete(self, entry_status_not_in: list[str] = None) -> int:
+    def delete(self, entry_status_not_in: list[str] | None = None) -> int:
         """Deletes all CRF and requisition metadata for the
         related_visit instance excluding where entry_status in
         [KEYED, NOT_REQUIRED].

edc_metadata/metadata_rules/logic.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import TYPE_CHECKING
 
 from ..constants import DO_NOTHING, NOT_REQUIRED, REQUIRED
@@ -24,13 +25,13 @@ class Logic:
     rule; consequence and alternative.
     """
 
-    valid_results = [REQUIRED, NOT_REQUIRED, DO_NOTHING]
+    valid_results = (REQUIRED, NOT_REQUIRED, DO_NOTHING)
 
     def __init__(
         self,
-        predicate: P | PF | callable = None,
-        consequence: str = None,
-        alternative: str = None,
+        predicate: P | PF | Callable | None = None,
+        consequence: str | None = None,
+        alternative: str | None = None,
         comment: str | None = None,
     ) -> None:
         if not callable(predicate):

edc_metadata/metadata_rules/predicate.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import Any
 
 from django.apps import apps as django_apps
@@ -16,7 +17,7 @@ class NoValueError(Exception):
 
 class BasePredicate:
     @staticmethod
-    def get_value(attr: str = None, source_model: str | None = None, **kwargs) -> Any:
+    def get_value(attr: str | None = None, source_model: str | None = None, **kwargs) -> Any:
         """Returns a value by checking for the attr on each arg.
 
         Each arg in args may be a model instance, queryset, or None.
@@ -62,23 +63,23 @@ class P(BasePredicate):
         predicate = P('age', '<=', 64)
     """
 
-    funcs = {
-        "is": lambda x, y: True if x is y else False,
-        "is not": lambda x, y: True if x is not y else False,
-        "gt": lambda x, y: True if x > y else False,
-        ">": lambda x, y: True if x > y else False,
-        "gte": lambda x, y: True if x >= y else False,
-        ">=": lambda x, y: True if x >= y else False,
-        "lt": lambda x, y: True if x < y else False,
-        "<": lambda x, y: True if x < y else False,
-        "lte": lambda x, y: True if x <= y else False,
-        "<=": lambda x, y: True if x <= y else False,
-        "eq": lambda x, y: True if x == y else False,
-        "equals": lambda x, y: True if x == y else False,
-        "==": lambda x, y: True if x == y else False,
-        "neq": lambda x, y: True if x != y else False,
-        "!=": lambda x, y: True if x != y else False,
-        "in": lambda x, y: True if x in y else False,
+    funcs = {  # noqa: RUF012
+        "is": lambda x, y: x is y,
+        "is not": lambda x, y: x is not y,
+        "gt": lambda x, y: x > y,
+        ">": lambda x, y: x > y,
+        "gte": lambda x, y: x >= y,
+        ">=": lambda x, y: x >= y,
+        "lt": lambda x, y: x < y,
+        "<": lambda x, y: x < y,
+        "lte": lambda x, y: x <= y,
+        "<=": lambda x, y: x <= y,
+        "eq": lambda x, y: x == y,
+        "equals": lambda x, y: x == y,
+        "==": lambda x, y: x == y,
+        "neq": lambda x, y: x != y,
+        "!=": lambda x, y: x != y,
+        "in": lambda x, y: x in y,
     }
 
     def __init__(self, attr: str, operator: str, expected_value: list | str) -> None:
@@ -91,8 +92,7 @@ class P(BasePredicate):
 
     def __repr__(self) -> str:
         return (
-            f"{self.__class__.__name__}({self.attr}, {self.operator}, "
-            f"{self.expected_value})"
+            f"{self.__class__.__name__}({self.attr}, {self.operator}, {self.expected_value})"
         )
 
     def __call__(self, **kwargs) -> bool:
@@ -122,14 +122,12 @@ class PF(BasePredicate):
 
     """
 
-    def __init__(self, *attrs, func: callable = None) -> None:
+    def __init__(self, *attrs, func: Callable | None = None) -> None:
         self.attrs = attrs
         self.func = func
 
     def __call__(self, **kwargs) -> Any:
-        values = []
-        for attr in self.attrs:
-            values.append(self.get_value(attr=attr, **kwargs))
+        values = [self.get_value(attr=attr, **kwargs) for attr in self.attrs]
         return self.func(*values)
 
     def __repr__(self) -> str:

edc_model_form/mixins/report_datetime_modelform_mixin.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from edc_utils import to_utc
-
 
 class ReportDatetimeModelFormMixin:
     # may also be appt_datetime or requisition_datetime
@@ -11,7 +9,7 @@ class ReportDatetimeModelFormMixin:
 
     @property
     def report_datetime(self) -> datetime | None:
-        """Returns the report_datetime in UTC or None from
+        """Returns the report_datetime or None from
         cleaned_data.
 
         if key does not exist, returns the instance report_datetime.
@@ -22,8 +20,6 @@ class ReportDatetimeModelFormMixin:
         report_datetime = None
         if self.report_datetime_field_attr in self.cleaned_data:
             report_datetime = self.cleaned_data.get(self.report_datetime_field_attr)
-            if report_datetime:
-                report_datetime = to_utc(report_datetime)
         elif self.instance:
             report_datetime = getattr(self.instance, self.report_datetime_field_attr)
         return report_datetime