endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/services/anonymization.py

@@ -1,58 +1,72 @@
 # endoreg_db/services/anonymization.py
+import logging
 from pathlib import Path
+from typing import Optional
+
 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.models import RawPdfFile, VideoFile
+from endoreg_db.services.__old.video_import import VideoImportService
+from endoreg_db.services.report_import import ReportImportService
 from endoreg_db.utils.paths import STORAGE_DIR
-import logging
+from endoreg_db.utils.storage import ensure_local_file, file_exists
 
 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):
+
+    def __init__(self, project_root: Optional[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.project_root: Path = project_root or STORAGE_DIR
         self.video_service = VideoImportService()
-        self.pdf_service = PdfImportService()
+        self.pdf_service = ReportImportService()
 
     # ---------- 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()
+        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')),
+                "anonymizationStatus": vf.state.anonymization_status
+                if vf.state
+                else "not_started",
+                "fileExists": file_exists(vf.raw_file),
                 "uuid": str(vf.uuid) if vf.uuid else None,
             }
 
-        pdf = RawPdfFile.objects.select_related("state", "sensitive_meta").filter(pk=file_id).first()
+        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')),
+                "anonymizationStatus": pdf.state.anonymization_status
+                if pdf.state
+                else "not_started",
+                "fileExists": file_exists(pdf.file),
                 "hash": pdf.pdf_hash,
             }
         return None
@@ -62,116 +76,129 @@ class AnonymizationService:
     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()
+        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}")
+                    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:
+                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
+                safe_processor_name = processor_name or "unknown_processor"
                 self.video_service.import_and_anonymize(
                     file_path=file_path,
                     center_name=center_name,
-                    processor_name=processor_name,
+                    processor_name=safe_processor_name,
                     save_video=True,
-                    delete_source=False
+                    delete_source=False,
+                )
+
+                logger.info(
+                    f"Video anonymization completed for VideoFile ID: {file_id}"
                 )
-                
-                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.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()
+        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}")
-                
+                logger.info(f"Starting report processing for RawPdfFile ID: {file_id}")
+
                 # Check if already processed
-                if pdf.state and getattr(pdf.state, 'anonymized', False):
+                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}")
+
+                file_field = pdf.file
+                if not file_field or not file_field.name:
+                    logger.error(f"report 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}")
+
+                if not file_exists(file_field):
+                    logger.error(
+                        "report file missing from storage for RawPdfFile %s", file_id
+                    )
                     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}")
+
+                with ensure_local_file(file_field) as local_path:
+                    self.pdf_service.import_and_anonymize(
+                        file_path=local_path,
+                        center_name=center_name,
+                    )
+
+                logger.info(f"report 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
+                if pdf.state and hasattr(pdf.state, "processing_failed"):
                     pdf.state.save(update_fields=["processing_failed"])
-                elif pdf.sensitive_meta:
-                    pdf.sensitive_meta.processing_failed = True
+                elif pdf.sensitive_meta and hasattr(
+                    pdf.sensitive_meta, "processing_failed"
+                ):
                     pdf.sensitive_meta.save(update_fields=["processing_failed"])
                 raise
 
@@ -183,41 +210,53 @@ class AnonymizationService:
     def validate(file_id: int):
         vf = VideoFile.objects.select_related("state").filter(pk=file_id).first()
         if vf:
-            vf.state.mark_anonymization_validated()
+            state = vf.state or vf.get_or_create_state()
+            if hasattr(state, "mark_anonymization_validated"):
+                state.mark_anonymization_validated()
             return "video"
 
         pdf = RawPdfFile.objects.select_related("state").filter(pk=file_id).first()
         if pdf:
-            pdf.state.mark_anonymization_validated()
+            state = pdf.state or pdf.get_or_create_state()
+            if hasattr(state, "mark_anonymization_validated"):
+                state.mark_anonymization_validated()
             return "pdf"
 
         return None
-    
+
+    @staticmethod
     def list_items():
         video_files = VideoFile.objects.select_related("state").all()
-        pdf_files = RawPdfFile.objects.select_related("state").all()  # was sensitive_meta
+        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,
-            })
-            
-            
+            data.append(
+                {
+                    "id": vf.pk,
+                    "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,
-            })
+            data.append(
+                {
+                    "id": pdf.pk,
+                    "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/lookup_service.py

@@ -24,9 +24,10 @@ Architecture:
 # services/lookup_service.py
 from __future__ import annotations
 
-from typing import Any, Dict, List
+import logging
+from typing import Any, Dict, List, Optional
 
-from django.db.models import Prefetch
+from django.db.models import Prefetch, QuerySet
 
 from endoreg_db.models.medical.examination import ExaminationRequirementSet
 from endoreg_db.models.medical.patient.patient_examination import PatientExamination
@@ -88,31 +89,43 @@ def load_patient_exam_for_eval(pk: int) -> PatientExamination:
     )
 
 
-def requirement_sets_for_patient_exam(pe: PatientExamination) -> List[RequirementSet]:
+def requirement_sets_for_patient_exam(
+    pe: PatientExamination, user_tags: Optional[List[str]] = None
+) -> QuerySet:
     """
-    Get all requirement sets applicable to a patient examination.
-
-    This function resolves requirement sets through the examination's requirement set links.
-    It follows the relationship: PatientExamination → Examination → ExaminationRequirementSet → RequirementSet
+    Retrieve all RequirementSets linked to a PatientExamination's examination.
 
     Args:
-        pe: PatientExamination instance to get requirement sets for
+        pe: PatientExamination instance
+        user_tags: Optional list of tag names to filter requirement sets
 
     Returns:
-        List of RequirementSet instances applicable to the examination, with related data prefetched
+        QuerySet of RequirementSet instances
     """
-    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()
-    )
+    if not pe or not pe.examination:
+        from endoreg_db.models import RequirementSet
+
+        return RequirementSet.objects.none()
+
+    # Start with examination-linked requirement sets
+    req_sets = pe.examination.exam_reqset_links.select_related(
+        "requirement_set"
+    ).values_list("requirement_set", flat=True)
+
+    from endoreg_db.models import RequirementSet
 
+    qs = RequirementSet.objects.filter(pk__in=req_sets)
 
-def build_initial_lookup(pe: PatientExamination) -> Dict[str, Any]:
+    # Apply tag filtering if provided
+    if user_tags:
+        qs = qs.filter(tags__name__in=user_tags).distinct()
+
+    return qs
+
+
+def build_initial_lookup(
+    pe: PatientExamination, user_tags: Optional[List[str]] = None
+) -> Dict[str, Any]:
     """
     Build the initial lookup dictionary for a patient examination.
 
@@ -135,14 +148,14 @@ def build_initial_lookup(pe: PatientExamination) -> Dict[str, Any]:
         Dictionary containing initial lookup data with the following keys:
         - patient_examination_id: ID of the patient examination
         - requirement_sets: List of available requirement sets with metadata
-        - availableFindings: List of finding IDs available for the examination
-        - requiredFindings: List of finding IDs that are required by defaults
-        - requirementDefaults: Default findings per requirement
-        - classificationChoices: Available classification choices per requirement
-        - requirementsBySet: Empty dict (populated on selection)
-        - requirementStatus: Empty dict (computed on evaluation)
-        - requirementSetStatus: Empty dict (computed on evaluation)
-        - suggestedActions: Empty dict (computed on evaluation)
+        - available_findings: List of finding IDs available for the examination
+        - required_findings: List of finding IDs that are required by defaults
+        - requirement_defaults: Default findings per requirement
+        - classification_choices: Available classification choices per requirement
+        - requirements_by_set: Empty dict (populated on selection)
+        - requirement_status: Empty dict (computed on evaluation)
+        - requirement_set_status: Empty dict (computed on evaluation)
+        - suggested_actions: Empty dict (computed on evaluation)
     """
     # Available + required findings
     available_findings = (
@@ -153,7 +166,7 @@ def build_initial_lookup(pe: PatientExamination) -> Dict[str, Any]:
     required_findings: List[int] = []  # fill by scanning requirements below
 
     # Requirement sets: ids + meta
-    rs_objs = requirement_sets_for_patient_exam(pe)
+    rs_objs = requirement_sets_for_patient_exam(pe, user_tags=user_tags)
     requirement_sets = [
         {
             "id": rs.id,
@@ -189,20 +202,22 @@ def build_initial_lookup(pe: PatientExamination) -> Dict[str, Any]:
     return {
         "patient_examination_id": pe.id,
         "requirement_sets": requirement_sets,
-        "availableFindings": available_findings,
-        "requiredFindings": required_findings,
-        "requirementDefaults": req_defaults,
-        "classificationChoices": cls_choices,
+        "available_findings": available_findings,
+        "required_findings": required_findings,
+        "requirement_defaults": req_defaults,
+        "classification_choices": 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
+        "requirements_by_set": {},  # Will be populated when requirement sets are selected
+        "requirement_status": {},  # Status of each requirement (satisfied/unsatisfied)
+        "requirement_set_status": {},  # Status of each requirement set
+        "suggested_actions": {},  # Suggested actions to satisfy requirements
         # You can add "selectedRequirementSetIds" as the user makes choices
     }
 
 
-def create_lookup_token_for_pe(pe_id: int) -> str:
+def create_lookup_token_for_pe(
+    pe_id: int, user_tags: Optional[List[str]] = None
+) -> str:
     """
     Create a lookup token for a patient examination.
 
@@ -220,7 +235,7 @@ def create_lookup_token_for_pe(pe_id: int) -> str:
         Exception: For any other errors during initialization
     """
     pe = load_patient_exam_for_eval(pe_id)
-    token = LookupStore().init(build_initial_lookup(pe))
+    token = LookupStore().init(build_initial_lookup(pe, user_tags=user_tags))
     return token
 
 
@@ -245,18 +260,16 @@ def recompute_lookup(token: str) -> Dict[str, Any]:
 
     Returns:
         Dictionary of updates containing:
-        - requirementsBySet: Requirements grouped by selected requirement sets
-        - requirementStatus: Boolean status for each requirement
-        - requirementSetStatus: Boolean status for each requirement set
-        - requirementDefaults: Default findings per requirement
-        - classificationChoices: Available choices per requirement
-        - suggestedActions: UI actions to satisfy unsatisfied requirements
+        - requirements_by_set: Requirements grouped by selected requirement sets
+        - requirement_status: Boolean status for each requirement
+        - requirement_set_status: Boolean status for each requirement set
+        - requirement_defaults: Default findings per requirement
+        - classification_choices: Available choices per requirement
+        - suggested_actions: UI actions to satisfy unsatisfied requirements
 
     Raises:
         ValueError: If lookup data is invalid or patient examination not found
     """
-    import logging
-
     logger = logging.getLogger(__name__)
 
     store = LookupStore(token=token)
@@ -383,12 +396,12 @@ def recompute_lookup(token: str) -> Dict[str, Any]:
         # 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
+            "requirements_by_set": requirements_by_set,
+            "requirement_status": requirement_status,
+            "requirement_set_status": set_status,
+            "requirement_defaults": req_defaults,  # keep your existing key
+            "classification_choices": cls_choices,  # keep your existing key
+            "suggested_actions": suggested_actions,  # new
         }
 
         logger.debug(

endoreg_db/services/lookup_store.py

@@ -173,8 +173,8 @@ class LookupStore:
         # Check if required fields are present
         required_fields = [
             "patient_examination_id",
-            "requirementsBySet",
-            "requirementStatus",
+            "requirements_by_set",
+            "requirement_status",
         ]
         missing_fields = [field for field in required_fields if field not in data]