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

endoreg_db/views/label_video_segment/validate.py

@@ -1,226 +0,0 @@
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-from django.db import transaction
-from endoreg_db.models import LabelVideoSegment, VideoFile
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-
-
-class LabelVideoSegmentValidateView(APIView):
-    """
-    POST /api/label-video-segment/<int:segment_id>/validate/
-    
-    Validiert ein einzelnes LabelVideoSegment und markiert es als verifiziert.
-    Dies wird verwendet, um vom Benutzer überprüfte Segment-Annotationen zu bestätigen.
-    
-    Body (optional):
-    {
-      "is_validated": true,  // optional, default true
-      "notes": "..."         // optional, Validierungsnotizen
-    }
-    """
-    permission_classes = DEBUG_PERMISSIONS
-
-    @transaction.atomic
-    def post(self, request, segment_id: int):
-        try:
-            # Segment abrufen
-            segment = LabelVideoSegment.objects.select_related('state', 'video_file', 'label').get(pk=segment_id)
-            
-            # Validierungsstatus aus Request (default: True)
-            is_validated = request.data.get('is_validated', True)
-            notes = request.data.get('notes', '')
-            
-            # State-Objekt abrufen oder erstellen
-            if not hasattr(segment, 'state') or segment.state is None:
-                # State muss existieren - wenn nicht, könnte ein Model-Problem vorliegen
-                return Response({
-                    "error": "Segment has no state object. Cannot validate."
-                }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-            
-            # State aktualisieren
-            segment.state.is_validated = is_validated
-            if notes:
-                # Falls ein notes-Feld existiert
-                if hasattr(segment.state, 'validation_notes'):
-                    segment.state.validation_notes = notes
-            segment.state.save()
-            
-            return Response({
-                "message": f"Segment {segment_id} validation status updated.",
-                "segment_id": segment_id,
-                "is_validated": is_validated,
-                "label": segment.label.name if segment.label else None,
-                "video_id": segment.video_file.id if segment.video_file else None,
-                "start_frame": segment.start_frame_number,
-                "end_frame": segment.end_frame_number
-            }, status=status.HTTP_200_OK)
-            
-        except LabelVideoSegment.DoesNotExist:
-            return Response({
-                "error": f"Segment {segment_id} not found."
-            }, status=status.HTTP_404_NOT_FOUND)
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error validating segment {segment_id}: {e}")
-            return Response({
-                "error": f"Validation failed: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class BulkSegmentValidateView(APIView):
-    """
-    POST /api/label-video-segments/validate-bulk/
-    
-    Validiert mehrere LabelVideoSegments gleichzeitig.
-    Nützlich für Batch-Validierung nach Review.
-    
-    Body:
-    {
-      "segment_ids": [1, 2, 3, ...],
-      "is_validated": true,  // optional, default true
-      "notes": "..."         // optional, gilt für alle Segmente
-    }
-    """
-    permission_classes = DEBUG_PERMISSIONS
-
-    @transaction.atomic
-    def post(self, request):
-        segment_ids = request.data.get('segment_ids', [])
-        is_validated = request.data.get('is_validated', True)
-        notes = request.data.get('notes', '')
-        
-        if not segment_ids:
-            return Response({
-                "error": "segment_ids is required"
-            }, status=status.HTTP_400_BAD_REQUEST)
-        
-        try:
-            # Alle Segmente abrufen
-            segments = LabelVideoSegment.objects.filter(pk__in=segment_ids).select_related('state')
-            
-            if not segments.exists():
-                return Response({
-                    "error": "No segments found with provided IDs"
-                }, status=status.HTTP_404_NOT_FOUND)
-            
-            updated_count = 0
-            failed_ids = []
-            
-            for segment in segments:
-                try:
-                    if segment.state:
-                        segment.state.is_validated = is_validated
-                        if notes and hasattr(segment.state, 'validation_notes'):
-                            segment.state.validation_notes = notes
-                        segment.state.save()
-                        updated_count += 1
-                    else:
-                        failed_ids.append(segment.id)
-                except Exception as e:
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.error(f"Error validating segment {segment.id}: {e}")
-                    failed_ids.append(segment.id)
-            
-            response_data = {
-                "message": f"Bulk validation completed. {updated_count} segments updated.",
-                "updated_count": updated_count,
-                "requested_count": len(segment_ids),
-                "is_validated": is_validated
-            }
-            
-            if failed_ids:
-                response_data["failed_ids"] = failed_ids
-                response_data["warning"] = f"{len(failed_ids)} segments could not be validated"
-            
-            return Response(response_data, status=status.HTTP_200_OK)
-            
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error in bulk validation: {e}")
-            return Response({
-                "error": f"Bulk validation failed: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class VideoSegmentValidationCompleteView(APIView):
-    """
-    POST /api/videos/<int:video_id>/segments/validate-complete/
-    
-    Markiert alle Segmente eines Videos als validiert.
-    Nützlich nach vollständiger Review eines Videos.
-    
-    Body (optional):
-    {
-      "label_name": "...",   // optional, nur Segmente mit diesem Label validieren
-      "notes": "..."         // optional
-    }
-    """
-    permission_classes = DEBUG_PERMISSIONS
-
-    @transaction.atomic
-    def post(self, request, video_id: int):
-        try:
-            # Video abrufen
-            video = VideoFile.objects.get(pk=video_id)
-            
-            label_name = request.data.get('label_name')
-            notes = request.data.get('notes', '')
-            
-            # Segmente filtern
-            segments_query = LabelVideoSegment.objects.filter(video_file=video).select_related('state', 'label')
-            
-            if label_name:
-                segments_query = segments_query.filter(label__name=label_name)
-            
-            segments = segments_query.all()
-            
-            if not segments.exists():
-                return Response({
-                    "message": "No segments found to validate",
-                    "video_id": video_id,
-                    "updated_count": 0
-                }, status=status.HTTP_200_OK)
-            
-            updated_count = 0
-            failed_count = 0
-            
-            for segment in segments:
-                try:
-                    if segment.state:
-                        segment.state.is_validated = True
-                        if notes and hasattr(segment.state, 'validation_notes'):
-                            segment.state.validation_notes = notes
-                        segment.state.save()
-                        updated_count += 1
-                    else:
-                        failed_count += 1
-                except Exception as e:
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.error(f"Error validating segment {segment.id}: {e}")
-                    failed_count += 1
-            
-            return Response({
-                "message": f"Video segment validation completed for video {video_id}",
-                "video_id": video_id,
-                "total_segments": len(segments),
-                "updated_count": updated_count,
-                "failed_count": failed_count,
-                "label_filter": label_name
-            }, status=status.HTTP_200_OK)
-            
-        except VideoFile.DoesNotExist:
-            return Response({
-                "error": f"Video {video_id} not found"
-            }, status=status.HTTP_404_NOT_FOUND)
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error completing validation for video {video_id}: {e}")
-            return Response({
-                "error": f"Validation completion failed: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/media/segments.py

@@ -1,71 +0,0 @@
-"""
-Modern Media Framework - Video Segment API Views
-October 14, 2025 - Migration to unified /api/media/videos/<pk>/segments/ pattern
-
-This module provides modern framework views for video segment management,
-wrapping legacy segment views with pk-based parameter handling.
-"""
-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(['GET'])
-@permission_classes([EnvironmentAwarePermission])
-def video_segments_by_pk(request, pk):
-    """
-    Modern media framework endpoint for retrieving video segments.
-    
-    GET /api/media/videos/<int:pk>/segments/?label=<label_name>
-    
-    Returns all segments for a video, optionally filtered by label name.
-    This is the modern replacement for /api/video/<id>/segments/
-    
-    Query Parameters:
-        label (str, optional): Filter segments by label name (e.g., 'outside')
-    
-    Returns:
-        200: List of video segments
-        404: Video not found
-    """
-    try:
-        video = VideoFile.objects.get(id=pk)
-    except VideoFile.DoesNotExist:
-        logger.warning(f"Video with pk {pk} not found")
-        return Response(
-            {'error': f'Video with id {pk} not found'},
-            status=status.HTTP_404_NOT_FOUND
-        )
-    
-    # Start with all segments for this video
-    queryset = LabelVideoSegment.objects.filter(video_file=video)
-    
-    # Optional filtering by label name
-    label_name = request.GET.get('label')
-    if label_name:
-        try:
-            label = Label.objects.get(name=label_name)
-            queryset = queryset.filter(label=label)
-            logger.info(f"Filtering segments for video {pk} by label '{label_name}'")
-        except Label.DoesNotExist:
-            logger.warning(f"Label '{label_name}' not found, returning empty result")
-            return Response(
-                {'error': f"Label '{label_name}' not found"},
-                status=status.HTTP_404_NOT_FOUND
-            )
-    
-    # Order by start time for consistent results
-    segments = queryset.order_by('start_frame_number')
-    serializer = LabelVideoSegmentSerializer(segments, many=True)
-    
-    logger.info(f"Returning {len(segments)} segments for video {pk}")
-    return Response(serializer.data)

endoreg_db/views/meta/available_files_list.py

@@ -1,146 +0,0 @@
-from endoreg_db.models import RawPdfFile, VideoFile
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-import logging
-
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-logger = logging.getLogger(__name__)
-
-class AvailableFilesListView(APIView):
-    """
-    API endpoint to list available PDFs and videos for anonymization selection.
-
-    GET: Returns lists of available PDF and video files with their metadata
-    """
-
-    permission_classes = DEBUG_PERMISSIONS
-
-    def _validate_pagination_params(self, request):
-        """Validates and returns pagination parameters, raising ValueError on failure."""
-        try:
-            limit = int(request.query_params.get('limit', 50))
-            offset = int(request.query_params.get('offset', 0))
-        except (ValueError, TypeError):
-            raise ValueError("Invalid 'limit' or 'offset' parameter. Must be integers.")
-
-        if limit < 0 or offset < 0:
-            raise ValueError("'limit' and 'offset' must be non-negative.")
-        
-        if limit > 100:
-            logger.warning(f"Client requested limit of {limit}, capping at 100.")
-            limit = 100
-
-        return limit, offset
-
-    def get(self, request):
-        """
-        List available PDF and video files for anonymization selection.
-
-        Query Parameters:
-        - type: Filter by file type ('pdf' or 'video')
-        - status: Filter by anonymization status
-        - limit: Number of results to return (default 50, max 100)
-        - offset: Offset for pagination (default 0)
-
-        Returns:
-        {
-            "pdfs": [...],
-            "videos": [...],
-            "total_pdfs": N,
-            "total_videos": N
-        }
-        """
-        try:
-            limit, offset = self._validate_pagination_params(request)
-            file_type = request.query_params.get('type', 'all').lower()
-        except ValueError as e:
-            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
-
-        try:
-            response_data = {}
-
-            # Get PDFs if requested
-            if file_type in ['all', 'pdf']:
-                pdf_queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
-                total_pdfs = pdf_queryset.count()
-                paginated_pdfs = pdf_queryset[offset:offset + limit]
-
-                pdf_list = []
-                for pdf in paginated_pdfs:
-                    # Safely handle missing file attribute
-                    file_name = 'Unknown'
-                    file_path = None
-                    if hasattr(pdf, 'file') and pdf.file:
-                        file_name = pdf.file.name.split('/')[-1]
-                        file_path = pdf.file.name
-                    pdf_data = {
-                        'id': pdf.id,
-                        'filename': file_name,
-                        'file_path': file_path,
-                        'sensitive_meta_id': pdf.sensitive_meta_id,
-                        'anonymized_text': getattr(pdf, 'anonymized_text', None),
-                        'created_at': pdf.date_created if hasattr(pdf, 'created_at') else None,
-                        'patient_info': None
-                    }
-
-                    # Add patient info if available
-                    if pdf.sensitive_meta:
-                        pdf_data['patient_info'] = {
-                            'patient_first_name': pdf.sensitive_meta.patient_first_name,
-                            'patient_last_name': pdf.sensitive_meta.patient_last_name,
-                            'patient_dob': pdf.sensitive_meta.patient_dob,
-                            'examination_date': pdf.sensitive_meta.examination_date,
-                            'center_name': pdf.sensitive_meta.center.name if pdf.sensitive_meta.center else None
-                        }
-
-                    pdf_list.append(pdf_data)
-
-                response_data['pdfs'] = pdf_list
-                response_data['total_pdfs'] = total_pdfs
-
-            # Get Videos if requested
-            if file_type in ['all', 'video']:
-                video_queryset = VideoFile.objects.select_related('sensitive_meta').all()
-                total_videos = video_queryset.count()
-                paginated_videos = video_queryset[offset:offset + limit]
-
-                video_list = []
-                for video in paginated_videos:
-                    # Safely handle missing raw_file attribute
-                    file_name = 'Unknown'
-                    file_path = None
-                    if hasattr(video, 'raw_file') and video.raw_file:
-                        file_name = video.raw_file.name.split('/')[-1]
-                        file_path = video.raw_file.name
-                    video_data = {
-                        'id': video.id,
-                        'filename': file_name,
-                        'file_path': file_path,
-                        'sensitive_meta_id': video.sensitive_meta_id,
-                        'patient_info': None
-                    }
-
-                    # Add patient info if available
-                    if video.sensitive_meta:
-                        video_data['patient_info'] = {
-                            'patient_first_name': video.sensitive_meta.patient_first_name,
-                            'patient_last_name': video.sensitive_meta.patient_last_name,
-                            'patient_dob': video.sensitive_meta.patient_dob,
-                            'examination_date': video.sensitive_meta.examination_date,
-                            'center_name': video.sensitive_meta.center.name if video.sensitive_meta.center else None
-                        }
-
-                    video_list.append(video_data)
-
-                response_data['videos'] = video_list
-                response_data['total_videos'] = total_videos
-
-            return Response(response_data)
-        except Exception as e:
-            logger.error(f"Error listing available files: {e}", exc_info=True)
-            return Response(
-                {"error": "An unexpected error occurred while fetching files."},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/meta/report_meta.py

@@ -1,53 +0,0 @@
-from endoreg_db.models import RawPdfFile
-
-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
-from pathlib import Path
-import logging
-
-logger = logging.getLogger(__name__)
-
-class ReportFileMetadataView(APIView):
-    """
-    API-Endpunkt für Report-Datei-Metadaten
-    GET /api/reports/{report_id}/file-metadata/
-    """
-
-    def get(self, _request, report_id):
-        try:
-            report = get_object_or_404(RawPdfFile, id=report_id)
-
-            if not report.file:
-                return Response(
-                    {"error": "Keine Datei für diesen Report verfügbar"},
-                    status=status.HTTP_404_NOT_FOUND
-                )
-
-            metadata = self._get_file_metadata(report)
-            return Response(metadata)
-
-        except (ValueError, TypeError) as e:
-            logger.error("Fehler beim Laden der Datei-Metadaten: %s", str(e))
-            return Response(
-                {"error": "Metadaten konnten nicht geladen werden"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
-
-    def _get_file_metadata(self, report):
-        """Sammelt Datei-Metadaten"""
-        file_path = Path(report.file.name)
-
-        try:
-            file_size = report.file.size
-        except OSError:
-            file_size = 0
-
-        return {
-            'filename': file_path.name,
-            'file_type': file_path.suffix.lower().lstrip('.'),
-            'file_size': file_size,
-            'upload_date': report.created_at if hasattr(report, 'created_at') else None,
-            'last_modified': report.updated_at if hasattr(report, 'updated_at') else None
-        }

endoreg_db/views/meta/sensitive_meta_detail.py

@@ -1,148 +0,0 @@
-from endoreg_db.models import SensitiveMeta
-from endoreg_db.serializers import SensitiveMetaDetailSerializer, SensitiveMetaUpdateSerializer
-
-from django.db import transaction
-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
-
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-import logging
-
-logger = logging.getLogger(__name__)
-
-class SensitiveMetaDetailView(APIView):
-    """
-    API endpoint to retrieve and update SensitiveMeta details with verification state.
-
-    GET: Returns detailed SensitiveMeta information for annotation/verification
-    PATCH: Updates SensitiveMeta fields including verification state
-    """
-
-    permission_classes = DEBUG_PERMISSIONS  # Changed from IsAuthenticated for development
-
-    def get(self, request, sensitive_meta_id=None):
-        """
-        Retrieve SensitiveMeta details for display and annotation.
-
-        Supports both URL parameter and query parameter access patterns:
-        - /api/pdf/sensitivemeta/123/ (URL parameter)
-        - /api/pdf/sensitivemeta/?id=123 (query parameter - for backward compatibility)
-        - /api/pdf/sensitivemeta/ (list all - returns empty list instead of 400)
-
-        Returns detailed information suitable for user verification.
-        """
-        # Handle both URL parameter and query parameter patterns
-        if not sensitive_meta_id:
-            sensitive_meta_id = request.query_params.get('id')
-
-        # If no ID provided, return empty list instead of error
-        if not sensitive_meta_id:
-            return Response([], status=status.HTTP_200_OK)
-
-        try:
-            # Convert to int if it's a string
-            sensitive_meta_id = int(sensitive_meta_id)
-
-            # Get the SensitiveMeta instance with related data
-            sensitive_meta = SensitiveMeta.objects.select_related(
-                'center',
-                'patient_gender',
-                'pseudo_patient',
-                'pseudo_examination'
-            ).prefetch_related(
-                'examiners',
-                'state'
-            ).get(id=sensitive_meta_id)
-
-            # Serialize for display
-            serializer = SensitiveMetaDetailSerializer(sensitive_meta)
-
-            # Return direct data to match anonymization store expectations
-            # Instead of wrapping in "sensitive_meta" key, return data directly
-            response_data = serializer.data
-
-            logger.info(f"Retrieved SensitiveMeta {sensitive_meta_id} for user {request.user}")
-            return Response(response_data, status=status.HTTP_200_OK)
-
-        except ValueError:
-            return Response(
-                {"error": "Invalid sensitive_meta_id format. Must be an integer."},
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        except SensitiveMeta.DoesNotExist:
-            return Response(
-                {"error": f"SensitiveMeta with ID {sensitive_meta_id} not found"},
-                status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            logger.error(f"Error retrieving SensitiveMeta {sensitive_meta_id}: {e}")
-            return Response(
-                {"error": "Internal server error occurred"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
-
-    @transaction.atomic
-    def patch(self, request, sensitive_meta_id=None):
-        """
-        Update SensitiveMeta fields including verification state.
-
-        Accepts partial updates for any field in SensitiveMetaUpdateSerializer.
-        Special handling for verification state changes.
-        """
-        if not sensitive_meta_id:
-            return Response(
-                {"error": "sensitive_meta_id is required"},
-                status=status.HTTP_400_BAD_REQUEST
-            )
-
-        try:
-            # Get the SensitiveMeta instance
-            sensitive_meta = get_object_or_404(SensitiveMeta, id=sensitive_meta_id)
-
-            # Validate and update using serializer
-            serializer = SensitiveMetaUpdateSerializer(
-                sensitive_meta,
-                data=request.data,
-                partial=True
-            )
-
-            if serializer.is_valid():
-                updated_instance = serializer.save()
-
-                # Return updated data using detail serializer
-                response_serializer = SensitiveMetaDetailSerializer(updated_instance)
-
-                response_data = {
-                    "message": "SensitiveMeta updated successfully",
-                    "sensitive_meta": response_serializer.data,
-                    "updated_fields": list(request.data.keys())
-                }
-
-                logger.info(
-                    f"Updated SensitiveMeta {sensitive_meta_id} by user {request.user}. "
-                    f"Fields: {list(request.data.keys())}"
-                )
-
-                return Response(response_data, status=status.HTTP_200_OK)
-            else:
-                return Response(
-                    {
-                        "error": "Validation failed",
-                        "details": serializer.errors
-                    },
-                    status=status.HTTP_400_BAD_REQUEST
-                )
-
-        except SensitiveMeta.DoesNotExist:
-            return Response(
-                {"error": f"SensitiveMeta with ID {sensitive_meta_id} not found"},
-                status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            logger.error(f"Error updating SensitiveMeta {sensitive_meta_id}: {e}")
-            return Response(
-                {"error": "Internal server error occurred"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )