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

endoreg_db/serializers/pdf/anony_text_validation.py

@@ -1,11 +1,14 @@
 from pathlib import Path
-from rest_framework import serializers
+
 from django.conf import settings
+from rest_framework import serializers
+
 from ...models import RawPdfFile
 
+
 class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
     """
-    Serializer to fetch PDF metadata along with `anonymized_text` from `RawPdfFile`.
+    Serializer to fetch report metadata along with `anonymized_text` from `RawPdfFile`.
     Ensures Vue.js can process JSON efficiently.
     """
 
@@ -15,36 +18,46 @@ class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = RawPdfFile
-        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
-                  'sensitive_meta_id', 'anonymized_text']
+        fields = [
+            "id",
+            "file",
+            "pdf_url",
+            "full_pdf_path",
+            "sensitive_meta_id",
+            "anonymized_text",
+        ]
 
     @staticmethod
     def get_next_pdf(last_id=None):
         """
-        Retrieves the first available PDF if `last_id` is NOT provided.
-        Otherwise, fetches the next available PDF where `id > last_id`.
+        Retrieves the first available report if `last_id` is NOT provided.
+        Otherwise, fetches the next available report where `id > last_id`.
         """
         query_filter = {} if last_id is None else {"id__gt": int(last_id)}
-        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by('id').first()
-        return pdf_entry  
+        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by("id").first()
+        return pdf_entry
 
     def get_pdf_url(self, obj):
         """
-        Returns the absolute URL for accessing the anonymized text PDF endpoint for the given object.
-        
+        Returns the absolute URL for accessing the anonymized text report endpoint for the given object.
+
         If the request context or file is missing, returns None.
         """
-        request = self.context.get('request')
-        return request.build_absolute_uri(f"/pdf/anony_text/?id={obj.id}") if request and obj.file else None
+        request = self.context.get("request")
+        return (
+            request.build_absolute_uri(f"/pdf/anony_text/?id={obj.id}")
+            if request and obj.file
+            else None
+        )
 
     def get_file(self, obj):
         """
-        Retrieves the relative file path of the PDF from the model instance.
-        
+        Retrieves the relative file path of the report from the model instance.
+
         Returns:
             The relative file path as a string, or None if no file is associated.
         """
-        return str(obj.file.name).strip() if obj.file else None  
+        return str(obj.file.name).strip() if obj.file else None
 
     def get_full_pdf_path(self, obj):
         """
@@ -54,32 +67,35 @@ class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
             return None
         pdf_relative_path = str(obj.file.name)
         full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
-        return str(full_path) if full_path.exists() else None  
+        return str(full_path) if full_path.exists() else None
 
     def validate_anonymized_text(self, value):
         """
         Validates that the anonymized text is non-empty and does not exceed 5000 characters.
-        
+
         Raises:
             serializers.ValidationError: If the text is empty or exceeds the length limit.
         """
         if not value.strip():
             raise serializers.ValidationError("Anonymized text cannot be empty.")
-        #FIXME move this to a settings variable @Hamzaukw @maxhild
+        # FIXME move this to a settings variable @Hamzaukw @maxhild
         if len(value) > 5000:  # Arbitrary limit to prevent excessively long text
-            raise serializers.ValidationError("Anonymized text exceeds the maximum length of 5000 characters.")
+            raise serializers.ValidationError(
+                "Anonymized text exceeds the maximum length of 5000 characters."
+            )
         return value
 
     def update(self, instance, validated_data):
         """
         Update the `anonymized_text` field of a RawPdfFile instance with validated data.
-        
+
         Only the `anonymized_text` field is modified; all other fields remain unchanged.
-        
+
         Returns:
             The updated RawPdfFile instance.
         """
-        instance.anonymized_text = validated_data.get('anonymized_text', instance.anonymized_text)
+        instance.anonymized_text = validated_data.get(
+            "anonymized_text", instance.anonymized_text
+        )
         instance.save()
         return instance
-

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_file_list.py

@@ -1,14 +1,22 @@
-from typing import Literal
-from endoreg_db.models import VideoFile
-
+# endoreg_db/serializers/video/video_file_list.py
+from typing import Literal, Optional
+import logging
 
 from rest_framework import serializers
 
+from endoreg_db.models import VideoFile
+
+logger = logging.getLogger(__name__)
+
 
 class VideoFileListSerializer(serializers.ModelSerializer):
     """
     Minimal serializer to return only basic video information
     for the video selection dropdown in Vue.js.
+
+    Convention:
+        - Serializer methods must NOT raise if video state is missing or invalid.
+        - They return safe defaults and log what went wrong.
     """
 
     # Add computed fields for video status
@@ -20,48 +28,71 @@ class VideoFileListSerializer(serializers.ModelSerializer):
         model = VideoFile
         fields = ["id", "original_file_name", "status", "assignedUser", "anonymized"]
 
-    def get_status(self, obj:VideoFile) -> Literal['completed'] | Literal['in_progress'] | Literal['available']:
+    # --- internal helper -------------------------------------------------
+    def _get_video_state(self, obj: VideoFile):
         """
-        Determine the processing status of a video file as 'completed', 'in_progress', or 'available'.
-        
-        Returns:
-            str: The video's status based on its processing state.
-            
-        Raises:
-            ValueError: If the video's state cannot be accessed.
+        Best-effort accessor for obj.state.
+
+        Serializer layer must never raise here; it only logs and returns None
+        if the state cannot be loaded for any reason.
         """
         try:
-            state = obj.state
-            if not state:
-                return 'available'
-            if state.anonymized:
-                return 'completed'
-            if state.frames_extracted:
-                return 'in_progress'
-            return 'available'
-        except Exception as _e:
-            raise ValueError("Video state should not be None") from _e
-
-    def get_assignedUser(self, obj):
+            return getattr(obj, "state", None)
+        except Exception as exc:  # pragma: no cover - type of error is DB/backend-specific
+            logger.warning(
+                "VideoFileListSerializer: unable to access state for VideoFile(id=%s): %s",
+                getattr(obj, "id", "unknown"),
+                exc,
+            )
+            return None
+
+    # --- public serializer fields ----------------------------------------
+    def get_status(
+        self, obj: VideoFile
+    ) -> Literal["completed", "in_progress", "available"]:
+        """
+        Determine the processing status of a video file as 'completed',
+        'in_progress', or 'available'.
+
+        Contract:
+            - Never raises.
+            - Missing or invalid state -> treated as 'available'.
+        """
+        state = self._get_video_state(obj)
+
+        if not state:
+            return "available"
+
+        # Use getattr with defaults to tolerate partially populated state objects
+        anonymized = getattr(state, "anonymized", False)
+        frames_extracted = getattr(state, "frames_extracted", False)
+
+        if anonymized:
+            return "completed"
+        if frames_extracted:
+            return "in_progress"
+        return "available"
+
+    def get_assignedUser(self, obj: VideoFile):
         """
         Returns the user assigned to the video, or None if no user is assigned.
-        
+
         Currently always returns None as user assignment is not implemented.
         """
         # For now return None, can be extended when user assignment is implemented
         return None
 
-    def get_anonymized(self, obj):
+    def get_anonymized(self, obj: VideoFile) -> bool:
         """
         Determine whether the video has been anonymized.
-        
-        Returns:
-            bool: True if the video's state indicates it is anonymized; False otherwise or if state information is unavailable.
+
+        Contract:
+            - Never raises.
+            - Returns False if state does not exist or cannot be loaded.
         """
-        try:
-            state = getattr(obj, 'state', None)
-            if state:
-                return getattr(state, 'anonymized', False)
+        state = self._get_video_state(obj)
+        if not state:
             return False
-        except Exception:
-            return False
+
+        # getattr to be robust against partially/populated state
+        return bool(getattr(state, "anonymized", False))

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: