endoreg-db 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

endoreg_db/urls.py

@@ -10,20 +10,23 @@ from .views.csrf import csrf_token_view
 #from .views.feature_selection_view import FetchSingleFramePredictionView // its implemented in ando-ai other project need to add here
 from .views.video_segmentation_views import VideoView, VideoLabelView,UpdateLabelSegmentsView
 from .views.views_for_timeline import video_timeline_view
-from .views.raw_video_meta_validation_views import VideoFileForMetaView
+from .views.raw_video_meta_validation_views import VideoFileForMetaView, VideoFileForMetaView
+from .views.raw_pdf_meta_validation_views import PDFFileForMetaView
+from .views.raw_pdf_meta_validation_views import UpdateSensitiveMetaView
+from .views.raw_pdf_anony_text_validation_views import RawPdfAnonyTextView, UpdateAnonymizedTextView
 router = DefaultRouter()
 router.register(r'patients', PatientViewSet)
 
+
 urlpatterns = [
     path('start-examination/', start_examination, name="start_examination"),
     path('get-location-choices/<int:location_id>/', get_location_choices, name="get_location_choices"),
     path('get-morphology-choices/<int:morphology_id>/', get_morphology_choices, name="get_morphology_choices"),
     path('api/', include(router.urls)),
     path('api/conf/', csrf_token_view, name='csrf_token'),
-    
 
 
-#--------------------------------------VIDEO SEGMENTATION END POINTS--------------------------------------
+#--------------------------------------START : VIDEO SEGMENTATION END POINTS--------------------------------------
 
        # The dropdown contains video names and their corresponding IDs, which are retrieved from the database(RawVideoFile). Additionally, this route(api/videos) also fetches labels along with their names and IDs from the label table.
        # We will modify this implementation later as per our requirements.
@@ -153,21 +156,117 @@ urlpatterns = [
     #
     path("api/video/<int:video_id>/label/<int:label_id>/update_segments/", UpdateLabelSegmentsView.as_view(), name="update_label_segments"),
 
-#----------------------------------END--VIDEO SEGMENTATION SECTION-------------------------------
-    #this is for to test the timeline
-    #need to delete this url and also endoreg_db_production/endoreg_db/views/views_for_timeline.py and endoreg_db_production/endoreg_db/templates/timeline.html
-    path('video/<int:video_id>/timeline/', video_timeline_view, name='video_timeline'),
 
-    
-    
-    
+#----------------------------------START : SENSITIVE META AND RAWVIDEOFILE VIDEO PATIENT DETAILS-------------------------------
+
+    # API Endpoint for fetching video metadata or streaming the next available video
+    # This endpoint is used by the frontend to fetch:
+    #  - The first available video if `last_id` is NOT provided.
+    #  - The next available video where `id > last_id` if `last_id` is provided.
+    #  - If `Accept: application/json` is set in headers, it returns video metadata as JSON.
+    #  - If no videos are available, it returns {"error": "No more videos available."}.
     #  const url = lastId ? `http://localhost:8000/api/video/meta/?last_id=${lastId}` : "http://localhost:8000/api/video/meta/";
     path("api/video/sensitivemeta/", VideoFileForMetaView.as_view(), name="video_meta"),  # Single endpoint for both first and next video    
-    ]
 
 
 
+    # This API endpoint allows updating specific patient details (SensitiveMeta)
+    # linked to a video. It is used to correct or modify the patient's first name,
+    # last name, date of birth, and examination date.
+    # Fetch video metadata and update patient details
+    # The frontend should send a JSON request body like this:
+    # {
+    #     "sensitive_meta_id": 2,          # The ID of the SensitiveMeta entry (REQUIRED)
+    #     "patient_first_name": "John",    # New first name (REQUIRED, cannot be empty)
+    #     "patient_last_name": "Doe",      # New last name (REQUIRED, cannot be empty)
+    #     "patient_dob": "1985-06-15",     # New Date of Birth (REQUIRED, format YYYY-MM-DD)
+    #     "examination_date": "2024-03-20" # New Examination Date (OPTIONAL, format YYYY-MM-DD)
+    # }
+    # - The frontend sends a PATCH request to this endpoint with updated patient data.
+    # - The backend validates the input using the serializer (`SensitiveMetaUpdateSerializer`).
+    # - If validation passes, the patient information is updated in the database.
+    # - If there are errors (e.g., missing fields, incorrect date format), 
+    #   the API returns structured error messages.
+    path("api/video/update_sensitivemeta/", VideoFileForMetaView.as_view(), name="update_patient_meta"),
+
+
+        
+        
+#----------------------------------START : SENSITIVE META AND RAWPDFOFILE PDF PATIENT DETAILS-------------------------------
+        
+    #The first request (without id) fetches the first available PDF metadata.
+    #The "Next" button (with id) fetches the next available PDF.
+    #If an id is provided, the API returns the actual PDF file instead of JSON.
+    path("api/pdf/sensitivemeta/", PDFFileForMetaView.as_view(), name="pdf_meta"),  
+
+
+
+
+    # This API endpoint allows updating specific patient details (SensitiveMeta)
+    # linked to a PDF record. It enables modifying the patient's first name,
+    # last name, date of birth, and examination date.
+
+    # The frontend should send a JSON request body like this:
+    # {
+    #     "sensitive_meta_id": 2,          # The ID of the SensitiveMeta entry (REQUIRED)
+    #     "patient_first_name": "John",    # New first name (OPTIONAL, if provided, cannot be empty)
+    #     "patient_last_name": "Doe",      # New last name (OPTIONAL, if provided, cannot be empty)
+    #     "patient_dob": "1985-06-15",     # New Date of Birth (OPTIONAL, format YYYY-MM-DD)
+    #     "examination_date": "2024-03-20" # New Examination Date (OPTIONAL, format YYYY-MM-DD)
+    # }
+
+    # - The frontend sends a PATCH request to this endpoint with the updated patient data.
+    # - The backend processes the request and updates only the fields that are provided.
+    # - If validation passes, the corresponding SensitiveMeta entry is updated in the database.
+    # - If errors occur (e.g., invalid ID, empty fields, incorrect date format), 
+    #   the API returns structured error messages.
+
+    path("api/pdf/update_sensitivemeta/", UpdateSensitiveMetaView.as_view(), name="update_pdf_meta"),
+
 
 
 
+
+    #  API Endpoint for Fetching PDF Data (Including Anonymized Text)
+    # - This endpoint is used when the page loads.
+    # - Fetches the first available PDF (if no `last_id` is provided).
+    # - If `last_id` is given, fetches the next available PDF.
+    # - The frontend calls this endpoint on **page load** and when clicking the **next button**.
+    # Example frontend usage:
+    #     const url = lastId ? `http://localhost:8000/api/pdf/anony_text/?last_id=${lastId}` 
+    #                        : "http://localhost:8000/api/pdf/anony_text/";
+    path("api/pdf/anony_text/", RawPdfAnonyTextView.as_view(), name="pdf_anony_text"),  
+
+    #  API Endpoint for Updating the `anonymized_text` Field in `RawPdfFile`
+    # - This endpoint is called when the user edits the anonymized text and clicks **Save**.
+    # - Updates only the `anonymized_text` field for the specified PDF `id`.
+    # - The frontend sends a **PATCH request** to this endpoint with the updated text.
+    # Example frontend usage:
+    #     axios.patch("http://localhost:8000/api/pdf/update_anony_text/", { id: 1, anonymized_text: "Updated text" });
+    path("api/pdf/update_anony_text/", UpdateAnonymizedTextView.as_view(), name="update_pdf_anony_text"),
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    #this is for, to test the timeline
+    #need to delete this url and also endoreg_db_production/endoreg_db/views/views_for_timeline.py and endoreg_db_production/endoreg_db/templates/timeline.html
+    path('video/<int:video_id>/timeline/', video_timeline_view, name='video_timeline'),
+    ]
+
+    
 #https://biigle.de/manual/tutorials/videos/navigating-timeline#for time line example
+from django.conf import settings
+from django.conf.urls.static import static
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

endoreg_db/views/raw_pdf_anony_text_validation_views.py

@@ -0,0 +1,95 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from django.http import FileResponse, Http404
+import os, mimetypes
+from ..models import RawPdfFile
+from ..serializers.raw_pdf_anony_text_validation import RawPdfAnonyTextSerializer
+
+class RawPdfAnonyTextView(APIView):
+    """
+    API for:
+    - Fetching PDF metadata including `anonymized_text`.
+    - Fetching the next available PDF.
+    - Serving the actual PDF file.
+    """
+
+    def get(self, request):
+        """
+        Handles:
+        - First available PDF if `last_id` is NOT provided.
+        - Next available PDF if `last_id` is provided.
+        - Returns the actual PDF file if `id` is provided.
+        """
+
+        pdf_id = request.GET.get("id")
+        last_id = request.GET.get("last_id")
+
+        if pdf_id:
+            return self.serve_pdf_file(pdf_id)
+        else:
+            return self.fetch_pdf_metadata(last_id)
+
+    def fetch_pdf_metadata(self, last_id):
+        """
+        Fetches the next available PDF metadata, including `anonymized_text`.
+        """
+        pdf_entry = RawPdfAnonyTextSerializer.get_next_pdf(last_id)
+
+        if pdf_entry is None:
+            return Response({"error": "No more PDFs available."}, status=status.HTTP_404_NOT_FOUND)
+
+        serialized_pdf = RawPdfAnonyTextSerializer(pdf_entry, context={'request': self.request})
+        return Response(serialized_pdf.data, status=status.HTTP_200_OK)
+
+    def serve_pdf_file(self, pdf_id):
+        """
+        Serves the actual PDF file for viewing.
+        """
+        try:
+            pdf_entry = RawPdfFile.objects.get(id=pdf_id)
+            if not pdf_entry.file:
+                return Response({"error": "PDF file not found."}, status=status.HTTP_404_NOT_FOUND)
+
+            full_pdf_path = pdf_entry.file.path
+            if not os.path.exists(full_pdf_path):
+                raise Http404("PDF file not found on server.")
+
+            mime_type, _ = mimetypes.guess_type(full_pdf_path)
+            response = FileResponse(open(full_pdf_path, "rb"), content_type=mime_type or "application/pdf")
+            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_pdf_path)}"'
+            return response
+
+        except RawPdfFile.DoesNotExist:
+            return Response({"error": "Invalid PDF ID."}, status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class UpdateAnonymizedTextView(APIView):
+    """
+    API to update only `anonymized_text` in `RawPdfFile`
+    """
+
+    def patch(self, request):
+        """
+        Updates `anonymized_text` for a given `pdf_id`.
+        """
+        pdf_id = request.data.get("id")
+
+        if not pdf_id:
+            return Response({"error": "pdf_id is required."}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            pdf_entry = RawPdfFile.objects.get(id=pdf_id)
+        except RawPdfFile.DoesNotExist:
+            return Response({"error": "PDF not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        serializer = RawPdfAnonyTextSerializer(pdf_entry, data=request.data, partial=True)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response({"message": "PDF anonymized_text updated successfully.", "updated_data": serializer.data},
+                            status=status.HTTP_200_OK)
+
+        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)

endoreg_db/views/raw_pdf_meta_validation_views.py

@@ -0,0 +1,111 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from django.http import FileResponse, Http404
+import mimetypes
+import os
+from ..models import RawPdfFile
+from ..serializers.raw_pdf_meta_validation import PDFFileForMetaSerializer
+
+
+class PDFFileForMetaView(APIView):
+    """
+    API endpoint to:
+    - Fetch PDF metadata if `id` is NOT provided.
+    - Serve the actual PDF file if `id` is provided.
+    """
+
+    def get(self, request):
+        """
+        Handles both:
+        Fetching PDF metadata** (if `id` is NOT provided)
+         Serving the actual PDF file** (if `id` is provided)
+        """
+
+        pdf_id = request.GET.get("id")  # Check if 'id' is provided in the query params
+        last_id = request.GET.get("last_id")  # Check if 'last_id' is provided for pagination
+
+        if pdf_id:
+            return self.serve_pdf_file(pdf_id)  # Serve the actual PDF file
+        else:
+            return self.fetch_pdf_metadata(last_id)  # Fetch metadata for the first or next PDF
+
+    def fetch_pdf_metadata(self, last_id):
+        """
+        Fetches the first or next available PDF metadata.
+        """
+        pdf_entry = PDFFileForMetaSerializer.get_next_pdf(last_id)
+
+        if pdf_entry is None:
+            return Response({"error": "No more PDFs available."}, status=status.HTTP_404_NOT_FOUND)
+
+        serialized_pdf = PDFFileForMetaSerializer(pdf_entry, context={'request': self.request})
+
+        print("Debugging API Response:")
+        print("Serialized Data:", serialized_pdf.data)  # Debugging
+        return Response(serialized_pdf.data, status=status.HTTP_200_OK)
+    
+    def serve_pdf_file(self, pdf_id):
+        """
+        Serves the actual PDF file for download or viewing.
+        """
+        try:
+            pdf_entry = RawPdfFile.objects.get(id=pdf_id)  # Get the PDF file by ID
+
+            if not pdf_entry.file:
+                return Response({"error": "PDF file not found."}, status=status.HTTP_404_NOT_FOUND)
+
+            full_pdf_path = pdf_entry.file.path  # Get the absolute file path
+
+            if not os.path.exists(full_pdf_path):
+                raise Http404("PDF file not found on server.")
+
+            mime_type, _ = mimetypes.guess_type(full_pdf_path)  # Detect file type
+            response = FileResponse(open(full_pdf_path, "rb"), content_type=mime_type or "application/pdf")
+
+            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_pdf_path)}"'  # Allows direct viewing
+
+            return response  # Sends the PDF file as a stream
+
+        except RawPdfFile.DoesNotExist:
+            return Response({"error": "Invalid PDF ID."}, status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from ..models import SensitiveMeta
+from ..serializers.raw_pdf_meta_validation import SensitiveMetaUpdateSerializer
+
+class UpdateSensitiveMetaView(APIView):
+    """
+    API endpoint to update patient details in the SensitiveMeta table.
+    Handles partial updates (only edited fields).
+    """
+
+    def patch(self, request, *args, **kwargs):
+        """
+        Updates the provided fields for a specific patient record.
+        Only updates fields that are sent in the request.
+        """
+        sensitive_meta_id = request.data.get("sensitive_meta_id")  # Required field
+
+        if not sensitive_meta_id:
+            return Response({"error": "sensitive_meta_id is required."}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            sensitive_meta = SensitiveMeta.objects.get(id=sensitive_meta_id)
+        except SensitiveMeta.DoesNotExist:
+            return Response({"error": "Patient record not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        # Serialize the request data with partial=True to allow partial updates
+        serializer = SensitiveMetaUpdateSerializer(sensitive_meta, data=request.data, partial=True)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response({"message": "Patient information updated successfully.", "updated_data": serializer.data},
+                            status=status.HTTP_200_OK)
+        
+        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)

endoreg_db/views/raw_video_meta_validation_views.py

@@ -1,38 +1,148 @@
 from rest_framework.views import APIView
 from rest_framework.response import Response
 from rest_framework import status
+from django.http import FileResponse, Http404
+import mimetypes
+import os
 from ..models import RawVideoFile
-from ..serializers.raw_video_meta_validation import VideoFileForMetaSerializer
+from ..serializers.raw_video_meta_validation import VideoFileForMetaSerializer,SensitiveMetaUpdateSerializer
+from ..models import SensitiveMeta
+
 
 class VideoFileForMetaView(APIView):
     """
     API endpoint to fetch video metadata step-by-step.
-    If last_id is not provided  Returns the first video.
-     If last_id is given Returns the next available video.
+    Uses the serializer to get the first or next available video.
     """
 
-    ##need to change this fucntion , like the previous one
-
     def get(self, request):
         """
-        Handles:
-        First video if last_id is nt in query params.
-        Next video where id > last_id` if provided.
+        - Fetches the **first available video** if `last_id` is NOT provided.
+        - Fetches the **next available video** where `id > last_id` if provided.
+        - If no video is available, returns a structured error response.
         """
-        last_id = request.GET.get("last_id")  # Get last_id from query params (e.g., ?last_id=2)
+        last_id = request.GET.get("last_id")  # Get last_id from query params
+
+        #  Get the next video as a model instance
+        video_entry = VideoFileForMetaSerializer.get_next_video(last_id)
+
+        if video_entry is None:
+            return Response({"error": "No more videos available."}, status=status.HTTP_404_NOT_FOUND)
+
+        serialized_video = VideoFileForMetaSerializer(video_entry, context={'request': request})
+
+        # Check if required fields are missing
+        response_data = serialized_video.data
+        missing_fields = {}
+
+        if response_data.get('file') is None:
+            missing_fields['file'] = "No file associated with this entry."
+
+        if response_data.get('video_url') is None:
+            missing_fields['video_url'] = "Video file is missing."
+
+        if response_data.get('full_video_path') is None:
+            missing_fields['full_video_path'] = "No file path found on server."
 
+        if not response_data.get('patient_first_name'):
+            missing_fields['patient_first_name'] = "Patient first name is missing."
+
+        if not response_data.get('patient_last_name'):
+            missing_fields['patient_last_name'] = "Patient last name is missing."
+
+        if not response_data.get('patient_dob'):
+            missing_fields['patient_dob'] = "Patient date of birth is missing."
+
+        if not response_data.get('examination_date'):
+            missing_fields['examination_date'] = "Examination date is missing."
+
+        if response_data.get('duration') is None:
+            missing_fields['duration'] = "Unable to determine video duration. The file might be corrupted or unreadable."
+
+        if missing_fields:
+            return Response({"error": "Missing required data.", "details": missing_fields}, 
+                            status=status.HTTP_400_BAD_REQUEST)
+
+        return Response(serialized_video.data, status=status.HTTP_200_OK)
+
+    def serve_video_file(self, video_entry):
+        """
+        Streams the video file dynamically.
+        """
         try:
-            # If last_id is provided, fetch the next video where id > last_id
-            # id__gt is orm syntax which is equal to SELECT * FROM rawvideofile WHERE id > 2 ORDER BY id ASC LIMIT 1;
+            full_video_path = video_entry.file.path  #  Get file path
 
-            query_filter = {} if last_id is None else {"id__gt": int(last_id)}
-            video_entry = RawVideoFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+            if not os.path.exists(full_video_path):
+                raise Http404("Video file not found.")
 
-            if not video_entry:
-                return Response({"message": "No more videos available."}, status=status.HTTP_404_NOT_FOUND)
+            mime_type, _ = mimetypes.guess_type(full_video_path)  # Detects file type
+            response = FileResponse(open(full_video_path, "rb"), content_type=mime_type or "video/mp4")
 
-            serializer = VideoFileForMetaSerializer(video_entry)
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_video_path)}"'  # Allows direct streaming
+
+            return response  # Sends the video file as a stream
 
         except Exception as e:
-            return Response({"error": f"Internal server error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        
+
+    def patch(self, request, *args, **kwargs):
+        """
+        Calls the serializer to update `SensitiveMeta` data.
+        """
+
+        # Ensure all required fields are provided
+        required_fields = ["sensitive_meta_id", "patient_first_name", "patient_last_name", "patient_dob", "examination_date"]
+        missing_fields = [field for field in required_fields if field not in request.data]
+
+        if missing_fields:
+            return Response({"error": "Missing required fields", "missing_fields": missing_fields}, status=status.HTTP_400_BAD_REQUEST)
+
+        #  Call serializer for validation
+        serializer = SensitiveMetaUpdateSerializer(data=request.data, partial=True)
+
+        if serializer.is_valid():
+            #  Get the instance and update it
+            sensitive_meta = SensitiveMeta.objects.get(id=request.data["sensitive_meta_id"])
+            updated_instance = serializer.update(sensitive_meta, serializer.validated_data)
+
+            return Response({
+                "message": "Patient information updated successfully.",
+                "updated_data": SensitiveMetaUpdateSerializer(updated_instance).data
+            }, status=status.HTTP_200_OK)
+
+        #  Return validation errors
+        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+    
+
+    """
+    await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+const updatePatientInfo = async () => {
+    const updatedData = {
+        sensitive_meta_id: 2,
+        patient_first_name: "Placeholder",
+        patient_last_name: "Placeholder",
+        patient_dob: "1994-06-15",
+        examination_date: "2024-06-15"
+    };
+
+    try {
+        const response = await axios.patch("http://localhost:8000/api/video/update_sensitivemeta/", updatedData, {
+            headers: { "Content-Type": "application/json" }
+        });
+
+        console.log("Update Success:", response.data);
+        alert("Patient information updated successfully!");
+
+        return response.data;  
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+        alert("Failed to update patient information.");
+        return error.response?.data || { error: "Unknown error" };  
+    }
+};
+
+
+updatePatientInfo().then(response => console.log("Final Response:", response));
+
+    """

endoreg_db/views/video_segmentation_views.py

@@ -31,9 +31,14 @@ class VideoView(APIView):
         Returns a list of all available videos along with available labels.
         Used to populate the video selection dropdown in Vue.js.
         """
+        
         videos = RawVideoFile.objects.all()
         labels = Label.objects.all()  # Fetch all labels
 
+        if not videos.exists():
+            return Response({"error": "No videos found in the database."}, status=status.HTTP_404_NOT_FOUND)
+
+
         video_serializer = VideoListSerializer(videos, many=True)
         label_serializer = LabelSerializer(labels, many=True)  # Serialize labels
 
@@ -134,16 +139,28 @@ class UpdateLabelSegmentsView(APIView):
 
     def put(self, request, video_id, label_id):
         """
-        Handles PUT request to update or create label segments.
+        Updates segments for a given video & label.
         """
-        serializer = LabelSegmentUpdateSerializer(data=request.data)
 
-        if serializer.is_valid():
-            result = serializer.save()
-            return Response({
-                "message": "Segments updated successfully",
-                "updated_segments": result["updated_segments"],
-                "new_segments": result["new_segments"]
-            }, status=status.HTTP_200_OK)
-        
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        # Ensure required fields are provided
+        required_fields = ["video_id", "label_id", "segments"]
+        missing_fields = [field for field in required_fields if field not in request.data]
+
+        if missing_fields:
+            return Response({"error": "Missing required fields", "missing": missing_fields}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Validate input data
+        serializer = LabelSegmentUpdateSerializer(data=request.data, partial=True)
+
+        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
+        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)

{endoreg_db-0.6.1.dist-info → endoreg_db-0.6.3.dist-info}/METADATA

@@ -1,8 +1,18 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.6.1
+Version: 0.6.3
 Summary: EndoReg Db Django App
+Project-URL: Homepage, https://info.coloreg.de
+Project-URL: Repository, https://github.com/wg-lux/endoreg-db
+Author: Max Hild, Hamza Zahid, Peter Kowalczyk
+Author-email: "Thomas J. Lux" <lux_t1@ukw.de>
+Maintainer: Max Hild, Hamza Zahid, Peter Kowalczyk
+Maintainer-email: "Thomas J. Lux" <lux_t1@ukw.de>
 License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.11
 Requires-Dist: agl-report-reader>=0.4.0
 Requires-Dist: django-bootstrap5>=24.3