endoreg-db 0.8.8.0__py3-none-any.whl → 0.8.9.2__py3-none-any.whl

endoreg_db/models/requirement/requirement.py

@@ -1,28 +1,15 @@
 import logging
 from subprocess import run
-from typing import TYPE_CHECKING, Dict, List, Union, cast, Tuple
+from typing import TYPE_CHECKING, Dict, List, Tuple, Union, cast
 
 from django.db import models
+from pydantic import BaseModel
 
 from endoreg_db.utils.links.requirement_link import RequirementLinks
 
-
 logger = logging.getLogger(__name__)
 
 
-def _validate_requirement_configuration(instance: "Requirement") -> bool:
-    """Ensures requirement fixtures declare both requirement_types and operators."""
-    if not instance.requirement_types.exists():
-        raise ValueError(
-            f"Requirement '{instance.name}' must be associated with at least one RequirementType."
-        )
-    if not instance.operators.exists():
-        raise ValueError(
-            f"Requirement '{instance.name}' must be associated with at least one RequirementOperator."
-        )
-    return True
-
-
 QuerySet = models.QuerySet
 
 if TYPE_CHECKING:
@@ -130,33 +117,43 @@ class Requirement(models.Model):
 
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
-    
+
+    operator_instructions = models.TextField(
+        help_text="semicolon-separated list of target attributes for the requirement",
+    )
+
+    @property
+    def operator_instructions_parsed(self):
+        from endoreg_db.models.requirement.requirement_operator import RequirementOperator
+
+        instructions = RequirementOperator.parse_instructions(self.operator_instructions)
+        return instructions
 
     numeric_value = models.FloatField(
         blank=True,
         null=True,
-        help_text="Numeric value for the requirement. If not set, the requirement is not used in calculations.",
+        help_text="Numeric value for the requirement. ons.",
     )
     numeric_value_min = models.FloatField(
         blank=True,
         null=True,
-        help_text="Minimum numeric value for the requirement. If not set, the requirement is not used in calculations.",
+        help_text="Minimum numeric value for the requirement. ons.",
     )
     numeric_value_max = models.FloatField(
         blank=True,
         null=True,
-        help_text="Maximum numeric value for the requirement. If not set, the requirement is not used in calculations.",
+        help_text="Maximum numeric value for the requirement. ons.",
     )
     string_value = models.CharField(
         max_length=100,
         blank=True,
         null=True,
-        help_text="String value for the requirement. If not set, the requirement is not used in calculations.",
+        help_text="String value for the requirement. ons.",
     )
     string_values = models.TextField(
         blank=True,
         null=True,
-        help_text=" ','-separated list of string values for the requirement.If not set, the requirement is not used in calculations.",
+        help_text=" ','-separated list of string values for the requirement.ons.",
     )
     objects = RequirementManager()
 
@@ -166,9 +163,9 @@ class Requirement(models.Model):
         related_name="linked_requirements",
     )
 
-    operators = models.ManyToManyField(
+    operator = models.ForeignKey(
         "RequirementOperator",
-        blank=True,
+        on_delete=models.CASCADE,
         related_name="required_in",
     )
 
@@ -271,12 +268,8 @@ class Requirement(models.Model):
     )
 
     if TYPE_CHECKING:
-        requirement_types = cast(
-            models.manager.RelatedManager["RequirementType"], requirement_types
-        )
-        operators = cast(
-            models.manager.RelatedManager["RequirementOperator"], operators
-        )
+        requirement_types = cast(models.manager.RelatedManager["RequirementType"], requirement_types)
+        operator = models.ForeignKey["RequirementOperator"]
         # requirement_sets = cast(models.manager.RelatedManager["RequirementSet"], requirement_sets)
         examinations = cast(models.manager.RelatedManager["Examination"], examinations)
         examination_indications = cast(
@@ -299,9 +292,7 @@ class Requirement(models.Model):
             models.manager.RelatedManager["FindingClassificationChoice"],
             finding_classification_choices,
         )
-        finding_interventions = cast(
-            models.manager.RelatedManager["FindingIntervention"], finding_interventions
-        )
+        finding_interventions = cast(models.manager.RelatedManager["FindingIntervention"], finding_interventions)
         medications = cast(models.manager.RelatedManager["Medication"], medications)
         medication_indications = cast(
             models.manager.RelatedManager["MedicationIndication"],
@@ -311,9 +302,7 @@ class Requirement(models.Model):
             models.manager.RelatedManager["MedicationIntakeTime"],
             medication_intake_times,
         )
-        medication_schedules = cast(
-            models.manager.RelatedManager["MedicationSchedule"], medication_schedules
-        )
+        medication_schedules = cast(models.manager.RelatedManager["MedicationSchedule"], medication_schedules)
         genders = cast(models.manager.RelatedManager["Gender"], genders)
 
     def natural_key(self):
@@ -328,13 +317,6 @@ class Requirement(models.Model):
         """Returns the name of the requirement as its string representation."""
         return str(self.name)
 
-    # override save method to add a validation step; requirements need at least one operator and at least one requirement type
-    # def save(self, *args, **kwargs):
-    #     _valid = _validate_requirement_configuration(
-    #         self,
-    #     )
-    #     super().save(*args, **kwargs)
-
     @property
     def expected_models(
         self,
@@ -388,32 +370,18 @@ class Requirement(models.Model):
         # requirement_sets is not part of RequirementLinks (avoids circular import); collect other related models
         models_dict = RequirementLinks(
             examinations=[_ for _ in self.examinations.all() if _ is not None],
-            examination_indications=[
-                _ for _ in self.examination_indications.all() if _ is not None
-            ],
+            examination_indications=[_ for _ in self.examination_indications.all() if _ is not None],
             lab_values=[_ for _ in self.lab_values.all() if _ is not None],
             diseases=[_ for _ in self.diseases.all() if _ is not None],
-            disease_classification_choices=[
-                _ for _ in self.disease_classification_choices.all() if _ is not None
-            ],
+            disease_classification_choices=[_ for _ in self.disease_classification_choices.all() if _ is not None],
             events=[_ for _ in self.events.all() if _ is not None],
             findings=[_ for _ in self.findings.all() if _ is not None],
-            finding_classifications=[
-                _ for _ in self.finding_classifications.all() if _ is not None
-            ],
-            finding_classification_choices=[
-                _ for _ in self.finding_classification_choices.all() if _ is not None
-            ],
-            finding_interventions=[
-                _ for _ in self.finding_interventions.all() if _ is not None
-            ],
+            finding_classifications=[_ for _ in self.finding_classifications.all() if _ is not None],
+            finding_classification_choices=[_ for _ in self.finding_classification_choices.all() if _ is not None],
+            finding_interventions=[_ for _ in self.finding_interventions.all() if _ is not None],
             medications=[_ for _ in self.medications.all() if _ is not None],
-            medication_indications=[
-                _ for _ in self.medication_indications.all() if _ is not None
-            ],
-            medication_intake_times=[
-                _ for _ in self.medication_intake_times.all() if _ is not None
-            ],
+            medication_indications=[_ for _ in self.medication_indications.all() if _ is not None],
+            medication_intake_times=[_ for _ in self.medication_intake_times.all() if _ is not None],
         )
         return models_dict
 
@@ -437,63 +405,7 @@ class Requirement(models.Model):
         """
         return self.links.active()
 
-    def _parse_string_values(self) -> Dict[str, str]:
-        """Parses the optional ``string_values`` field into a dictionary.
-
-        Values follow a simple ``key=value`` syntax separated by commas. Entries
-        without an equals sign are treated as boolean flags (value ``"true"``).
-        """
-        if not self.string_values:
-            return {}
-
-        parsed: Dict[str, str] = {}
-        for raw_entry in self.string_values.split(","):
-            entry = raw_entry.strip()
-            if not entry:
-                continue
-            if "=" in entry:
-                key, value = entry.split("=", 1)
-                parsed[key.strip()] = value.strip()
-            else:
-                parsed[entry] = "true"
-        return parsed
-
-    def _resolve_queryset_config(self, kwargs: Dict) -> tuple[str, int | None]:
-        """Derives queryset evaluation settings from kwargs or ``string_values``.
-
-        Supported modes:
-            - ``any`` (default): at least one item may satisfy the requirement.
-            - ``all``: every item in the queryset must satisfy the requirement.
-            - ``min_count``/``at_least``/``min``: at least *n* items must satisfy.
-        """
-        settings = self._parse_string_values()
-
-        mode_raw = kwargs.get("queryset_mode") or settings.get("qs_mode") or "any"
-        mode = str(mode_raw).strip().lower()
-        mode_aliases = {
-            "min": "min_count",
-            "at_least": "min_count",
-            "minimum": "min_count",
-        }
-        mode = mode_aliases.get(mode, mode)
-        if mode not in {"any", "all", "min_count"}:
-            mode = "any"
-
-        min_count_raw = kwargs.get("queryset_min_count")
-        if min_count_raw is None:
-            for candidate_key in ("qs_min_count", "qs_min", "qs_count", "qs_required"):
-                if candidate_key in settings:
-                    min_count_raw = settings[candidate_key]
-                    break
-
-        try:
-            min_count = int(min_count_raw) if min_count_raw is not None else None
-        except (TypeError, ValueError):
-            min_count = None
-
-        return mode, min_count
-
-    def evaluate(self, *args, mode: str, **kwargs):
+    def evaluate(self, input_obj):
         """
         Evaluates whether the requirement is satisfied for the given input models using linked operators and gender constraints.
 
@@ -511,230 +423,21 @@ class Requirement(models.Model):
 
         If the requirement specifies genders, only input containing a patient with a matching gender will be considered valid for evaluation.
         """
+        is_valid: bool = False
 
-        try:
-            _validate_requirement_configuration(self)
-        except Exception as e:
-            logger.warning(str(e))
-        # TODO Review, Optimize or remove
-        if mode not in ["strict", "loose"]:
-            raise ValueError(f"Invalid mode: {mode}. Use 'strict' or 'loose'.")
+        requirement_req_links = self.active_links
 
-        evaluate_result_list_func = all if mode == "strict" else any
+        # expected_models = self.expected_models
 
-        requirement_req_links = self.links
-        expected_models = self.expected_models
+        operator = self.operator
+        assert isinstance(operator, RequirementOperator)
 
-        operators = list(self.operators.all())
-        has_operators = bool(operators)
-        requirement_has_conditions = bool(requirement_req_links.active())
-        queryset_mode, queryset_min_count = self._resolve_queryset_config(kwargs)
+        operator_instructions = self.operator_instructions_parsed
 
-        # helpers to avoid passing a complex tuple to isinstance/issubclass which confuses type checkers
-        def _is_expected_instance(obj) -> bool:
-            for cls in expected_models:
-                if isinstance(cls, type):
-                    try:
-                        if isinstance(obj, cls):
-                            return True
-                    except Exception:
-                        # cls might not be a runtime type
-                        continue
-            return False
-
-        def _is_queryset_of_expected(qs) -> bool:
-            if not isinstance(qs, models.QuerySet) or not hasattr(qs, "model"):
-                return False
-            for cls in expected_models:
-                if isinstance(cls, type):
-                    try:
-                        if issubclass(qs.model, cls):
-                            return True
-                    except Exception:
-                        continue
-            return False
-
-        # Aggregate RequirementLinks from all input arguments
-        aggregated_input_links_data = {}
-        processed_inputs_count = 0
-
-        for _input in args:
-            # Check if the input is an instance of any of the expected model types
-            if not _is_expected_instance(_input):
-                # Allow QuerySets of expected models
-                if _is_queryset_of_expected(_input):
-                    if not _input.exists():
-                        # Empty queryset: enforce stricter modes immediately
-                        if queryset_mode == "all":
-                            return False
-                        if queryset_mode == "min_count":
-                            required = (
-                                queryset_min_count
-                                if queryset_min_count is not None
-                                else 1
-                            )
-                            if required > 0:
-                                return False
-                        continue
-
-                    queryset_results: List[bool] = []
-                    queryset_true_count = 0
-                    queryset_item_count = 0
-
-                    for item in _input:
-                        if not hasattr(item, "links") or not isinstance(
-                            item.links, RequirementLinks
-                        ):
-                            raise TypeError(
-                                f"Item {item} of type {type(item)} in QuerySet does not have a valid .links attribute of type RequirementLinks."
-                            )
-
-                        item_active_links = item.links.active()
-                        item_input_links = RequirementLinks(**item_active_links)
-
-                        for link_key, link_list in item_active_links.items():
-                            if link_key not in aggregated_input_links_data:
-                                aggregated_input_links_data[link_key] = []
-                            aggregated_input_links_data[link_key].extend(link_list)
-
-                        per_item_args = tuple(
-                            item if arg is _input else arg for arg in args
-                        )
-                        op_kwargs = kwargs.copy()
-                        op_kwargs["requirement"] = self
-                        op_kwargs["original_input_args"] = per_item_args
-
-                        if has_operators:
-                            item_operator_results: List[bool] = []
-                            for operator in operators:
-                                try:
-                                    operator_result = operator.evaluate(
-                                        requirement_links=requirement_req_links,
-                                        input_links=item_input_links,
-                                        **op_kwargs,
-                                    )
-                                    item_operator_results.append(operator_result)
-                                except Exception as exc:
-                                    logger.debug(
-                                        f"Operator {operator.name} evaluation failed for item {item}: {exc}"
-                                    )
-                                    item_operator_results.append(False)
-                            item_result = (
-                                evaluate_result_list_func(item_operator_results)
-                                if item_operator_results
-                                else True
-                            )
-                        else:
-                            item_result = not requirement_has_conditions
-
-                        queryset_results.append(item_result)
-                        if item_result:
-                            queryset_true_count += 1
-                        queryset_item_count += 1
-                        processed_inputs_count += 1
-
-                    if queryset_mode == "all":
-                        if queryset_item_count == 0 or not all(queryset_results):
-                            return False
-                    elif queryset_mode == "min_count":
-                        required = (
-                            queryset_min_count if queryset_min_count is not None else 1
-                        )
-                        if queryset_true_count < max(required, 0):
-                            return False
-                    # queryset_mode == "any" imposes no extra constraint here
-                    continue  # Move to the next arg after processing queryset
-                else:
-                    raise TypeError(
-                        f"Input type {type(_input)} is not among expected models: {self.expected_models} nor a QuerySet of expected models."
-                    )
-
-            # Process single model instance
-            if not hasattr(_input, "links") or not isinstance(
-                _input.links, RequirementLinks
-            ):
-                raise TypeError(
-                    f"Input {_input} of type {type(_input)} does not have a valid .links attribute of type RequirementLinks."
-                )
-
-            active_input_links = _input.links.active()  # Get dict of non-empty lists
-            for link_key, link_list in active_input_links.items():
-                if link_key not in aggregated_input_links_data:
-                    aggregated_input_links_data[link_key] = []
-                aggregated_input_links_data[link_key].extend(link_list)
-            processed_inputs_count += 1
-
-        if (
-            not processed_inputs_count and args
-        ):  # If args were provided but none were processable (e.g. all empty querysets)
-            # This situation implies no relevant data was provided for evaluation against the requirement.
-            # Depending on operator logic (e.g., "requires at least one matching item"), this might lead to False.
-            # For "models_match_any", an empty input_links will likely result in False if requirement_req_links is not empty.
-            pass
-
-        # Deduplicate items within each list after aggregation
-        for key in aggregated_input_links_data:
-            try:
-                # Using dict.fromkeys to preserve order and remove duplicates for hashable items
-                aggregated_input_links_data[key] = list(
-                    dict.fromkeys(aggregated_input_links_data[key])
-                )
-            except TypeError:
-                # Fallback for non-hashable items (though Django models are hashable)
-                temp_list = []
-                for item in aggregated_input_links_data[key]:
-                    if item not in temp_list:
-                        temp_list.append(item)
-                aggregated_input_links_data[key] = temp_list
-
-        final_input_links = RequirementLinks(**aggregated_input_links_data)
-
-        # Gender strict check: if this requirement has genders, only pass if patient.gender is in the set
-        genders_exist = self.genders.exists()
-        if genders_exist:
-            # Import here to avoid circular import
-            from endoreg_db.models.administration.person.patient import Patient
-
-            patient = None
-            for arg in args:
-                if isinstance(arg, Patient):
-                    patient = arg
-                    break
-            if patient is None or patient.gender is None:
-                return False
-            if not self.genders.filter(pk=patient.gender.pk).exists():
-                return False
-
-        if (
-            not has_operators
-        ):  # If a requirement has no operators, its evaluation is ambiguous.
-            if not requirement_has_conditions:  # No conditions in requirement
-                return True  # Vacuously true if requirement itself is empty
-            return False  # Cannot be satisfied if requirement has conditions but no operators to check them
-
-        operator_results = []
-        for operator in operators:
-            # Prepare kwargs for the operator, including the current Requirement instance
-            op_kwargs = (
-                kwargs.copy()
-            )  # Start with kwargs passed to Requirement.evaluate
-            op_kwargs["requirement"] = self  # Add the Requirement instance itself
-            op_kwargs["original_input_args"] = (
-                args  # Add the original input arguments for operators that need them (e.g., age operators)
-            )
-            operator_results.append(
-                operator.evaluate(
-                    requirement_links=requirement_req_links,
-                    input_links=final_input_links,
-                    **op_kwargs,
-                )
-            )
-
-        is_valid = evaluate_result_list_func(operator_results)
+        is_valid = operator.evaluate(input_links)
 
         return is_valid
 
-
     def evaluate_with_details(self, *args, mode: str, **kwargs) -> Tuple[bool, str]:
         """
         Evaluates whether the requirement is satisfied for the given input models using linked operators and gender constraints.
@@ -763,9 +466,7 @@ class Requirement(models.Model):
                 code="INVALID_MODE",
                 technical_message=f"Invalid mode: {mode}. Use 'strict' or 'loose'.",
                 user_message=(
-                    "Diese Voraussetzung ist intern mit einem ungültigen "
-                    "Bewertungsmodus konfiguriert und kann aktuell nicht "
-                    "korrekt geprüft werden."
+                    "Diese Voraussetzung ist intern mit einem ungültigen Bewertungsmodus konfiguriert und kann aktuell nicht korrekt geprüft werden."
                 ),
             )
 
@@ -816,20 +517,14 @@ class Requirement(models.Model):
                         if queryset_mode == "all":
                             return (
                                 False,
-                                "Für diese Voraussetzung müssen alle passenden Einträge vorliegen, "
-                                "aber es wurden keine entsprechenden Datensätze gefunden.",
+                                "Für diese Voraussetzung müssen alle passenden Einträge vorliegen, aber es wurden keine entsprechenden Datensätze gefunden.",
                             )
                         if queryset_mode == "min_count":
-                            required = (
-                                queryset_min_count
-                                if queryset_min_count is not None
-                                else 1
-                            )
+                            required = queryset_min_count if queryset_min_count is not None else 1
                             if required > 0:
                                 return (
                                     False,
-                                    f"Für diese Voraussetzung werden mindestens {required} passende "
-                                    "Einträge benötigt, es wurden jedoch keine gefunden.",
+                                    f"Für diese Voraussetzung werden mindestens {required} passende Einträge benötigt, es wurden jedoch keine gefunden.",
                                 )
                         # queryset_mode == "any" bei leerem QS -> neutral (keine zusätzliche Einschränkung)
                         continue
@@ -839,15 +534,12 @@ class Requirement(models.Model):
                     queryset_item_count = 0
 
                     for item in _input:
-                        if not hasattr(item, "links") or not isinstance(
-                            item.links, RequirementLinks
-                        ):
+                        if not hasattr(item, "links") or not isinstance(item.links, RequirementLinks):
                             raise RequirementEvaluationError(
                                 requirement=self,
                                 code="MISSING_LINKS_ATTR",
                                 technical_message=(
-                                    f"Item {item} of type {type(item)} in QuerySet does not "
-                                    f"have a valid .links attribute of type RequirementLinks."
+                                    f"Item {item} of type {type(item)} in QuerySet does not have a valid .links attribute of type RequirementLinks."
                                 ),
                                 user_message=(
                                     "Für einen Datensatz fehlen die intern benötigten Verknüpfungen, "
@@ -865,9 +557,7 @@ class Requirement(models.Model):
                                 aggregated_input_links_data[link_key] = []
                             aggregated_input_links_data[link_key].extend(link_list)
 
-                        per_item_args = tuple(
-                            item if arg is _input else arg for arg in args
-                        )
+                        per_item_args = tuple(item if arg is _input else arg for arg in args)
                         op_kwargs = kwargs.copy()
                         op_kwargs["requirement"] = self
                         op_kwargs["original_input_args"] = per_item_args
@@ -890,11 +580,7 @@ class Requirement(models.Model):
                                         exc,
                                     )
                                     item_operator_results.append(False)
-                            item_result = (
-                                evaluate_result_list_func(item_operator_results)
-                                if item_operator_results
-                                else True
-                            )
+                            item_result = evaluate_result_list_func(item_operator_results) if item_operator_results else True
                         else:
                             # keine Operatoren -> Bedingung erfüllt, wenn Requirement selbst keine Bedingungen hat
                             item_result = not requirement_has_conditions
@@ -913,14 +599,11 @@ class Requirement(models.Model):
                                 "Für diese Voraussetzung müssen alle relevanten Einträge die Bedingung erfüllen.",
                             )
                     elif queryset_mode == "min_count":
-                        required = (
-                            queryset_min_count if queryset_min_count is not None else 1
-                        )
+                        required = queryset_min_count if queryset_min_count is not None else 1
                         if queryset_true_count < max(required, 0):
                             return (
                                 False,
-                                f"Für diese Voraussetzung werden mindestens {max(required, 0)} "
-                                f"passende Einträge benötigt (gefunden: {queryset_true_count}).",
+                                f"Für diese Voraussetzung werden mindestens {max(required, 0)} passende Einträge benötigt (gefunden: {queryset_true_count}).",
                             )
                     # queryset_mode == "any": keine zusätzliche Einschränkung
                     continue
@@ -929,32 +612,18 @@ class Requirement(models.Model):
                 raise RequirementEvaluationError(
                     requirement=self,
                     code="INVALID_INPUT_TYPE",
-                    technical_message=(
-                        f"Input type {type(_input)} is not among expected models: "
-                        f"{self.expected_models} nor a QuerySet of expected models."
-                    ),
-                    user_message=(
-                        "Diese Voraussetzung wurde mit einem nicht passenden Datentyp "
-                        "aufgerufen und kann aktuell nicht korrekt geprüft werden."
-                    ),
+                    technical_message=(f"Input type {type(_input)} is not among expected models: {self.expected_models} nor a QuerySet of expected models."),
+                    user_message=("Diese Voraussetzung wurde mit einem nicht passenden Datentyp aufgerufen und kann aktuell nicht korrekt geprüft werden."),
                     meta={"input_type": str(type(_input))},
                 )
 
             # Einzelinstanz erwarteten Typs
-            if not hasattr(_input, "links") or not isinstance(
-                _input.links, RequirementLinks
-            ):
+            if not hasattr(_input, "links") or not isinstance(_input.links, RequirementLinks):
                 raise RequirementEvaluationError(
                     requirement=self,
                     code="MISSING_LINKS_ATTR",
-                    technical_message=(
-                        f"Input {_input} of type {type(_input)} does not have a valid "
-                        f".links attribute of type RequirementLinks."
-                    ),
-                    user_message=(
-                        "Für die Auswertung dieser Voraussetzung fehlen die intern "
-                        "benötigten Verknüpfungsinformationen."
-                    ),
+                    technical_message=(f"Input {_input} of type {type(_input)} does not have a valid .links attribute of type RequirementLinks."),
+                    user_message=("Für die Auswertung dieser Voraussetzung fehlen die intern benötigten Verknüpfungsinformationen."),
                     meta={"input_type": str(type(_input))},
                 )
 
@@ -971,9 +640,7 @@ class Requirement(models.Model):
         # Deduplizieren der aggregierten Links
         for key in aggregated_input_links_data:
             try:
-                aggregated_input_links_data[key] = list(
-                    dict.fromkeys(aggregated_input_links_data[key])
-                )
+                aggregated_input_links_data[key] = list(dict.fromkeys(aggregated_input_links_data[key]))
             except TypeError:
                 # Fallback für nicht-hashbare Items
                 tmp: list = []
@@ -1004,8 +671,7 @@ class Requirement(models.Model):
             if not self.genders.filter(pk=patient.gender.pk).exists():
                 return (
                     False,
-                    "Diese Voraussetzung gilt nur für bestimmte Geschlechter und ist "
-                    "für diesen Patienten nicht erfüllt.",
+                    "Diese Voraussetzung gilt nur für bestimmte Geschlechter und ist für diesen Patienten nicht erfüllt.",
                 )
 
         # --- Fall: keine Operatoren -----------------------------------------
@@ -1033,9 +699,7 @@ class Requirement(models.Model):
                     **op_kwargs,
                 )
                 operator_results.append(operator_result)
-                operator_details.append(
-                    f"{operator.name}: {'erfüllt' if operator_result else 'nicht erfüllt'}"
-                )
+                operator_details.append(f"{operator.name}: {'erfüllt' if operator_result else 'nicht erfüllt'}")
             except Exception as e:
                 operator_results.append(False)
                 operator_details.append(f"{operator.name}: technischer Fehler ({e})")
@@ -1054,11 +718,7 @@ class Requirement(models.Model):
         elif len(operator_results) == 1:
             details = operator_details[0]
         else:
-            failed_details = [
-                detail
-                for detail, result in zip(operator_details, operator_results)
-                if not result
-            ]
+            failed_details = [detail for detail, result in zip(operator_details, operator_results) if not result]
             if failed_details:
                 details = "; ".join(failed_details)
             else:
@@ -1072,4 +732,4 @@ class Requirement(models.Model):
             # nicht kritisch
             pass
 
-        return bool(is_valid), details
+        return bool(is_valid), details