clinicedc 2.0.23__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

@@ -55,31 +55,32 @@ class RandomizationListImporter:
 
 
     Format:
-        sid,assignment,site_name, orig_site, orig_allocation, orig_desc
-        1,single_dose,gaborone
-        2,two_doses,gaborone
+        sid,site_name, assignment, description, orig_site, orig_allocation, orig_desc
+        1,gaborone,intervention,single_dose
+        2,gaborone,control,two_doses
         ...
     """
 
-    required_csv_fieldnames = ["sid", "assignment", "site_name"]
+    required_csv_fieldnames = ("sid", "assignment", "site_name", "description")
     verifier_cls = RandomizationListVerifier
 
     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,13 +25,13 @@ 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,
-        **kwargs,
+        required_csv_fieldnames: tuple[str, ...] | None = None,
+        **kwargs,  # noqa: ARG002
     ):
         self.count: int = 0
         self.messages: list[str] = []
@@ -68,33 +68,38 @@ class RandomizationListVerifier:
                 )
             elif message := self.verify():
                 self.messages.append(message)
-        if self.messages:
-            if (
-                "migrate" not in sys.argv
-                and "makemigrations" not in sys.argv
-                and "import_randomization_list" not in sys.argv
-            ):
-                raise RandomizationListError(", ".join(self.messages))
+        if self.messages and (
+            "migrate" not in sys.argv
+            and "makemigrations" not in sys.argv
+            and "import_randomization_list" not in sys.argv
+        ):
+            raise RandomizationListError(", ".join(self.messages))
 
     def verify(self) -> str | None:
         message = None
+
         with self.randomizationlist_path.open(mode="r") as f:
             reader = csv.DictReader(f)
-            for index, row in enumerate(reader, start=1):
-                row = {k: v.strip() for k, v in row.items() if k}
-                message = self.inspect_row(index - 1, row)
-                if message:
-                    break
-                if self.sid_count_for_tests and index == self.sid_count_for_tests:
-                    break
-        if not message:
-            if self.count != index:
-                message = (
-                    f"Randomization list count is off. Expected {index} (CSV). "
-                    f"Got {self.count} (model_cls). See file "
-                    f"{self.randomizationlist_path}. "
-                    f"Resolve this issue before using the system."
-                )
+            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 index, row in enumerate(sorted_rows, start=1):
+            sys.stdout.write(f"Index: {index}, SID: {row.get('sid')}, Row: {row}\n")
+            message = self.inspect_row(index - 1, row)
+            if message:
+                break
+            if self.sid_count_for_tests and index == self.sid_count_for_tests:
+                break
+
+        if not message and self.count != index:
+            message = (
+                f"Randomization list count is off. Expected {index} (CSV). "
+                f"Got {self.count} (model_cls). See file "
+                f"{self.randomizationlist_path}. "
+                f"Resolve this issue before using the system."
+            )
         return message
 
     def inspect_row(self, index: int, row) -> str | None:
@@ -103,7 +108,7 @@ class RandomizationListVerifier:
         Note:Index is zero-based
         """
         message = None
-        obj1 = self.randomizer_model_cls.objects.all().order_by("sid")[index]
+        obj1 = self.randomizer_model_cls.objects.all().order_by("site_name", "sid")[index]
         try:
             obj2 = self.randomizer_model_cls.objects.get(sid=row["sid"])
         except ObjectDoesNotExist:

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_randomization/site_randomizers.py

@@ -28,7 +28,22 @@ class SiteRandomizerError(Exception):
 
 
 class SiteRandomizers:
-    """Main controller of :class:`SiteRandomizers` objects."""
+    """Main controller of :class:`SiteRandomizers` objects.
+
+    To rescan the CSV file for randomizer additional slots:
+
+        from edc_randomization.site_randomizers import site_randomizers
+        # assuming the randimizer is "default"
+        site_randomizers.get("default").import_list(add=True,dryrun=True)
+
+    If all OK:
+
+        # assuming the randimizer is "default"
+        site_randomizers.get("default").import_list(add=True,dryrun=False)
+
+    See
+
+    """
 
     def __init__(self):
         self._registry = {}
@@ -57,12 +72,12 @@ class SiteRandomizers:
     def get(self, name):
         try:
             return self._registry[str(name)]
-        except KeyError:
+        except KeyError as e:
             raise NotRegistered(
                 f"A Randomizer class by this name is not registered. "
                 f"Expected one of {list(self._registry.keys())}. "
                 f"Got '{name}'. See site_randomizer."
-            )
+            ) from e
 
     def get_by_model(self, model=None):
         """Returns the randomizer class for this model label_lower.
@@ -75,10 +90,12 @@ class SiteRandomizers:
         return None
 
     def get_as_choices(self):
-        choices = []
-        for randomizer_cls in self._registry.values():
-            choices.append((randomizer_cls.name, randomizer_cls.name))
-        return tuple(choices)
+        return tuple(
+            [
+                (randomizer_cls.name, randomizer_cls.name)
+                for randomizer_cls in self._registry.values()
+            ]
+        )
 
     def randomize(
         self,
@@ -115,7 +132,7 @@ class SiteRandomizers:
                         before_import_registry = copy.copy(site_randomizers._registry)
                         import_module(f"{app}.{module_name}")
                         if verbose:
-                            sys.stdout.write(" * registered randomizer from " f"'{app}'\n")
+                            sys.stdout.write(f" * registered randomizer from '{app}'\n")
                     except Exception as e:
                         if f"No module named '{app}.{module_name}'" not in str(e):
                             raise

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: