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

endoreg_db/serializers/meta/sensitive_meta_detail.py

@@ -1,6 +1,5 @@
 from rest_framework import serializers
 import logging
-
 from ...models import SensitiveMeta
 
 logger = logging.getLogger(__name__)
@@ -10,153 +9,99 @@ class SensitiveMetaDetailSerializer(serializers.ModelSerializer):
     Serializer for displaying SensitiveMeta details with verification state.
     Includes all relevant fields for annotation and verification.
     """
-    
+
     # State verification fields
     is_verified = serializers.SerializerMethodField()
     dob_verified = serializers.SerializerMethodField()
     names_verified = serializers.SerializerMethodField()
-    
-    # Related fields for better display
+
+    # Related fields
     center_name = serializers.CharField(source="center.name", read_only=True)
     patient_gender_name = serializers.CharField(source="patient_gender.name", read_only=True)
-    
-    # Examiner information
     examiners_display = serializers.SerializerMethodField()
-    
-    # Formatted dates for display
+
+    # Formatted display fields
     patient_dob_display = serializers.SerializerMethodField()
     examination_date_display = serializers.SerializerMethodField()
-    
-    # Hash displays (last 8 characters for security)
+
+    # Hash displays (last 8 chars)
     patient_hash_display = serializers.SerializerMethodField()
     examination_hash_display = serializers.SerializerMethodField()
 
+    # Text fields
+    text = serializers.SerializerMethodField()
+    anonymized_text = serializers.SerializerMethodField()
+
     class Meta:
         model = SensitiveMeta
         fields = [
-            'id',
-            'patient_first_name',
-            'patient_last_name', 
-            'patient_dob',
-            'patient_dob_display',
-            'examination_date',
-            'examination_date_display',
-            'center_name',
-            'patient_gender_name',
-            'endoscope_type',
-            'endoscope_sn',
-            'patient_hash_display',
-            'examination_hash_display',
-            'examiners_display',
-            'is_verified',
-            'dob_verified',
-            'names_verified',
+            "id",
+            "casenumber",
+            "patient_first_name",
+            "patient_last_name",
+            "patient_dob",
+            "patient_dob_display",
+            "examination_date",
+            "examination_date_display",
+            "examination_time",
+            "center_name",
+            "patient_gender_name",
+            "endoscope_type",
+            "endoscope_sn",
+            "patient_hash_display",
+            "examination_hash_display",
+            "examiners_display",
+            "is_verified",
+            "dob_verified",
+            "names_verified",
+            "text",
+            "anonymized_text",
+            "external_id",
+            "external_id_origin"
         ]
         read_only_fields = [
-            'id',
-            'patient_hash_display',
-            'examination_hash_display',
+            "id",
+            "patient_hash_display",
+            "examination_hash_display",
         ]
 
-    def get_is_verified(self, obj):
-        """
-        Return the overall verification status of the given SensitiveMeta instance.
-        
-        Returns:
-            bool: True if the instance is verified; False if the verification attribute is missing.
-        
-        Raises:
-            Exception: Propagates unexpected exceptions after logging.
-        """
-        try:
-            return obj.is_verified
-        except AttributeError:
-            return False
-        except Exception as e:
-            logger.exception(f"Unexpected error in get_is_verified for SensitiveMeta {getattr(obj, 'pk', None)}: {e}")
-            raise
-
-    def get_dob_verified(self, obj):
-        """
-        Return the date of birth verification status for the given object.
-        
-        Returns:
-            bool: True if the date of birth is verified; otherwise, False if unavailable or on error.
-        """
-        try:
-            return obj.state.dob_verified
-        except Exception:
-            return False
-
-    def get_names_verified(self, obj):
-        """
-        Return whether the patient's names have been verified.
-        
-        Returns:
-            bool: True if the names are verified; False if not verified or if an error occurs.
-        """
-        try:
-            return obj.state.names_verified
-        except Exception:
-            return False
+    # --- Verification getters ---
+    def get_is_verified(self, obj): return getattr(obj, "is_verified", False)
+    def get_dob_verified(self, obj): return getattr(getattr(obj, "state", None), "dob_verified", False)
+    def get_names_verified(self, obj): return getattr(getattr(obj, "state", None), "names_verified", False)
 
+    # --- Examiner display ---
     def get_examiners_display(self, obj):
-        """
-        Return a list of examiner full names for the given SensitiveMeta instance.
-        
-        Returns:
-            list[str]: List of examiner names in "First Last" format, or an empty list if unavailable.
-        """
         try:
-            if obj.pk:
-                examiners = obj.examiners.all()
-                return [f"{e.first_name} {e.last_name}" for e in examiners]
-            return []
+            return [f"{e.first_name} {e.last_name}" for e in obj.examiners.all()] if obj.pk else []
         except Exception as e:
-            logger.warning(f"Error getting examiners for SensitiveMeta {obj.pk}: {e}")
+            logger.warning(f"Error fetching examiners for SensitiveMeta {obj.pk}: {e}")
             return []
 
+    # --- Date formatters ---
     def get_patient_dob_display(self, obj):
-        """
-        Return the patient's date of birth formatted as "YYYY-MM-DD" for display.
-        
-        Returns:
-            str or None: Formatted date string if available, otherwise None.
-        """
-        if obj.patient_dob:
-            return obj.patient_dob.strftime("%Y-%m-%d")
-        return None
+        return obj.patient_dob.strftime("%Y-%m-%d") if obj.patient_dob else None
 
     def get_examination_date_display(self, obj):
-        """
-        Return the examination date formatted as "YYYY-MM-DD" for display.
-        
-        Returns:
-            str or None: Formatted examination date string, or None if not set.
-        """
-        if obj.examination_date:
-            return obj.examination_date.strftime("%Y-%m-%d")
-        return None
+        return obj.examination_date.strftime("%Y-%m-%d") if obj.examination_date else None
 
+    # --- Hash short forms ---
     def get_patient_hash_display(self, obj):
-        """
-        Return the last eight characters of the patient's hash, prefixed with ellipsis, or None if not available.
-        
-        Returns:
-            str or None: Truncated patient hash for display, or None if the hash is not set.
-        """
-        if obj.patient_hash:
-            return f"...{obj.patient_hash[-8:]}"
-        return None
+        return f"...{obj.patient_hash[-8:]}" if obj.patient_hash else None
 
     def get_examination_hash_display(self, obj):
-        """
-        Return the last eight characters of the examination hash, prefixed with ellipsis, or None if not available.
-        
-        Returns:
-            str or None: Truncated examination hash for display, or None if the hash is not set.
-        """
-        if obj.examination_hash:
-            return f"...{obj.examination_hash[-8:]}"
-        return None
+        return f"...{obj.examination_hash[-8:]}" if obj.examination_hash else None
+
+    # --- Text fields ---
+    def get_text(self, obj):
+        return obj.text if isinstance(obj.text, str) else None
+
+    def get_anonymized_text(self, obj):
+        return obj.anonymized_text if isinstance(obj.anonymized_text, str) else None
+    
+    def get_external_id(self, obj) -> str | None:  
+        return obj.external_id if isinstance(obj.external_id, str) else None  
+    
+    def get_external_id_origin(self, obj) -> str | None:  
+        return obj.external_id_origin if isinstance(obj.external_id_origin, str) else None 
 

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/serializers/misc/file_overview.py

@@ -1,12 +1,15 @@
-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.anonymization import AnonymizationState as PdfAnonymizationState
+from endoreg_db.models.state.anonymization import AnonymizationState as VideoAnonymizationState
 
 if TYPE_CHECKING:
     pass
 
+
 class FileOverviewSerializer(serializers.Serializer):
     """
     Polymorphic "union" serializer – we normalise both model types
@@ -21,121 +24,62 @@ class FileOverviewSerializer(serializers.Serializer):
     anonymizationStatus = serializers.CharField(read_only=True)
     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)
 
     # --- 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
-            
+            vs = instance.get_or_create_state()
+            anonym_status = (
+                vs.anonymization_status if vs else VideoAnonymizationState.NOT_STARTED
+            )
+
             # ------- annotation status (validated label segments)
             if instance.label_video_segments.filter(state__is_validated=True).exists():
-                annot_status = "done"
+                annot_status = "validated"
             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:
-                        examiners = list(sm.examiners.all())
-                        if examiners:
-                            examiner_names = ", ".join(str(e) for e in examiners)
-                            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]")
-                if sm.patient_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]")
-                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]")
-                    except Exception:
-                        pass
 
         elif isinstance(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"
-            # PDF annotation == "sensitive meta validated"
-            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 ""
+
+            # ------- anonymization status using RawPdfState model
+            rps = instance.get_or_create_state()
+            anonym_status = (
+                rps.anonymization_status if rps else PdfAnonymizationState.NOT_STARTED
+            )
+
+            # ------- annotation status (not applicable for PDFs)
+            annot_status = (
+                            PdfAnonymizationState.VALIDATED if rps.anonymization_validated else PdfAnonymizationState.NOT_STARTED 
+                            )
 
         else:  # shouldn't happen
             raise TypeError(f"Unsupported instance for overview: {type(instance)}")
@@ -147,6 +91,4 @@ class FileOverviewSerializer(serializers.Serializer):
             "anonymizationStatus": anonym_status,
             "annotationStatus": annot_status,
             "createdAt": created_at,
-            "text": text,
-            "anonymizedText": anonym_text,
         }

endoreg_db/serializers/misc/{vop_patient_data.py → 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/serializers/requirements/requirement_sets.py

@@ -1,29 +1,99 @@
-from ...models.requirement.requirement_set import RequirementSet
-from .requirement_schema import RequirementSetSchema
+from rest_framework import serializers
+
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+
+
+class RequirementSetSerializer(serializers.ModelSerializer):
+    """
+    Serializer for RequirementSet model with optional tag field.
+
+    This serializer provides a flexible representation of requirement sets,
+    including role-based tags for filtering (e.g., "Gastroenterologist", "Student").
+
+    Fields:
+        id: Primary key
+        name: Display name of the requirement set
+        description: Optional description text
+        requirement_set_type: Type classification
+        tags: List of tag names (optional, read-only)
+    """
+
+    tags = serializers.SlugRelatedField(
+        many=True, read_only=True, slug_field="name", required=False
+    )
+
+    requirement_set_type = serializers.CharField(
+        source="requirement_set_type.name", read_only=True, allow_null=True
+    )
+
+    class Meta:
+        model = RequirementSet
+        fields = ["id", "name", "description", "requirement_set_type", "tags"]
+
+    def to_representation(self, instance):
+        """
+        Customize representation to exclude tags field if empty or not prefetched.
+
+        This prevents N+1 query issues and keeps the response clean when tags
+        aren't needed or weren't prefetched in the queryset.
+        """
+        representation = super().to_representation(instance)
+
+        # Only include tags if they exist and were prefetched
+        if not representation.get("tags"):
+            representation.pop("tags", None)
+
+        return representation
+
 
 def requirement_set_to_dict(requirement_set: RequirementSet) -> dict:
     """
     Convert a RequirementSet instance to a dictionary representation.
-    
+
+    This function performs additional queries to fetch related data including
+    requirements and linked sets. Use RequirementSetSerializer for simpler
+    representations without the overhead of additional queries.
+
     Args:
-        requirement_set (RequirementSet): The RequirementSet instance to convert.
-    
+        requirement_set: The RequirementSet instance to convert.
+
     Returns:
-        dict: A dictionary representation of the RequirementSet.
+        Dictionary representation of the RequirementSet with full nested details:
+        - id, name, description: Basic metadata
+        - requirements: List of requirement dictionaries
+        - links: List of linked requirement set data
+        - tags: List of tag names (if any exist)
     """
-    
-    requirement_set = RequirementSet.objects.select_related(
-        "created_by", "updated_by"
-    ).prefetch_related(
-        "requirements", "links"
-    ).get(id=requirement_set.id)
-
-    links = requirement_set.links_to_sets()
-    
-    return {
-        "id": requirement_set.id,
-        "name": requirement_set.name,
-        "description": requirement_set.description,
-        "requirements": [req.to_dict() for req in requirement_set.requirements.all()],
-        "links": [link.model_dump() for link in links]
-    }
+    # Fetch the requirement set with all related data to avoid N+1 queries
+    requirement_set_full = (
+        RequirementSet.objects.select_related("requirement_set_type")
+        .prefetch_related("requirements", "links_to_sets", "tags")
+        .get(pk=requirement_set.pk)
+    )
+
+    # Get linked requirement sets
+    linked_sets = requirement_set_full.links_to_sets.all()
+
+    result = {
+        "id": requirement_set_full.pk,
+        "name": requirement_set_full.name,
+        "description": requirement_set_full.description or "",
+        "requirement_set_type": requirement_set_full.requirement_set_type.name
+        if requirement_set_full.requirement_set_type
+        else None,
+        "requirements": [
+            {"id": req.pk, "name": req.name, "description": req.description or ""}
+            for req in requirement_set_full.requirements.all()
+        ],
+        "linked_sets": [
+            {"id": link.pk, "name": link.name, "description": link.description or ""}
+            for link in linked_sets
+        ],
+    }
+
+    # Add tags if they exist
+    tags = list(requirement_set_full.tags.values_list("name", flat=True))
+    if tags:
+        result["tags"] = tags
+
+    return result

endoreg_db/serializers/video/segmentation.py

@@ -10,7 +10,8 @@ from django.conf import settings
 from typing import TYPE_CHECKING
 from rest_framework.exceptions import ValidationError
 if TYPE_CHECKING:
-    from endoreg_db.models import Video
+    from endoreg_db.models import VideoFile
+    
 class VideoFileSerializer(serializers.ModelSerializer):
     """
     Serializer that dynamically handles video retrieval and streaming.

endoreg_db/serializers/video/video_processing_history.py

@@ -4,7 +4,10 @@ Video Processing History Serializer
 Serializes VideoProcessingHistory model for API responses.
 Created as part of Phase 1.1: Video Correction API Endpoints.
 """
+from collections.abc import Mapping
+
 from rest_framework import serializers
+
 from endoreg_db.models import VideoProcessingHistory
 
 
@@ -16,8 +19,8 @@ class VideoProcessingHistorySerializer(serializers.ModelSerializer):
     with download URLs for processed files.
     """
     download_url = serializers.SerializerMethodField()
-    operation_display = serializers.CharField(source='get_operation_display', read_only=True)
-    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    operation_display = serializers.SerializerMethodField()
+    status_display = serializers.SerializerMethodField()
     duration = serializers.ReadOnlyField()
     is_complete = serializers.ReadOnlyField()
     
@@ -57,13 +60,24 @@ class VideoProcessingHistorySerializer(serializers.ModelSerializer):
         
         # Build URL to download endpoint (to be implemented)
         # Format: /api/media/processed-videos/{video_id}/{history_id}/
-        request = self.context.get('request')
+        context = self.context if isinstance(self.context, Mapping) else None
+        request = context.get('request') if context else None
         if request:
             return request.build_absolute_uri(
                 f'/api/media/processed-videos/{obj.video.id}/{obj.id}/'
             )
         
         return f'/api/media/processed-videos/{obj.video.id}/{obj.id}/'
+
+    def get_operation_display(self, obj) -> str:
+        display = getattr(obj, "get_operation_display", None)
+        result = display() if callable(display) else obj.operation
+        return str(result)
+
+    def get_status_display(self, obj) -> str:
+        display = getattr(obj, "get_status_display", None)
+        result = display() if callable(display) else obj.status
+        return str(result)
     
     def validate_operation(self, value):
         """
@@ -120,8 +134,9 @@ class VideoProcessingHistorySerializer(serializers.ModelSerializer):
         """
         if not isinstance(value, dict):
             raise serializers.ValidationError("config must be a dictionary")
-        
-        operation = self.initial_data.get('operation')
+
+        initial = self.initial_data if isinstance(self.initial_data, Mapping) else {}
+        operation = initial.get('operation')
         
         # Validate masking config
         if operation == VideoProcessingHistory.OPERATION_MASKING: