endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/services/anonymization.py

@@ -0,0 +1,223 @@
+# endoreg_db/services/anonymization.py
+from pathlib import Path
+from django.db import transaction
+from django.conf import settings
+from endoreg_db.models import VideoFile, RawPdfFile
+from endoreg_db.services.video_import import VideoImportService
+from endoreg_db.services.pdf_import import PdfImportService
+from endoreg_db.utils.paths import STORAGE_DIR
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AnonymizationService:
+    """
+    Orchestrates long‑running anonymization tasks so the view only
+    does HTTP <-> Service translation.
+    """
+    
+    def __init__(self, project_root: Path = None):
+        """
+        Initialize the AnonymizationService with service instances.
+        
+        Args:
+            project_root: Path to the project root. If None, uses settings.BASE_DIR
+        """
+        if project_root is None:
+            project_root = STORAGE_DIR
+        
+        self.video_service = VideoImportService()
+        self.pdf_service = PdfImportService()
+
+    # ---------- READ ----------------------------------------------------
+    @staticmethod
+    def get_status(file_id: int):
+        """
+        Retrieve the anonymization status and media type for a file by its ID.
+        
+        Returns:
+            dict or None: A dictionary containing the file's media type and anonymization status if found, or None if no matching file exists.
+        """
+        vf = VideoFile.objects.select_related("state", "sensitive_meta").filter(pk=file_id).first()
+        if vf:
+            return {
+                "mediaType": "video",
+                "anonymizationStatus": vf.state.anonymization_status if vf.state else "not_started",
+                "fileExists": bool(vf.raw_file and hasattr(vf.raw_file, 'path')),
+                "uuid": str(vf.uuid) if vf.uuid else None,
+            }
+
+        pdf = RawPdfFile.objects.select_related("state", "sensitive_meta").filter(pk=file_id).first()
+        if pdf:
+            return {
+                "mediaType": "pdf",
+                "anonymizationStatus": pdf.state.anonymization_status if pdf.state else "not_started",
+                "fileExists": bool(pdf.file and hasattr(pdf.file, 'path')),
+                "hash": pdf.pdf_hash,
+            }
+        return None
+
+    # ---------- COMMANDS ------------------------------------------------
+    @transaction.atomic
+    def start(self, file_id: int):
+        """
+        Start anonymization process for a file by its ID.
+        
+        Args:
+            file_id: The ID of the file to anonymize
+            
+        Returns:
+            str or None: Media type if successful, None if file not found
+        """
+        # Try VideoFile first
+        vf = VideoFile.objects.select_related("state", "sensitive_meta", "center", "video_meta__processor").filter(pk=file_id).first()
+        if vf:
+            try:
+                logger.info(f"Starting video anonymization for VideoFile ID: {file_id}")
+                
+                # Check if already processed
+                if vf.state and vf.state.anonymized:
+                    logger.info(f"VideoFile {file_id} already anonymized, skipping")
+                    return "video"
+                
+                # Get file path
+                file_path = vf.get_raw_file_path()
+                if not file_path or not Path(file_path).exists():
+                    logger.error(f"Raw file not found for VideoFile {file_id}: {file_path}")
+                    return None
+                
+                # Get processor name
+                processor_name = None
+                if vf.video_meta and vf.video_meta.processor:
+                    processor_name = vf.video_meta.processor.name
+                elif hasattr(vf, 'processor') and vf.processor:
+                    processor_name = vf.processor.name
+                
+                # Get center name
+                center_name = vf.center.name if vf.center else "unknown_center"
+                
+                # Mark as started
+                if vf.state:
+                    vf.state.processing_started = True
+                    vf.state.save(update_fields=["processing_started"])
+                
+                # Use VideoImportService for anonymization
+                self.video_service.import_and_anonymize(
+                    file_path=file_path,
+                    center_name=center_name,
+                    processor_name=processor_name,
+                    save_video=True,
+                    delete_source=False
+                )
+                
+                logger.info(f"Video anonymization completed for VideoFile ID: {file_id}")
+                return "video"
+                
+            except Exception as e:
+                logger.error(f"Failed to anonymize VideoFile {file_id}: {e}")
+                # Mark as failed if state exists
+                if vf.state:
+                    vf.state.processing_started = False  # Mark processing as not started due to failure
+                    vf.state.save(update_fields=["processing_started"])
+                raise
+
+        # Try RawPdfFile
+        pdf = RawPdfFile.objects.select_related("state", "sensitive_meta", "center").filter(pk=file_id).first()
+        if pdf:
+            try:
+                logger.info(f"Starting PDF processing for RawPdfFile ID: {file_id}")
+                
+                # Check if already processed
+                if pdf.state and getattr(pdf.state, 'anonymized', False):
+                    logger.info(f"RawPdfFile {file_id} already processed, skipping")
+                    return "pdf"
+                
+                # Get file path
+                if not pdf.file or not hasattr(pdf.file, 'path'):
+                    logger.error(f"PDF file not found for RawPdfFile {file_id}")
+                    return None
+                
+                file_path = Path(pdf.file.path)
+                if not file_path.exists():
+                    logger.error(f"PDF file does not exist: {file_path}")
+                    return None
+                
+                # Get center name
+                center_name = pdf.center.name if pdf.center else "unknown_center"
+                
+                # Mark as started
+                if pdf.state:
+                    pdf.state.processing_started = True
+                    pdf.state.save(update_fields=["processing_started"])
+                elif pdf.sensitive_meta:
+                    pdf.sensitive_meta.anonymization_started = True
+                    pdf.sensitive_meta.save(update_fields=["anonymization_started"])
+                
+                
+                # Use PdfImportService for processing
+                # Use PdfImportService for processing
+                self.pdf_service.import_and_anonymize(
+                    file_path=file_path,
+                    center_name=center_name,
+                )
+                
+                logger.info(f"PDF processing completed for RawPdfFile ID: {file_id}")
+                return "pdf"
+                
+            except Exception as e:
+                logger.error(f"Failed to process RawPdfFile {file_id}: {e}")
+                # Mark as failed if state exists
+                if pdf.state:
+                    pdf.state.processing_failed = True
+                    pdf.state.save(update_fields=["processing_failed"])
+                elif pdf.sensitive_meta:
+                    pdf.sensitive_meta.processing_failed = True
+                    pdf.sensitive_meta.save(update_fields=["processing_failed"])
+                raise
+
+        logger.warning(f"No file found with ID: {file_id}")
+        return None
+
+    @staticmethod
+    @transaction.atomic
+    def validate(file_id: int):
+        vf = VideoFile.objects.select_related("state").filter(pk=file_id).first()
+        if vf:
+            vf.state.mark_anonymization_validated()
+            return "video"
+
+        pdf = RawPdfFile.objects.select_related("state").filter(pk=file_id).first()
+        if pdf:
+            pdf.state.mark_anonymization_validated()
+            return "pdf"
+
+        return None
+    
+    def list_items():
+        video_files = VideoFile.objects.select_related("state").all()
+        pdf_files = RawPdfFile.objects.select_related("state").all()  # was sensitive_meta
+
+        data = []
+        for vf in video_files:
+            data.append({
+                "id": vf.id,
+                "mediaType": "video",
+                "anonymizationStatus": vf.state.anonymization_status if vf.state else "not_started",
+                "createdAt": vf.date_created,
+                "updatedAt": vf.date_modified,
+            })
+            
+            
+
+        for pdf in pdf_files:
+            data.append({
+                "id": pdf.id,
+                "mediaType": "pdf",
+                "anonymizationStatus": pdf.state.anonymization_status if pdf.state else "not_started",
+                "createdAt": pdf.date_created,
+                "updatedAt": pdf.date_modified,
+            })
+        return data
+
+
+        return data

endoreg_db/services/examination_evaluation.py

@@ -0,0 +1,149 @@
+# app/services/evaluation.py
+from __future__ import annotations
+from typing import Dict, List, Set, Tuple
+from django.db.models import Prefetch
+
+from endoreg_db.schemas.examination_evaluation import ExaminationEvalReport, RequirementSetEval, RequirementEval
+from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+import endoreg_db.services.lookup_service
+
+def _get_requirement_sets_for_exam(exam: PatientExamination) -> List[RequirementSet]:
+    """
+    Decide how an examination maps to requirement sets.
+    Adjust this to your actual relation:
+    - maybe exam.type.requirement_sets
+    - or via information_sources
+    - or a direct M2M on Examination
+    """
+    # The new loader prefetches via `examination.exam_reqset_links`.
+    # We extract the RequirementSet from each link.
+    sets = []
+    if hasattr(exam, "examination") and hasattr(exam.examination, "exam_reqset_links"):
+        for link in exam.examination.exam_reqset_links.all():
+            if hasattr(link, "requirement_set"):
+                sets.append(link.requirement_set)
+    return sets
+
+def _eval_requirement(requirement, input_object, mode="loose") -> Tuple[bool, str | None]:
+    """
+    Evaluate a single Requirement and return (bool, message).
+    The `message` can be None or contain a short explanation.
+    """
+    ok = requirement.evaluate(input_object, mode=mode)
+    msg = None
+    # If your Requirement has a reason/explanation API, inject it here.
+    # Example: msg = requirement.last_reason if hasattr(requirement, "last_reason") else None
+    return ok, msg
+
+def _reduce_bools(bools: List[bool], set_type_name: str | None) -> bool:
+    from endoreg_db.models.requirement.requirement_set import REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP
+    func = REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP.get(set_type_name or "all", all)
+    return bool(func(bools))
+
+def _eval_set_tree(root: RequirementSet, input_object, visited: Set[int]) -> RequirementSetEval:
+    """
+    Recursively evaluate a RequirementSet node and linked children.
+    Protect against cycles with visited set.
+    """
+    if root.pk in visited:
+        # Cycle detected -> treat as already evaluated (neutral element for AND is True; but better: skip node)
+        # We skip to avoid infinite recursion; AND/OR exact treatment depends on your business semantics.
+        return RequirementSetEval(
+            id=root.pk,
+            name=root.name,
+            type=(root.requirement_set_type.name if root.requirement_set_type else None),
+            is_satisfied=True,
+            requirements=[],
+            linked_sets=[]
+        )
+
+    visited.add(root.pk)
+
+    # Evaluate direct requirements
+    req_evals: List[RequirementEval] = []
+    for r in root.requirements.all():
+        ok, msg = _eval_requirement(r, input_object)
+        req_evals.append(
+            RequirementEval(
+                id=r.pk,
+                name=getattr(r, "name", f"Requirement {r.pk}"),
+                description=getattr(r, "description", None),
+                satisfied=ok,
+                message=msg,
+            )
+        )
+
+    # Evaluate linked sets
+    child_evals: List[RequirementSetEval] = []
+    for child in root.links_to_sets.all():
+        child_evals.append(_eval_set_tree(child, input_object, visited))
+
+    # Combine booleans
+    bools = [re.satisfied for re in req_evals] + [ce.is_satisfied for ce in child_evals]
+    set_type_name = root.requirement_set_type.name if root.requirement_set_type else "all"
+    satisfied = _reduce_bools(bools, set_type_name)
+
+    return RequirementSetEval(
+        id=root.pk,
+        name=root.name,
+        type=set_type_name,
+        is_satisfied=satisfied,
+        requirements=req_evals,
+        linked_sets=child_evals,
+    )
+    
+
+
+def evaluate_examination(request: dict) -> ExaminationEvalReport:
+    """
+    Communicates with: components/RequirementGenerator
+    Evaluates a PatientExamination by its Lookup. The frontend sends this structure:
+    
+    
+        requirement_set_ids: plainRequirementSetIds,
+        lookup_token: lookupToken,
+        patient_examination_id: patientExaminationId
+    };
+    
+    And expects a response to be processed like this:
+
+            const response = await axiosInstance.post('/api/evaluate-requirements/', payload);
+            const results = response.data.results || [];
+            const summary = response.data.summary || {};
+
+            // Update evaluation results
+            plainRequirementSetIds.forEach((setId: number) => {
+                evaluationResults.value[setId] = results.filter((r: RequirementEvaluationResult) =>
+                    summary[setId]?.requirements.includes(r.requirement_name)
+                );
+            });
+    """
+    exam_id = request.get("patient_examination_id")
+    if not exam_id:
+        return ExaminationEvalReport(
+            examination_id=None,
+            summary={"is_satisfied": True, "failed_count": 0, "total_sets": 0},
+            sets=[],
+            errors=["No patient_examination_id provided in request."]
+        )
+    
+    # Use the dedicated loader function from the lookup service.
+    exam = endoreg_db.services.lookup_service.load_patient_exam_for_eval(pk=exam_id)
+
+    # This object (exam) is the "input_object" for requirement.evaluate(...)
+    sets = _get_requirement_sets_for_exam(exam)
+
+    visited: Set[int] = set()
+    set_evals: List[RequirementSetEval] = [_eval_set_tree(s, exam, visited) for s in sets]
+
+    # Aggregate summary
+    overall = all(se.is_satisfied for se in set_evals) if set_evals else True
+    failed = sum(1 for se in set_evals if not se.is_satisfied)
+
+    return ExaminationEvalReport(
+        examination_id=exam.pk,
+        summary={"is_satisfied": overall, "failed_count": failed, "total_sets": len(set_evals)},
+        sets=set_evals,
+        errors=[],  # fill with any global issues you detect
+    )

endoreg_db/services/lookup_service.py

@@ -0,0 +1,241 @@
+# services/lookup_service.py
+from __future__ import annotations
+from typing import Dict, Any, List
+from django.db.models import Prefetch
+from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+from endoreg_db.models.medical.examination import ExaminationRequirementSet
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+from .lookup_store import LookupStore
+
+
+def load_patient_exam_for_eval(pk: int) -> PatientExamination:
+    """
+    Fetch PatientExamination with everything needed for evaluation,
+    following the *Examination → ExaminationRequirementSet → RequirementSet* graph.
+    """
+    return (
+        PatientExamination.objects
+        .select_related("patient", "examination")
+        .prefetch_related(
+            "patient_findings",
+            # Prefetch ERS groups on the Examination…
+            Prefetch(
+                "examination__exam_reqset_links",
+                queryset=ExaminationRequirementSet.objects.only("id", "name", "enabled_by_default"),
+            ),
+            # …and the RequirementSets reachable via those ERS groups.
+            Prefetch(
+                "examination__exam_reqset_links__requirement_set",
+                queryset=(
+                    RequirementSet.objects
+                    .select_related("requirement_set_type")
+                    .prefetch_related(
+                        "requirements",
+                        "links_to_sets",
+                        "links_to_sets__requirements",
+                        "links_to_sets__requirement_set_type",
+                    )
+                ),
+            ),
+        )
+        .get(pk=pk)
+    )
+
+
+def requirement_sets_for_patient_exam(pe: PatientExamination) -> List[RequirementSet]:
+    """
+    Correctly resolve RequirementSets for a PE via ERS hub:
+        RequirementSet.objects.filter(reqset_exam_links__examinations=exam)
+    """
+    exam = pe.examination
+    if not exam:
+        return []
+    return list(
+        RequirementSet.objects
+        .filter(reqset_exam_links__examinations=exam)
+        .select_related("requirement_set_type")
+        .prefetch_related("requirements")
+        .distinct()
+    )
+
+def build_initial_lookup(pe: PatientExamination) -> Dict[str, Any]:
+    """
+    Build the initial lookup dict you will return to the client.
+    Keep keys small and stable; values must be JSON-serializable.
+    """
+    # Available + required findings
+    available_findings = [f.id for f in pe.examination.get_available_findings()] if pe.examination else []
+    required_findings: List[int] = []  # fill by scanning requirements below
+
+    # Requirement sets: ids + meta
+    rs_objs = requirement_sets_for_patient_exam(pe)
+    requirement_sets = [
+        {
+            "id": rs.id,
+            "name": rs.name,
+            "type": rs.requirement_set_type.name if rs.requirement_set_type else "all",
+        }
+        for rs in rs_objs
+    ]
+
+    # Requirement-level defaults and classification choices (skeleton)
+    # You said: each Requirement can provide default findings and addable choices
+    req_defaults: Dict[str, Any] = {}
+    cls_choices: Dict[str, Any] = {}
+
+    for rs in rs_objs:
+        for req in rs.requirements.all():
+            # You’ll implement these helpers on Requirement
+            defaults = getattr(req, "default_findings", lambda pe: [])(pe)
+            choices = getattr(req, "classification_choices", lambda pe: [])(pe)
+            if defaults:
+                req_defaults[str(req.id)] = defaults  # list of {finding_id, payload...}
+                required_findings.extend([d.get("finding_id") for d in defaults if "finding_id" in d])
+            if choices:
+                cls_choices[str(req.id)] = choices   # list of {classification_id, label, ...}
+
+    # De-dup required
+    required_findings = sorted(set(required_findings))
+
+    return {
+        "patient_examination_id": pe.id,
+        "requirement_sets": requirement_sets,
+        "availableFindings": available_findings,
+        "requiredFindings": required_findings,
+        "requirementDefaults": req_defaults,
+        "classificationChoices": cls_choices,
+        # New fields for expanded lookup payload
+        "requirementsBySet": {},  # Will be populated when requirement sets are selected
+        "requirementStatus": {},  # Status of each requirement (satisfied/unsatisfied)
+        "requirementSetStatus": {},  # Status of each requirement set
+        "suggestedActions": {},  # Suggested actions to satisfy requirements
+        # You can add "selectedRequirementSetIds" as the user makes choices
+    }
+
+def create_lookup_token_for_pe(pe_id: int) -> str:
+    pe = load_patient_exam_for_eval(pe_id)
+    token = LookupStore().init(build_initial_lookup(pe))
+    return token
+
+def recompute_lookup(token: str) -> Dict[str, Any]:
+    import logging
+    logger = logging.getLogger(__name__)
+    
+    store = LookupStore(token=token)
+    
+    # Simple reentrancy guard using data
+    data = store.get_all()
+    if data.get('_recomputing'):
+        logger.warning(f"Recompute already in progress for token {token}, skipping")
+        return {}
+    
+    store.set('_recomputing', True)
+    
+    try:
+        # First validate and attempt to recover corrupted data
+        validated_data = store.validate_and_recover_data(token)
+        if validated_data is None:
+            logger.error(f"No lookup data found for token {token}")
+            raise ValueError(f"No lookup data found for token {token}")
+        
+        data = validated_data
+        logger.debug(f"Recomputing lookup for token {token}, data keys: {list(data.keys())}")
+        
+        # Check if required data exists
+        if "patient_examination_id" not in data:
+            logger.error(f"Invalid lookup data for token {token}: missing patient_examination_id. Data: {data}")
+            raise ValueError(f"Invalid lookup data for token {token}: missing patient_examination_id")
+        
+        if not data.get("patient_examination_id"):
+            logger.error(f"Invalid lookup data for token {token}: patient_examination_id is empty. Data: {data}")
+            raise ValueError(f"Invalid lookup data for token {token}: patient_examination_id is empty")
+
+        pe_id = data["patient_examination_id"]
+        logger.debug(f"Loading patient examination {pe_id} for token {token}")
+        
+        try:
+            pe = load_patient_exam_for_eval(pe_id)
+        except Exception as e:
+            logger.error(f"Failed to load patient examination {pe_id} for token {token}: {e}")
+            raise ValueError(f"Failed to load patient examination {pe_id}: {e}")
+
+        selected_rs_ids: List[int] = data.get("selectedRequirementSetIds", [])
+        logger.debug(f"Selected requirement set IDs for token {token}: {selected_rs_ids}")
+        
+        rs_objs = [rs for rs in requirement_sets_for_patient_exam(pe) if rs.id in selected_rs_ids]
+        logger.debug(f"Found {len(rs_objs)} requirement set objects for token {token}")
+
+        # 1) requirements grouped by set (already prefetched in load func)
+        requirements_by_set = {
+            rs.id: [ {"id": r.id, "name": r.name} for r in rs.requirements.all() ]
+            for rs in rs_objs
+        }
+
+        # 2) status per requirement + set status
+        requirement_status: Dict[str, bool] = {}
+        set_status: Dict[str, bool] = {}
+        for rs in rs_objs:
+            req_results = []
+            for r in rs.requirements.all():
+                ok = bool(r.evaluate(pe, mode="strict"))  # or "loose" if you prefer
+                requirement_status[str(r.id)] = ok
+                req_results.append(ok)
+            set_status[str(rs.id)] = rs.eval_function(req_results) if rs.eval_function else all(req_results)
+
+        # 3) suggestions per requirement (defaults + classification choices you already expose)
+        suggested_actions: Dict[str, List[Dict[str, Any]]] = {}
+        req_defaults: Dict[str, Any] = {}
+        cls_choices: Dict[str, Any] = {}
+
+        for rs in rs_objs:
+            for r in rs.requirements.all():
+                defaults = getattr(r, "default_findings", lambda pe: [])(pe)  # [{finding_id, payload...}]
+                choices  = getattr(r, "classification_choices", lambda pe: [])(pe)  # [{classification_id, label,...}]
+                if defaults:
+                    req_defaults[str(r.id)] = defaults
+                if choices:
+                    cls_choices[str(r.id)] = choices
+
+                if not requirement_status.get(str(r.id), False):
+                    # turn default proposals into explicit UI actions
+                    acts = []
+                    for d in defaults or []:
+                        acts.append({
+                            "type": "add_finding",
+                            "finding_id": d.get("finding_id"),
+                            "classification_ids": d.get("classification_ids") or [],
+                            "note": "default"
+                        })
+                    # If r expects patient edits, add an edit action hint
+                    if "PatientExamination" in [m.__name__ for m in r.expected_models]:
+                        acts.append({"type": "edit_patient", "fields": ["gender", "dob"]})  # example
+                    if acts:
+                        suggested_actions[str(r.id)] = acts
+
+        # 4) (optional) staged changes simulation hook (see §3)
+        # staged = data.get("staged", {})
+        # if you implement server-side simulation later, adjust requirement_status with staged result here
+
+        updates = {
+            "requirementsBySet": requirements_by_set,
+            "requirementStatus": requirement_status,
+            "requirementSetStatus": set_status,
+            "requirementDefaults": req_defaults,         # keep your existing key
+            "classificationChoices": cls_choices,        # keep your existing key
+            "suggestedActions": suggested_actions,       # new
+        }
+        
+        logger.debug(f"Updating store for token {token} with {len(updates)} update keys")
+        
+        # Only write if changed (idempotent)
+        prev_derived = store.get_many(list(updates.keys()))
+        if prev_derived != updates:
+            store.set_many(updates)  # <-- does NOT call recompute
+            logger.debug(f"Derived data changed, updated store for token {token}")
+        else:
+            logger.debug(f"Derived data unchanged, skipping store update for token {token}")
+        
+        store.mark_recompute_done()
+        return updates
+    finally:
+        store.set('_recomputing', False)