endoreg-db 0.8.2.2__py3-none-any.whl → 0.8.2.4__py3-none-any.whl

endoreg_db/helpers/default_objects.py

@@ -1,5 +1,4 @@
 import random
-from typing import Optional
 from endoreg_db.models import (
     Center, 
     Gender, 
@@ -18,7 +17,6 @@ import shutil
 from pathlib import Path
 from django.conf import settings # Import settings
 from django.core.files.storage import default_storage # Import default storage
-from django.db.models.fields.files import FieldFile
 
 from endoreg_db.utils import (
     create_mock_patient_name,
@@ -46,10 +44,6 @@ DEFAULT_INDICATIONS = [
 DEFAULT_SEGMENTATION_MODEL_NAME = "image_multilabel_classification_colonoscopy_default"
 
 DEFAULT_GENDER = "unknown"
-DEFAULT_PATIENT_FIRST_NAME = "TestFirst"
-DEFAULT_PATIENT_LAST_NAME = "TestLast"
-DEFAULT_PATIENT_GENDER_NAME = "female"
-DEFAULT_PATIENT_BIRTH_DATE = date(1970, 1, 1)
 
 def get_information_source_prediction():
     """
@@ -176,41 +170,33 @@ def get_default_center() -> Center:
     return center
 
 def generate_patient(**kwargs) -> Patient:
-    """Create a Patient with deterministic defaults unless ``randomize=True`` is supplied."""
-
-    randomize = kwargs.pop("randomize", False)
-
-    gender = kwargs.get("gender")
-    if gender is None:
-        if randomize:
-            gender = get_random_gender()
-        else:
-            gender = Gender.objects.get(name=DEFAULT_PATIENT_GENDER_NAME)
-    elif not isinstance(gender, Gender):
+    """
+    Creates a Patient instance with randomized or specified attributes.
+    
+    Randomly generates first name, last name, date of birth, gender, and center for the patient unless overridden by keyword arguments. Raises ValueError if the provided gender is invalid.
+    
+    Args:
+        **kwargs: Optional overrides for patient attributes such as 'first_name', 'last_name', 'birth_date', 'gender', and 'center'.
+    
+    Returns:
+        A Patient instance with the specified or randomly generated attributes.
+    """
+    # Set default values
+    gender = kwargs.get("gender", get_random_gender())
+    if not isinstance(gender, Gender):
         gender = Gender.objects.get(name=gender)
 
-    first_name = kwargs.get("first_name")
-    last_name = kwargs.get("last_name")
-    if first_name is None or last_name is None:
-        if randomize:
-            generated_first, generated_last = create_mock_patient_name(gender=gender.name)
-        else:
-            generated_first, generated_last = DEFAULT_PATIENT_FIRST_NAME, DEFAULT_PATIENT_LAST_NAME
-        first_name = first_name or generated_first
-        last_name = last_name or generated_last
-
-    dob = kwargs.get("dob")
-    if dob is None:
-        birth_date = kwargs.get("birth_date", DEFAULT_PATIENT_BIRTH_DATE)
-        if isinstance(birth_date, date):
-            dob = birth_date
-        else:
-            dob = date.fromisoformat(str(birth_date))
-
-    center = kwargs.get("center")
+    if not isinstance(gender, Gender):
+        raise ValueError("No Gender Found")
+    first_name, last_name = create_mock_patient_name(gender = gender.name)
+    first_name = kwargs.get("first_name", first_name)
+    last_name = kwargs.get("last_name", last_name)
+    birth_date = kwargs.get("birth_date", "1970-01-01")
+    dob = date.fromisoformat(birth_date)
+    center = kwargs.get("center", None)
     if center is None:
         center = get_default_center()
-    elif not isinstance(center, Center):
+    else:
         center = Center.objects.get(name=center)
 
     patient = Patient(
@@ -275,7 +261,6 @@ def get_default_egd_pdf():
     shutil.copy(egd_path, temp_file_path)
 
     pdf_file = None
-    file_field: Optional[FieldFile] = None
     try:
         # Create the PDF record using the temporary file.
         # delete_source=True will ensure temp_file_path is deleted by create_from_file
@@ -290,11 +275,8 @@ def get_default_egd_pdf():
             raise RuntimeError("Failed to create PDF file object")
         
         # Use storage API to check existence
-        file_field = pdf_file.file
-        if not isinstance(file_field, FieldFile):
-            raise RuntimeError("RawPdfFile.file did not return a FieldFile instance")
-        if not default_storage.exists(file_field.path):
-            raise RuntimeError(f"PDF file does not exist in storage at {file_field.path}")
+        if not default_storage.exists(pdf_file.file.path):
+            raise RuntimeError(f"PDF file does not exist in storage at {pdf_file.file.path}")
         
         # Check that the source temp file was deleted
         if temp_file_path.exists():
@@ -326,11 +308,10 @@ def get_default_egd_pdf():
 
     # pdf_file.file.path might fail if storage doesn't support direct paths (like S3)
     # Prefer using storage API for checks. Logging path if available.
-    if file_field is not None:
-        try:
-            logger.info(f"PDF file created: {file_field.name}, Path: {file_field.path}")
-        except NotImplementedError:
-            logger.info(f"PDF file created: {file_field.name}, Path: (Not available from storage)")
+    try:
+        logger.info(f"PDF file created: {pdf_file.file.name}, Path: {pdf_file.file.path}")
+    except NotImplementedError:
+        logger.info(f"PDF file created: {pdf_file.file.name}, Path: (Not available from storage)")
 
 
     return pdf_file

endoreg_db/management/commands/import_video.py

@@ -294,12 +294,10 @@ class Command(BaseCommand):
                 
                 # Updated to handle new return signature (path, metadata)
                 cleaned_video_path, extracted_metadata = frame_cleaner.clean_video(
-                    video_path=Path(video_file_obj.raw_file.path),
+                    Path(video_file_obj.raw_file.path),
                     video_file_obj=video_file_obj,  # Pass VideoFile object to store metadata
-                    device_name=processor_name,
-                    endoscope_roi=video_file_obj.processor.get_roi_endoscope_image if video_file_obj.processor else None,
-                    output_path=video_file_obj.get_processed_file_path(),
-                    technique="mask_overlay"  # Use mask overlay technique as default, if not set this will be inferred.
+                    report_reader=report_reader,
+                    device_name=processor_name
                 )
                 
                 # Save the cleaned video using Django's FileField

endoreg_db/models/media/video/video_file.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Optional, Union, cast
 
 from django.db import models
 from django.core.files import File
-from django.db.models.fields.files import FieldFile
 from django.core.validators import FileExtensionValidator
 from django.db.models import F
 from endoreg_db.utils.calc_duration_seconds import _calc_duration_vf
@@ -128,36 +127,36 @@ class VideoFile(models.Model):
     sensitive_meta = models.OneToOneField(
         "SensitiveMeta", on_delete=models.SET_NULL, null=True, blank=True, related_name="video_file"
     ) # type: ignore
-    center = models.ForeignKey("Center", on_delete=models.PROTECT) # type: ignore
+    center = models.ForeignKey("Center", on_delete=models.PROTECT)
     processor = models.ForeignKey(
         "EndoscopyProcessor", on_delete=models.PROTECT, blank=True, null=True
-    ) # type: ignore
+    )
     video_meta = models.OneToOneField(
         "VideoMeta", on_delete=models.SET_NULL, null=True, blank=True, related_name="video_file"
-    ) # type: ignore
+    )
     examination = models.ForeignKey(
         "PatientExamination",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
         related_name="video_files",
-    ) # type: ignore
+    )
     patient = models.ForeignKey(
         "Patient",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
         related_name="video_files",
-    ) # type: ignore
+    )
     ai_model_meta = models.ForeignKey(
         "ModelMeta", on_delete=models.SET_NULL, blank=True, null=True
-    ) # type: ignore
+    )
     state = models.OneToOneField(
         "VideoState", on_delete=models.SET_NULL, null=True, blank=True, related_name="video_file"
-    ) # type: ignore
+    )
     import_meta = models.OneToOneField(
         "VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True
-    ) # type: ignore
+    )
 
     original_file_name = models.CharField(max_length=255, blank=True, null=True)
     uploaded_at = models.DateTimeField(auto_now_add=True)
@@ -198,9 +197,7 @@ class VideoFile(models.Model):
         """
         from endoreg_db.models import FFMpegMeta
         if self.video_meta is not None:
-            if self.video_meta.ffmpeg_meta is not None:
-                return self.video_meta.ffmpeg_meta
-            raise AssertionError("Expected FFMpegMeta instance.")
+            return self.video_meta.ffmpeg_meta
         else:
             self.initialize_video_specs()
             ffmpeg_meta = self.video_meta.ffmpeg_meta if self.video_meta else None
@@ -219,19 +216,20 @@ class VideoFile(models.Model):
         Raises:
             Value Error if no active VideoFile is available.
         """
-        active = self.active_file
-        if not isinstance(active, FieldFile):
-            raise ValueError("Active file is not a stored FieldFile instance.")
-        if not active.name:
-            raise ValueError("Active file has no associated name.")
-        return active.url
+        _file = self.active_file
+        assert _file is not None, "No active file available. VideoFile has neither raw nor processed file."
+        if not _file or not _file.name:
+            raise ValueError("Active file has no associated file.")
+        url = _file.url
+
+        return url
     
     @property
-    def active_raw_file(self) -> FieldFile:
-        raw = self.raw_file
-        if isinstance(raw, FieldFile) and raw.name:
-            return raw
-        raise ValueError("No raw file available for this video")
+    def active_raw_file(self) -> File:
+        if self.has_raw:
+            return self.raw_file
+        else:
+            raise ValueError("Has no raw file")
         
     @property
     def active_raw_file_url(self)-> str:
@@ -243,10 +241,12 @@ class VideoFile(models.Model):
         
         Returns:
         """
-        raw = self.active_raw_file
-        if not raw.name:
-            raise ValueError("Active raw file has no associated name.")
-        return raw.url
+        _file = self.active_raw_file
+        assert _file is not None, "No active file available. VideoFile has neither raw nor processed file."
+        if not _file or not _file.name:
+            raise ValueError("Active file has no associated file.")
+        url = _file.url
+        return url
         
 
     # Pipeline Functions
@@ -363,7 +363,7 @@ class VideoFile(models.Model):
     
 
     @property
-    def active_file(self) -> FieldFile:
+    def active_file(self) -> File:
         """
         Return the active video file, preferring the processed file if available.
         
@@ -373,15 +373,12 @@ class VideoFile(models.Model):
         Raises:
             ValueError: If neither a processed nor a raw file is available.
         """
-        processed = self.processed_file
-        if isinstance(processed, FieldFile) and processed.name:
-            return processed
-
-        raw = self.raw_file
-        if isinstance(raw, FieldFile) and raw.name:
-            return raw
-
-        raise ValueError("No active file available. VideoFile has neither raw nor processed file.")
+        if self.is_processed:
+            return self.processed_file
+        elif self.has_raw:
+            return self.raw_file
+        else:
+            raise ValueError("No active file available. VideoFile has neither raw nor processed file.")
         
 
     @property
@@ -396,17 +393,13 @@ class VideoFile(models.Model):
             ValueError: If neither a processed nor raw file is present.
         """
         active = self.active_file
-        if active is self.processed_file:
-            path = _get_processed_file_path(self)
-        elif active is self.raw_file:
-            path = _get_raw_file_path(self)
+        if active == self.processed_file:
+            return _get_processed_file_path(self)
+        elif active == self.raw_file:
+            return _get_raw_file_path(self)
         else:
             raise ValueError("No active file path available. VideoFile has neither raw nor processed file.")
 
-        if path is None:
-            raise ValueError("Active file path could not be resolved.")
-        return path
-
 
     @classmethod
     def create_from_file(cls, file_path: Union[str, Path], center_name: str, **kwargs) -> Optional["VideoFile"]:
@@ -455,14 +448,13 @@ class VideoFile(models.Model):
         """
         # Ensure frames are deleted before the main instance
         _delete_frames(self)
-
+        
         # Call the original delete method to remove the instance from the database
-        active_path = self.active_file_path
-        logger.info(f"Deleting VideoFile: {self.uuid} - {active_path}")
-
+        logger.info(f"Deleting VideoFile: {self.uuid} - {self.active_file_path}")
+        
         # Delete associated files if they exist
-        if active_path.exists():
-            active_path.unlink(missing_ok=True)
+        if self.active_file_path.exists():
+            self.active_file_path.unlink(missing_ok=True)
         
         # Delete file storage
         if self.raw_file and self.raw_file.storage.exists(self.raw_file.name):
@@ -487,9 +479,8 @@ class VideoFile(models.Model):
                 
         try:
             # Call parent delete with proper parameters
-            result = super().delete(using=using, keep_parents=keep_parents)
+            super().delete(using=using, keep_parents=keep_parents)
             logger.info(f"VideoFile {self.uuid} deleted successfully.")
-            return result
         except Exception as e:
             logger.error(f"Error deleting VideoFile {self.uuid}: {e}")
             raise

endoreg_db/models/metadata/sensitive_meta.py

@@ -37,7 +37,7 @@ class SensitiveMeta(models.Model):
         blank=True,
         null=True,
         help_text="FK to the pseudo-anonymized Patient record."
-    ) # type: ignore
+    )
     patient_first_name = models.CharField(max_length=255, blank=True, null=True)
     patient_last_name = models.CharField(max_length=255, blank=True, null=True)
     patient_dob = models.DateTimeField(
@@ -51,24 +51,24 @@ class SensitiveMeta(models.Model):
         blank=True,
         null=True,
         help_text="FK to the pseudo-anonymized PatientExamination record."
-    ) # type: ignore
+    )
     patient_gender = models.ForeignKey(
         "Gender",
         on_delete=models.CASCADE,
         blank=True,
         null=True,
-    ) # type: ignore
+    )
     examiners = models.ManyToManyField(
         "Examiner",
         blank=True,
         help_text="Pseudo-anonymized examiner(s) associated with the examination."
-    ) # type: ignore
+    )
     center = models.ForeignKey(
         "Center",
         on_delete=models.CASCADE,
         blank=True, # Should ideally be False if always required before save
         null=True,  # Should ideally be False
-    ) # type: ignore
+    )
 
     # Raw examiner names stored temporarily until pseudo-examiner is created/linked
     examiner_first_name = models.CharField(max_length=255, blank=True, null=True, editable=False)
@@ -258,7 +258,7 @@ class SensitiveMeta(models.Model):
 
         # 4. Handle ManyToMany linking (examiners) *after* the instance has a PK.
         if examiner_to_link and self.pk and not self.examiners.filter(pk=examiner_to_link.pk).exists():
-            self.examiners.add(examiner_to_link) # type: ignore
+            self.examiners.add(examiner_to_link)
             # Adding to M2M handles its own DB interaction, no second super().save() needed.
 
     def mark_dob_verified(self):