endoreg-db 0.8.5.7__tar.gz → 0.8.6.3__tar.gz

{endoreg_db-0.8.5.7 → endoreg_db-0.8.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.5.7
+Version: 0.8.6.3
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db

{endoreg_db-0.8.5.7 → endoreg_db-0.8.6.3}/endoreg_db/serializers/misc/__init__.py

@@ -1,5 +1,5 @@
 from .file_overview import FileOverviewSerializer
-from .vop_patient_data import VoPPatientDataSerializer
+from .sensitive_patient_data import VoPPatientDataSerializer
 from .stats import StatsSerializer
 from .upload_job import UploadJobStatusSerializer, UploadCreateResponseSerializer
 from .translatable_field_mix_in import TranslatableFieldMixin

{endoreg_db-0.8.5.7 → endoreg_db-0.8.6.3}/endoreg_db/serializers/misc/file_overview.py

@@ -1,12 +1,19 @@
-from rest_framework import serializers
 from typing import TYPE_CHECKING
-from endoreg_db.models.media import VideoFile, RawPdfFile
-from endoreg_db.models.state.video import AnonymizationStatus as VideoAnonymizationStatus
-from endoreg_db.models.state.raw_pdf import AnonymizationStatus as PdfAnonymizationStatus
+
+from rest_framework import serializers
+
+from endoreg_db.models.media import RawPdfFile, VideoFile
+from endoreg_db.models.state.raw_pdf import (
+    AnonymizationStatus as PdfAnonymizationStatus,
+)
+from endoreg_db.models.state.video import (
+    AnonymizationStatus as VideoAnonymizationStatus,
+)
 
 if TYPE_CHECKING:
     pass
 
+
 class FileOverviewSerializer(serializers.Serializer):
     """
     Polymorphic "union" serializer – we normalise both model types
@@ -22,75 +29,81 @@ class FileOverviewSerializer(serializers.Serializer):
     annotationStatus = serializers.CharField(read_only=True)
     createdAt = serializers.DateTimeField(read_only=True)
     text = serializers.CharField(required=False, allow_blank=True, read_only=True)
-    anonymizedText = serializers.CharField(required=False, allow_blank=True, read_only=True)
+    anonymizedText = serializers.CharField(
+        required=False, allow_blank=True, read_only=True
+    )
 
     # --- converting DB objects to that shape -----------------------
     def to_representation(self, instance):
         """
         Return a unified dictionary representation of either a VideoFile or RawPdfFile instance for front-end use.
-        
+
         For VideoFile instances, extracts and structures metadata such as patient, examination, equipment, and examiner information, and generates an anonymized version of the text by replacing sensitive fields with placeholders. For RawPdfFile instances, extracts text and anonymized text directly and determines statuses based on available fields.
-        
+
         Parameters:
             instance: A VideoFile or RawPdfFile object to be serialized.
-        
+
         Returns:
             dict: A normalized dictionary containing id, filename, mediaType, anonymizationStatus, annotationStatus, createdAt, text, and anonymizedText fields.
-        
+
         Raises:
             TypeError: If the instance is not a VideoFile or RawPdfFile.
         """
         text = ""
         anonym_text = ""
-        
+
         if isinstance(instance, VideoFile):
             media_type = "video"
             created_at = instance.uploaded_at
             filename = instance.original_file_name or (
-                instance.raw_file.name.split("/")[-1] if instance.raw_file else "unknown"
+                instance.raw_file.name.split("/")[-1]
+                if instance.raw_file
+                else "unknown"
             )
-            
+
             # ------- anonymization status using VideoState model
             vs = instance.state
-            anonym_status = vs.anonymization_status if vs else VideoAnonymizationStatus.NOT_STARTED
-            
+            anonym_status = (
+                vs.anonymization_status if vs else VideoAnonymizationStatus.NOT_STARTED
+            )
+
             # ------- annotation status (validated label segments)
             if instance.label_video_segments.filter(state__is_validated=True).exists():
                 annot_status = "done"
             else:
                 annot_status = "not_started"
-            
+
             # ------- Extract text from sensitive_meta for videos
             if instance.sensitive_meta:
                 sm = instance.sensitive_meta
                 # Create a structured text representation from sensitive meta
                 text_parts = []
-                
+
                 # Patient information
                 if sm.patient_first_name or sm.patient_last_name:
                     patient_name = f"{sm.patient_first_name or ''} {sm.patient_last_name or ''}".strip()
                     text_parts.append(f"Patient: {patient_name}")
-                
+
                 if sm.patient_dob:
                     text_parts.append(f"Date of Birth: {sm.patient_dob.date()}")
-                
+
                 if sm.patient_gender:
                     text_parts.append(f"Gender: {sm.patient_gender}")
-                
+
                 # Examination information
                 if sm.examination_date:
                     text_parts.append(f"Examination Date: {sm.examination_date}")
-                
+
                 if sm.center:
                     text_parts.append(f"Center: {sm.center.name}")
-                
+
                 # Equipment information
                 if sm.endoscope_type:
                     text_parts.append(f"Endoscope Type: {sm.endoscope_type}")
-                
+
                 if sm.endoscope_sn:
                     text_parts.append(f"Endoscope SN: {sm.endoscope_sn}")
-                
+
                 # Examiner information
                 if sm.pk:  # Only if saved
                     try:
@@ -100,39 +113,56 @@ class FileOverviewSerializer(serializers.Serializer):
                             text_parts.append(f"Examiners: {examiner_names}")
                     except Exception:
                         pass  # Ignore examiner lookup errors
-                
+
                 text = "\n".join(text_parts)
-                
+
                 # Create anonymized version by replacing sensitive data
                 anonym_text = text
                 if sm.patient_first_name:
-                    anonym_text = anonym_text.replace(sm.patient_first_name, "[FIRST_NAME]")
+                    anonym_text = anonym_text.replace(
+                        sm.patient_first_name, "[FIRST_NAME]"
+                    )
                 if sm.patient_last_name:
-                    anonym_text = anonym_text.replace(sm.patient_last_name, "[LAST_NAME]")
+                    anonym_text = anonym_text.replace(
+                        sm.patient_last_name, "[LAST_NAME]"
+                    )
                 if sm.patient_dob:
-                    anonym_text = anonym_text.replace(str(sm.patient_dob.date()), "[DOB]")
+                    anonym_text = anonym_text.replace(
+                        str(sm.patient_dob.date()), "[DOB]"
+                    )
                 if sm.endoscope_sn:
                     anonym_text = anonym_text.replace(sm.endoscope_sn, "[ENDOSCOPE_SN]")
-                
+
                 # Replace examiner names if available
                 if sm.pk:
                     try:
                         examiners = list(sm.examiners.all())
                         for examiner in examiners:
-                            anonym_text = anonym_text.replace(str(examiner), "[EXAMINER]")
+                            anonym_text = anonym_text.replace(
+                                str(examiner), "[EXAMINER]"
+                            )
                     except Exception:
                         pass
 
         elif isinstance(instance, RawPdfFile):
-            instance:RawPdfFile
+            instance: RawPdfFile
             media_type = "pdf"
             created_at = instance.date_created
             filename = instance.file.name.split("/")[-1] if instance.file else "unknown"
-            # Check anonymized_text field
-            anonym_status = "done" if (instance.anonymized_text and instance.anonymized_text.strip()) else "not_started"
+
+            # ------- anonymization status using RawPdfState model (like VideoFile)
+            ps = instance.state
+            anonym_status = (
+                ps.anonymization_status if ps else PdfAnonymizationStatus.NOT_STARTED
+            )
+
             # PDF annotation == "sensitive meta validated"
-            annot_status = "done" if getattr(instance.sensitive_meta, "is_verified", False) else "not_started"
-            
+            annot_status = (
+                "done"
+                if getattr(instance.sensitive_meta, "is_verified", False)
+                else "not_started"
+            )
+
             # Extract text content from PDF
             text = instance.text or ""
             anonym_text = instance.anonymized_text or ""

endoreg_db-0.8.5.7/endoreg_db/serializers/misc/vop_patient_data.py → endoreg_db-0.8.6.3/endoreg_db/serializers/misc/sensitive_patient_data.py

@@ -80,7 +80,7 @@ class VoPPatientDataSerializer(serializers.Serializer):
 
         elif isinstance(instance, RawPdfFile):
             # Generate PDF streaming URL using pdf_id (RawPdfFile.id)
-            pdf_stream_url = f"/api/pdfstream/{instance.pk}/"
+            pdf_stream_url = f"/api/media/pdfs/{instance.pk}/stream/"
             
             return {
                 "id": instance.pk,

endoreg_db-0.8.6.3/endoreg_db/services/lookup_service.py

@@ -0,0 +1,411 @@
+"""
+Lookup Service Module
+
+This module provides server-side evaluation and lookup functionality for patient examinations.
+It handles requirement set evaluation, finding availability, and status computation for
+medical examination workflows.
+
+The lookup system uses a token-based approach where client sessions are stored in Django cache,
+allowing for efficient state management and recomputation of derived data.
+
+Key Components:
+- PatientExamination loading with optimized prefetching
+- Requirement set resolution and evaluation
+- Status computation for requirements and requirement sets
+- Suggested actions for unsatisfied requirements
+- Cache-based session management
+
+Architecture:
+1. LookupStore: Handles cache-based session storage
+2. lookup_service: Core business logic for evaluation
+3. LookupViewSet: Django REST API endpoints
+"""
+
+# services/lookup_service.py
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from django.db.models import Prefetch
+
+from endoreg_db.models.medical.examination import ExaminationRequirementSet
+from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+
+from .lookup_store import LookupStore
+
+
+def load_patient_exam_for_eval(pk: int) -> PatientExamination:
+    """
+    Load a PatientExamination with all related data needed for evaluation.
+
+    This function performs optimized database queries to fetch a PatientExamination
+    along with all related objects required for requirement evaluation, including:
+    - Patient and examination details
+    - Patient findings
+    - Examination requirement sets and their requirements
+    - Nested requirement set relationships
+
+    The query uses select_related and prefetch_related to minimize database hits
+    and ensure all data is available for evaluation without additional queries.
+
+    Args:
+        pk: Primary key of the PatientExamination to load
+
+    Returns:
+        PatientExamination: Fully loaded instance with all related data prefetched
+
+    Raises:
+        PatientExamination.DoesNotExist: If no examination exists with the given pk
+    """
+    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]:
+    """
+    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
+
+    Args:
+        pe: PatientExamination instance to get requirement sets for
+
+    Returns:
+        List of RequirementSet instances applicable to the examination, with related data prefetched
+    """
+    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 dictionary for a patient examination.
+
+    This function creates the base lookup data structure that will be stored in cache
+    and used by the client for requirement evaluation. It includes:
+
+    - Available findings for the examination type
+    - Required findings based on requirement defaults
+    - Requirement sets metadata
+    - Default findings and classification choices per requirement
+    - Empty placeholders for dynamic data (status, suggestions, etc.)
+
+    The returned dictionary is JSON-serializable and contains stable keys that
+    won't change between versions.
+
+    Args:
+        pe: PatientExamination instance to build lookup for
+
+    Returns:
+        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 + 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:
+    """
+    Create a lookup token for a patient examination.
+
+    This function initializes a new lookup session for the given patient examination
+    by building the initial lookup data and storing it in the cache via LookupStore.
+
+    Args:
+        pe_id: Primary key of the PatientExamination
+
+    Returns:
+        String token that can be used to access the lookup session
+
+    Raises:
+        PatientExamination.DoesNotExist: If examination doesn't exist
+        Exception: For any other errors during initialization
+    """
+    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]:
+    """
+    Recompute derived lookup data based on current patient examination state and user selections.
+
+    This function performs the core evaluation logic for the lookup system. It:
+
+    1. Validates and recovers corrupted lookup data
+    2. Loads the current PatientExamination state from database
+    3. Evaluates requirements against the current examination state
+    4. Computes status for individual requirements and requirement sets
+    5. Generates suggested actions for unsatisfied requirements
+    6. Updates the cache with new derived data (idempotent)
+
+    The function includes reentrancy protection to prevent concurrent recomputation
+    of the same token.
+
+    Args:
+        token: Lookup session token
+
+    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
+
+    Raises:
+        ValueError: If lookup data is invalid or patient examination not found
+    """
+    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)