endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/Frames_NICE_and_PARIS_classifications_views.py

@@ -0,0 +1,247 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from endoreg_db.models import VideoFile
+from ..serializers.Frames_NICE_and_PARIS_classifications import (
+    ForNiceClassificationSerializer,
+    ForParisClassificationSerializer,
+)
+
+
+class ForNiceClassificationView(APIView):
+    """
+    NICE Classification API View
+
+    GET: Führt NICE-Klassifikation für alle Videos durch
+    POST: Führt NICE-Klassifikation für spezifizierte Videos durch
+
+    POST Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
+    """
+
+    def get(self, request):
+        """Legacy GET endpoint - processes all videos"""
+        print("[DEBUG] NICE Classification View hit (GET)")
+        return self._process_classification(request)
+
+    def post(self, request):
+        """New POST endpoint - processes specified videos"""
+        print("[DEBUG] NICE Classification View hit (POST)")
+        return self._process_classification(request)
+
+    def _process_classification(self, request):
+        try:
+            # Handle POST data for specific video IDs
+            video_ids = None
+            if request.method == "POST" and hasattr(request, "data"):
+                video_ids = request.data.get("video_ids", None)
+
+            if video_ids:
+                videos = VideoFile.objects.filter(id__in=video_ids)
+                print(
+                    f"[DEBUG] Processing NICE classification for specific videos: {video_ids}"
+                )
+            else:
+                videos = VideoFile.objects.all()
+                print("[DEBUG] Processing NICE classification for all videos")
+
+            print(f"[DEBUG] Total videos found: {videos.count()}")
+            for v in videos:
+                print(f"[DEBUG] Video ID: {v.id}")
+
+            if not videos.exists():
+                return Response(
+                    {"error": "No videos found in the database."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            serializer = ForNiceClassificationSerializer()
+            response_data = serializer.to_representation(videos)
+
+            if not response_data:
+                return Response(
+                    {"error": "No valid segments for NICE classification."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return Response(
+                {"error": f"Internal server error: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class ForParisClassificationView(APIView):
+    """
+    PARIS Classification API View
+
+    GET: Führt PARIS-Klassifikation für alle Videos durch
+    POST: Führt PARIS-Klassifikation für spezifizierte Videos durch
+
+    POST Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
+    """
+
+    def get(self, request):
+        """Legacy GET endpoint - processes all videos"""
+        print("[DEBUG] PARIS Classification View hit (GET)")
+        return self._process_classification(request)
+
+    def post(self, request):
+        """New POST endpoint - processes specified videos"""
+        print("[DEBUG] PARIS Classification View hit (POST)")
+        return self._process_classification(request)
+
+    def _process_classification(self, request):
+        try:
+            # Handle POST data for specific video IDs
+            video_ids = None
+            if request.method == "POST" and hasattr(request, "data"):
+                video_ids = request.data.get("video_ids", None)
+
+            if video_ids:
+                videos = VideoFile.objects.filter(id__in=video_ids)
+                print(
+                    f"[DEBUG] Processing PARIS classification for specific videos: {video_ids}"
+                )
+            else:
+                videos = VideoFile.objects.all()
+                print("[DEBUG] Processing PARIS classification for all videos")
+
+            print(f"[DEBUG] Total videos found: {videos.count()}")
+
+            filtered_videos = [
+                video
+                for video in videos
+                if getattr(
+                    video, "frame_dir", None
+                )  # no more readable_predictions check
+            ]
+
+            if not filtered_videos:
+                return Response(
+                    {"error": "No videos with valid frame_dir found."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            serializer = ForParisClassificationSerializer()
+            response_data = serializer.to_representation(filtered_videos)
+
+            if not response_data:
+                return Response(
+                    {"error": "No valid PARIS segments found."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return Response(
+                {"error": f"Internal server error: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class BatchClassificationView(APIView):
+    """
+    Batch Classification API View
+
+    POST: Führt beide Klassifikationstypen (NICE und PARIS) für spezifizierte Videos durch
+
+    POST Body: {
+        "video_ids": [1, 2, 3],
+        "types": ["nice", "paris"]  # Optional, default beide
+    }
+    """
+
+    def post(self, request):
+        try:
+            video_ids = request.data.get("video_ids", None)
+            classification_types = request.data.get("types", ["nice", "paris"])
+
+            if video_ids:
+                videos = VideoFile.objects.filter(id__in=video_ids)
+            else:
+                videos = VideoFile.objects.all()
+
+            if not videos.exists():
+                return Response(
+                    {"error": "No videos found."}, status=status.HTTP_404_NOT_FOUND
+                )
+
+            results = {}
+
+            if "nice" in classification_types:
+                nice_serializer = ForNiceClassificationSerializer()
+                results["nice"] = nice_serializer.to_representation(videos)
+
+            if "paris" in classification_types:
+                # Filter videos for PARIS (need frame_dir)
+                filtered_videos = [
+                    video for video in videos if getattr(video, "frame_dir", None)
+                ]
+
+                if filtered_videos:
+                    paris_serializer = ForParisClassificationSerializer()
+                    results["paris"] = paris_serializer.to_representation(
+                        filtered_videos
+                    )
+                else:
+                    results["paris"] = {
+                        "error": "No videos with valid frame_dir found for PARIS classification."
+                    }
+
+            return Response(
+                {"message": "Batch classification completed.", "results": results},
+                status=status.HTTP_200_OK,
+            )
+
+        except Exception as e:
+            return Response(
+                {"error": f"Internal server error: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class ClassificationStatusView(APIView):
+    """
+    Classification Status API View
+
+    GET: Gibt den Status der Klassifikationen für ein Video zurück
+    """
+
+    def get(self, request, video_id):
+        try:
+            video = VideoFile.objects.get(id=video_id)
+
+            # Check if classifications exist for this video
+            # This would typically check for saved classification results in the database
+            # For now, we'll return basic status information
+
+            status_info = {
+                "video_id": video_id,
+                "video_name": getattr(video, "original_file_name", "Unknown"),
+                "has_frame_dir": bool(getattr(video, "frame_dir", None)),
+                "nice_classification_available": True,  # Always available for NICE
+                "paris_classification_available": bool(
+                    getattr(video, "frame_dir", None)
+                ),
+                "last_processed": None,  # Would come from classification results table
+                "classification_results": {
+                    "nice": None,  # Would contain saved NICE results
+                    "paris": None,  # Would contain saved PARIS results
+                },
+            }
+
+            return Response(status_info, status=status.HTTP_200_OK)
+
+        except VideoFile.DoesNotExist:
+            return Response(
+                {"error": f"Video with ID {video_id} not found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception as e:
+            return Response(
+                {"error": f"Internal server error: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/__init__.py

@@ -0,0 +1,157 @@
+from ..utils.translation import build_multilingual_response
+from .anonymization import (
+    AnonymizationOverviewView,
+    AnonymizationValidateView,
+    anonymization_current,
+    anonymization_status,
+    start_anonymization,
+)
+from .auth import KeycloakVideoView, keycloak_callback, keycloak_login, public_home
+from .examination import (
+    ExaminationManifestCache,
+    ExaminationViewSet,
+    get_classification_choices_for_examination,
+    get_classifications_for_examination,
+    get_findings_for_examination,
+    get_instruments_for_examination,
+    get_interventions_for_examination,
+    get_location_classification_choices_for_examination,
+    get_location_classifications_for_examination,
+    get_morphology_classification_choices_for_examination,
+    get_morphology_classifications_for_examination,
+)
+from .finding import (
+    FindingViewSet,
+    get_classifications_for_finding,
+    get_interventions_for_finding,
+)
+from .finding_classification import (
+    FindingClassificationViewSet,
+    get_classification_choices,
+    get_location_choices,  # DEPRECATED
+    get_morphology_choices,  # DEPRECATED
+)
+from .media import (
+    get_sensitive_metadata_pk,
+    label_list,
+    pdf_sensitive_metadata,
+    pdf_sensitive_metadata_list,
+    pdf_sensitive_metadata_verify,
+    sensitive_metadata_list,
+    video_sensitive_metadata,
+    video_sensitive_metadata_verify,
+)
+from .meta import SensitiveMetaListView, SensitiveMetaVerificationView
+from .misc import (
+    CenterViewSet,
+    ExaminationStatsView,
+    GenderViewSet,
+    GeneralStatsView,
+    SensitiveMetaStatsView,
+    UploadFileView,
+    UploadStatusView,
+    VideoSegmentStatsView,
+    csrf_token_view,
+)
+from .patient import PatientViewSet
+from .patient_examination import (
+    ExaminationCreateView,
+    PatientExaminationDetailView,
+    PatientExaminationListView,
+    PatientExaminationViewSet,
+)
+from .patient_finding import OptimizedPatientFindingViewSet, PatientFindingViewSet
+from .patient_finding_classification import create_patient_finding_classification
+from .report import ReportReimportView, ReportStreamView
+from .requirement import LookupViewSet, evaluate_requirements
+from .video import (  # Video Correction (Phase 1.1) - Implemented; Existing views
+    VideoApplyMaskView,
+    VideoCorrectionView,
+    VideoExaminationViewSet,
+    VideoReimportView,
+    VideoRemoveFramesView,
+    VideoStreamView,
+)
+
+__all__ = [
+    # Anonymization views
+    "anonymization_status",
+    "anonymization_current",
+    "start_anonymization",
+    "AnonymizationOverviewView",
+    "AnonymizationValidateView",
+    # Auth views
+    "KeycloakVideoView",
+    "keycloak_login",
+    "keycloak_callback",
+    "public_home",
+    # Examination views
+    "ExaminationManifestCache",
+    "ExaminationViewSet",
+    "get_classification_choices_for_examination",
+    "get_morphology_classification_choices_for_examination",
+    "get_location_classification_choices_for_examination",
+    "get_classifications_for_examination",
+    "get_location_classifications_for_examination",
+    "get_morphology_classifications_for_examination",
+    "get_findings_for_examination",
+    "get_instruments_for_examination",
+    "get_interventions_for_examination",
+    # Finding Views
+    "FindingViewSet",
+    "get_interventions_for_finding",
+    "get_classifications_for_finding",
+    # Finding Classification Views
+    "FindingClassificationViewSet",
+    "get_classification_choices",
+    "get_morphology_choices",  # DEPRECATED
+    "get_location_choices",  # DEPRECATED
+    # Meta Views
+    "SensitiveMetaListView",
+    "SensitiveMetaVerificationView",
+    # Misc
+    "CenterViewSet",
+    "csrf_token_view",
+    "GenderViewSet",
+    "ExaminationStatsView",
+    "VideoSegmentStatsView",
+    "SensitiveMetaStatsView",
+    "GeneralStatsView",
+    "build_multilingual_response",
+    "UploadFileView",
+    "UploadStatusView",
+    # Patient Views
+    "PatientViewSet",
+    # Patient Examination Views
+    "ExaminationCreateView",
+    "PatientExaminationDetailView",
+    "PatientExaminationListView",
+    "PatientExaminationViewSet",
+    # Patient Finding Views
+    "PatientFindingViewSet",
+    "OptimizedPatientFindingViewSet",
+    # Patient Finding Classification Views
+    "create_patient_finding_classification",
+    # report
+    "ReportReimportView",
+    "ReportStreamView",
+    # Requirement Views
+    "evaluate_requirements",
+    "LookupViewSet",
+    # Video Views (Phase 1.1 - Implemented)
+    "VideoApplyMaskView",
+    "VideoRemoveFramesView",
+    "VideoCorrectionView",
+    "VideoReimportView",
+    "VideoStreamView",
+    "VideoExaminationViewSet",
+    "ReportReimportView",
+    "label_list",
+    "get_sensitive_metadata_pk",
+    "video_sensitive_metadata",
+    "video_sensitive_metadata_verify",
+    "pdf_sensitive_metadata",
+    "pdf_sensitive_metadata_verify",
+    "sensitive_metadata_list",
+    "pdf_sensitive_metadata_list",
+]

endoreg_db/views/anonymization/__init__.py

@@ -0,0 +1,31 @@
+from .overview import (
+    AnonymizationOverviewView,
+    anonymization_status,
+    anonymization_current,
+    start_anonymization,
+    polling_coordinator_info,
+    clear_processing_locks,
+    has_raw_video_file,
+)
+
+from .validate import AnonymizationValidateView
+
+from .media_management import (
+    MediaManagementView,
+    force_remove_media,
+    reset_processing_status,
+)
+
+__all__ = [
+    "AnonymizationOverviewView",
+    "AnonymizationValidateView",
+    "anonymization_status",
+    "start_anonymization",
+    "anonymization_current",
+    "polling_coordinator_info",
+    "clear_processing_locks",
+    "MediaManagementView",
+    "force_remove_media",
+    "reset_processing_status",
+    "has_raw_video_file",
+]