clinicedc 2.0.24__py3-none-any.whl → 2.0.25__py3-none-any.whl

edc_identifier/simple_identifier.py

@@ -8,6 +8,8 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from django.utils import timezone
 
+from edc_constants.constants import NULL_STRING
+
 from .utils import convert_to_human_readable
 
 if TYPE_CHECKING:
@@ -22,10 +24,13 @@ class IdentifierError(Exception):
     pass
 
 
+IDENTIFER_PREFIX_LENGTH = 2
+
+
 class SimpleIdentifier:
     random_string_length: int = 5
     template: str = "{device_id}{random_string}"
-    identifier_prefix: str = None
+    identifier_prefix: str = NULL_STRING
 
     def __init__(
         self,
@@ -90,7 +95,7 @@ class SimpleSequentialIdentifier:
         random_number: int = choice(range(1000, 9999))  # nosec B311
         sequence: str = f"{sequence}{random_number}"
         chk: int = int(sequence) % 11
-        self.identifier: str = f"{self.prefix or ''}{sequence}{chk}"
+        self.identifier: str = f"{self.prefix or NULL_STRING}{sequence}{chk}"
 
     def __str__(self) -> str:
         return self.identifier
@@ -111,12 +116,13 @@ class SimpleUniqueIdentifier:
     model: str = "edc_identifier.identifiermodel"
     template: str = "{device_id}{random_string}"
     identifier_prefix: str | None = None
+    identifier_prefix_length: int = 2
     identifier_cls = SimpleIdentifier
     make_human_readable: bool | None = None
 
     def __init__(
         self,
-        model: str = None,
+        model: str | None = None,
         identifier_attr: str | None = None,
         identifier_type: str | None = None,
         identifier_prefix: str | None = None,
@@ -140,9 +146,13 @@ class SimpleUniqueIdentifier:
         self.identifier_attr = identifier_attr or self.identifier_attr
         self.identifier_type = identifier_type or self.identifier_type
         self.identifier_prefix = identifier_prefix or self.identifier_prefix
-        if self.identifier_prefix and len(self.identifier_prefix) != 2:
+        if (
+            self.identifier_prefix
+            and len(self.identifier_prefix) != self.identifier_prefix_length
+        ):
             raise IdentifierError(
-                f"Expected identifier_prefix of length=2. Got {len(identifier_prefix)}"
+                f"Expected identifier_prefix of length={self.identifier_prefix_length}. "
+                f"Got {len(identifier_prefix)}"
             )
         self.make_human_readable = make_human_readable or self.make_human_readable
         self.device_id = django_apps.get_app_config("edc_device").device_id

edc_identifier/subject_identifier.py

@@ -10,8 +10,8 @@ class SubjectIdentifier(ResearchIdentifier):
     label: str = "subjectidentifier"
     padding: int = 4
 
-    def __init__(self, last_name: str = None, **kwargs):
-        self.last_name = last_name
+    def __init__(self, last_name: str | None = None, **kwargs):
+        self.last_name = last_name or ""
         super().__init__(**kwargs)
 
     def pre_identifier(self) -> None:

edc_identifier/utils.py

@@ -14,23 +14,22 @@ def is_subject_identifier_or_raise(subject_identifier, reference_obj=None, raise
     * If `subject_identifier` is None, does nothing, unless
       `raise_on_none` is `True`.
     """
-    if subject_identifier or raise_on_none:
-        if not re.match(
-            ResearchProtocolConfig().subject_identifier_pattern,
-            subject_identifier or "",
-        ):
-            reference_msg = ""
-            if reference_obj:
-                reference_msg = f"See {reference_obj!r}. "
-            raise SubjectIdentifierError(
-                f"Invalid format for subject identifier. {reference_msg}"
-                f"Got `{subject_identifier or ''}`. "
-                f"Expected pattern `{ResearchProtocolConfig().subject_identifier_pattern}`"
-            )
+    valid_subject_identifier = subject_identifier and re.match(
+        ResearchProtocolConfig().subject_identifier_pattern, subject_identifier or ""
+    )
+    if not valid_subject_identifier or (not subject_identifier and raise_on_none):
+        reference_msg = ""
+        if reference_obj:
+            reference_msg = f"See {reference_obj!r}. "
+        raise SubjectIdentifierError(
+            f"Invalid format for subject identifier. {reference_msg}"
+            f"Got `{subject_identifier or ''}`. "
+            f"Expected pattern `{ResearchProtocolConfig().subject_identifier_pattern}`"
+        )
     return subject_identifier
 
 
-def get_human_phrase(no_hyphen: bool = None) -> str:
+def get_human_phrase(no_hyphen: bool | None = None) -> str:
     """Returns 6 digits split by a '-', e.g. DEC-96E.
 
     There are 213,127,200 permutations from an unambiguous alphabet.

edc_listboard/view_mixins/search_listboard_view_mixin.py

@@ -13,12 +13,12 @@ from edc_model_admin.utils import add_to_messages_once
 
 
 class SearchListboardMixin:
-    search_fields = ["slug"]
+    search_fields = ("slug",)
 
     default_querystring_attrs: str = "q"
     alternate_search_attr: str = "subject_identifier"
     default_lookup = "icontains"
-    operators: list[str] = [
+    operators: tuple[str, ...] = (
         "exact",
         "iexact",
         "contains",
@@ -33,7 +33,7 @@ class SearchListboardMixin:
         "endswith",
         "istartswith",
         "iendswith",
-    ]
+    )
 
     def __init__(self, **kwargs):
         self._search_term = None
@@ -66,12 +66,11 @@ class SearchListboardMixin:
 
     @property
     def search_term(self) -> str | None:
-        if not self._search_term:
-            if search_term := self.raw_search_term:
-                self._search_term = escape(search_term).strip()
+        if (not self._search_term) and (search_term := self.raw_search_term):
+            self._search_term = escape(search_term).strip()
         return self._search_term
 
-    def get_search_fields(self) -> list[str]:
+    def get_search_fields(self) -> tuple[str, ...]:
         """Override to add additional search fields"""
         return self.search_fields
 

edc_metadata/view_mixins/metadata_view_mixin.py

@@ -16,16 +16,19 @@ class MetadataViewError(Exception):
 
 class MetadataViewMixin:
     panel_model: str = "edc_lab.panel"
-    metadata_show_status: list[str] = [REQUIRED, KEYED]
+    metadata_show_status: tuple[str] = (REQUIRED, KEYED)
 
     def get_context_data(self, **kwargs) -> dict:
         if self.appointment:
             # always refresh metadata / run rules
             refresh_metadata_for_timepoint(self.appointment, allow_create=True)
             referer = self.request.headers.get("Referer")
-            if referer and "subject_review_listboard" in referer:
-                if self.appointment.related_visit:
-                    update_appt_status_for_timepoint(self.appointment.related_visit)
+            if (
+                referer
+                and "subject_review_listboard" in referer
+                and self.appointment.related_visit
+            ):
+                update_appt_status_for_timepoint(self.appointment.related_visit)
             crf_qs = self.get_crf_metadata()
             requisition_qs = self.get_requisition_metadata()
             kwargs.update(crfs=crf_qs, requisitions=requisition_qs)

edc_randomization/randomization_list_importer.py

@@ -67,19 +67,20 @@ class RandomizationListImporter:
     def __init__(
         self,
         randomizer_model_cls=None,
-        randomizer_name: str = None,
-        randomizationlist_path: Path | str = None,
-        assignment_map: dict[str, int] = None,
-        verbose: bool = None,
-        overwrite: bool = None,
-        add: bool = None,
-        dryrun: bool = None,
-        username: str = None,
-        revision: str = None,
-        sid_count_for_tests: int = None,
-        extra_csv_fieldnames: list[str] | None = None,
-        **kwargs,
+        randomizer_name: str | None = None,
+        randomizationlist_path: Path | str | None = None,
+        assignment_map: dict[str, int] | None = None,
+        verbose: bool | None = None,
+        overwrite: bool | None = None,
+        add: bool | None = None,
+        dryrun: bool | None = None,
+        username: str | None = None,
+        revision: str | None = None,
+        sid_count_for_tests: int | None = None,
+        extra_csv_fieldnames: tuple[str] | None = None,
+        **kwargs,  # noqa: ARG002
     ):
+        extra_csv_fieldnames = extra_csv_fieldnames or ()
         self.verify_messages: str | None = None
         self.add = add
         self.overwrite = overwrite
@@ -92,7 +93,7 @@ class RandomizationListImporter:
         self.randomizer_name = randomizer_name
         self.assignment_map = assignment_map
         self.randomizationlist_path: Path = Path(randomizationlist_path).expanduser()
-        self.required_csv_fieldnames.extend(extra_csv_fieldnames or [])
+        self.required_csv_fieldnames = (*self.required_csv_fieldnames, *extra_csv_fieldnames)
 
         if self.dryrun:
             sys.stdout.write(
@@ -223,12 +224,15 @@ class RandomizationListImporter:
             sid_count = self.sid_count_for_tests
         else:
             sid_count = len(self.get_sid_list())
-        with self.randomizationlist_path.open(mode="r") as csvfile:
-            reader = csv.DictReader(csvfile)
-            for row in tqdm(reader, total=sid_count):
+        with self.randomizationlist_path.open(mode="r") as f:
+            reader = csv.DictReader(f)
+            all_rows = [{k: v.strip() for k, v in row.items() if k} for row in reader]
+            sorted_rows = sorted(
+                all_rows, key=lambda row: (row.get("site_name", ""), row.get("sid", ""))
+            )
+            for row in tqdm(sorted_rows, total=sid_count):
                 if self.sid_count_for_tests and len(objs) == self.sid_count_for_tests:
                     break
-                row = {k: v.strip() for k, v in row.items()}
                 try:
                     self.randomizer_model_cls.objects.get(sid=row["sid"])
                 except ObjectDoesNotExist:

edc_randomization/randomization_list_verifier.py

@@ -25,12 +25,12 @@ class RandomizationListVerifier:
     def __init__(
         self,
         randomizer_name=None,
-        randomizationlist_path: Path | str = None,
+        randomizationlist_path: Path | str | None = None,
         randomizer_model_cls=None,
         assignment_map=None,
         fieldnames=None,
         sid_count_for_tests=None,
-        required_csv_fieldnames: list[str] | None = None,
+        required_csv_fieldnames: tuple[str, ...] | None = None,
         **kwargs,  # noqa: ARG002
     ):
         self.count: int = 0

edc_randomization/randomizer.py

@@ -101,7 +101,7 @@ class Randomizer:
     )
     filename: str = "randomization_list.csv"
     randomizationlist_folder: Path | str = get_randomization_list_path()
-    extra_csv_fieldnames: list[str] | None = None
+    extra_csv_fieldnames: tuple[str] | None = None
     trial_is_blinded: bool = True
     importer_cls: Any = RandomizationListImporter
     apps = None  # if not using django_apps

edc_review_dashboard/middleware.py

@@ -1,3 +1,5 @@
+import contextlib
+
 from django.conf import settings
 
 from .dashboard_templates import dashboard_templates
@@ -10,12 +12,10 @@ class DashboardMiddleware:
     def __call__(self, request):
         return self.get_response(request)
 
-    def process_view(self, request, *args) -> None:
+    def process_view(self, request, *args) -> None:  # noqa: ARG002
         template_data = dashboard_templates
-        try:
+        with contextlib.suppress(AttributeError):
             template_data.update(settings.REVIEW_DASHBOARD_BASE_TEMPLATES)
-        except AttributeError:
-            pass
         request.template_data.update(**template_data)
 
     def process_template_response(self, request, response):

edc_review_dashboard/views/subject_review_listboard_view.py

@@ -49,15 +49,15 @@ class SubjectReviewListboardView(
     listboard_view_permission_codename = "edc_review_dashboard.view_subject_review_listboard"
 
     navbar_selected_item = "subject_review"
-    ordering = ["subject_identifier", "visit_code", "visit_code_sequence"]
+    ordering = ("subject_identifier", "visit_code", "visit_code_sequence")
     paginate_by = 25
     search_form_url = "subject_review_listboard_url"
-    search_fields = [
+    search_fields = (
         "subject_identifier",
         "visit_code",
         "user_created",
         "user_modified",
-    ]
+    )
 
     #  attr to call SubjectReviewListboardView.urls in urls.py
     urlconfig_getattr = "review_listboard_urls"

edc_screening/age_evaluator.py

@@ -25,7 +25,7 @@ class AgeEvaluator(ReportableAgeEvaluator):
             self.reasons_ineligible = "Age unknown"
         return eligible
 
-    def in_bounds_or_raise(self, age: int = None, **kwargs):
+    def in_bounds_or_raise(self, age: int | None = None, **kwargs):  # noqa: ARG002
         self.reasons_ineligible = ""
         dob = localtime(timezone.now() - relativedelta(years=age)).date()
         age_units = "years"

edc_screening/eligibility.py

@@ -18,14 +18,14 @@ class Eligibility:
     # default to eligible if >=18
     age_evaluator = AgeEvaluator(age_lower=18, age_lower_inclusive=True)
 
-    custom_reasons_dict: dict = {}
+    custom_reasons_dict: dict = {}  # noqa: RUF012
 
     def __init__(
         self,
-        age: int = None,
-        gender: str = None,
-        pregnant: bool = None,
-        breast_feeding: bool = None,
+        age: int | None = None,
+        gender: str | None = None,
+        pregnant: bool | None = None,
+        breast_feeding: bool | None = None,
         **additional_criteria,
     ) -> None:
         self.criteria = dict(**additional_criteria)

edc_screening/exceptions.py

@@ -17,15 +17,15 @@ class ScreeningEligibilityCleanedDataKeyError(Exception):
     pass
 
 
-class ScreeningEligibilityInvalidCombination(Exception):
+class ScreeningEligibilityInvalidCombination(Exception):  # noqa: N818
     pass
 
 
-class RequiredFieldValueMissing(Exception):
+class RequiredFieldValueMissing(Exception):  # noqa: N818
     pass
 
 
-class InvalidScreeningIdentifierFormat(Exception):
+class InvalidScreeningIdentifierFormat(Exception):  # noqa: N818
     def __init__(self, *args, **kwargs):
         self.code = INVALID_SCREENING_IDENTIFIER
         super().__init__(*args, **kwargs)

edc_screening/gender_evaluator.py

@@ -2,7 +2,7 @@ from edc_constants.constants import FEMALE, MALE
 
 
 class GenderEvaluator:
-    eligible_gender = [MALE, FEMALE]
+    eligible_gender = (MALE, FEMALE)
 
     def __init__(self, gender=None, **kwargs) -> None:  # noqa
         self.eligible = False

edc_screening/modelform_mixins.py

@@ -27,7 +27,7 @@ class AlreadyConsentedFormMixin:
             raise forms.ValidationError(self.already_consented_validation_message(url))
         return cleaned_data
 
-    def already_consented_validation_url(self, cleaned_data: dict | None = None) -> str:
+    def already_consented_validation_url(self, cleaned_data: dict | None = None) -> str:  # noqa: ARG002
         url_name = url_names.get("subject_dashboard_url")
         return reverse(
             url_name,

edc_screening/screening_eligibility.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from django.utils.html import format_html
 from django.utils.safestring import mark_safe
 
 from edc_constants.constants import NO, PENDING, TBD, YES
@@ -33,7 +32,7 @@ class ScreeningEligibility:
     eligible_fld_name: str = "eligible"
     eligible_value_default: str = TBD
     default_display_label = TBD
-    eligible_values_list: list = [YES, NO, TBD]
+    eligible_values_list: list = (YES, NO, TBD)
     ineligible_display_label: str = "INELIGIBLE"
     is_eligible_value: str = YES
     is_ineligible_value: str = NO
@@ -44,9 +43,9 @@ class ScreeningEligibility:
     def __init__(
         self,
         model_obj: SubjectScreeningModel | EligibilityModelMixin = None,
-        cleaned_data: dict = None,
+        cleaned_data: dict | None = None,
         eligible_value_default: str | None = None,
-        eligible_values_list: list | None = None,
+        eligible_values_list: tuple[str, ...] | None = None,
         is_eligible_value: str | None = None,
         is_ineligible_value: str | None = None,
         eligible_display_label: str | None = None,
@@ -126,7 +125,7 @@ class ScreeningEligibility:
     @property
     def is_eligible(self) -> bool:
         """Returns True if eligible else False"""
-        return True if self.eligible == self.is_eligible_value else False
+        return self.eligible == self.is_eligible_value
 
     def _assess_eligibility(self) -> None:
         self.set_fld_attrs_on_self()
@@ -136,30 +135,29 @@ class ScreeningEligibility:
             self.reasons_ineligible.update(**missing_data)
             self.eligible = self.eligible_value_default  # probably TBD
         for fldattr, fc in self.get_required_fields().items():
-            if fldattr not in missing_data:
-                if fc and fc.value:
-                    msg = fc.msg if fc.msg else fldattr.title().replace("_", " ")
-                    is_callable = False
-                    try:
-                        value = fc.value(getattr(self, fldattr))
-                    except TypeError:
-                        value = fc.value
-                    else:
-                        is_callable = True
-                    if (
-                        (isinstance(value, str) and getattr(self, fldattr) != value)
-                        or (
-                            isinstance(value, (list, tuple))
-                            and getattr(self, fldattr) not in value
-                        )
-                        or (
-                            isinstance(value, range)
-                            and not (min(value) <= getattr(self, fldattr) <= max(value))
-                        )
-                        or (is_callable and value is False)
-                    ):
-                        self.reasons_ineligible.update({fldattr: msg})
-                        self.eligible = self.is_ineligible_value  # probably NO
+            if fldattr not in missing_data and fc and fc.value:
+                msg = fc.msg if fc.msg else fldattr.title().replace("_", " ")
+                is_callable = False
+                try:
+                    value = fc.value(getattr(self, fldattr))
+                except TypeError:
+                    value = fc.value
+                else:
+                    is_callable = True
+                if (
+                    (isinstance(value, str) and getattr(self, fldattr) != value)
+                    or (
+                        isinstance(value, (list, tuple))
+                        and getattr(self, fldattr) not in value
+                    )
+                    or (
+                        isinstance(value, range)
+                        and not (min(value) <= getattr(self, fldattr) <= max(value))
+                    )
+                    or (is_callable and value is False)
+                ):
+                    self.reasons_ineligible.update({fldattr: msg})
+                    self.eligible = self.is_ineligible_value  # probably NO
         if self.is_eligible:
             if self.is_eligible and not self.get_required_fields():
                 self.eligible = self.eligible_value_default
@@ -194,7 +192,7 @@ class ScreeningEligibility:
                     "does not exist on class. "
                     f"See {self.__class__.__name__}. "
                     f"Got {e}"
-                )
+                ) from e
             if self.model_obj:
                 try:
                     value = (
@@ -207,7 +205,7 @@ class ScreeningEligibility:
                         "Attribute does not exist on model. "
                         f"See {self.model_obj.__class__.__name__}. "
                         f"Got {e}"
-                    )
+                    ) from e
             else:
                 value = self.cleaned_data.get(fldattr)
             setattr(self, fldattr, value)
@@ -230,10 +228,7 @@ class ScreeningEligibility:
 
     def formatted_reasons_ineligible(self) -> str:
         str_values = "<BR>".join([x for x in self.reasons_ineligible.values() if x])
-        return format_html(
-            "{}",
-            mark_safe(str_values),  # nosec B703 B308
-        )
+        return mark_safe(str_values)  # noqa: S308
 
     @property
     def display_label(self) -> str:

edc_screening/utils.py

@@ -40,10 +40,8 @@ def format_reasons_ineligible(*str_values: str | None, delimiter: str | None = N
     str_values = str_values or []
     str_values = tuple(x for x in str_values if x)
     if str_values:
-        reasons = format_html(
-            "{}",
-            mark_safe(delimiter.join(str_values)),  # noqa: S308
-        )
+        formatted_string = delimiter.join(str_values)
+        reasons = mark_safe(formatted_string)  # noqa: S308
     return reasons
 
 
@@ -120,15 +118,15 @@ def is_eligible_or_raise(
             if url and url_name.endswith("changelist"):
                 url = f"{url}?q={subject_screening.screening_identifier}"
         if not url:
-            msg = format_html(
-                "{}",
+            safe_string = mark_safe(  # noqa: S308
                 "Not allowed. Subject is not eligible. "
-                f"Got {subject_screening.screening_identifier}",
+                f"Got {subject_screening.screening_identifier}.",
             )
         else:
-            msg = format_html(
-                'Not allowed. Subject is not eligible. See subject <A href="{}">{}</A>',
-                mark_safe(url),  # noqa: S308
-                subject_screening.screening_identifier,
+            safe_string = format_html(
+                "Not allowed. Subject is not eligible. See subject "
+                '<A href="{url}">{screening_identifier}</A>',
+                url=url,
+                screening_identifier=subject_screening.screening_identifier,
             )
-        raise forms.ValidationError(msg)
+        raise forms.ValidationError(safe_string)

edc_sites/admin/list_filters.py

@@ -17,10 +17,10 @@ class SiteListFilter(SimpleListFilter):
         else:
             site_ids = sites.get_site_ids_for_user(request=request)
         for site in Site.objects.filter(id__in=site_ids).order_by("id"):
-            names.append((site.id, f"{site.id} {sites.get(site.id).description}"))
+            names.append((site.id, f"{site.id} {sites.get(site.id).description}"))  # noqa: PERF401
         return tuple(names)
 
-    def queryset(self, request, queryset):
+    def queryset(self, request, queryset):  # noqa: ARG002
         if self.value() and self.value() != "none":
             queryset = queryset.filter(site__id=self.value())
         return queryset

edc_sites/admin/site_model_admin_mixin.py

@@ -46,7 +46,7 @@ class SiteModelAdminMixin:
             ]
         return sites.get_view_only_site_ids_for_user(request=request)
 
-    def has_viewallsites_permission(self, request, obj=None) -> bool:
+    def has_viewallsites_permission(self, request, obj=None) -> bool:  # noqa: ARG002
         """Checks if the user has the EDC custom codename
         "viewallsites" for this model.
 
@@ -54,7 +54,7 @@ class SiteModelAdminMixin:
         """
         opts = self.opts
         codename_allsites = get_permission_codename("viewallsites", opts)
-        return request.user.has_perm("%s.%s" % (opts.app_label, codename_allsites))
+        return request.user.has_perm(f"{opts.app_label}.{codename_allsites}")
 
     @admin.display(description="Site", ordering="site__id")
     def site_code(self, obj=None):
@@ -75,7 +75,7 @@ class SiteModelAdminMixin:
         to mulitple sites.
         """
         list_filter = super().get_list_filter(request)
-        list_filter = [x for x in list_filter if x != "site" and x != SiteListFilter]
+        list_filter = [x for x in list_filter if x not in ("site", SiteListFilter)]
         if self.user_may_view_other_sites(request) or self.has_viewallsites_permission(
             request
         ):
@@ -95,25 +95,25 @@ class SiteModelAdminMixin:
             or self.has_viewallsites_permission(request)
         ) and "site" not in list_display:
             list_display = tuple(list_display)
-            list_display = list_display[:pos] + (self.site_code,) + list_display[pos:]
+            list_display = list_display[:pos], self.site_code, list_display[pos:]
         elif "site" in list_display:
             list_display = tuple(
                 [x for x in list_display if x not in ["site", self.site_code]]
             )
-            list_display = list_display[:pos] + (self.site_code,) + list_display[pos:]
+            list_display = list_display[:pos], self.site_code, list_display[pos:]
         return list_display
 
     def get_queryset(self, request) -> QuerySet:
         """Limit modeladmin queryset for the current site only"""
         qs = super().get_queryset(request)
-        site_ids = [request.site.id] + self.get_view_only_site_ids_for_user(request=request)
+        site_ids = (request.site.id, *self.get_view_only_site_ids_for_user(request=request))
         try:
             qs = qs.select_related("site").filter(site_id__in=site_ids)
-        except FieldError:
+        except FieldError as e:
             raise SiteModeAdminMixinError(
                 f"Model missing field `site`. Model `{self.model}`. Did you mean to use "
                 f"the SiteModelAdminMixin? See `{self}`."
-            )
+            ) from e
         return qs
 
     def get_form(self, request, obj=None, change=False, **kwargs):

edc_sites/exceptions.py

@@ -6,5 +6,5 @@ class InvalidSiteForSubjectError(Exception):
     pass
 
 
-class InvalidSiteForUser(Exception):
+class InvalidSiteForUser(Exception):  # noqa: N818
     pass

edc_sites/forms.py

@@ -1 +1,3 @@
-from .modelform_mixins import SiteModelFormMixin  # noqa
+from .modelform_mixins import SiteModelFormMixin
+
+__all__ = ["SiteModelFormMixin"]