endoreg-db 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

endoreg_db/urls.py

@@ -7,23 +7,32 @@ from .views.patient_views import (
     get_morphology_choices, 
 )
 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
+# endoreg_db_production/endoreg_db/urls.py
+from endoreg_db.views.views import (
+    VideoView,
+    keycloak_login,
+    keycloak_callback,
+    public_home,
+)#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.
@@ -31,7 +40,7 @@ urlpatterns = [
         # will be displayed on the frontend using route(api/video/<int:video_id>/).
         # once label is selected from the dropdown,using its name, details can be fetched from rawvideofile using route("api/video/<int:video_id>/label/<str:label_name>/) 
         #If editing is required, a form will be available for each label. This form dynamically updates when the selected label changes. It will display all segments associated with the selected label, each with a delete option. Below these segments, there may be a button for adding more segments.
-        #If any values in the form are modified, the updated data will be saved in the database table.
+        #If any values in the form are modified, the updated data will be saved in the dafrom .views import VideoView, keycloak_login, keycloak_callbacktabase table.
     
     
     
@@ -42,7 +51,15 @@ urlpatterns = [
     # Example request: GET /api/videos/
     # Response: Returns a JSON list of videos (id, file path, video_url, sequences, label_names).
     # it also fetch the label from teh label table
-    path("api/videos/", VideoView.as_view(), name="video_list"),
+
+    # for kaycloak:-
+    # /api/videos/ , protected API
+    # /login/ , sends user to Keycloak login page
+    # /login/callback/ , where Keycloak sends the user after login
+    path('', public_home, name='public_home'),
+    path('api/videos/', VideoView.as_view(), name='video_list'),
+    path('login/', keycloak_login, name='keycloak_login'),
+    path('login/callback/', keycloak_callback, name='keycloak_callback'),
     
     #need to change this route
     #path('api/prediction/', FetchSingleFramePredictionView.as_view(), name='fetch-single-frame-prediction'),#.as_view() converts the class-based view into a function that Django can use for routing.
@@ -153,21 +170,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/utils/__init__.py

@@ -11,6 +11,7 @@ from .hashs import (
     get_examiner_hash,
     get_video_hash,
     get_patient_examination_hash,
+    DJANGO_NAME_SALT
 )
 from .names import (
     create_mock_patient_name,
@@ -18,6 +19,28 @@ from .names import (
     guess_name_gender,
 )
 
+from .paths import (
+    STORAGE_DIR,
+    FRAME_DIR,
+    VIDEO_DIR,
+    RAW_VIDEO_DIR,
+    RAW_FRAME_DIR,
+    TEST_RUN,
+    TEST_RUN_FRAME_NUMBER,
+    FRAME_PROCESSING_BATCH_SIZE,
+    WEIGHTS_DIR,
+    WEIGHTS_DIR_NAME,
+    FRAME_DIR_NAME,
+    VIDEO_DIR_NAME,
+    STORAGE_DIR_NAME,
+    RAW_FRAME_DIR_NAME,
+    RAW_VIDEO_DIR_NAME,
+    PDF_DIR_NAME,
+    PDF_DIR,
+    RAW_PDF_DIR,
+    RAW_PDF_DIR_NAME,
+)
+
 __all__ = [
     "load_model_data_from_yaml",
     "collect_center_names",
@@ -33,4 +56,24 @@ __all__ = [
     "get_pdf_hash",
     "get_video_hash",
     "get_patient_examination_hash",
+    "STORAGE_DIR",
+    "FRAME_DIR",
+    "VIDEO_DIR",
+    "RAW_VIDEO_DIR",
+    "RAW_FRAME_DIR",
+    "TEST_RUN",
+    "TEST_RUN_FRAME_NUMBER",
+    "FRAME_PROCESSING_BATCH_SIZE",
+    "DJANGO_NAME_SALT",
+    "WEIGHTS_DIR",
+    "WEIGHTS_DIR_NAME",
+    "FRAME_DIR_NAME",
+    "VIDEO_DIR_NAME",
+    "STORAGE_DIR_NAME",
+    "RAW_FRAME_DIR_NAME",
+    "RAW_VIDEO_DIR_NAME",
+    "RAW_PDF_DIR_NAME",
+    "PDF_DIR_NAME",
+    "PDF_DIR",
+    "RAW_PDF_DIR",
 ]

endoreg_db/utils/dataloader.py

@@ -38,15 +38,22 @@ def load_data_with_foreign_keys(
     command, model, yaml_data, foreign_keys, foreign_key_models, verbose
 ):
     """
-    Load data handling foreign keys and many-to-many relationships.
-
-    Args:
-        command: Command object for stdout writing.
-        model: The Django model for the data.
-        yaml_data: Data loaded from YAML.
-        foreign_keys: List of foreign keys.
-        foreign_key_models: Corresponding models for the foreign keys.
-        verbose: Boolean indicating whether to print verbose output.
+    Load YAML data into Django model instances with FK and M2M support.
+    
+    Processes each YAML entry to create or update a model instance. For each entry, the
+    function extracts field data and uses the presence of a 'name' field to decide whether
+    to update an existing instance or create a new one. Foreign key fields listed in
+    foreign_keys are handled by retrieving related objects via natural keys. When a field
+    contains a list, it is treated as a many-to-many relationship and the corresponding
+    objects are set after the instance is saved. Missing or unresolved foreign keys trigger
+    warnings if verbose output is enabled.
+    
+    Parameters:
+        model: The Django model class representing the data.
+        yaml_data: A list of dictionaries representing YAML entries.
+        foreign_keys: A list of foreign key field names to process from each entry.
+        foreign_key_models: The corresponding Django model classes for each foreign key.
+        verbose: If True, prints detailed output and warnings during processing.
     """
     for entry in yaml_data:
         fields = entry.get("fields", {})
@@ -56,7 +63,10 @@ def load_data_with_foreign_keys(
 
         # Handle foreign keys and many-to-many relationships
         for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
-            # print(fk_field, fk_model)
+            # Skip fields that are not in the data
+            if fk_field not in fields:
+                continue
+
             target_keys = fields.pop(fk_field, None)
 
             # Ensure the foreign key exists
@@ -73,18 +83,20 @@ def load_data_with_foreign_keys(
             if isinstance(target_keys, list):  # Assume many-to-many relationship
                 related_objects = []
                 for key in target_keys:
-                    obj, created = fk_model.objects.get_or_create(name=key)
-                    if created and verbose:
-                        command.stdout.write(
-                            command.style.SUCCESS(f"Created {fk_model.__name__} {key}")
-                        )
+                    try:
+                        obj = fk_model.objects.get_by_natural_key(key)
+                    except ObjectDoesNotExist:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING(
+                                    f"{fk_model.__name__} with key {key} not found"
+                                )
+                            )
+                        continue
                     related_objects.append(obj)
                 m2m_relationships[fk_field] = related_objects
             else:  # Single foreign key relationship
                 try:
-                    if model == "endoreg_db.case_template_rule":
-                        # print(fk_model, target_keys)
-                        pass
                     obj = fk_model.objects.get_by_natural_key(target_keys)
                 except ObjectDoesNotExist:
                     if verbose:
@@ -115,4 +127,11 @@ def load_data_with_foreign_keys(
 
         # Set many-to-many relationships
         for field_name, related_objs in m2m_relationships.items():
-            getattr(obj, field_name).set(related_objs)
+            if related_objs:  # Only set if there are objects to set
+                getattr(obj, field_name).set(related_objs)
+                if verbose:
+                    command.stdout.write(
+                        command.style.SUCCESS(
+                            f"Set {len(related_objs)} {field_name} for {model.__name__} {name}"
+                        )
+                    )

endoreg_db/utils/hashs.py

@@ -5,6 +5,7 @@ from datetime import datetime, date
 import os
 
 SALT = os.getenv("DJANGO_SALT", "default_salt")
+DJANGO_NAME_SALT = os.environ.get("DJANGO_SALT", "default_salt")
 
 
 def get_video_hash(video_path):

endoreg_db/utils/paths.py

@@ -0,0 +1,86 @@
+import os
+from pathlib import Path
+
+STORAGE_DIR_NAME = os.environ.get("DJANGO_STORAGE_DIR_NAME", "data")
+FRAME_DIR_NAME = os.environ.get("DJANGO_FRAME_DIR_NAME", "db_frames")
+VIDEO_DIR_NAME = os.environ.get("DJANGO_VIDEO_DIR_NAME", "db_videos")
+WEIGHTS_DIR_NAME = os.environ.get("DJANGO_WEIGHTS_DIR_NAME", "db_model_weights")
+PDF_DIR_NAME = os.environ.get("DJANGO_PDF_DIR_NAME", "pdfs")
+
+def get_storage_dir(raw: bool = False):
+    """
+    Get the storage directory from the environment variable or settings.
+    """
+    storage_dir = os.environ.get("DJANGO_STORAGE_DIR", "data")
+    storage_dir = Path(storage_dir).expanduser()
+
+    if raw:
+        name = storage_dir.name
+        storage_dir = storage_dir.parent / f"raw_{name}"
+
+
+    if not storage_dir.exists():
+        storage_dir.mkdir(parents=True, exist_ok=True)
+    return storage_dir
+
+def get_frame_dir(raw: bool = False):
+    """
+    Get the frame directory from the environment variable or settings.
+    """
+    frame_dir_name = os.environ.get("DJANGO_FRAME_DIR_NAME", FRAME_DIR_NAME)
+    storage_dir = get_storage_dir(raw)
+    frame_dir = storage_dir / frame_dir_name
+    if not frame_dir.exists():
+        frame_dir.mkdir(parents=True, exist_ok=True)
+    return frame_dir
+
+def get_video_dir(raw: bool = False):
+    """
+    Get the video directory from the environment variable or settings.
+    """
+    video_dir_name = os.environ.get("DJANGO_VIDEO_DIR_NAME", VIDEO_DIR_NAME)
+    storage_dir = get_storage_dir(raw)
+    video_dir = storage_dir / video_dir_name
+    if not video_dir.exists():
+        video_dir.mkdir(parents=True, exist_ok=True)
+    return video_dir
+
+def get_weights_dir():
+    """
+    Get the weights directory from the environment variable or settings.
+    """
+    weights_dir_name = os.environ.get("DJANGO_WEIGHTS_DIR_NAME", WEIGHTS_DIR_NAME)
+    storage_dir = get_storage_dir()
+    weights_dir = storage_dir / weights_dir_name
+    if not weights_dir.exists():
+        weights_dir.mkdir(parents=True, exist_ok=True)
+    return weights_dir
+
+def get_pdf_dir(raw: bool = False):
+    """
+    Get the pdf directory from the environment variable or settings.
+    """
+    pdf_dir_name = os.environ.get("DJANGO_PDF_DIR_NAME", PDF_DIR_NAME)
+    storage_dir = get_storage_dir(raw)
+    pdf_dir = storage_dir / pdf_dir_name
+    if not pdf_dir.exists():
+        pdf_dir.mkdir(parents=True, exist_ok=True)
+    return pdf_dir
+
+STORAGE_DIR = get_storage_dir()
+FRAME_DIR = get_frame_dir()
+VIDEO_DIR = get_video_dir()
+PDF_DIR = get_pdf_dir()
+PDF_DIR_NAME = PDF_DIR.name
+RAW_VIDEO_DIR = get_video_dir(raw=True)
+RAW_VIDEO_DIR_NAME = RAW_VIDEO_DIR.name
+RAW_FRAME_DIR = get_frame_dir(raw=True)
+RAW_FRAME_DIR_NAME = RAW_FRAME_DIR.name
+RAW_PDF_DIR = get_pdf_dir(raw=True)
+RAW_PDF_DIR_NAME = RAW_PDF_DIR.name
+WEIGHTS_DIR = get_weights_dir()
+TEST_RUN = os.environ.get("TEST_RUN", False)
+TEST_RUN_FRAME_NUMBER = os.environ.get("TEST_RUN_FRAME_NUMBER", 1000)
+# AI Stuff
+FRAME_PROCESSING_BATCH_SIZE = os.environ.get("DJANGO_FRAME_PROCESSING_BATCH_SIZE", 10)
+

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)