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

endoreg_db/models/requirement/requirement_error.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass
+from typing import Optional, Any, Mapping, TYPE_CHECKING
+if TYPE_CHECKING:
+    from endoreg_db.models.requirement.requirement import Requirement
+
+
+@dataclass
+class RequirementEvaluationErrorContext:
+    """
+    Extra context for evaluation errors.
+
+    - requirement: DB object (so we can use names, groups, translations, etc.)
+    - code: stable internal code, preferred over free-text matching
+    - 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):
+    """
+    Domain-level error that signals: this requirement could be evaluated.
+
+    It carries:
+    - a Requirement instance (from DB)
+    - a stable error code
+    - a technical message for logs
+    - an optional user-ready message
+    """
+
+    def __init__(
+        self,
+        requirement: "Requirement",     
+        code: str,
+        technical_message: str,
+        user_message: Optional[str] = None,
+        meta: Optional[Mapping[str, Any]] = None,
+        *args,
+    ) -> None:
+        self.context = RequirementEvaluationErrorContext(
+            requirement=requirement,
+            code=code,
+            technical_message=technical_message,
+            user_message=user_message,
+            meta=meta,
+        )
+        # Base Exception message = technical message
+        super().__init__(technical_message, *args)
+        
+    
+
+    @property
+    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")
+
+    @property
+    def code(self) -> str:
+        return self.context.code
+
+    @property
+    def technical_message(self) -> str:
+        return self.context.technical_message
+
+    @property
+    def user_message(self) -> Optional[str]:
+        return self.context.user_message
+
+    @property
+    def meta(self) -> Optional[Mapping[str, Any]]:
+        return self.context.meta

endoreg_db/models/requirement/requirement_evaluation/evaluate_with_dependencies.py

@@ -0,0 +1,268 @@
+from collections import defaultdict, deque
+from typing import Iterable, Dict, List, Literal, Tuple
+from endoreg_db.models.requirement import Requirement, RequirementSet
+from endoreg_db.models.requirement.requirement_error import RequirementEvaluationError
+import logging
+
+logger = logging.getLogger(__name__)
+
+RequirementStatus = Literal["PASSED", "FAILED", "BLOCKED", "ERROR"]
+
+def topologically_sort_requirement_sets(
+    sets: Iterable[RequirementSet],
+) -> List[RequirementSet]:
+    """
+    Topologically sort requirement sets by `depends_on`.
+
+    Raises ValueError if a cycle is detected.
+    """
+    sets = list(sets)
+    id_map = {s.id: s for s in sets}
+
+    depends = {s.id: {d.id for d in s.depends_on.all()} for s in sets}
+    indegree = defaultdict(int)
+    for set_id, deps in depends.items():
+        for d_id in deps:
+            indegree[set_id] += 1
+
+    queue = deque([sid for sid in id_map if indegree[sid] == 0])
+    ordered_ids: List[int] = []
+
+    while queue:
+        sid = queue.popleft()
+        ordered_ids.append(sid)
+        for other_id, deps in depends.items():
+            if sid in deps:
+                deps.remove(sid)
+                indegree[other_id] -= 1
+                if indegree[other_id] == 0:
+                    queue.append(other_id)
+
+    if len(ordered_ids) != len(sets):
+        raise ValueError("RequirementSet dependency cycle detected.")
+
+    return [id_map[sid] for sid in ordered_ids]
+
+
+
+
+def evaluate_requirement_sets_with_dependencies(
+    sets: Iterable[RequirementSet],
+    *args,
+    mode: str = "strict",
+    **kwargs,
+) -> Dict[int, Dict[int, Tuple[RequirementStatus, str]]]:
+    """
+    Evaluates RequirementSets with set-level `depends_on`.
+
+    Returns:
+        {
+          set_id: {
+            requirement_id: (status, details)
+          }
+        }
+    """
+    ordered_sets = topologically_sort_requirement_sets(sets)
+    set_results: Dict[int, Dict[int, Tuple[RequirementStatus, str]]] = {}
+    set_statuses: Dict[int, RequirementStatus] = {}
+
+    for req_set in ordered_sets:
+        set_id = req_set.id
+        dep_set_ids = [s.id for s in req_set.depends_on.all()]
+
+        # Any dependency set FAILED or ERROR → this set is BLOCKED
+        blocking_deps = [
+            (dep_id, set_statuses[dep_id])
+            for dep_id in dep_set_ids
+            if dep_id in set_statuses and set_statuses[dep_id] in ("FAILED", "ERROR")
+        ]
+
+        reqs = list(req_set.requirements.all())
+        set_results[set_id] = {}
+
+        if blocking_deps:
+            failed_names = ", ".join(
+                str(RequirementSet.objects.get(pk=dep_id).name)
+                for dep_id, _ in blocking_deps
+            )
+            msg = (
+                f"Die Voraussetzungengruppe '{req_set.name}' wurde nicht geprüft, "
+                f"weil die abhängige(n) Gruppe(n) {failed_names} "
+                "noch nicht erfüllt sind."
+            )
+            for req in reqs:
+                set_results[set_id][req.id] = ("BLOCKED", msg)
+            set_statuses[set_id] = "BLOCKED"
+            continue
+
+        # Dependencies only BLOCKED → also BLOCKED (design choice)
+        blocked_only = [
+            (dep_id, set_statuses[dep_id])
+            for dep_id in dep_set_ids
+            if dep_id in set_statuses and set_statuses[dep_id] == "BLOCKED"
+        ]
+        if blocked_only and not blocking_deps:
+            msg = (
+                f"Die Voraussetzungengruppe '{req_set.name}' wurde nicht geprüft, "
+                "weil abhängige Gruppen noch ausstehend sind."
+            )
+            for req in reqs:
+                set_results[set_id][req.id] = ("BLOCKED", msg)
+            set_statuses[set_id] = "BLOCKED"
+            continue
+
+        # All deps PASSED or no deps → evaluate each requirement
+        had_failed = False
+        had_error = False
+
+        for req in reqs:
+            try:
+                met, details = req.evaluate_with_details(*args, mode=mode, **kwargs)
+                status: RequirementStatus = "PASSED" if met else "FAILED"
+                if status == "FAILED":
+                    had_failed = True
+                set_results[set_id][req.id] = (status, details)
+
+            except RequirementEvaluationError as exc:
+                # domain-level failure → treat as FAILED but with nice message
+                had_failed = True
+                msg = (
+                    f"Fehler bei der Auswertung der Voraussetzung '{req.name}': "
+                    f"{exc.code}: {exc.technical_message}"
+                )
+                logger.warning(
+                    "RequirementSet %s / Requirement %s domain error: %s",
+                    req_set.id,
+                    req.id,
+                    exc,
+                )
+                set_results[set_id][req.id] = ("FAILED", msg)
+
+            except Exception as exc:
+                had_error = True
+                logger.exception(
+                    "Unexpected error while evaluating RequirementSet %s / Requirement %s",
+                    req_set.id,
+                    req.id,
+                )
+                msg = (
+                    f"Technischer Fehler bei der Auswertung von '{req.name}': {exc}"
+                )
+                set_results[set_id][req.id] = ("ERROR", msg)
+
+        # derive set status
+        if had_failed:
+            set_statuses[set_id] = "FAILED"
+        elif had_error:
+            set_statuses[set_id] = "ERROR"
+        else:
+            # if no requirements → call it PASSED (vacuous truth), or adjust as you like
+            set_statuses[set_id] = "PASSED"
+
+    return set_results
+
+#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],
+) -> List[Requirement]:
+    """
+    Topologically sort requirements by `depends_on`.
+
+    Raises ValueError if a cycle is detected.
+    """
+    reqs = list(requirements)
+    id_map = {r.id: r for r in reqs}
+
+    # Build adjacency + indegree for Kahn's algorithm
+    depends = {r.id: {d.id for d in r.depends_on.all()} for r in reqs}
+    indegree = defaultdict(int)
+    for r_id, deps in depends.items():
+        for d_id in deps:
+            indegree[r_id] += 1
+
+    queue = deque([r_id for r_id in id_map if indegree[r_id] == 0])
+    ordered_ids: List[int] = []
+
+    while queue:
+        r_id = queue.popleft()
+        ordered_ids.append(r_id)
+        # remove this node as dep from others
+        for other_id, deps in depends.items():
+            if r_id in deps:
+                deps.remove(r_id)
+                indegree[other_id] -= 1
+                if indegree[other_id] == 0:
+                    queue.append(other_id)
+
+    if len(ordered_ids) != len(reqs):
+        raise ValueError("Requirement dependency cycle detected.")
+
+    return [id_map[rid] for rid in ordered_ids]
+
+def evaluate_requirements_with_dependencies(
+    requirements: Iterable[Requirement],
+    *args,
+    mode: str = "strict",
+    **kwargs,
+) -> Dict[int, Tuple[RequirementStatus, str]]:
+    ordered = topologically_sort_requirements(requirements)
+    results: Dict[int, Tuple[RequirementStatus, str]] = {}
+
+    for req in ordered:
+        dep_ids = [d.id for d in req.depends_on.all()]
+
+        # If any dependency FAILED or ERROR → BLOCKED
+        blocking = [
+            (dep_id, results[dep_id])
+            for dep_id in dep_ids
+            if dep_id in results and results[dep_id][0] in ("FAILED", "ERROR")
+        ]
+
+        if blocking:
+            failed_names = ", ".join(
+                str(Requirement.objects.get(pk=dep_id).name) for dep_id, _ in blocking
+            )
+            results[req.id] = (
+                "BLOCKED",
+                f"Die Voraussetzung '{req.name}' wurde nicht geprüft, "
+                f"weil die abhängige(n) Voraussetzung(en) {failed_names} "
+                "noch nicht erfüllt sind.",
+            )
+            continue
+
+        # If dependencies exist but are only BLOCKED → still BLOCKED (design choice)
+        blocked_only = [
+            (dep_id, results[dep_id])
+            for dep_id in dep_ids
+            if dep_id in results and results[dep_id][0] == "BLOCKED"
+        ]
+        if blocked_only and not blocking:
+            results[req.id] = (
+                "BLOCKED",
+                f"Die Voraussetzung '{req.name}' wurde nicht geprüft, "
+                "weil abhängige Voraussetzungen noch ausstehend sind.",
+            )
+            continue
+
+        # All deps passed (or none) → evaluate requirement itself
+        try:
+            met, details = req.evaluate_with_details(*args, mode=mode, **kwargs)
+        except RequirementEvaluationError as exc:
+            met = False
+            results[req.id] = (
+                "FAILED",
+                f"Nachtragebedarf bei der Auswertung von '{req.name}': {exc}"
+            )
+        except Exception as exc:
+            met = False
+            logger.exception("Unexpected error while evaluating requirement %s", req)
+            results[req.id] = (
+                "ERROR",
+                f"Technischer Fehler bei der Auswertung von '{req.name}': {exc}",
+            )
+        else:
+            status: RequirementStatus = "PASSED" if met else "FAILED"
+            results[req.id] = (status, details)
+
+    return results

endoreg_db/models/requirement/requirement_evaluation/operator_evaluation_models.py

@@ -1,9 +1,6 @@
-from endoreg_db.models import (
-    PatientExamination
-)
+from endoreg_db.models import PatientExamination
 
-#TODO this should be a list of all models that are used in the requirement evaluation
-#TODO All those models must have a "get_requirement_links" property
+# TODO Still used anywhere?
 operator_evaluation_models = [
     PatientExamination,
-]
+]

endoreg_db/models/requirement/requirement_evaluation/requirement_type_parser.py

@@ -1,7 +1,17 @@
-# Currently those strings MUST match the ones
-# in the requirement_type data definitions
+"""
+Validated registry of requirement-type model bindings.
+
+The registry ensures the string keys stay aligned with the Django models while
+providing structured validation via Pydantic. Downstream code should consume
+``data_model_dict``/``data_model_dict_reverse`` instead of re-declaring
+unvalidated mappings.
+"""
+
+from typing import Dict
+
+from django.db import models
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
-from typing import Dict, Union
 from endoreg_db.models import (
     Disease,
     DiseaseClassification,
@@ -12,23 +22,24 @@ from endoreg_db.models import (
     Examination,
     ExaminationIndication,
     Finding,
-    FindingIntervention,
     FindingClassification,
     FindingClassificationChoice,
+    FindingIntervention,
     LabValue,
+    Patient,
     PatientDisease,
     PatientEvent,
     PatientExamination,
     PatientFinding,
     PatientFindingClassification,
     PatientFindingIntervention,
+    PatientLabSample,
     PatientLabValue,
-    PatientLabSample,  # Assuming PatientLabSample is defined elsewhere,
-    Patient,
-    PatientMedication,  # Added PatientMedication
-    PatientMedicationSchedule, # Added PatientMedicationSchedule
+    PatientMedication,
+    PatientMedicationSchedule,
 )
 from endoreg_db.models.other.gender import Gender
+
 # if TYPE_CHECKING:
 #     from endoreg_db.models import (
 #         RequirementOperator,
@@ -36,60 +47,75 @@ from endoreg_db.models.other.gender import Gender
 #     )
 
 
+class DataModelEntry(BaseModel):
+    """Validated binding between an identifier string and a Django model class."""
 
-data_model_dict: Dict[str, Union[
-    Disease,
-    DiseaseClassification,
-    DiseaseClassificationChoice,
-    Event,
-    EventClassification,
-    EventClassificationChoice,
-    Examination,
-    ExaminationIndication,
-    Finding,
-    FindingIntervention,
-    FindingClassification,
-    FindingClassificationChoice,
-    LabValue,
-    PatientDisease,
-    PatientEvent,
-    PatientExamination,
-    PatientFinding,
-    PatientFindingIntervention,
-    PatientFindingClassification,
-    PatientLabValue,
-    PatientLabSample,
-    Patient,
-    PatientMedication,  # Added PatientMedication
-    PatientMedicationSchedule, # Added PatientMedicationSchedule
-]] = {
-    "disease": Disease,
-    "disease_classification_choice": DiseaseClassificationChoice,
-    "disease_classification": DiseaseClassification,
-    "event": Event,
-    "event_classification": EventClassification,
-    "event_classification_choice": EventClassificationChoice,
-    "examination": Examination,
-    "examination_indication": ExaminationIndication,
-    "finding": Finding,
-    "finding_intervention": FindingIntervention,
-    "finding_classification": FindingClassification,
-    "finding_classification_choice": FindingClassificationChoice,
-    "lab_value": LabValue,
-    "patient_disease": PatientDisease,
-    "patient_event": PatientEvent,
-    "patient_examination": PatientExamination,
-    "patient_finding": PatientFinding,
-    "patient_finding_intervention": PatientFindingIntervention,
-    "patient_finding_classification": PatientFindingClassification,
-    "patient_lab_value": PatientLabValue,
-    "patient_lab_sample": PatientLabSample,  # Changed from string "PatientLabSample" to the class
-    "patient": Patient,
-    "patient_medication": PatientMedication,  # Added PatientMedication mapping
-    "patient_medication_schedule": PatientMedicationSchedule, # Added PatientMedicationSchedule mapping
-    "gender": Gender,
-}
-
-data_model_dict_reverse = {
-    v: k for k, v in data_model_dict.items()
-}
+    name: str = Field(min_length=1)
+    model: type[models.Model]
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @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
+            raise TypeError(f"{value!r} is not a Django model class")
+        return value
+
+
+class DataModelRegistry(BaseModel):
+    """Collection of ``DataModelEntry`` items with duplicate safeguards."""
+
+    entries: tuple[DataModelEntry, ...]
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @model_validator(mode="after")
+    def ensure_unique(self) -> "DataModelRegistry":
+        names = [entry.name for entry in self.entries]
+        models_set = [entry.model for entry in self.entries]
+        if len(names) != len(set(names)):
+            raise ValueError("Duplicate requirement type names detected")
+        if len(models_set) != len(set(models_set)):
+            raise ValueError("Duplicate Django model classes detected in registry")
+        return self
+
+    def as_mapping(self) -> Dict[str, type[models.Model]]:
+        return {entry.name: entry.model for entry in self.entries}
+
+    def as_reverse_mapping(self) -> Dict[type[models.Model], str]:
+        return {entry.model: entry.name for entry in self.entries}
+
+
+DATA_MODEL_REGISTRY = DataModelRegistry(
+    entries=(
+        DataModelEntry(name="disease", model=Disease),
+        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="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="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_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="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()