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

endoreg_db/views/patient_examination/DEPRECATED_video_backup.py

@@ -1,164 +0,0 @@
-# from rest_framework import viewsets, status
-# from rest_framework.response import Response
-# from django.shortcuts import get_object_or_404
-# from endoreg_db.models import Examination, VideoFile, Finding, FindingClassification
-# from django.db import transaction
-# from django.utils import timezone
-# import logging
-
-
-# class VideoExaminationViewSet(viewsets.ModelViewSet):
-#     """
-#     ViewSet for Video Examination CRUD operations
-#     Handles POST and PATCH for video examinations at timestamps
-#     """
-#     def get_queryset(self):
-#         return []
-
-#     def create(self, request, *args, **kwargs):
-
-#         logger = logging.getLogger(__name__)
-#         try:
-#             data = request.data
-#             required_fields = ['videoId', 'timestamp', 'examinationTypeId', 'findingId']
-#             for field in required_fields:
-#                 if field not in data or data[field] is None:
-#                     return Response({'error': f'Missing or null required field: {field}'}, status=status.HTTP_400_BAD_REQUEST)
-#             try:
-#                 video_id = int(data['videoId'])
-#                 timestamp = float(data['timestamp'])
-#                 examination_type_id = int(data['examinationTypeId'])
-#                 finding_id = int(data['findingId'])
-#             except (ValueError, TypeError) as e:
-#                 return Response({'error': f'Invalid data type in request: {str(e)}'}, status=status.HTTP_400_BAD_REQUEST)
-#             if timestamp < 0:
-#                 return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
-#             with transaction.atomic():
-#                 try:
-#                     video = VideoFile.objects.get(id=video_id)
-#                 except VideoFile.DoesNotExist:
-#                     return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 try:
-#                     examination = Examination.objects.get(id=examination_type_id)
-#                 except Examination.DoesNotExist:
-#                     return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 try:
-#                     finding = Finding.objects.get(id=finding_id)
-#                 except Finding.DoesNotExist:
-#                     return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if data.get('locationClassificationId'):
-#                     try:
-#                         FindingClassification.objects.get(id=data['locationClassificationId'], classification_types__name__iexact="location")
-#                     except FindingClassification.DoesNotExist:
-#                         return Response({'error': 'Location classification not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if data.get('morphologyClassificationId'):
-#                     try:
-#                         FindingClassification.objects.get(id=data['morphologyClassificationId'], classification_types__name__iexact="morphology")
-#                     except FindingClassification.DoesNotExist:
-#                         return Response({'error': 'Morphology classification not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 examination_data = {
-#                     'id': f"exam_{video.id}_{timestamp}_{examination.id}",
-#                     'video_id': video_id,
-#                     'timestamp': timestamp,
-#                     'examination_type': examination.name,
-#                     'finding': finding.name,
-#                     'location_classification': data.get('locationClassificationId'),
-#                     'location_choice': data.get('locationChoiceId'),
-#                     'morphology_classification': data.get('morphologyClassificationId'),
-#                     'morphology_choice': data.get('morphologyChoiceId'),
-#                     'interventions': data.get('interventionIds', []),
-#                     'notes': data.get('notes', ''),
-#                     'created_at': timezone.now().isoformat()
-#                 }
-#                 logger.info(f"Created video examination for video {video_id} at timestamp {timestamp}")
-#                 return Response(examination_data, status=status.HTTP_201_CREATED)
-#         except Exception as e:
-#             logger.error(f"Unexpected error creating examination: {str(e)}")
-#             return Response({'error': 'Internal server error while creating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-#     def update(self, request, *args, **kwargs):
-#         logger = logging.getLogger(__name__)
-#         try:
-#             examination_id = kwargs.get('pk')
-#             if not examination_id:
-#                 return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
-#             data = request.data
-#             if 'videoId' in data:
-#                 try:
-#                     data['videoId'] = int(data['videoId'])
-#                 except (ValueError, TypeError):
-#                     return Response({'error': 'Invalid videoId format'}, status=status.HTTP_400_BAD_REQUEST)
-#             if 'timestamp' in data:
-#                 try:
-#                     timestamp = float(data['timestamp'])
-#                     if timestamp < 0:
-#                         return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
-#                     data['timestamp'] = timestamp
-#                 except (ValueError, TypeError):
-#                     return Response({'error': 'Invalid timestamp format'}, status=status.HTTP_400_BAD_REQUEST)
-#             with transaction.atomic():
-#                 if 'videoId' in data:
-#                     try:
-#                         VideoFile.objects.get(id=data['videoId'])
-#                     except VideoFile.DoesNotExist:
-#                         return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if 'examinationTypeId' in data:
-#                     try:
-#                         examination_type_id = int(data['examinationTypeId'])
-#                         Examination.objects.get(id=examination_type_id)
-#                     except (ValueError, TypeError):
-#                         return Response({'error': 'Invalid examination type ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#                     except Examination.DoesNotExist:
-#                         return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if 'findingId' in data:
-#                     try:
-#                         finding_id = int(data['findingId'])
-#                         Finding.objects.get(id=finding_id)
-#                     except (ValueError, TypeError):
-#                         return Response({'error': 'Invalid finding ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#                     except Finding.DoesNotExist:
-#                         return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 examination_data = {
-#                     'id': examination_id,
-#                     'video_id': data.get('videoId'),
-#                     'timestamp': data.get('timestamp'),
-#                     'examination_type': data.get('examinationTypeId'),
-#                     'finding': data.get('findingId'),
-#                     'location_classification': data.get('locationClassificationId'),
-#                     'location_choice': data.get('locationChoiceId'),
-#                     'morphology_classification': data.get('morphologyClassificationId'),
-#                     'morphology_choice': data.get('morphologyChoiceId'),
-#                     'interventions': data.get('interventionIds', []),
-#                     'notes': data.get('notes', ''),
-#                     'updated_at': '2024-01-01T00:00:00Z'
-#                 }
-#                 logger.info(f"Updated video examination {examination_id}")
-#                 return Response(examination_data, status=status.HTTP_200_OK)
-#         except Exception as e:
-#             logger.error(f"Unexpected error updating examination {examination_id}: {str(e)}")
-#             return Response({'error': 'Internal server error while updating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-#     def destroy(self, request, *args, **kwargs):
-#         logger = logging.getLogger(__name__)
-#         try:
-#             examination_id = kwargs.get('pk')
-#             if not examination_id:
-#                 return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
-#             try:
-#                 if not str(examination_id).strip():
-#                     return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#             except (ValueError, TypeError):
-#                 return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#             with transaction.atomic():
-#                 logger.info(f"Deleted video examination {examination_id}")
-#                 return Response({'message': f'Examination {examination_id} deleted successfully'}, status=status.HTTP_204_NO_CONTENT)
-#         except Exception as e:
-#             logger.error(f"Unexpected error deleting examination {examination_id}: {str(e)}")
-#             return Response({'error': 'Internal server error while deleting examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-# from rest_framework.decorators import api_view
-# @api_view(["GET"])
-# def get_examinations_for_video(request, video_id):
-#     _video = get_object_or_404(VideoFile, id=video_id)
-#     #TODO no functionality implemented yet
-#     return Response([])

endoreg_db/views/patient_finding_location/__init__.py

@@ -1,5 +0,0 @@
-from .pfl_create import create_patient_finding_location
-
-__all__ = [
-    "create_patient_finding_location",
-]

endoreg_db/views/patient_finding_location/pfl_create.py

@@ -1,70 +0,0 @@
-from endoreg_db.serializers.patient_finding.patient_finding import PatientFindingSerializer
-from rest_framework.viewsets import ModelViewSet
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-from rest_framework import status
-from endoreg_db.models.medical.patient.patient_finding import PatientFinding
-from endoreg_db.models.medical.patient.patient_finding_location import PatientFindingLocation
-from endoreg_db.models.medical.patient.patient_finding_morphology import PatientFindingMorphology
-from endoreg_db.models import ( FindingLocationClassificationChoice, FindingMorphologyClassificationChoice )
-from rest_framework import serializers
-from utils.permissions import EnvironmentAwarePermission
-
-class PatientFindingViewSet(ModelViewSet):
-    queryset = PatientFinding.objects.all()
-    serializer_class = PatientFindingSerializer
-
-@api_view(['POST'])
-@permission_classes([EnvironmentAwarePermission])
-def create_patient_finding_location(request):
-    """
-    Create a patient finding location relationship.
-    Expected payload: {
-        "patient_finding_id": 1,
-        "location_classification_choice_id": 2
-    }
-    """
-    try:
-        patient_finding_id = request.data.get('patient_finding_id')
-        choice_id = request.data.get('location_classification_choice_id')
-        
-        if not patient_finding_id or not choice_id:
-            return Response(
-                {'detail': 'patient_finding_id and location_classification_choice_id are required'}, 
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        
-        # Get the objects
-        try:
-            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
-        except PatientFinding.DoesNotExist:
-            return Response(
-                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        try:
-            choice = FindingLocationClassificationChoice.objects.get(id=choice_id)
-        except FindingLocationClassificationChoice.DoesNotExist:
-            return Response(
-                {'detail': f'LocationClassificationChoice with id {choice_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        # Create the relationship
-        patient_finding_location = PatientFindingLocation.objects.create(
-            patient_finding=patient_finding,
-            location_classification_choice=choice
-        )
-        
-        return Response({
-            'id': patient_finding_location.id,
-            'patient_finding_id': patient_finding.id,
-            'location_classification_choice_id': choice.id
-        }, status=status.HTTP_201_CREATED)
-        
-    except Exception as e:
-        return Response(
-            {'detail': f'Error creating patient finding location: {str(e)}'}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )

endoreg_db/views/patient_finding_morphology/__init__.py

@@ -1,5 +0,0 @@
-from .pfm_create import create_patient_finding_morphology
-
-__all__ = [
-    "create_patient_finding_morphology",
-]

endoreg_db/views/patient_finding_morphology/pfm_create.py

@@ -1,70 +0,0 @@
-from endoreg_db.serializers.patient_finding.patient_finding import PatientFindingSerializer
-from rest_framework.viewsets import ModelViewSet
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-from rest_framework import status
-from endoreg_db.models.medical.patient.patient_finding import PatientFinding
-from endoreg_db.models.medical.patient.patient_finding_location import PatientFindingLocation
-from endoreg_db.models.medical.patient.patient_finding_morphology import PatientFindingMorphology
-from endoreg_db.models import ( FindingLocationClassificationChoice, FindingMorphologyClassificationChoice)
-from rest_framework import serializers
-from utils.permissions import EnvironmentAwarePermission
-
-class PatientFindingViewSet(ModelViewSet):
-    queryset = PatientFinding.objects.all()
-    serializer_class = PatientFindingSerializer
-
-@api_view(['POST'])
-@permission_classes([EnvironmentAwarePermission])
-def create_patient_finding_morphology(request):
-    """
-    Create a patient finding morphology relationship.
-    Expected payload: {
-        "patient_finding_id": 1,
-        "morphology_classification_choice_id": 2
-    }
-    """
-    try:
-        patient_finding_id = request.data.get('patient_finding_id')
-        choice_id = request.data.get('morphology_classification_choice_id')
-        
-        if not patient_finding_id or not choice_id:
-            return Response(
-                {'detail': 'patient_finding_id and morphology_classification_choice_id are required'}, 
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        
-        # Get the objects
-        try:
-            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
-        except PatientFinding.DoesNotExist:
-            return Response(
-                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        try:
-            choice = FindingMorphologyClassificationChoice.objects.get(id=choice_id)
-        except FindingMorphologyClassificationChoice.DoesNotExist:
-            return Response(
-                {'detail': f'MorphologyClassificationChoice with id {choice_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        # Create the relationship
-        patient_finding_morphology = PatientFindingMorphology.objects.create(
-            patient_finding=patient_finding,
-            morphology_classification_choice=choice
-        )
-        
-        return Response({
-            'id': patient_finding_morphology.id,
-            'patient_finding_id': patient_finding.id,
-            'morphology_classification_choice_id': choice.id
-        }, status=status.HTTP_201_CREATED)
-        
-    except Exception as e:
-        return Response(
-            {'detail': f'Error creating patient finding morphology: {str(e)}'}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )

endoreg_db/views/pdf/__init__.py

@@ -1,8 +0,0 @@
-from .reimport import PdfReimportView
-from .pdf_stream import PdfStreamView
-
-
-__all__ = [
-    "PdfReimportView",
-    "PdfStreamView",
-]

endoreg_db/views/video/segmentation.py

@@ -1,274 +0,0 @@
-from pathlib import Path
-import os
-import mimetypes
-from django.http import FileResponse, Http404
-from rest_framework import viewsets, decorators, status
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.decorators import api_view, permission_classes
-
-from ...serializers.label_video_segment.label_video_segment_update import LabelSegmentUpdateSerializer
-
-from ...serializers.label.label import LabelSerializer
-
-from ...serializers.video.video_file_list import VideoFileListSerializer
-from ...models import VideoFile, Label, LabelVideoSegment
-from ...serializers.video.segmentation import VideoFileSerializer
-from ...utils.permissions import DEBUG_PERMISSIONS
-
-# Phase 3.2: Import video streaming functionality from dedicated module
-# Phase 3.2: VideoStreamView and _stream_video_file moved to video_stream.py
-from .video_stream import _stream_video_file
-
-
-class VideoViewSet(viewsets.ReadOnlyModelViewSet):
-    """
-    /api/videos/          → list of metadata   (JSON)
-    /api/videos/<id>/     → single metadata   (JSON)
-    /videos/<id>/stream/  → raw file          (FileResponse, range-aware)
-    """
-    queryset = VideoFile.objects.all()
-    serializer_class = VideoFileListSerializer   # for the list view
-    permission_classes = DEBUG_PERMISSIONS
-
-    def list(self, request, *args, **kwargs):
-        """
-        Returns a JSON response with all video metadata and available labels.
-        
-        The response includes serialized lists of all videos and labels in the database.
-        """
-        videos = VideoFile.objects.all()
-        labels = Label.objects.all()
-
-        video_serializer = VideoFileListSerializer(videos, many=True)
-        label_serializer = LabelSerializer(labels, many=True)
-
-        return Response({
-            "videos": video_serializer.data, 
-            "labels": label_serializer.data  
-        }, status=status.HTTP_200_OK)
-
-    # ---------- JSON ---------- #
-    def retrieve(self, request, *args, **kwargs):
-        """
-        Retrieves detailed metadata for a specific video as a JSON response.
-        
-        Returns:
-            JSON representation of the requested video's metadata.
-        """
-        obj = self.get_object()
-        return Response(VideoFileSerializer(obj, context={'request': request}).data)
-
-    # ---------- BYTES ---------- #
-    @decorators.action(methods=['get'], detail=True,
-                       url_path='stream', renderer_classes=[])  # <- disable HTML & JSON renderers
-    def stream(self, request, pk=None):
-        """
-        Streams the raw video file for the specified video with HTTP range and CORS support.
-        """
-        try:
-            vf: VideoFile = self.get_object()
-            frontend_origin = os.environ.get('FRONTEND_ORIGIN', 'http://localhost:8000')
-            return _stream_video_file(vf, frontend_origin)
-        except Http404:
-            # Re-raise Http404 exceptions as they should bubble up
-            raise
-        except Exception as e:
-            # Log unexpected errors and convert to Http404
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Unexpected error in video stream for pk={pk}: {str(e)}")
-            raise Http404("Video streaming failed")
-
-
-# Phase 3.2: VideoStreamView moved to video_stream.py - imported at top
-# Old implementation removed to avoid duplication
-
-
-class VideoLabelView(APIView):
-    """
-    API to fetch time segments (start & end times in seconds) for a specific label.
-    """
-
-    def get(self, request, video_id, label_name):
-        """
-        Retrieves time segments and frame-level predictions for a specific label on a video.
-        
-        Returns a JSON response containing the label name, a list of time segments (with frame ranges and timestamps), and frame-wise prediction data. Responds with HTTP 404 if the video or label does not exist, or HTTP 200 with empty data if no segments are found. Returns HTTP 500 with an error message for unexpected exceptions.
-        """
-        try:
-            # Verify video exists
-            video_entry = VideoFile.objects.get(id=video_id)
-            
-            # Try to get label by name
-            try:
-                label = Label.objects.get(name=label_name)
-            except Label.DoesNotExist:
-                return Response({
-                    "error": f"Label '{label_name}' not found in database"
-                }, status=status.HTTP_404_NOT_FOUND)
-            
-            # Get label video segments directly from the database
-            label_segments = LabelVideoSegment.objects.filter(
-                video_file=video_entry,
-                label=label
-            ).order_by('start_frame_number')
-            
-            if not label_segments.exists():
-                # No segments found for this label, return empty data
-                return Response({
-                    "label": label_name,
-                    "time_segments": [],
-                    "frame_predictions": {}
-                }, status=status.HTTP_200_OK)
-            
-            # Convert segments to time-based format
-            # Fix: Ensure fps is a number, not a string
-            fps_raw = getattr(video_entry, 'fps', None) or (video_entry.get_fps() if hasattr(video_entry, 'get_fps') else 25)
-            
-            # Convert fps to float if it's a string
-            try:
-                if isinstance(fps_raw, str):
-                    fps = float(fps_raw)
-                elif isinstance(fps_raw, (int, float)):
-                    fps = float(fps_raw)
-                else:
-                    fps = 25.0  # Default fallback
-            except (ValueError, TypeError):
-                fps = 25.0  # Default fallback if conversion fails
-            
-            # Ensure fps is positive
-            if fps <= 0:
-                fps = 25.0
-            
-            time_segments = []
-            frame_predictions = {}
-            
-            for segment in label_segments:
-                # Now fps is guaranteed to be a float
-                start_time = segment.start_frame_number / fps
-                end_time = segment.end_frame_number / fps
-                
-                segment_data = {
-                    "segment_id": segment.id,
-                    "segment_start": segment.start_frame_number,
-                    "segment_end": segment.end_frame_number,
-                    "start_time": round(start_time, 2),
-                    "end_time": round(end_time, 2),
-                    "frames": {}
-                }
-                
-                # Add frame-wise data if available
-                for frame_num in range(segment.start_frame_number, segment.end_frame_number + 1):
-                    frame_filename = f"frame_{str(frame_num).zfill(7)}.jpg"
-                    frame_predictions[frame_num] = {
-                        "frame_number": frame_num,
-                        "label": label_name,
-                        "confidence": 1.0  # Default confidence
-                    }
-                    
-                    # Fix: Safely construct frame_file_path to avoid string/string division errors
-                    frame_file_path = ""
-                    if hasattr(video_entry, 'frame_dir') and video_entry.frame_dir:
-                        try:
-                            # Ensure frame_dir is converted to Path properly
-                            if isinstance(video_entry.frame_dir, str):
-                                frame_dir = Path(video_entry.frame_dir)
-                            elif isinstance(video_entry.frame_dir, Path):
-                                frame_dir = video_entry.frame_dir
-                            else:
-                                # Try to convert to string first, then to Path
-                                frame_dir = Path(str(video_entry.frame_dir))
-                            
-                            frame_file_path = str(frame_dir / frame_filename)
-                        except (TypeError, ValueError) as e:
-                            # Log warning but don't fail the request
-                            import logging
-                            logger = logging.getLogger(__name__)
-                            logger.warning(f"Could not construct frame path for frame {frame_num}: {e}")
-                            frame_file_path = ""
-                    
-                    segment_data["frames"][frame_num] = {
-                        "frame_filename": frame_filename,
-                        "frame_file_path": frame_file_path,
-                        "predictions": frame_predictions[frame_num]
-                    }
-                
-                time_segments.append(segment_data)
-            
-            return Response({
-                "label": label_name,
-                "time_segments": time_segments,
-                "frame_predictions": frame_predictions
-            }, status=status.HTTP_200_OK)
-
-        except VideoFile.DoesNotExist:
-            return Response({
-                "error": "Video not found"
-            }, status=status.HTTP_404_NOT_FOUND)
-
-        except Exception as e:
-            # Log the error for debugging
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error in VideoLabelView for video {video_id}, label {label_name}: {str(e)}")
-            
-            return Response({
-                "error": f"Internal error: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-class UpdateLabelSegmentsView(APIView):
-    """
-    API to update or create label segments for a video.
-    """
-
-    def put(self, request, video_id, label_id):
-        """
-        Updates segments for a given video & label.
-        """
-
-        # Prepare data for serializer by combining URL params with request data
-        serializer_data = {
-            "video_id": video_id,    # From URL parameter
-            "label_id": label_id,    # From URL parameter  
-            "segments": request.data.get("segments", [])  # From request body
-        }
-
-        # Validate input data
-        serializer = LabelSegmentUpdateSerializer(data=serializer_data)
-
-        if not serializer.is_valid():
-            return Response({"error": "Invalid segment data", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
-
-        # Process and save segment updates
-        try:
-            result = serializer.save()
-            return Response({
-                "message": "Segments updated successfully.",
-                "updated_segments": result["updated_segments"],
-                "new_segments": result["new_segments"],
-                "deleted_segments": result["deleted_segments"]
-            }, status=status.HTTP_200_OK)
-        except Exception as e:
-            return Response({
-                "error": f"Failed to update segments: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-           
-@api_view(['GET'])
-@permission_classes(DEBUG_PERMISSIONS)
-def rerun_segmentation(request, video_id):
-    """
-    Rerun segmentation for a specific video.
-    """
-    try:
-        video_file = VideoFile.objects.get(id=video_id)
-        video_file.pipe_1()
-        video_file.test_after_pipe_1()
-        return Response({'status': 'success', 'message': 'Segmentation rerun successfully'})
-    except VideoFile.DoesNotExist:
-        return Response({'status': 'error', 'message': 'Video file not found'}, status=status.HTTP_404_NOT_FOUND)
-    except Exception as e:
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.error(f"Error in rerun_segmentation: {e}")
-        return Response({'status': 'error', 'message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/video/task_status.py

@@ -1,49 +0,0 @@
-from endoreg_db.utils.permissions import EnvironmentAwarePermission
-
-
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-from celery import current_app
-
-class TaskStatusView(APIView):
-    """
-    GET /api/task-status/{task_id}/ - Get status of async task
-    """
-    #TODO refactor, this should be specified as video task status or moved to a more appropriate module
-    permission_classes = [EnvironmentAwarePermission]
-
-    def get(self, request, task_id):
-        try:
-            task_result = current_app.AsyncResult(task_id)
-
-            response_data = {
-                'task_id': task_id,
-                'status': task_result.status,
-                'progress': 0,
-                'message': 'Task pending...'
-            }
-
-            if task_result.status == 'PENDING':
-                response_data['message'] = 'Task is waiting to be processed'
-            elif task_result.status == 'PROGRESS':
-                response_data.update(task_result.result or {})
-            elif task_result.status == 'SUCCESS':
-                response_data.update({
-                    'progress': 100,
-                    'message': 'Task completed successfully',
-                    'result': task_result.result
-                })
-            elif task_result.status == 'FAILURE':
-                response_data.update({
-                    'message': str(task_result.result),
-                    'error': True
-                })
-
-            return Response(response_data, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            return Response(
-                {"error": f"Failed to get task status: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )