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

endoreg_db/models/requirement/requirement.py

@@ -3,7 +3,6 @@ from subprocess import run
 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
 
@@ -124,9 +123,13 @@ class Requirement(models.Model):
 
     @property
     def operator_instructions_parsed(self):
-        from endoreg_db.models.requirement.requirement_operator import RequirementOperator
+        from endoreg_db.models.requirement.requirement_operator import (
+            RequirementOperator,
+        )
 
-        instructions = RequirementOperator.parse_instructions(self.operator_instructions)
+        instructions = RequirementOperator.parse_instructions(
+            self.operator_instructions
+        )
         return instructions
 
     numeric_value = models.FloatField(
@@ -268,7 +271,9 @@ class Requirement(models.Model):
     )
 
     if TYPE_CHECKING:
-        requirement_types = cast(models.manager.RelatedManager["RequirementType"], requirement_types)
+        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)
@@ -292,7 +297,9 @@ 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"],
@@ -302,7 +309,9 @@ 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):
@@ -370,18 +379,32 @@ 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
 
@@ -457,7 +480,9 @@ class Requirement(models.Model):
                 - bei ungültigem Modus
                 - bei komplett falschen Input-Typen / fehlender .links-Struktur
         """
-        from endoreg_db.models.requirement.requirement_error import RequirementEvaluationError
+        from endoreg_db.models.requirement.requirement_error import (
+            RequirementEvaluationError,
+        )
 
         # --- Mode validieren -------------------------------------------------
         if mode not in ["strict", "loose"]:
@@ -520,7 +545,11 @@ class Requirement(models.Model):
                                 "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,
@@ -534,7 +563,9 @@ 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",
@@ -557,7 +588,9 @@ 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
@@ -580,7 +613,11 @@ 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
@@ -599,7 +636,9 @@ 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,
@@ -612,18 +651,28 @@ class Requirement(models.Model):
                 raise RequirementEvaluationError(
                     requirement=self,
                     code="INVALID_INPUT_TYPE",
-                    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."),
+                    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 .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))},
                 )
 
@@ -640,7 +689,9 @@ 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 = []
@@ -699,7 +750,9 @@ 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})")
@@ -718,7 +771,11 @@ 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:

endoreg_db/models/requirement/requirement_error.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Optional, Any, Mapping, TYPE_CHECKING
+
 if TYPE_CHECKING:
     from endoreg_db.models.requirement.requirement import Requirement
 
@@ -14,13 +15,13 @@ class RequirementEvaluationErrorContext:
     - user_message: optional pre-formatted text for UI
     - meta: optional arbitrary payload for logging / debugging
     """
+
     requirement: "Requirement"
     code: str
     technical_message: str
     user_message: Optional[str] = None
     description: Optional[str] = None
     meta: Optional[Mapping[str, Any]] = None
-    
 
 
 class RequirementEvaluationError(Exception):
@@ -36,7 +37,7 @@ class RequirementEvaluationError(Exception):
 
     def __init__(
         self,
-        requirement: "Requirement",     
+        requirement: "Requirement",
         code: str,
         technical_message: str,
         user_message: Optional[str] = None,
@@ -52,18 +53,16 @@ class RequirementEvaluationError(Exception):
         )
         # Base Exception message = technical message
         super().__init__(technical_message, *args)
-        
-    
 
     @property
-    def requirement(self) ->  "Requirement":
+    def requirement(self) -> "Requirement":
         return self.context.requirement
 
     @property
     def requirement_name(self) -> str:
         # This is the DB name, *not* the internal Python repr
         return getattr(self.context.requirement, "name", "unknown")
-    
+
     @property
     def requirement_description(self) -> str:
         return getattr(self.context.requirement, "description")

endoreg_db/models/requirement/requirement_evaluation/__init__.py

@@ -3,4 +3,4 @@
 
 __all__ = [
     # "get_operator_function"
-]
+]

endoreg_db/models/requirement/requirement_evaluation/evaluate_with_dependencies.py

@@ -8,6 +8,7 @@ logger = logging.getLogger(__name__)
 
 RequirementStatus = Literal["PASSED", "FAILED", "BLOCKED", "ERROR"]
 
+
 def topologically_sort_requirement_sets(
     sets: Iterable[RequirementSet],
 ) -> List[RequirementSet]:
@@ -44,8 +45,6 @@ def topologically_sort_requirement_sets(
     return [id_map[sid] for sid in ordered_ids]
 
 
-
-
 def evaluate_requirement_sets_with_dependencies(
     sets: Iterable[RequirementSet],
     *args,
@@ -145,9 +144,7 @@ def evaluate_requirement_sets_with_dependencies(
                     req_set.id,
                     req.id,
                 )
-                msg = (
-                    f"Technischer Fehler bei der Auswertung von '{req.name}': {exc}"
-                )
+                msg = f"Technischer Fehler bei der Auswertung von '{req.name}': {exc}"
                 set_results[set_id][req.id] = ("ERROR", msg)
 
         # derive set status
@@ -161,7 +158,9 @@ def evaluate_requirement_sets_with_dependencies(
 
     return set_results
 
-#TODO Remove when sure that no per requirement evaluation will happen. Needs the depends on attribute for the reatuirements.
+
+# TODO Remove when sure that no per requirement evaluation will happen. Needs the depends on attribute for the reatuirements.
+
 
 def topologically_sort_requirements(
     requirements: Iterable[Requirement],
@@ -200,6 +199,7 @@ def topologically_sort_requirements(
 
     return [id_map[rid] for rid in ordered_ids]
 
+
 def evaluate_requirements_with_dependencies(
     requirements: Iterable[Requirement],
     *args,
@@ -252,7 +252,7 @@ def evaluate_requirements_with_dependencies(
             met = False
             results[req.id] = (
                 "FAILED",
-                f"Nachtragebedarf bei der Auswertung von '{req.name}': {exc}"
+                f"Nachtragebedarf bei der Auswertung von '{req.name}': {exc}",
             )
         except Exception as exc:
             met = False
@@ -265,4 +265,4 @@ def evaluate_requirements_with_dependencies(
             status: RequirementStatus = "PASSED" if met else "FAILED"
             results[req.id] = (status, details)
 
-    return results
+    return results

endoreg_db/models/requirement/requirement_evaluation/get_values.py

@@ -8,6 +8,7 @@ if TYPE_CHECKING:
         Requirement,
     )
 
+
 def get_values_from_kwargs(
     requirement: "Requirement",
     patient: Optional["Patient"] = None,
@@ -16,9 +17,9 @@ def get_values_from_kwargs(
 ) -> dict:
     """
     Aggregates and validates input values required for evaluating a requirement.
-    
+
     Checks the requirement's types to ensure that necessary parameters such as `patient` or `patient_examination` are provided when required. Raises a ValueError if a required parameter is missing. Returns a dictionary containing the validated inputs and any additional keyword arguments.
-    
+
     Returns:
         A dictionary with keys for 'patient', 'patient_examination', and any extra keyword arguments.
     """
@@ -37,4 +38,3 @@ def get_values_from_kwargs(
 
     # Prepare and return the extracted values
     return {"patient": patient, "patient_examination": patient_examination, **kwargs}
-

endoreg_db/models/requirement/requirement_evaluation/requirement_type_parser.py

@@ -58,7 +58,9 @@ class DataModelEntry(BaseModel):
     @field_validator("model")
     @classmethod
     def ensure_model_subclass(cls, value: type[models.Model]) -> type[models.Model]:
-        if not issubclass(value, models.Model):  # Defensive: ensure provided class is a Django model
+        if not issubclass(
+            value, models.Model
+        ):  # Defensive: ensure provided class is a Django model
             raise TypeError(f"{value!r} is not a Django model class")
         return value
 
@@ -90,32 +92,46 @@ class DataModelRegistry(BaseModel):
 DATA_MODEL_REGISTRY = DataModelRegistry(
     entries=(
         DataModelEntry(name="disease", model=Disease),
-        DataModelEntry(name="disease_classification_choice", model=DiseaseClassificationChoice),
+        DataModelEntry(
+            name="disease_classification_choice", model=DiseaseClassificationChoice
+        ),
         DataModelEntry(name="disease_classification", model=DiseaseClassification),
         DataModelEntry(name="event", model=Event),
         DataModelEntry(name="event_classification", model=EventClassification),
-        DataModelEntry(name="event_classification_choice", model=EventClassificationChoice),
+        DataModelEntry(
+            name="event_classification_choice", model=EventClassificationChoice
+        ),
         DataModelEntry(name="examination", model=Examination),
         DataModelEntry(name="examination_indication", model=ExaminationIndication),
         DataModelEntry(name="finding", model=Finding),
         DataModelEntry(name="finding_intervention", model=FindingIntervention),
         DataModelEntry(name="finding_classification", model=FindingClassification),
-        DataModelEntry(name="finding_classification_choice", model=FindingClassificationChoice),
+        DataModelEntry(
+            name="finding_classification_choice", model=FindingClassificationChoice
+        ),
         DataModelEntry(name="lab_value", model=LabValue),
         DataModelEntry(name="patient_disease", model=PatientDisease),
         DataModelEntry(name="patient_event", model=PatientEvent),
         DataModelEntry(name="patient_examination", model=PatientExamination),
         DataModelEntry(name="patient_finding", model=PatientFinding),
-        DataModelEntry(name="patient_finding_intervention", model=PatientFindingIntervention),
-        DataModelEntry(name="patient_finding_classification", model=PatientFindingClassification),
+        DataModelEntry(
+            name="patient_finding_intervention", model=PatientFindingIntervention
+        ),
+        DataModelEntry(
+            name="patient_finding_classification", model=PatientFindingClassification
+        ),
         DataModelEntry(name="patient_lab_value", model=PatientLabValue),
         DataModelEntry(name="patient_lab_sample", model=PatientLabSample),
         DataModelEntry(name="patient", model=Patient),
         DataModelEntry(name="patient_medication", model=PatientMedication),
-        DataModelEntry(name="patient_medication_schedule", model=PatientMedicationSchedule),
+        DataModelEntry(
+            name="patient_medication_schedule", model=PatientMedicationSchedule
+        ),
         DataModelEntry(name="gender", model=Gender),
     ),
 )
 
 data_model_dict: Dict[str, type[models.Model]] = DATA_MODEL_REGISTRY.as_mapping()
-data_model_dict_reverse: Dict[type[models.Model], str] = DATA_MODEL_REGISTRY.as_reverse_mapping()
+data_model_dict_reverse: Dict[type[models.Model], str] = (
+    DATA_MODEL_REGISTRY.as_reverse_mapping()
+)

endoreg_db/models/requirement/requirement_operator.py

@@ -4,7 +4,9 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Union
 from django.db import models
 from pydantic import BaseModel
 
-from endoreg_db.utils.requirement_operator_logic.new_operator_logic import REQUIREMENT_OPERATORS, model_attribute_set_any
+from endoreg_db.utils.requirement_operator_logic.new_operator_logic import (
+    REQUIREMENT_OPERATORS,
+)
 
 # see how operator evaluation function is fetched, add to docs #TODO
 # endoreg_db/utils/requirement_operator_logic/model_evaluators.py
@@ -55,12 +57,16 @@ def _parse_operator_instructions(raw: str):
                     key, value = _attribute.split(":", 1)
                     kwargs[key.strip()] = value.strip()
                 else:
-                    raise ValueError(f"Invalid keyword argument format in target_attributes: '{entry}'. Expected format is '$key:value'.")
+                    raise ValueError(
+                        f"Invalid keyword argument format in target_attributes: '{entry}'. Expected format is '$key:value'."
+                    )
             elif _prefix == "@":
                 # Positional argument
                 args.append(_attribute)
         else:
-            raise ValueError(f"Invalid prefix '{_prefix}' in target_attributes entry: '{entry}'. Valid prefixes are {valid_prefixes}.")
+            raise ValueError(
+                f"Invalid prefix '{_prefix}' in target_attributes entry: '{entry}'. Valid prefixes are {valid_prefixes}."
+            )
     return OperatorInstructions(
         input_targets=input_targets,
         requirement_targets=input_targets,
@@ -72,7 +78,9 @@ def _parse_operator_instructions(raw: str):
 def _validate_operator_instructions(instance: "Requirement") -> bool:
     """Ensures requirement fixtures declare at least one target attribute."""
     if not instance.operator_instructions_parsed:
-        raise ValueError(f"Requirement '{instance.name}' must declare at least one target attribute.")
+        raise ValueError(
+            f"Requirement '{instance.name}' must declare at least one target attribute."
+        )
     return True
 
 
@@ -101,7 +109,9 @@ class RequirementOperator(models.Model):
 
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
-    evaluation_function_name = models.CharField(max_length=255, blank=True, null=True)  # Added field
+    evaluation_function_name = models.CharField(
+        max_length=255, blank=True, null=True
+    )  # Added field
 
     objects = RequirementOperatorManager()
 
@@ -151,10 +161,18 @@ class RequirementOperator(models.Model):
     def get_operator_function(self) -> Callable[..., bool]:
         _operator_function = REQUIREMENT_OPERATORS.get(self.name)
         if not _operator_function:
-            raise ValueError(f"Operator function for '{self.name}' not found in REQUIREMENT_OPERATORS.")
+            raise ValueError(
+                f"Operator function for '{self.name}' not found in REQUIREMENT_OPERATORS."
+            )
         return _operator_function
 
-    def evaluate(self, operator_instructions: "OperatorInstructions", requirement: "Requirement", input_obj: Any, **kwargs) -> bool:
+    def evaluate(
+        self,
+        operator_instructions: "OperatorInstructions",
+        requirement: "Requirement",
+        input_obj: Any,
+        **kwargs,
+    ) -> bool:
         """ """
         eval_result: bool = False
         requirement_links: "RequirementLinks" = requirement.links
@@ -162,6 +180,8 @@ class RequirementOperator(models.Model):
         operator_function = self.get_operator_function()
 
         input_model = type(input_obj)
-        assert input_model in expected_input_models, f"Input model {input_model} not in expected models {expected_input_models}"
+        assert input_model in expected_input_models, (
+            f"Input model {input_model} not in expected models {expected_input_models}"
+        )
 
         return eval_result

endoreg_db/models/requirement/requirement_set.py

@@ -83,7 +83,7 @@ class RequirementSet(models.Model):
 
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
-    
+
     depends_on = models.ManyToManyField(
         "self",
         symmetrical=False,
@@ -94,7 +94,7 @@ class RequirementSet(models.Model):
             "bevor dieses Set geprüft wird ('after')."
         ),
     )
-    
+
     requirements = models.ManyToManyField(
         "Requirement",
         blank=True,
@@ -135,17 +135,31 @@ class RequirementSet(models.Model):
     if TYPE_CHECKING:
         from typing import Optional, cast
 
-        from endoreg_db.models import ExaminationRequirementSet, InformationSource, Requirement, Tag
+        from endoreg_db.models import (
+            ExaminationRequirementSet,
+            InformationSource,
+            Requirement,
+            Tag,
+        )
 
         tags = cast(models.manager.RelatedManager["Tag"], tags)
         requirements = cast(models.manager.RelatedManager["Requirement"], requirements)
-        links_to_sets = cast(models.manager.RelatedManager["RequirementSet"], links_to_sets)
-        reqset_exam_links = cast(models.manager.RelatedManager["ExaminationRequirementSet"], reqset_exam_links)
-        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+        links_to_sets = cast(
+            models.manager.RelatedManager["RequirementSet"], links_to_sets
+        )
+        reqset_exam_links = cast(
+            models.manager.RelatedManager["ExaminationRequirementSet"],
+            reqset_exam_links,
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
         requirement_set_type: models.ForeignKey["RequirementSetType | None"]
 
         @property
-        def links_from_sets(self) -> "models.manager.RelatedManager[RequirementSet]": ...
+        def links_from_sets(
+            self,
+        ) -> "models.manager.RelatedManager[RequirementSet]": ...
 
     def natural_key(self):
         """Return the natural key as a tuple containing the instance's name."""
@@ -175,7 +189,9 @@ class RequirementSet(models.Model):
         results = []
         for requirement in self.requirements.all():
             # Get the appropriate input for this specific requirement
-            evaluation_input = self._get_evaluation_input_for_requirement(requirement, input_object)
+            evaluation_input = self._get_evaluation_input_for_requirement(
+                requirement, input_object
+            )
             result = requirement.evaluate(evaluation_input, mode=mode)
             results.append(result)
         return results
@@ -199,7 +215,9 @@ class RequirementSet(models.Model):
                 return input_object
 
         # Import here to avoid circular imports
-        from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+        from endoreg_db.models.medical.patient.patient_examination import (
+            PatientExamination,
+        )
         from endoreg_db.models.medical.patient.patient_finding import PatientFinding
 
         # Handle PatientExamination -> PatientFinding conversion
@@ -239,7 +257,10 @@ class RequirementSet(models.Model):
 
         If the requirement set type is defined and matches a known type, returns the corresponding function from REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP. Returns None if no matching function is found.
         """
-        if self.requirement_set_type and self.requirement_set_type.name in REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP:
+        if (
+            self.requirement_set_type
+            and self.requirement_set_type.name in REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP
+        ):
             return REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP[self.requirement_set_type.name]
         return None
 
@@ -260,7 +281,9 @@ class RequirementSet(models.Model):
 
         results = evaluate_r_results + evaluate_rs_results
 
-        eval_result = self.eval_function(results) if self.eval_function else all(results)
+        eval_result = (
+            self.eval_function(results) if self.eval_function else all(results)
+        )
 
         return eval_result
 

endoreg_db/models/state/__init__.py

@@ -3,6 +3,7 @@ from .raw_pdf import RawPdfState
 from .sensitive_meta import SensitiveMetaState
 from .video import VideoState
 from .anonymization import AnonymizationState
+
 __all__ = [
     "SensitiveMetaState",
     "VideoState",

endoreg_db/models/state/audit_ledger.py

@@ -127,7 +127,12 @@ class AuditLedger(models.Model):
         Returns:
             The count of unique object primary keys matching the specified type and action.
         """
-        return AuditLedger.objects.filter(object_type=object_type, action=action).values("object_pk").distinct().count()
+        return (
+            AuditLedger.objects.filter(object_type=object_type, action=action)
+            .values("object_pk")
+            .distinct()
+            .count()
+        )
 
     def collect_counters(self):
         """
@@ -140,7 +145,9 @@ class AuditLedger(models.Model):
         return {
             "totalCases": AuditLedger._distinct("VideoFile", "created"),
             "totalVideos": AuditLedger._distinct("VideoFile", "created"),
-            "totalAnnotations": AuditLedger.objects.filter(action="annotation_added").count(),
+            "totalAnnotations": AuditLedger.objects.filter(
+                action="annotation_added"
+            ).count(),
             "totalAnonymizations": AuditLedger._distinct("VideoFile", "anonymized"),
             "totalImages": AuditLedger._distinct("Image", "created"),
             "videosCompleted": AuditLedger._distinct("VideoFile", "validated"),

endoreg_db/models/{media → state}/processing_history/__init__.py

@@ -1,5 +1,3 @@
 from .processing_history import ProcessingHistory
 
-__all__ = [
-    "ProcessingHistory"
-]
+__all__ = ["ProcessingHistory"]