endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/models/media/pdf/raw_pdf.py

@@ -4,38 +4,39 @@
 # Class contains classmethod to create object from pdf file
 # objects contains methods to extract text, extract metadata from text and anonymize text from pdf file uzing agl_report_reader.ReportReader class
 # ------------------------------------------------------------------------------
-import os
-from django.db import models
+from typing import TYPE_CHECKING, Optional, cast
+
 from django.core.exceptions import ValidationError
-from django.core.validators import FileExtensionValidator
 from django.core.files import File
-from numpy import isin  # Import Django File
+from django.core.validators import FileExtensionValidator
+from django.db import models
+
 from endoreg_db.utils.file_operations import get_uuid_filename
-from typing import TYPE_CHECKING, Optional, Union
-# Use the specific paths from the centralized paths module
-from ...utils import PDF_DIR
 from endoreg_db.utils.hashs import get_pdf_hash
+from endoreg_db.utils.paths import PDF_DIR
+from endoreg_db.utils.storage import (
+    delete_field_file,
+    ensure_local_file,
+    file_exists,
+    save_local_file,
+)
 
 if TYPE_CHECKING:
-    from endoreg_db.models.administration.person import (
-        Patient,
-        Examiner,
-    )
-    from .report_file import AnonymExaminationReport
-    from ...medical.patient import PatientExamination
-    from ...administration import Center
-    from ...metadata.pdf_meta import PdfType
-    from ...state import RawPdfState
-from ...metadata import SensitiveMeta
+    from django.db.models.fields.files import FieldFile
+
+    from endoreg_db.models.state import RawPdfState
 
 # setup logging to pdf_import.log
 import logging
-
 from pathlib import Path
 
+from ...metadata import SensitiveMeta
+
 logger = logging.getLogger("raw_pdf")
 
+
 class RawPdfFile(models.Model):
+    objects = models.Manager()
     # Fields from AbstractPdfFile
     pdf_hash = models.CharField(max_length=255, unique=True)
     pdf_type = models.ForeignKey(
@@ -49,72 +50,128 @@ class RawPdfFile(models.Model):
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
-    ) # type: ignore
+    )
     examination = models.ForeignKey(
         "PatientExamination",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
         related_name="raw_pdf_files",
-    ) # type: ignore
+    )
     examiner = models.ForeignKey(
         "Examiner",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
-    ) # type: ignore
+    )
     text = models.TextField(blank=True, null=True)
     date_created = models.DateTimeField(auto_now_add=True)
     date_modified = models.DateTimeField(auto_now=True)
     anonymized = models.BooleanField(default=False, help_text="True if the PDF has been anonymized.")
-
-    # Fields specific to RawPdfFile (keeping existing related_names)
     file = models.FileField(
         # Use the relative path from the specific PDF_DIR
         upload_to=PDF_DIR.name,
         validators=[FileExtensionValidator(allowed_extensions=["pdf"])],
-    ) # type: ignore
-    
+    )
     anonymized_file = models.FileField(
         upload_to=PDF_DIR.name,
         validators=[FileExtensionValidator(allowed_extensions=["pdf"])],
         null=True,
         blank=True,
-    ) # type: ignore
-
+    )
     state = models.OneToOneField(
         "RawPdfState",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
         related_name="raw_pdf_file",
-    ) # type: ignore
-    
-    objects = models.Manager()
-    
+    )
+    patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="raw_pdf_files",
+    )
+    sensitive_meta = models.ForeignKey(
+        "SensitiveMeta",
+        on_delete=models.SET_NULL,
+        related_name="raw_pdf_files",
+        null=True,
+        blank=True,
+    )
+    state_report_processing_required = models.BooleanField(default=True)
+    state_report_processed = models.BooleanField(default=False)
+    raw_meta = models.JSONField(blank=True, null=True)
+    anonym_examination_report = models.OneToOneField(
+        "AnonymExaminationReport",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="raw_pdf_file",
+    )
+    anonymized_text = models.TextField(blank=True, null=True)
+
+    # Type hinting is needed, improve and use correct django types
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            AnonymExaminationReport,
+            Center,
+            Examiner,
+            Patient,
+            PatientExamination,
+            RawPdfState,
+            SensitiveMeta,
+        )
+
+        center: models.ForeignKey["Center | None"]
+        examination: models.ForeignKey["PatientExamination | None"]
+        examiner: models.ForeignKey["Examiner | None"]
+        state: models.ForeignKey["RawPdfState | None"]
+        patient: models.ForeignKey["Patient | None"]
+        sensitive_meta: models.ForeignKey["SensitiveMeta | None"]
+        anonym_examination_report: models.OneToOneField["AnonymExaminationReport | None"]
+        file = cast(FieldFile, file)
+        anonymized_file = cast(FieldFile, anonymized_file)
+
     @property
-    def file_path(self) -> Path|None:
+    def uuid(self):
+        """
+        Compatibility property - returns pdf_hash as UUID-like identifier.
+
+        Note: RawPdfFile uses pdf_hash instead of UUID for identification.
+        This property exists for API backward compatibility.
+        """
+        return self.pdf_hash
+
+    @property
+    def file_path(self) -> Path | None:
         """
         Returns the file path of the stored PDF file if available; otherwise, returns None.
         """
+        from django.db.models.fields.files import FieldFile
+
         # assert self.file has path attribute
-        assert isinstance(self.file, models.FieldFile)
+        assert isinstance(self.file, FieldFile)
         if self.file and self.file.name:
             try:
                 return Path(self.file.path)
             except (ValueError, AttributeError, NotImplementedError):
                 return None
         return None
-    
+
     def set_file_path(self, file_path: Path):
         """
         Sets the file path of the stored PDF file.
         """
-        self.file = File(file_path) # type: ignore
-        self.save(update_fields=['file'])
+        if not file_path.exists():
+            raise FileNotFoundError(f"File path does not exist: {file_path}")
+
+        save_local_file(self.file, file_path, name=file_path.name, save=False)
+        self.save(update_fields=["file"])
 
     @property
-    def anonymized_file_path(self) -> Path|None:
+    def anonymized_file_path(self) -> Path | None:
         """
         Returns the file path of the anonymized PDF file if available; otherwise, returns None.
         """
@@ -124,13 +181,76 @@ class RawPdfFile(models.Model):
             except (ValueError, AttributeError, NotImplementedError):
                 return None
         return None
-    
+
     def set_anonymized_file_path(self, file_path: Path):
         """
         Sets the file path of the anonymized PDF file.
         """
-        self.anonymized_file = File(file_path) # type: ignore
-        self.save(update_fields=['anonymized_file'])
+        if not file_path.exists():
+            raise FileNotFoundError(f"File path does not exist: {file_path}")
+
+        save_local_file(self.anonymized_file, file_path, name=file_path.name, save=False)
+        self.save(update_fields=["anonymized_file"])
+
+    def get_raw_file_path(self) -> Optional[Path]:
+        """
+        Get the path to the raw PDF file, searching common locations.
+
+        This method attempts to find the original raw PDF file by checking:
+        1. Direct hash-based path in raw_pdfs/
+        2. Scanning raw_pdfs/ directory for files matching the hash
+        3. Checking the file field if it exists
+
+        Returns:
+            Path to raw file if it exists, None otherwise
+        """
+        from django.conf import settings
+
+        # Check if file field already points to a valid file
+        if self.file and self.file.name:
+            try:
+                file_path = Path(self.file.path)
+                if file_path.exists():
+                    logger.debug(f"Found raw PDF via file field: {file_path}")
+                    return file_path
+            except (ValueError, AttributeError, NotImplementedError):
+                pass
+
+        # Define potential raw directories
+        raw_dirs = [
+            PDF_DIR / "sensitive",  # Files might be in sensitive dir
+            Path(settings.BASE_DIR) / "data" / "raw_pdfs",
+            Path(settings.BASE_DIR) / "data" / "pdfs" / "raw",
+            PDF_DIR,  # General PDF directory
+        ]
+
+        # Check direct hash-based name in each directory
+        for raw_dir in raw_dirs:
+            if not raw_dir.exists():
+                continue
+
+            hash_path = raw_dir / f"{self.pdf_hash}.pdf"
+            if hash_path.exists():
+                logger.debug(f"Found raw PDF at: {hash_path}")
+                return hash_path
+
+        # Scan directories for matching hash
+        for raw_dir in raw_dirs:
+            if not raw_dir.exists():
+                continue
+
+            for file_path in raw_dir.glob("*.pdf"):
+                try:
+                    file_hash = get_pdf_hash(file_path)
+                    if file_hash == self.pdf_hash:
+                        logger.debug(f"Found matching PDF by hash: {file_path}")
+                        return file_path
+                except Exception as e:
+                    logger.debug(f"Error checking {file_path}: {e}")
+                    continue
+
+        logger.warning(f"No raw file found for PDF hash: {self.pdf_hash}")
+        return None
 
     @property
     def file_url(self):
@@ -141,7 +261,7 @@ class RawPdfFile(models.Model):
             return self.file.url if self.file and self.file.name else None
         except (ValueError, AttributeError):
             return None
-        
+
     @property
     def anonymized_file_url(self):
         """
@@ -152,45 +272,6 @@ class RawPdfFile(models.Model):
         except (ValueError, AttributeError):
             return None
 
-    patient = models.ForeignKey(
-        "Patient",
-        on_delete=models.SET_NULL,
-        blank=True,
-        null=True,
-        related_name="raw_pdf_files",
-    ) # type: ignore
-    sensitive_meta = models.ForeignKey(
-        "SensitiveMeta",
-        on_delete=models.SET_NULL,
-        related_name="raw_pdf_files",
-        null=True,
-        blank=True,
-    ) # type: ignore
-    state_report_processing_required = models.BooleanField(default=True)
-    state_report_processed = models.BooleanField(default=False)
-    raw_meta = models.JSONField(blank=True, null=True)
-    anonym_examination_report = models.OneToOneField(
-        "AnonymExaminationReport",
-        on_delete=models.SET_NULL,
-        blank=True,
-        null=True,
-        related_name="raw_pdf_file",
-    ) # type: ignore
-    anonymized_text = models.TextField(blank=True, null=True)
-
-    # Type hinting is needed, improve and use correct django types
-    if TYPE_CHECKING:
-        file : Optional[Union[models.FieldFile,models.FileField]] 
-        anonymized_file : Optional[Union[models.FieldFile,models.FileField]]  
-        pdf_type: Optional[models.ForeignKey]
-        examination: Optional[models.ForeignKey["PatientExamination"]]
-        examiner: Optional[models.ForeignKey["Examiner"]]
-        patient: Optional[models.ForeignKey["Patient"]]
-        center: Optional[models.ForeignKey["Center"]]
-        anonym_examination_report: Optional[models.OneToOneField["AnonymExaminationReport"]]
-        sensitive_meta: Optional[models.ForeignKey["SensitiveMeta"]]
-        state: Optional[models.ForeignKey["RawPdfState"]]
-
     def __str__(self):
         """
         Return a string representation of the RawPdfFile, including its PDF hash, type, and center.
@@ -201,72 +282,57 @@ class RawPdfFile(models.Model):
     def delete(self, *args, **kwargs):
         """
         Deletes the RawPdfFile instance from the database and removes the associated file from storage if it exists.
-        
+
         This method ensures that the physical PDF file is deleted from the file system after the database record is removed. Logs warnings or errors if the file cannot be found or deleted.
         """
-        # Call the original delete method first to remove DB record
-        if self.file:
-            try:
-                if self.file_path:
-                    os.remove(Path(self.file_path))
-                    logger.info("Original file removed: %s", self.file)
-            except Exception as e:
-                logger.warning(f"Could not get file path for {self.file.name} before deletion: {e}")
-        if self.anonymized_file:
-            try:
-                if self.anonymized_file_path:
-                    os.remove(Path(self.anonymized_file_path))
-                    logger.info("Anonymized file removed: %s", self.anonymized_file.name)
-            except OSError as e:
-                logger.error("Error removing anonymized file %s: %s", self.anonymized_file.name, e)
+        primary_name = self.file.name if self.file and self.file.name else None
+        anonymized_name = self.anonymized_file.name if self.anonymized_file and self.anonymized_file.name else None
 
-        super().delete(*args, **kwargs)
+        if delete_field_file(self.file, missing_ok=True, save=False):
+            logger.info("Original file removed from storage: %s", primary_name)
+        if delete_field_file(self.anonymized_file, missing_ok=True, save=False):
+            logger.info("Anonymized file removed from storage: %s", anonymized_name)
 
+        super().delete(*args, **kwargs)
 
     def validate_metadata_annotation(self, extracted_data_dict: Optional[dict] = None) -> bool:
         """
         Validate the metadata of the RawPdf instance.
-        
+
         Called after annotation in the frontend, this method deletes the associated active file, updates the sensitive meta data with the user annotated data.
         It also ensures the video file is properly saved after the metadata update.
         """
-        
+
         if not self.sensitive_meta:
             logger.error("No sensitive meta data associated with this PDF file.")
             return False
-        
+
         if not extracted_data_dict:
             logger.error("No extracted data provided for validation.")
             return False
-        
-        # Update sensitive meta with the provided data
-        self.sensitive_meta.update_from_dict(extracted_data_dict)
-        
+
+        if extracted_data_dict:
+            self.sensitive_meta.update_from_dict(extracted_data_dict)
+        else:
+            return False
+
         # Save the sensitive meta to ensure changes are persisted
         self.sensitive_meta.save()
-        
+
         # Save the RawPdfFile instance to ensure all changes are saved
         self.save()
-        
+
         logger.info(f"Metadata for PDF {self.pk} validated and updated successfully.")
-        
-        if self.file_path:
-            try:
-                os.unlink(self.file_path)  # Delete the original file if it exists
-            except OSError as e:
-                logger.error(f"Error removing original file {self.file_path}: {e}")
 
-        if self.anonymized_file_path:
-            try:
-                os.unlink(self.anonymized_file_path)
-            except OSError as e:
-                logger.error(f"Error removing anonymized file {self.anonymized_file_path}: {e}")
+        deleted_original = delete_field_file(self.file, missing_ok=True, save=False)
+        deleted_anonymized = delete_field_file(self.anonymized_file, missing_ok=True, save=False)
+        self.get_or_create_state().mark_anonymization_validated()
+
+        if deleted_original or deleted_anonymized:
+            self.save(update_fields=["file", "anonymized_file"])  # Persist cleared fields
 
-        self.save() # Save the model to persist the cleared file fields
-        
         logger.info(f"Files for PDF {self.pk} deleted successfully.")
         return True
-        
 
     @classmethod
     def create_from_file_initialized(
@@ -277,18 +343,18 @@ class RawPdfFile(models.Model):
     ):
         """
         Creates a RawPdfFile instance from a file and center name, ensuring an associated RawPdfState exists.
-        
+
         Parameters:
             file_path (Path): Path to the source PDF file.
             center_name (str): Name of the center to associate with the PDF.
             delete_source (bool): Whether to delete the source file after processing. Defaults to True.
-        
+
         Returns:
             RawPdfFile: The created or retrieved RawPdfFile instance with an associated RawPdfState.
         """
         raw_pdf = cls.create_from_file(
             file_path=file_path,
-            center_name=center_name,    
+            center_name=center_name,
             delete_source=delete_source,
         )
         _state = raw_pdf.get_or_create_state()
@@ -305,18 +371,18 @@ class RawPdfFile(models.Model):
     ):
         """
         Creates or retrieves a RawPdfFile instance from a given PDF file path and center name.
-        
+
         If a RawPdfFile with the same PDF hash already exists, verifies the file exists in storage and restores it if missing. Otherwise, creates a new RawPdfFile, assigns the file, and saves it to storage. Optionally deletes the source file after processing.
-        
+
         Parameters:
             file_path (Path): Path to the source PDF file.
             center_name (str): Name of the center to associate with the file.
             save (bool, optional): Deprecated; saving occurs internally.
             delete_source (bool, optional): Whether to delete the source file after processing (default True).
-        
+
         Returns:
             RawPdfFile: The created or retrieved RawPdfFile instance.
-        
+
         Raises:
             FileNotFoundError: If the source file does not exist.
             Center.DoesNotExist: If the specified center is not found.
@@ -338,28 +404,41 @@ class RawPdfFile(models.Model):
             raise ValueError(f"Could not calculate hash for {file_path}") from e
 
         # 2. Check if record with this hash already exists
-        existing_pdf_file = cls.objects.filter(pdf_hash=pdf_hash).first()  
+        existing_pdf_file = cls.objects.filter(pdf_hash=pdf_hash).first()
         if existing_pdf_file:
-            logger.warning("RawPdfFile with hash %s already exists (ID: %s)", pdf_hash, existing_pdf_file.pk)
+            logger.warning(
+                "RawPdfFile with hash %s already exists (ID: %s)",
+                pdf_hash,
+                existing_pdf_file.pk,
+            )
 
             # Verify physical file exists for the existing record
             try:
                 if existing_pdf_file is not None and isinstance(existing_pdf_file, cls):
-                # Use storage API to check existence
+                    # Use storage API to check existence
                     _file = existing_pdf_file.file
                     assert _file is not None
                     if not _file.storage.exists(_file.name):
-                        logger.warning("File for existing RawPdfFile %s not found in storage at %s. Attempting to restore from source %s", pdf_hash, _file.name, file_path)
+                        logger.warning(
+                            "File for existing RawPdfFile %s not found in storage at %s. Attempting to restore from source %s",
+                            pdf_hash,
+                            _file.name,
+                            file_path,
+                        )
                         # Re-save the file from the source to potentially fix it
                         with file_path.open("rb") as f:
                             django_file = File(f, name=Path(_file.name).name)  # Use existing name if possible
-                            existing_pdf_file.file = django_file # type: ignore
-                            existing_pdf_file.save(update_fields=['file'])  # Only update file field
+                            existing_pdf_file.file = django_file
+                            existing_pdf_file.save(update_fields=["file"])  # Only update file field
                     else:
                         pass
                         # logger.debug("File for existing RawPdfFile %s already exists in storage.", pdf_hash)
             except Exception as e:
-                logger.error("Error verifying/restoring file for existing record %s: %s", pdf_hash, e)
+                logger.error(
+                    "Error verifying/restoring file for existing record %s: %s",
+                    pdf_hash,
+                    e,
+                )
 
             # Delete the source temp file if requested
             if delete_source:
@@ -396,7 +475,9 @@ class RawPdfFile(models.Model):
             _file = raw_pdf.file
             assert _file is not None
             logger.info(
-                "Created and saved new RawPdfFile %s with file %s", raw_pdf.pk, _file.name
+                "Created and saved new RawPdfFile %s with file %s",
+                raw_pdf.pk,
+                _file.name,
             )
 
             if not _file.storage.exists(_file.name):
@@ -404,9 +485,7 @@ class RawPdfFile(models.Model):
                     "File was not saved correctly to storage path %s after model save.",
                     _file.name,
                 )
-                raise IOError(
-                    f"File not found at expected storage path after save: {_file.name}"
-                )
+                raise IOError(f"File not found at expected storage path after save: {_file.name}")
 
             try:
                 logger.info("File saved to absolute path: %s", _file.path)
@@ -428,7 +507,7 @@ class RawPdfFile(models.Model):
             except OSError as e:
                 logger.error("Error deleting source file %s: %s", file_path, e)
 
-        # raw_pdf.save() # unnecessary? 
+        # raw_pdf.save() # unnecessary?
         return raw_pdf
 
     def save(self, *args, **kwargs):
@@ -436,26 +515,20 @@ class RawPdfFile(models.Model):
         # This is primarily a fallback if instance created manually without using create_from_file
         """
         Saves the RawPdfFile instance, ensuring the PDF hash is set and related fields are derived from metadata.
-        
+
         If the PDF hash is missing, attempts to calculate it from the file before saving. Validates that the file has a `.pdf` extension. If related fields such as patient, examination, center, or examiner are unset but available in the associated sensitive metadata, they are populated accordingly before saving.
         """
         if not self.pk and not self.pdf_hash and self.file:
             try:
-                file_path = Path(self.file.path).resolve()
-                if not file_path.exists():
-                    raise FileNotFoundError(f"File path does not exist: {file_path}")
-                # Read from the file object before it's saved by storage
-                self.file.open('rb')  # Ensure file is open
-                self.file.seek(0)  # Go to beginning
-                self.pdf_hash = get_pdf_hash(file_path)  # Assuming get_pdf_hash can handle file obj
-                self.file.seek(0)  # Reset position
-                self.file.close()  # Close after reading
-                logger.info(f"Calculated hash during pre-save for {self.file.name}")
-            except Exception as e:
-                logger.warning("Could not calculate hash before initial save for %s: %s", self.file.name, e)
-                # Ensure file is closed if opened
-                if hasattr(self.file, 'closed') and not self.file.closed:
-                    self.file.close()
+                with ensure_local_file(self.file) as local_path:
+                    self.pdf_hash = get_pdf_hash(local_path)
+                    logger.info("Calculated hash during pre-save for %s", self.file.name)
+            except Exception as exc:
+                logger.warning(
+                    "Could not calculate hash before initial save for %s: %s",
+                    self.file.name,
+                    exc,
+                )
 
         if self.file and not self.file.name.endswith(".pdf"):
             raise ValidationError("Only PDF files are allowed")
@@ -463,18 +536,17 @@ class RawPdfFile(models.Model):
         # If hash is still missing after potential creation logic (e.g., direct instantiation)
         # and the file exists in storage, try calculating it from storage path.
         # This is less ideal as it requires the file to be saved first.
-        if not self.pdf_hash and self.pk and self.file and self.file.storage.exists(self.file.name):
+        if not self.pdf_hash and self.pk and self.file and file_exists(self.file):
             try:
-                file_path = Path(self.file.path).resolve()
-                if not file_path.exists():
-                    raise FileNotFoundError(f"File path does not exist: {file_path}")
-                logger.warning(f"Hash missing for saved file {self.file.name}. Recalculating.")
-                with self.file.storage.open(self.file.name, 'rb') as f:
-                    self.pdf_hash = get_pdf_hash(file_path)  # Assuming get_pdf_hash handles file obj
-                # No need to save again just for hash unless update_fields is used carefully
-                # Let the main super().save() handle saving the hash if it changed
-            except Exception as e:
-                logger.error("Could not calculate hash during save for existing file %s: %s", self.file.name, e)
+                with ensure_local_file(self.file) as local_path:
+                    logger.warning("Hash missing for saved file %s. Recalculating.", self.file.name)
+                    self.pdf_hash = get_pdf_hash(local_path)
+            except Exception as exc:
+                logger.error(
+                    "Could not calculate hash during save for existing file %s: %s",
+                    self.file.name,
+                    exc,
+                )
 
         # Derive related fields from sensitive_meta if available
         if not self.patient and self.sensitive_meta:
@@ -483,7 +555,7 @@ class RawPdfFile(models.Model):
             self.examination = self.sensitive_meta.pseudo_examination
         if not self.center and self.sensitive_meta:
             self.center = self.sensitive_meta.center
-        #TODO Outdated?
+        # TODO Outdated?
         # if not self.examiner and self.sensitive_meta and hasattr(self.sensitive_meta, 'pseudo_examiner'):
         #     self.examiner = self.sensitive_meta.pseudo_examiner
 
@@ -492,7 +564,7 @@ class RawPdfFile(models.Model):
     def get_or_create_state(self) -> "RawPdfState":
         """
         Retrieve the associated RawPdfState for this RawPdfFile, creating and linking a new one if none exists.
-        
+
         Returns:
             RawPdfState: The existing or newly created RawPdfState instance linked to this RawPdfFile.
         """
@@ -514,7 +586,7 @@ class RawPdfFile(models.Model):
         # Ensure fallback_file is a Path object.
         """
         Checks if the stored PDF file exists in storage and attempts to restore it from a fallback file path if missing.
-        
+
         Parameters:
             fallback_file: Path or string representing the fallback file location to restore from if the stored file is missing.
         """
@@ -534,7 +606,6 @@ class RawPdfFile(models.Model):
                 else:
                     logger.error(f"Fallback file {fallback_file} does not exist.")
         except Exception as e:
-
             logger.error(f"Error during verify_existing_file for {_file.name}: {e}")
 
     def process_file(self, text, anonymized_text, report_meta, verbose):
@@ -562,18 +633,19 @@ class RawPdfFile(models.Model):
         for key, value in serializable_report_meta.items():
             if isinstance(value, (datetime, date)):
                 serializable_report_meta[key] = value.isoformat()
-        
-        self.raw_meta = serializable_report_meta # Assign the version with string dates
 
-        sensitive_meta.save() # Save SensitiveMeta first
-        self.save() # Then save RawPdfFile
+        self.raw_meta = serializable_report_meta  # Assign the version with string dates
+
+        sensitive_meta.save()  # Save SensitiveMeta first
+        self.save()  # Then save RawPdfFile
 
         return text, anonymized_text, report_meta
 
     def get_report_reader_config(self):
+        from warnings import warn
+
         from ...administration import Center
         from ...metadata.pdf_meta import PdfType
-        from warnings import warn
 
         _center = self.center
         assert _center is not None, "Center must be set to get report reader config"
@@ -604,10 +676,10 @@ class RawPdfFile(models.Model):
         }
 
         return settings_dict
-    
+
     @staticmethod
     def get_pdf_by_id(pdf_id: int) -> "RawPdfFile":
         try:
             return RawPdfFile.objects.get(pk=pdf_id)
         except RawPdfFile.DoesNotExist:
-            raise ValueError(f"PDF with ID {pdf_id} does not exist.")
+            raise ValueError(f"PDF with ID {pdf_id} does not exist.")