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

endoreg_db/views/finding_classification/__init__.py

@@ -0,0 +1,13 @@
+from .finding_classification import FindingClassificationViewSet
+from .get_classification_choices import (
+    get_classification_choices,
+    get_morphology_choices, # DEPRECATED
+    get_location_choices, # DEPRECATED
+)
+
+__all__ = [
+    "FindingClassificationViewSet",
+    "get_classification_choices",
+    "get_morphology_choices", # DEPRECATED
+    "get_location_choices", # DEPRECATED
+]

endoreg_db/views/finding_classification/finding_classification.py

@@ -0,0 +1,42 @@
+# endoreg_db/views/finding_classification/base.py
+from rest_framework.viewsets import ReadOnlyModelViewSet
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework import status
+from endoreg_db.models import (
+    FindingClassification,
+)
+from ...serializers.finding_classification import (
+    FindingClassificationSerializer,
+    FindingClassificationChoiceSerializer,
+)
+
+class FindingClassificationViewSet(ReadOnlyModelViewSet):
+    queryset = FindingClassification.objects.all()
+    serializer_class = FindingClassificationSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly]
+
+    @action(detail=True, methods=['get'])
+    def choices(self, request, pk=None):
+        """
+        Get choices for a specific location classification.
+        Called by: GET /api/finding-classifications/{id}/choices/
+        """
+        try:
+            classification = self.get_object()
+            choices = classification.get_choices()
+            
+            serializer = FindingClassificationChoiceSerializer(choices, many=True)
+            return Response(serializer.data)
+        except FindingClassification.DoesNotExist:
+            return Response(
+                {"error": "FindingClassification not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+        except Exception as e:
+            return Response(
+                {"error": str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+

endoreg_db/views/finding_classification/get_classification_choices.py

@@ -0,0 +1,55 @@
+from endoreg_db.models import FindingClassification
+
+
+from django.http import JsonResponse
+from django.views.decorators.http import require_GET
+import warnings
+
+@require_GET
+def get_classification_choices(request, classification_id):
+    """
+    Fetch classification choices dynamically based on the selected FindingClassification.
+    """
+    try:
+        classification = FindingClassification.objects.get(id=classification_id)
+        choices = classification.get_choices()
+        data = [{"id": choice.id, "name": choice.name} for choice in choices]
+        return JsonResponse({"choices": data})
+    except FindingClassification.DoesNotExist:
+        return JsonResponse({"error": "Classification not found"}, status=404)
+    except Exception as e:
+        return JsonResponse({"error": str(e)}, status=500)
+
+
+@require_GET
+def get_location_choices(request, location_id):
+    """
+    Fetch location choices dynamically based on the selected FindingLocationClassification (Location).
+    """
+    warnings.warn(
+        "The get_location_choices function is deprecated and will be removed in future versions. "
+        "Use the 'get_classification_choices' function instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    # Fetch location choices using the new method
+    return get_classification_choices(request, location_id)
+
+
+@require_GET
+def get_morphology_choices(request, morphology_id):
+    """
+    Fetch morphology choices dynamically based on the selected FindingMorphologyClassification.
+    """
+    warnings.warn(
+        "The get_morphology_choices function is deprecated and will be removed in future versions. "
+        "Use the 'get_classification_choices' function instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    # Fetch morphology choices using the new method
+    return get_classification_choices(request, morphology_id)
+
+

endoreg_db/views/label/__init__.py

@@ -0,0 +1,5 @@
+from .label import LabelViewSet
+
+__all__ = [
+    "LabelViewSet",
+]

endoreg_db/views/label/label.py

@@ -0,0 +1,15 @@
+
+from rest_framework.viewsets import ReadOnlyModelViewSet
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+from endoreg_db.models import (
+    Label,
+)
+from endoreg_db.serializers.label import LabelSerializer
+
+
+
+class LabelViewSet(ReadOnlyModelViewSet):
+    queryset = Label.objects.all()
+    serializer_class = LabelSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly]
+

endoreg_db/views/label_video_segment/__init__.py

@@ -0,0 +1,16 @@
+from .create_lvs_from_annotation import create_video_segment_annotation
+from .label_video_segment_by_label import video_segments_by_label_id_view, video_segments_by_label_name_view
+from .label_video_segment_detail import video_segment_detail_view
+from .label_video_segment import video_segments_view
+from .update_lvs_from_annotation import update_label_video_segment
+from .get_lvs_by_name_and_video import get_lvs_by_name_and_video_id
+
+__all__ = [
+    'create_video_segment_annotation',
+    'video_segments_by_label_id_view',
+    'video_segments_by_label_name_view',
+    'video_segment_detail_view',
+    'video_segments_view',
+    'update_label_video_segment',
+    "get_lvs_by_name_and_video_id"
+]

endoreg_db/views/label_video_segment/create_lvs_from_annotation.py

@@ -0,0 +1,44 @@
+from endoreg_db.models import LabelVideoSegment
+from endoreg_db.serializers.label_video_segment.label_video_segment_annotation import LabelVideoSegmentAnnotationSerializer
+
+from django.db import transaction
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+@api_view(['POST'])
+@permission_classes([IsAuthenticated])
+def create_video_segment_annotation(request):
+    """
+    Create a new annotation.
+    If annotation type is 'segment', creates a user-source LabelVideoSegment.
+    """
+    logger.info(f"Creating annotation with data: {request.data}")
+
+    with transaction.atomic():
+        serializer = LabelVideoSegmentAnnotationSerializer(data=request.data)
+        if serializer.is_valid():
+            annotation = serializer.save()
+
+            # If the annotation type is 'segment', create a new LabelVideoSegment
+            if annotation.type == 'segment':
+                metadata = annotation.metadata or {}
+                #TODO @coderabbitai we should create a followup issue for @Hamzaukw so we adress this naming inconsistency in future
+                LabelVideoSegment.objects.create(
+                    video_id=annotation.video_id,
+                    start_frame=metadata.get('start_frame'),
+                    end_frame=metadata.get('end_frame'),
+                    label=metadata.get('label'),
+                    source='user'
+                )
+            
+            logger.info(f"Successfully created annotation {annotation.id}")
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+    
+    logger.error(f"Failed to create annotation with data: {request.data}, errors: {serializer.errors}")
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

endoreg_db/views/label_video_segment/get_lvs_by_name_and_video.py

@@ -0,0 +1,50 @@
+from endoreg_db.models import Label, LabelVideoSegment, VideoFile
+from endoreg_db.serializers.label_video_segment.label_video_segment import LabelVideoSegmentSerializer
+
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+import logging
+logger = logging.getLogger(__name__)
+
+@api_view(['GET'])
+@permission_classes([EnvironmentAwarePermission])
+def get_lvs_by_name_and_video_id(request, label_name, video_id):
+    """
+    Handles creation and retrieval of labeled video segments.
+    GET lists all labeled video segments, filtered by video ID and label name.
+    Returns appropriate error responses for invalid input or missing referenced objects.
+    """
+
+    # Check if label exists
+    try:
+        _label = Label.objects.get(name=label_name)
+    except Label.DoesNotExist:
+        logger.error(f"Label with name '{label_name}' does not exist.")
+        return Response(
+            {"error": f"Label with name '{label_name}' does not exist."},
+            status=status.HTTP_404_NOT_FOUND
+        )
+
+    # Check if video exists
+    try:
+        _video = VideoFile.objects.get(id=video_id)
+    except VideoFile.DoesNotExist:
+        logger.error(f"Video with ID '{video_id}' does not exist.")
+        return Response(
+            {"error": f"Video with ID '{video_id}' does not exist."},
+            status=status.HTTP_404_NOT_FOUND
+        )
+
+    # get all segments for the given video and label name
+    queryset = LabelVideoSegment.objects.filter(
+        video_file__id=video_id,
+        label__name=label_name
+    )
+
+    # Order by video and start time for consistent results
+    segments = queryset.order_by('video_file__id', 'start_frame_number')
+    serializer = LabelVideoSegmentSerializer(segments, many=True)
+    return Response(serializer.data)

endoreg_db/views/label_video_segment/label_video_segment.py

@@ -0,0 +1,77 @@
+from endoreg_db.models import Label, LabelVideoSegment, VideoFile
+from endoreg_db.serializers.label_video_segment.label_video_segment import LabelVideoSegmentSerializer
+
+from django.db import transaction
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+import logging
+logger = logging.getLogger(__name__)
+
+@api_view(['POST', 'GET'])
+@permission_classes([EnvironmentAwarePermission])
+def video_segments_view(request):
+    """
+    Handles creation and retrieval of labeled video segments.
+
+    POST creates a new labeled video segment with validated data and returns the created segment. GET lists all labeled video segments, optionally filtered by video ID and/or label ID. Returns appropriate error responses for invalid input or missing referenced objects.
+    """
+    if request.method == 'POST':
+        logger.info(f"Creating new video segment with data: {request.data}")
+
+        with transaction.atomic():
+            serializer = LabelVideoSegmentSerializer(data=request.data)
+            if serializer.is_valid():
+                try:
+                    segment = serializer.save()
+                    logger.info(f"Successfully created video segment {segment.pk}")
+                    return Response(
+                        LabelVideoSegmentSerializer(segment).data,
+                        status=status.HTTP_201_CREATED
+                    )
+                except Exception as e:
+                    logger.error(f"Error creating video segment: {str(e)}")
+                    return Response(
+                        {'error': f'Failed to create segment: {str(e)}'},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    )
+            else:
+                logger.warning(f"Invalid data for video segment creation: {serializer.errors}")
+                return Response(
+                    {'error': 'Invalid data', 'details': serializer.errors},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+    elif request.method == 'GET':
+        # Optional filtering by video_id
+        video_id = request.GET.get('video_id')
+        label_id = request.GET.get('label_id')
+
+        queryset = LabelVideoSegment.objects.all()
+
+        if video_id:
+            try:
+                video = VideoFile.objects.get(id=video_id)
+                queryset = queryset.filter(video_file=video)
+            except VideoFile.DoesNotExist:
+                return Response(
+                    {'error': f'Video with id {video_id} not found'},
+                    status=status.HTTP_404_NOT_FOUND
+                )
+
+        if label_id:
+            try:
+                label = Label.objects.get(id=label_id)
+                queryset = queryset.filter(label=label)
+            except Label.DoesNotExist:
+                return Response(
+                    {'error': f'Label with id {label_id} not found'},
+                    status=status.HTTP_404_NOT_FOUND
+                )
+
+        # Order by video and start time for consistent results
+        segments = queryset.order_by('video_file__id', 'start_frame_number')
+        serializer = LabelVideoSegmentSerializer(segments, many=True)
+        return Response(serializer.data)

endoreg_db/views/label_video_segment/label_video_segment_by_label.py

@@ -0,0 +1,174 @@
+from endoreg_db.models import Label, LabelVideoSegment, VideoFile
+from django.shortcuts import get_object_or_404
+from django.http import Http404
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_FPS = 50 #TODO move to settings or config
+
+@api_view(['GET'])
+@permission_classes(DEBUG_PERMISSIONS) #TODO: Uncomment this line if authentication is set up
+def video_segments_by_label_id_view(request, video_id, label_id):
+    """
+    Retrieves all labeled segments for a given video and label by their IDs.
+
+    Returns a list of time segments for the specified video and label, including start and end frames and their corresponding times in seconds. If no segments exist, returns an empty list. Responds with 404 if the video or label is not found.
+    """
+    try:
+        video = get_object_or_404(VideoFile, id=video_id)
+        label = get_object_or_404(Label, id=label_id)
+
+        # Get all segments for this video and label combination
+        segments = LabelVideoSegment.objects.filter(
+            video_file=video,
+            label=label
+        ).order_by('start_frame_number')
+
+        # Build response in the expected format
+        if segments.exists():
+            # Get video properties for time calculation
+            fps = video.get_fps() or DEFAULT_FPS  # Use module-level constant
+
+            time_segments = []
+            for segment in segments:
+                # Convert frame numbers to time
+                start_time = segment.start_frame_number / fps
+                end_time = segment.end_frame_number / fps
+
+                time_segments.append({
+                    'segment_start': segment.start_frame_number,
+                    'segment_end': segment.end_frame_number,
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'frames': {}  # Empty for now, can be populated if needed
+                })
+
+            response_data = {
+                'label': label.name,
+                'label_id': label.id,
+                'time_segments': time_segments
+            }
+        else:
+            # Return empty response if no segments found
+            response_data = {
+                'label': label.name,
+                'label_id': label.id,
+                'time_segments': []
+            }
+
+        return Response(response_data)
+    except Http404 as e:
+        return Response({'error': str(e)}, status=status.HTTP_404_NOT_FOUND)
+    except VideoFile.DoesNotExist:
+        return Response(
+            {'error': f'Video with id {video_id} not found'},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    except Label.DoesNotExist:
+        return Response(
+            {'error': f'Label with id {label_id} not found'},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    except Exception as e:
+        logger.error(f"Error fetching segments for video {video_id} and label {label_id}: {str(e)}")
+        return Response(
+            {'error': f'Internal server error: {str(e)}'},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+
+
+@api_view(['GET'])
+@permission_classes(DEBUG_PERMISSIONS) #TODO: Uncomment this line if authentication is set up
+def video_segments_by_label_name_view(request, video_id, label_name):
+    """
+    Retrieves labeled video segments for a given video and label name.
+
+    Handles cases where multiple labels share the same name by returning a conflict response with details of all matching labels and a suggestion to use the label ID endpoint. If a unique label is found, returns a list of segments for the specified video and label, including frame and time information. Returns appropriate error responses if the video or label is not found, or if an internal error occurs.
+    """
+    try:
+        video = get_object_or_404(VideoFile, id=video_id)
+
+        # Find all labels with this name
+        labels_with_name = Label.objects.filter(name=label_name)
+
+        if not labels_with_name.exists():
+            return Response(
+                {'error': f'No labels found with name "{label_name}"'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        if labels_with_name.count() > 1:
+            # Multiple labels with same name - log warning and return info about all
+            logger.warning(f"Multiple labels found with name '{label_name}': {[l.id for l in labels_with_name]}")
+
+            return Response({
+                'error': f'Multiple labels found with name "{label_name}"',
+                'suggestion': 'Use the label-id endpoint instead for unambiguous results',
+                'available_labels': [
+                    {'id': label.id, 'name': label.name, 'description': label.description}
+                    for label in labels_with_name
+                ]
+            }, status=status.HTTP_409_CONFLICT)
+
+        # Single label found - proceed normally
+        label = labels_with_name.first()
+
+        # Get all segments for this video and label combination
+        segments = LabelVideoSegment.objects.filter(
+            video_file=video,
+            label=label
+        ).order_by('start_frame_number')
+
+        # Build response in the expected format
+        if segments.exists():
+            # Get video properties for time calculation
+            fps = video.get_fps() or DEFAULT_FPS  # Use module-level constant
+
+            time_segments = []
+            for segment in segments:
+                # Convert frame numbers to time
+                start_time = segment.start_frame_number / fps
+                end_time = segment.end_frame_number / fps
+
+                time_segments.append({
+                    'segment_start': segment.start_frame_number,
+                    'segment_end': segment.end_frame_number,
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'frames': {}  # Empty for now, can be populated if needed
+                })
+
+            response_data = {
+                'label': label.name,
+                'label_id': label.id,
+                'time_segments': time_segments
+            }
+        else:
+            # Return empty response if no segments found
+            response_data = {
+                'label': label.name,
+                'label_id': label.id,
+                'time_segments': []
+            }
+
+        return Response(response_data)
+    except Http404 as e:
+        return Response({'error': str(e)}, status=status.HTTP_404_NOT_FOUND)
+    except VideoFile.DoesNotExist:
+        return Response(
+            {'error': f'Video with id {video_id} not found'},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    except Exception as e:
+        logger.error(f"Error fetching segments for video {video_id} and label '{label_name}': {str(e)}")
+        return Response(
+            {'error': f'Internal server error: {str(e)}'},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )

endoreg_db/views/label_video_segment/label_video_segment_detail.py

@@ -0,0 +1,73 @@
+from endoreg_db.models import LabelVideoSegment
+from endoreg_db.serializers.label_video_segment.label_video_segment import LabelVideoSegmentSerializer
+from django.db import transaction
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+
+import logging
+logger = logging.getLogger(__name__)
+
+@api_view(['GET', 'PUT', 'DELETE', 'PATCH'])
+@permission_classes(DEBUG_PERMISSIONS)
+def video_segment_detail_view(request, segment_id):
+    """
+    Handles retrieval, update, and deletion of a single labeled video segment.
+
+    Supports:
+    - GET: Returns details of the specified video segment.
+    - PUT: Partially updates the segment with validated data.
+    - DELETE: Removes the segment from the database.
+
+    Returns appropriate HTTP status codes and error messages for invalid data or exceptions.
+    """
+    segment = get_object_or_404(LabelVideoSegment, id=segment_id)
+
+    if request.method == 'GET':
+        serializer = LabelVideoSegmentSerializer(segment)
+        return Response(serializer.data)
+
+    elif request.method in ('PUT', 'PATCH'):
+        logger.info(f"Updating video segment {segment_id} with data: {request.data}")
+
+        partial = request.method == 'PATCH'  # Allow partial updates with PATCH
+
+        with transaction.atomic():
+            serializer = LabelVideoSegmentSerializer(segment, data=request.data, partial=partial)
+            if serializer.is_valid():
+                try:
+                    segment = serializer.save()
+                    logger.info(f"Successfully updated video segment {segment_id}")
+                    return Response(LabelVideoSegmentSerializer(segment).data)
+                except Exception as e:
+                    logger.error(f"Error updating video segment {segment_id}: {str(e)}")
+                    return Response(
+                        {'error': f'Failed to update segment: {str(e)}'},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    )
+            else:
+                logger.warning(f"Invalid data for video segment update: {serializer.errors}")
+                return Response(
+                    {'error': 'Invalid data', 'details': serializer.errors},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+    elif request.method == 'DELETE':
+        logger.info(f"Deleting video segment {segment_id}")
+        try:
+            with transaction.atomic():
+                segment.delete()
+                logger.info(f"Successfully deleted video segment {segment_id}")
+                return Response(
+                    {'message': f'Segment {segment_id} deleted successfully'},
+                    status=status.HTTP_204_NO_CONTENT
+                )
+        except Exception as e:
+            logger.error(f"Error deleting video segment {segment_id}: {str(e)}")
+            return Response(
+                {'error': f'Failed to delete segment: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/label_video_segment/update_lvs_from_annotation.py

@@ -0,0 +1,46 @@
+from endoreg_db.models import LabelVideoSegment, InformationSource
+from endoreg_db.serializers import LabelVideoSegmentSerializer
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+import logging
+
+logger = logging.getLogger(__name__)
+
+@api_view(['PATCH'])
+@permission_classes([IsAuthenticated])
+def update_label_video_segment(request, annotation_id) -> Response:
+    """
+    Update an existing LabelVideoSegment, treating it as a manual annotation.
+    """
+    logger.info(f"Updating LabelVideoSegment {annotation_id} with data: {request.data}")
+
+    try:
+        segment = LabelVideoSegment.objects.get(id=annotation_id)
+    except LabelVideoSegment.DoesNotExist:
+        logger.error(f"LabelVideoSegment {annotation_id} not found")
+        return Response(
+            {'error': 'Segment not found'},
+            status=status.HTTP_404_NOT_FOUND
+        )
+
+    data = request.data
+    updated = False
+
+    if 'start_frame' in data:
+        segment.start_frame_number = data['start_frame']
+        updated = True
+    
+    if 'end_frame' in data:
+        segment.end_frame_number = data['end_frame']
+        updated = True
+
+    if updated:
+        # Ensure the source is correct for a manual annotation
+        manual_source, _ = InformationSource.objects.get_or_create(name="manual_annotation")
+        segment.source = manual_source
+        segment.save()
+
+    serializer = LabelVideoSegmentSerializer(segment)
+    return Response(serializer.data)