endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/metadata/sensitive_meta_logic.py

@@ -18,14 +18,14 @@ from endoreg_db.utils.hashs import get_patient_examination_hash, get_patient_has
 from ..administration import Center, Examiner, FirstName, LastName, Patient
 from ..medical import PatientExamination
 from ..other import Gender
-from ..state import SensitiveMetaState
 
 if TYPE_CHECKING:
     from .sensitive_meta import SensitiveMeta  # Import model for type hinting
 
 logger = logging.getLogger(__name__)
 SECRET_SALT = os.getenv("DJANGO_SALT", "default_salt")
-DEFAULT_UNKNOWN_NAME = "unknown"
+DEFAULT_UNKNOWN = "unknown"
+
 
 # Regex-Pattern für verschiedene Datumsformate
 ISO_RX = re.compile(r"^\d{4}-\d{2}-\d{2}$")
@@ -192,6 +192,11 @@ def calculate_examination_hash(
     if not center:
         raise ValueError("Center is required to calculate examination hash.")
 
+    if not first_name:
+        raise ValueError("First name is required to calculate examination hash.")
+    if not last_name:
+        raise ValueError("Last name is required to calculate examination hash.")
+
     hash_str = get_patient_examination_hash(
         first_name=first_name,
         last_name=last_name,
@@ -233,7 +238,7 @@ def create_pseudo_examiner_logic(instance: "SensitiveMeta") -> "Examiner":
     return examiner
 
 
-def get_or_create_pseudo_patient_logic(instance: "SensitiveMeta") -> "Patient":
+def get_or_create_pseudo_patient_logic(instance: "SensitiveMeta"):
     """Gets or creates the pseudo patient based on instance data."""
     # Ensure necessary fields are set
     if not instance.patient_hash:
@@ -256,12 +261,12 @@ def get_or_create_pseudo_patient_logic(instance: "SensitiveMeta") -> "Patient":
         birth_year=year,
         birth_month=month,
     )
-    return patient
+    return patient, _created
 
 
 def get_or_create_pseudo_patient_examination_logic(
     instance: "SensitiveMeta",
-) -> "PatientExamination":
+):
     """Gets or creates the pseudo patient examination based on instance data."""
     # Ensure necessary fields are set
     if not instance.patient_hash:
@@ -270,9 +275,9 @@ def get_or_create_pseudo_patient_examination_logic(
         instance.examination_hash = calculate_examination_hash(instance)
 
     # Ensure the pseudo patient exists first, as PatientExamination might depend on it
-    if not instance.pseudo_patient_id:
-        pseudo_patient = get_or_create_pseudo_patient_logic(instance)
-        instance.pseudo_patient_id = pseudo_patient.pk  # Assign FK directly
+    if not instance.pseudo_patient:
+        pseudo_patient, _created = get_or_create_pseudo_patient_logic(instance)
+        instance.pseudo_patient = pseudo_patient  # Assign FK directly
 
     patient_examination, _created = (
         PatientExamination.get_or_create_pseudo_patient_examination_by_hash(
@@ -282,7 +287,7 @@ def get_or_create_pseudo_patient_examination_logic(
             # pseudo_patient=instance.pseudo_patient
         )
     )
-    return patient_examination
+    return patient_examination, _created
 
 
 @transaction.atomic  # Ensure all operations within save succeed or fail together
@@ -294,7 +299,7 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     This function is called on every save() operation and implements a two-phase approach:
 
     **Phase 1: Initial Creation (with defaults)**
-    - When a SensitiveMeta is first created (e.g., via get_or_create_sensitive_meta()),
+    - When a SensitiveMeta is first created (e.g., via create_from_dict),
       it may have missing patient data (names, DOB, etc.)
     - Default values are set to prevent hash calculation errors:
       * patient_first_name: "unknown"
@@ -381,19 +386,19 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     # Updated:  patient_first_name = "Max"     → hash = sha256("Max Mustermann...")
     #
     if not instance.patient_first_name:
-        instance.patient_first_name = DEFAULT_UNKNOWN_NAME
+        instance.patient_first_name = DEFAULT_UNKNOWN
         logger.debug(
             "SensitiveMeta (pk=%s): Patient first name missing, set to default '%s'.",
             instance.pk or "new",
-            DEFAULT_UNKNOWN_NAME,
+            DEFAULT_UNKNOWN,
         )
 
     if not instance.patient_last_name:
-        instance.patient_last_name = DEFAULT_UNKNOWN_NAME
+        instance.patient_last_name = DEFAULT_UNKNOWN
         logger.debug(
             "SensitiveMeta (pk=%s): Patient last name missing, set to default '%s'.",
             instance.pk or "new",
-            DEFAULT_UNKNOWN_NAME,
+            DEFAULT_UNKNOWN,
         )
 
     # 3. Ensure Gender exists (should be set before calling save, e.g., during creation/update)
@@ -426,13 +431,15 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
 
     # 5. Get or Create Pseudo Patient (depends on hash, center, gender, dob)
     # Assign directly to the FK field to avoid premature saving issues
-    pseudo_patient = get_or_create_pseudo_patient_logic(instance)
-    instance.pseudo_patient_id = pseudo_patient.pk
+    pseudo_patient, _created = get_or_create_pseudo_patient_logic(instance)
+    instance.pseudo_patient = pseudo_patient
 
     # 6. Get or Create Pseudo Examination (depends on hashes)
     # Assign directly to the FK field
-    pseudo_examination = get_or_create_pseudo_patient_examination_logic(instance)
-    instance.pseudo_examination_id = pseudo_examination.pk
+    pseudo_examination, _created = get_or_create_pseudo_patient_examination_logic(
+        instance
+    )
+    instance.pseudo_examination = pseudo_examination
 
     # 7. Get or Create Pseudo Examiner (depends on names, center)
     # This needs to happen *after* the main instance has a PK for M2M linking.
@@ -467,6 +474,8 @@ def create_sensitive_meta_from_dict(
         "patient_dob": date(1990, 1, 1),
         "examination_date": date.today(),
         "center": center_obj,  # ← Center object
+        "text": text #from extraction
+
     }
     sm = SensitiveMeta.create_from_dict(data)
 
@@ -477,6 +486,7 @@ def create_sensitive_meta_from_dict(
         "patient_dob": date(1990, 1, 1),
         "examination_date": date.today(),
         "center_name": "university_hospital_wuerzburg",  # ← String
+        "anonymized_text": "anonymized text"
     }
     sm = SensitiveMeta.create_from_dict(data)
     ```
@@ -620,6 +630,7 @@ def create_sensitive_meta_from_dict(
                             exam_date,
                         )
                         selected_data.pop("examination_date", None)
+
             except Exception as e:
                 logger.warning(
                     "Error parsing examination_date string '%s': %s, removing from data",
@@ -653,8 +664,8 @@ def create_sensitive_meta_from_dict(
         )
 
     # Handle Names and Gender
-    first_name = selected_data.get("patient_first_name") or DEFAULT_UNKNOWN_NAME
-    last_name = selected_data.get("patient_last_name") or DEFAULT_UNKNOWN_NAME
+    first_name = selected_data.get("patient_first_name") or DEFAULT_UNKNOWN
+    last_name = selected_data.get("patient_last_name") or DEFAULT_UNKNOWN
     selected_data["patient_first_name"] = first_name  # Ensure defaults are set
     selected_data["patient_last_name"] = last_name
 
@@ -674,7 +685,18 @@ def create_sensitive_meta_from_dict(
                 f"Gender with name '{patient_gender_input}' provided but not found. Attempting to guess or use default."
             )
             # Fall through to guessing logic if provided string name is invalid
-            patient_gender_input = None  # Reset to trigger guessing
+            normalized = (patient_gender_input or "").lower()
+            if normalized in {"male", "female", "unknown"}:
+                gender_obj, _ = Gender.objects.get_or_create(
+                    name=normalized,
+                    defaults={
+                        "abbreviation": normalized[:1].upper() or None,
+                        "description": "Auto-created default gender entry",
+                    },
+                )
+                selected_data["patient_gender"] = gender_obj
+            else:
+                patient_gender_input = None  # Reset to trigger guessing
 
     if not isinstance(
         selected_data.get("patient_gender"), Gender
@@ -690,10 +712,63 @@ def create_sensitive_meta_from_dict(
                 name=gender_name_to_use
             )
         except Gender.DoesNotExist:
-            # This should ideally not happen if "unknown" gender is guaranteed to exist
-            raise ValueError(
-                f"Default or guessed gender '{gender_name_to_use}' does not exist in Gender table."
+            gender_obj, _ = Gender.objects.get_or_create(
+                name=gender_name_to_use,
+                defaults={
+                    "abbreviation": gender_name_to_use[:1].upper() or None,
+                    "description": "Auto-created default gender entry",
+                },
             )
+            selected_data["patient_gender"] = gender_obj
+
+    # Handle Text
+    selected_data["text"] = data.get("text") or DEFAULT_UNKNOWN
+
+    # --- Add missing optional fields safely ---
+    file_path = data.get("file_path")
+    if file_path:
+        selected_data["file_path"] = str(file_path)
+        logger.debug(f"Set file_path: {file_path}")
+
+    casenumber = data.get("casenumber")
+    if casenumber:
+        selected_data["casenumber"] = str(casenumber).strip()
+        logger.debug(f"Set casenumber: {casenumber}")
+
+    exam_time = data.get("examination_time")
+    if exam_time:
+        try:
+            from datetime import time as dt_time
+
+            # Accepts strings like "14:35" or full datetime
+            if isinstance(exam_time, str):
+                h, m = exam_time.strip().split(":")[:2]
+                selected_data["examination_time"] = dt_time(int(h), int(m))
+            elif isinstance(exam_time, datetime):
+                selected_data["examination_time"] = exam_time.time()
+            elif isinstance(exam_time, date):
+                # no time info — ignore
+                logger.debug(
+                    f"examination_time value {exam_time} has no time component; skipping"
+                )
+            else:
+                selected_data["examination_time"] = exam_time
+        except Exception as e:
+            logger.warning(f"Invalid examination_time '{exam_time}': {e}")
+
+    anonymized_text = data.get("anonymized_text") or data.get("anonym_text")
+    if anonymized_text:
+        if isinstance(anonymized_text, (str, bytes)):
+            selected_data["anonymized_text"] = (
+                anonymized_text.decode()
+                if isinstance(anonymized_text, bytes)
+                else anonymized_text
+            )
+        else:
+            selected_data["anonymized_text"] = str(anonymized_text)
+        logger.debug(
+            "Set anonymized_text (length=%d)", len(selected_data["anonymized_text"])
+        )
 
     # Update name DB
     update_name_db(first_name, last_name)
@@ -715,7 +790,7 @@ def update_sensitive_meta_from_dict(
 
     **Integration with two-phase save pattern:**
     This function is typically called after initial SensitiveMeta creation when real
-    patient data becomes available (e.g., extracted from video OCR, PDF parsing, or
+    patient data becomes available (e.g., extracted from video OCR, report parsing, or
     manual annotation).
 
     **Example workflow:**
@@ -875,6 +950,36 @@ def update_sensitive_meta_from_dict(
             )
             selected_data.pop("patient_gender", None)
 
+    # TODO Review: Handle new optional fields on update
+    for key in (
+        "file_path",
+        "casenumber",
+        "examination_time",
+        "anonymized_text",
+        "anonym_text",
+    ):
+        if key in data and data[key] is not None:
+            val = data[key]
+            if key in ("file_path", "casenumber"):
+                setattr(instance, key, str(val))
+            elif key in ("anonymized_text", "anonym_text"):
+                setattr(
+                    instance,
+                    "anonymized_text",
+                    val if isinstance(val, str) else str(val),
+                )
+            elif key == "examination_time":
+                try:
+                    from datetime import time as dt_time
+
+                    if isinstance(val, str) and ":" in val:
+                        h, m = val.strip().split(":")[:2]
+                        setattr(instance, "examination_time", dt_time(int(h), int(m)))
+                    elif isinstance(val, datetime):
+                        setattr(instance, "examination_time", val.time())
+                except Exception as e:
+                    logger.warning(f"Skipping invalid examination_time '{val}': {e}")
+
     # Update other attributes from selected_data
     patient_name_changed = False
     for k, v in selected_data.items():
@@ -903,70 +1008,28 @@ def update_sensitive_meta_from_dict(
                             aware_dob,
                         )
                     elif isinstance(v, str):
-                        # Handle string DOB - check if it's a field name or actual date
-                        if v == "patient_dob" or v in [
-                            "patient_first_name",
-                            "patient_last_name",
-                            "examination_date",
-                        ]:
-                            logger.warning(
-                                "Skipping invalid patient_dob value '%s' during update - appears to be field name",
+                        parsed = parse_any_date(v)
+                        if parsed:
+                            aware_dob = timezone.make_aware(
+                                datetime.combine(parsed, datetime.min.time())
+                            )
+                            value_to_set = aware_dob
+                            logger.debug(
+                                "Parsed string patient_dob '%s' during update to aware datetime: %s",
                                 v,
+                            aware_dob,
                             )
-                            continue  # Skip this field
                         else:
-                            # Try to parse as date string
-                            try:
-                                import dateparser
-
-                                parsed_dob = dateparser.parse(
-                                    v, languages=["de"], settings={"DATE_ORDER": "DMY"}
-                                )
-                                if parsed_dob:
-                                    value_to_set = timezone.make_aware(
-                                        parsed_dob.replace(
-                                            hour=0, minute=0, second=0, microsecond=0
-                                        )
-                                    )
-                                    logger.debug(
-                                        "Parsed string patient_dob '%s' during update to aware datetime: %s",
-                                        v,
-                                        value_to_set,
-                                    )
-                                else:
-                                    logger.warning(
-                                        "Could not parse patient_dob string '%s' during update, skipping",
-                                        v,
-                                    )
-                                    continue
-                            except Exception as e:
-                                logger.warning(
-                                    "Error parsing patient_dob string '%s' during update: %s, skipping",
-                                    v,
-                                    e,
-                                )
-                                continue
-                elif k == "examination_date" and isinstance(v, str):
-                    if v == "examination_date" or v in [
-                        "patient_first_name",
-                        "patient_last_name",
-                        "patient_dob",
-                    ]:
-                        logger.warning(
-                            "Skipping invalid examination_date value '%s' during update - appears to be field name",
-                            v,
-                        )
-                        continue
-                    else:
-                        # Try to parse as date string
-                        try:
-                            import dateparser
-
-                            parsed_date = dateparser.parse(
-                                v, languages=["de"], settings={"DATE_ORDER": "DMY"}
+                            logger.warning(
+                                "Could not parse patient_dob string '%s' during update, skipping",
+                                v,
                             )
-                            if parsed_date:
-                                value_to_set = parsed_date.date()
+                            continue
+                    elif k == "examination_date":
+                        if isinstance(v, str):
+                            parsed = parse_any_date(v)
+                            if parsed:
+                                value_to_set = parsed  # field is DateField, so keep it as date
                                 logger.debug(
                                     "Parsed string examination_date '%s' during update to date: %s",
                                     v,
@@ -978,23 +1041,19 @@ def update_sensitive_meta_from_dict(
                                     v,
                                 )
                                 continue
-                        except Exception as e:
-                            logger.warning(
-                                "Error parsing examination_date string '%s' during update: %s, skipping",
-                                v,
-                                e,
-                            )
-                            continue
-                # --- End Conversion ---
+                        elif isinstance(v, date):
+                            value_to_set = v
 
-                # Check if patient name is changing
-                if (
-                    k in ["patient_first_name", "patient_last_name"]
-                    and getattr(instance, k) != value_to_set
-                ):
-                    patient_name_changed = True
+                        # --- End Conversion ---
 
-                setattr(instance, k, value_to_set)  # Use value_to_set
+                        # Check if patient name is changing
+                        if (
+                            k in ["patient_first_name", "patient_last_name"]
+                            and getattr(instance, k) != value_to_set
+                        ):
+                            patient_name_changed = True
+
+                        setattr(instance, k, value_to_set)  # Use value_to_set
 
             except Exception as e:
                 logger.error(
@@ -1023,15 +1082,21 @@ def update_or_create_sensitive_meta_from_dict(
     cls: Type["SensitiveMeta"],
     data: Dict[str, Any],
     instance: Optional["SensitiveMeta"] = None,
-) -> "SensitiveMeta":
+):
     """Logic to update or create a SensitiveMeta instance from a dictionary."""
     # Check if the instance already exists based on unique fields
+    sensitive_meta: "SensitiveMeta"
+    _created: bool
     if instance:
         # Update the existing instance
-        return update_sensitive_meta_from_dict(instance, data), False
+        sensitive_meta = update_sensitive_meta_from_dict(instance, data)
+        _created = False
+
     else:
         # Create a new instance
-        return create_sensitive_meta_from_dict(cls, data), True
+        sensitive_meta = create_sensitive_meta_from_dict(cls, data)
+        _created = True
+    return sensitive_meta, _created
 
 
 def _map_gender_string_to_standard(gender_str: str) -> Optional[str]:
@@ -1046,3 +1111,33 @@ def _map_gender_string_to_standard(gender_str: str) -> Optional[str]:
         if gender_lower in variants:
             return standard
     return None
+
+
+def _create_anonymized_record(
+    instance: "SensitiveMeta",
+    DEFAULT_ANONYMIZED=None,
+    DEFAULT_ANONYMIZED_DATE=timezone.make_aware(datetime(1900, 1, 1)),
+) -> None:
+    """
+    Create a SensitiveMeta instance with all sensitive fields set to anonymized defaults.
+    This is only called after anonymization and will delete all data that can identify a patient from the database.
+    What is left will only be the patient hash.
+
+    Args:
+        instance: The existing SensitiveMeta instance to anonymize
+        DEFAULT_ANONYMIZED: Usually None, The default string to use for anonymized fields (e.g., "anonymized,")
+    """
+
+    instance.refresh_from_db()
+    instance.get_patient_hash()
+    instance.get_patient_examination_hash()
+
+    anonymized_data = {
+        "patient_first_name": DEFAULT_ANONYMIZED,
+        "patient_last_name": DEFAULT_ANONYMIZED,
+        "patient_dob": DEFAULT_ANONYMIZED_DATE,
+        "examination_date": DEFAULT_ANONYMIZED_DATE,
+    }
+    sensitive_meta = update_sensitive_meta_from_dict(instance, anonymized_data)
+
+    sensitive_meta.save()

endoreg_db/models/metadata/video_meta.py

@@ -1,10 +1,10 @@
-from django.db import models
 import logging
 from pathlib import Path
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 # import endoreg_center_id from django settings
 from django.conf import settings
+from django.db import models
 
 # check if endoreg_center_id is set
 if not hasattr(settings, "ENDOREG_CENTER_ID"):
@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from ..administration import Center
-    from ..medical.hardware import EndoscopyProcessor, Endoscope
+    from ..medical.hardware import Endoscope, EndoscopyProcessor
 
 
 # VideoMeta
@@ -29,19 +29,40 @@ class VideoMeta(models.Model):
 
     Links to hardware (processor, endoscope), center, import details, and FFmpeg technical specs.
     """
-    processor = models.ForeignKey(
-        "EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True
-    )
-    endoscope = models.ForeignKey(
-        "Endoscope", on_delete=models.CASCADE, blank=True, null=True
-    )
+
+    processor = models.ForeignKey("EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True)
+    endoscope = models.ForeignKey("Endoscope", on_delete=models.CASCADE, blank=True, null=True)
     center = models.ForeignKey("Center", on_delete=models.CASCADE)
-    import_meta = models.OneToOneField(
-        "VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True
-    )
-    ffmpeg_meta = models.OneToOneField(
-        "FFMpegMeta", on_delete=models.CASCADE, blank=True, null=True
-    )
+    import_meta = models.OneToOneField("VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True)
+    ffmpeg_meta = models.OneToOneField("FFMpegMeta", on_delete=models.CASCADE, blank=True, null=True)
+
+    if TYPE_CHECKING:
+        processor: models.ForeignKey["EndoscopyProcessor|None"]
+        endoscope: models.ForeignKey["Endoscope|None"]
+        center: models.ForeignKey["Center|None"]
+        import_meta: models.OneToOneField["VideoImportMeta|None"]
+        ffmpeg_meta: models.OneToOneField["FFMpegMeta|None"]
+
+    @property
+    def center_safe(self) -> "Center":
+        center = self.center
+        if not center:
+            raise Center.DoesNotExist("Center does not exist for this VideoMeta instance.")
+        return center
+
+    @property
+    def processor_safe(self) -> "EndoscopyProcessor":
+        processor = self.processor
+        if not processor:
+            raise EndoscopyProcessor.DoesNotExist("EndoscopyProcessor does not exist for this VideoMeta instance.")
+        return processor
+
+    @property
+    def ffmpeg_meta_safe(self) -> "FFMpegMeta":
+        ffmpeg_meta = self.ffmpeg_meta
+        if not ffmpeg_meta:
+            raise FFMpegMeta.DoesNotExist("FFMpegMeta does not exist for this VideoMeta instance.")
+        return ffmpeg_meta
 
     @classmethod
     def create_from_file(
@@ -71,7 +92,7 @@ class VideoMeta(models.Model):
             raise RuntimeError(f"Failed to initialize FFMpeg metadata for {video_path.name}") from e
 
         if save_instance:
-            meta.save() # This ensures VideoImportMeta is created too
+            meta.save()  # This ensures VideoImportMeta is created too
             logger.info("Created and saved VideoMeta instance PK %s from %s", meta.pk, video_path.name)
         else:
             logger.info("Instantiated VideoMeta from %s (not saved yet)", video_path.name)
@@ -120,8 +141,8 @@ class VideoMeta(models.Model):
             # If the VideoMeta instance is already saved, save the link immediately.
             # Otherwise, the link will be saved when VideoMeta itself is saved.
             if self.pk:
-                self.save(update_fields=['ffmpeg_meta'])
-            logger.info("Successfully created and linked FFMpegMeta PK %s", self.ffmpeg_meta.pk)
+                self.save(update_fields=["ffmpeg_meta"])
+            logger.info("Successfully created and linked FFMpegMeta PK %s", self.ffmpeg_meta_safe.pk)
 
         except Exception as e:
             # Log the error and re-raise it
@@ -140,8 +161,8 @@ class VideoMeta(models.Model):
             logger.debug("Deleting existing FFMpegMeta PK %s before update.", existing_ffmpeg_pk)
             # Nullify the relation first before deleting the related object
             self.ffmpeg_meta = None
-            self.save(update_fields=['ffmpeg_meta']) # Save the null relation
-            FFMpegMeta.objects.filter(pk=existing_ffmpeg_pk).delete() # Delete the old object
+            self.save(update_fields=["ffmpeg_meta"])  # Save the null relation
+            FFMpegMeta.objects.filter(pk=existing_ffmpeg_pk).delete()  # Delete the old object
 
         # initialize_ffmpeg_meta handles creation, linking, saving the link, and raises exceptions
         self.initialize_ffmpeg_meta(video_path)
@@ -150,7 +171,7 @@ class VideoMeta(models.Model):
         """Retrieves the endoscope region of interest (ROI) from the associated processor."""
         from ..medical.hardware import EndoscopyProcessor
 
-        processor: EndoscopyProcessor = self.processor
+        processor: EndoscopyProcessor = self.processor_safe
         endo_roi = processor.get_roi_endoscope_image()
         return endo_roi
 
@@ -189,6 +210,7 @@ class FFMpegMeta(models.Model):
     """
     Stores technical video stream information extracted using FFmpeg (ffprobe).
     """
+
     width = models.IntegerField(null=True, blank=True)
     height = models.IntegerField(null=True, blank=True)
     duration = models.FloatField(null=True, blank=True)  # Duration in seconds
@@ -219,7 +241,6 @@ class FFMpegMeta(models.Model):
             logger.error("ffprobe execution failed for %s: %s", file_path, probe_err, exc_info=True)
             raise RuntimeError(f"ffprobe execution failed for {file_path}") from probe_err
 
-
         if not probe_data or "streams" not in probe_data:
             logger.error("Failed to get valid stream info from ffprobe for %s", file_path)
             # Raise exception instead of returning None
@@ -237,8 +258,8 @@ class FFMpegMeta(models.Model):
         height = video_stream.get("height")
         duration_str = video_stream.get("duration")
         # --- FIX: Handle potential format key ---
-        if duration_str is None and 'format' in probe_data and 'duration' in probe_data['format']:
-            duration_str = probe_data['format']['duration']
+        if duration_str is None and "format" in probe_data and "duration" in probe_data["format"]:
+            duration_str = probe_data["format"]["duration"]
             logger.debug("Using duration from format block: %s", duration_str)
         # --- End Fix ---
         duration = float(duration_str) if duration_str else None
@@ -253,10 +274,10 @@ class FFMpegMeta(models.Model):
         frame_rate_num, frame_rate_den = None, None
         if frame_rate_str and "/" in frame_rate_str:
             try:
-                num_str, den_str = frame_rate_str.split('/')
+                num_str, den_str = frame_rate_str.split("/")
                 frame_rate_num = int(num_str)
                 frame_rate_den = int(den_str)
-                if frame_rate_den == 0: # Avoid division by zero
+                if frame_rate_den == 0:  # Avoid division by zero
                     logger.warning("Invalid frame rate denominator (0) for %s", file_path)
                     frame_rate_num, frame_rate_den = None, None
             except ValueError:
@@ -267,8 +288,8 @@ class FFMpegMeta(models.Model):
         pixel_format = video_stream.get("pix_fmt")
         bit_rate_str = video_stream.get("bit_rate")
         # --- FIX: Handle potential format key for bit_rate ---
-        if bit_rate_str is None and 'format' in probe_data and 'bit_rate' in probe_data['format']:
-            bit_rate_str = probe_data['format']['bit_rate']
+        if bit_rate_str is None and "format" in probe_data and "bit_rate" in probe_data["format"]:
+            bit_rate_str = probe_data["format"]["bit_rate"]
             logger.debug("Using bit_rate from format block: %s", bit_rate_str)
         # --- End Fix ---
         bit_rate = int(bit_rate_str) if bit_rate_str else None
@@ -311,6 +332,7 @@ class VideoImportMeta(models.Model):
     """
     Stores metadata related to the import and processing status of a video.
     """
+
     file_name = models.CharField(max_length=255, blank=True, null=True)
     video_anonymized = models.BooleanField(default=False)
     video_patient_data_detected = models.BooleanField(default=False)
@@ -323,9 +345,7 @@ class VideoImportMeta(models.Model):
         result_html = ""
 
         result_html += f"Video anonymized: {self.video_anonymized}\n"
-        result_html += (
-            f"Video patient data detected: {self.video_patient_data_detected}\n"
-        )
+        result_html += f"Video patient data detected: {self.video_patient_data_detected}\n"
         result_html += f"Outside detected: {self.outside_detected}\n"
         result_html += f"Patient data removed: {self.patient_data_removed}\n"
         result_html += f"Outside removed: {self.outside_removed}\n"