endoreg-db 0.8.6.1__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/file_overview.py

@@ -3,12 +3,8 @@ from typing import TYPE_CHECKING
 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,
-)
+from endoreg_db.models.state.anonymization import AnonymizationState as PdfAnonymizationState
+from endoreg_db.models.state.anonymization import AnonymizationState as VideoAnonymizationState
 
 if TYPE_CHECKING:
     pass
@@ -28,10 +24,6 @@ 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):
@@ -62,110 +54,32 @@ class FileOverviewSerializer(serializers.Serializer):
             )
 
             # ------- anonymization status using VideoState model
-            vs = instance.state
+            vs = instance.get_or_create_state()
             anonym_status = (
-                vs.anonymization_status if vs else VideoAnonymizationStatus.NOT_STARTED
+                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"
 
-            # ------- anonymization status using RawPdfState model (like VideoFile)
-            ps = instance.state
+            # ------- anonymization status using RawPdfState model
+            rps = instance.get_or_create_state()
             anonym_status = (
-                ps.anonymization_status if ps else PdfAnonymizationStatus.NOT_STARTED
+                rps.anonymization_status if rps else PdfAnonymizationState.NOT_STARTED
             )
 
-            # PDF annotation == "sensitive meta validated"
+            # ------- annotation status (not applicable for PDFs)
             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 ""
+                            PdfAnonymizationState.VALIDATED if rps.anonymization_validated else PdfAnonymizationState.NOT_STARTED 
+                            )
 
         else:  # shouldn't happen
             raise TypeError(f"Unsupported instance for overview: {type(instance)}")
@@ -177,6 +91,4 @@ class FileOverviewSerializer(serializers.Serializer):
             "anonymizationStatus": anonym_status,
             "annotationStatus": annot_status,
             "createdAt": created_at,
-            "text": text,
-            "anonymizedText": anonym_text,
         }

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: