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

endoreg_db/views/report/report_list.py

@@ -1,112 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.report.report_list import ReportListSerializer
-
-from django.core.paginator import Paginator
-from django.db.models import Q
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-import logging
-logger = logging.getLogger(__name__)
-
-class ReportListView(APIView):
-    """
-    API-Endpunkt für paginierte Report-Listen mit optionaler Filterung
-    GET /api/reports/
-    """
-
-    def get(self, request):
-        try:
-            # Query-Parameter abrufen
-            page = int(request.GET.get('page', 1))
-            page_size = min(int(request.GET.get('page_size', 20)), 100)  # Max 100 pro Seite
-
-            # Filter-Parameter
-            file_type_filter = request.GET.get('file_type')
-            patient_name_filter = request.GET.get('patient_name')
-            casenumber_filter = request.GET.get('casenumber')
-            date_from = request.GET.get('date_from')
-            date_to = request.GET.get('date_to')
-
-            # Base QuerySet mit related data
-            queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
-
-            # Filter anwenden
-            if patient_name_filter:
-                queryset = queryset.filter(
-                    Q(sensitive_meta__patient_first_name__icontains=patient_name_filter) |
-                    Q(sensitive_meta__patient_last_name__icontains=patient_name_filter)
-                )
-
-            if casenumber_filter:
-                queryset = queryset.filter(
-                    sensitive_meta__case_number__icontains=casenumber_filter
-                )
-
-            if file_type_filter:
-                # Filter basierend auf Dateiendung
-                queryset = queryset.filter(file__endswith=f'.{file_type_filter}')
-
-            if date_from:
-                queryset = queryset.filter(created_at__gte=date_from)
-
-            if date_to:
-                queryset = queryset.filter(created_at__lte=date_to)
-
-            # Sortierung (neueste zuerst)
-            queryset = queryset.order_by('-created_at')
-
-            # Paginierung
-            paginator = Paginator(queryset, page_size)
-
-            if page > paginator.num_pages:
-                return Response({
-                    'count': paginator.count,
-                    'next': None,
-                    'previous': None,
-                    'results': []
-                })
-
-            page_obj = paginator.get_page(page)
-
-            # Serialisierung
-            serializer = ReportListSerializer(
-                page_obj.object_list,
-                many=True,
-                context={'request': request}
-            )
-
-            # URLs für Paginierung
-            next_url = None
-            previous_url = None
-
-            if page_obj.has_next():
-                next_url = request.build_absolute_uri(
-                    f"?page={page_obj.next_page_number()}&page_size={page_size}"
-                )
-
-            if page_obj.has_previous():
-                previous_url = request.build_absolute_uri(
-                    f"?page={page_obj.previous_page_number()}&page_size={page_size}"
-                )
-
-            return Response({
-                'count': paginator.count,
-                'next': next_url,
-                'previous': previous_url,
-                'results': serializer.data
-            })
-
-        except ValueError as e:
-            logger.error("Ungültige Parameter in ReportListView: %s", str(e))
-            return Response(
-                {"error": "Ungültige Parameter"},
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        except (AttributeError, TypeError, OSError) as e:
-            logger.error("Fehler in ReportListView: %s", str(e))
-            return Response(
-                {"error": "Fehler beim Laden der Reports"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/report/report_with_secure_url.py

@@ -1,28 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.report.report import ReportDataSerializer
-
-from django.shortcuts import get_object_or_404
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-import logging
-logger = logging.getLogger(__name__)
-
-class ReportWithSecureUrlView(APIView):
-    """
-    API-Endpunkt für Reports mit sicherer URL-Generierung
-    GET /api/reports/{report_id}/with-secure-url/
-    """
-
-    def get(self, request, report_id):
-        try:
-            report = get_object_or_404(RawPdfFile, id=report_id)
-            serializer = ReportDataSerializer(report, context={'request': request})
-            return Response(serializer.data)
-        except (ValueError, TypeError) as e:
-            logger.error("Fehler beim Laden des Reports %s: %s", report_id, str(e))
-            return Response(
-                {"error": "Report konnte nicht geladen werden"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/report/start_examination.py

@@ -1,7 +0,0 @@
-from django.shortcuts import render
-from django.contrib.admin.views.decorators import staff_member_required
-
-@staff_member_required
-def start_examination(request):
-    return render(request, 'admin/start_examination.html')
-

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
-            )

endoreg_db/views/video/timeline.py

@@ -1,46 +0,0 @@
-from django.shortcuts import render, get_object_or_404
-from ...models import VideoFile
-import json
-from ...serializers.video import VideoFileSerializer
-
-def video_timeline_view(request, video_id):
-    """
-    Fetches 'outside' label segments and passes their timestamps to the template.
-    """
-    video_entry = get_object_or_404(VideoFile, id=video_id)
-
-    # Get metadata (Assumes serializer method exists)
-    video_serializer = VideoFileSerializer(video_entry, context={'request': request})
-    label_segments = video_serializer.get_label_time_segments(video_entry)
-
-    segments = []
-    frame_markers = []  # Store frame timestamps
-    fps = 50  # Fixed FPS
-
-    # Ensure "outside" label exists
-    if "outside" in label_segments:
-        for segment in label_segments["outside"]["time_ranges"]:
-            segments.append({
-                "start_time": segment["start_time"],
-                "end_time": segment["end_time"]
-            })
-
-            # Extract frame timestamps for markers
-            for frame_num, _ in segment["frames"].items():
-                time_in_seconds = frame_num / fps
-                frame_markers.append(time_in_seconds)
-
-    # Set video duration correctly
-    video_duration = video_entry.duration if hasattr(video_entry, "duration") and video_entry.duration else 226  # Default to 226 seconds
-
-    print("Video ID:", video_id)
-    print("Segments:", segments)
-    print("Video Duration:", video_duration)
-
-    return render(request, "timeline.html", {
-        "video_id": video_id,
-        "video_url": video_serializer.get_video_url(video_entry),
-        "segments": json.dumps(segments),  # Send segment start/end times
-        "frame_markers": json.dumps(frame_markers),  # Send frame timestamps
-        "video_duration": video_duration,
-    })

endoreg_db/views/video/video_analyze.py

@@ -1,52 +0,0 @@
-from endoreg_db.models import VideoFile
-from endoreg_db.utils.permissions import EnvironmentAwarePermission
-
-from django.shortcuts import get_object_or_404
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-
-class VideoAnalyzeView(APIView):
-    """
-    POST /api/video-analyze/{id}/ - Analyze video for sensitive content
-    """
-    permission_classes = [EnvironmentAwarePermission]
-
-    def post(self, request, pk):
-        video = get_object_or_404(VideoFile, pk=pk)
-        use_minicpm = request.data.get('use_minicpm', True)
-        _detailed_analysis = request.data.get('detailed_analysis', True)
-
-        try:
-            # Import FrameCleaner here to avoid circular imports
-            from lx_anonymizer.frame_cleaner import FrameCleaner
-
-            cleaner = FrameCleaner(
-                video_path=video.file.path,
-                use_minicpm=use_minicpm
-            )
-
-            # Perform analysis
-            analysis_result = cleaner.analyze_video_sensitivity()
-
-            # Update video metadata
-            if hasattr(video, 'sensitive_frame_count'):
-                video.sensitive_frame_count = analysis_result.get('sensitive_frames', 0)
-            if hasattr(video, 'total_frames'):
-                video.total_frames = analysis_result.get('total_frames', 0)
-            if hasattr(video, 'sensitive_ratio'):
-                video.sensitive_ratio = analysis_result.get('sensitivity_ratio', 0.0)
-
-            try:
-                video.save()
-            except Exception as e:
-                print(f"Warning: Could not save video metadata: {e}")
-
-            return Response(analysis_result, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            return Response(
-                {"error": f"Analysis failed: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )