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

endoreg_db/helpers/default_objects.py

@@ -1,4 +1,5 @@
 import random
+from typing import Optional
 from endoreg_db.models import (
     Center, 
     Gender, 
@@ -17,6 +18,7 @@ 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,
@@ -44,6 +46,10 @@ 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():
     """
@@ -170,33 +176,41 @@ def get_default_center() -> Center:
     return center
 
 def generate_patient(**kwargs) -> Patient:
-    """
-    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):
+    """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):
         gender = Gender.objects.get(name=gender)
 
-    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)
+    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 center is None:
         center = get_default_center()
-    else:
+    elif not isinstance(center, Center):
         center = Center.objects.get(name=center)
 
     patient = Patient(
@@ -261,6 +275,7 @@ 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
@@ -275,8 +290,11 @@ def get_default_egd_pdf():
             raise RuntimeError("Failed to create PDF file object")
         
         # Use storage API to check existence
-        if not default_storage.exists(pdf_file.file.path):
-            raise RuntimeError(f"PDF file does not exist in storage at {pdf_file.file.path}")
+        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}")
         
         # Check that the source temp file was deleted
         if temp_file_path.exists():
@@ -308,10 +326,11 @@ 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.
-    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)")
+    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)")
 
 
     return pdf_file

endoreg_db/management/commands/import_video.py

@@ -294,10 +294,12 @@ class Command(BaseCommand):
                 
                 # Updated to handle new return signature (path, metadata)
                 cleaned_video_path, extracted_metadata = frame_cleaner.clean_video(
-                    Path(video_file_obj.raw_file.path),
+                    video_path=Path(video_file_obj.raw_file.path),
                     video_file_obj=video_file_obj,  # Pass VideoFile object to store metadata
-                    report_reader=report_reader,
-                    device_name=processor_name
+                    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.
                 )
                 
                 # Save the cleaned video using Django's FileField

endoreg_db/migrations/0003_add_center_display_name.py

@@ -0,0 +1,30 @@
+from django.db import migrations, models
+
+
+def populate_display_name(apps, schema_editor):
+    Center = apps.get_model('endoreg_db', 'Center')
+    for center in Center.objects.all():
+        if not center.display_name:
+            center.display_name = center.name
+            center.save(update_fields=['display_name'])
+
+
+def reset_display_name(apps, schema_editor):
+    Center = apps.get_model('endoreg_db', 'Center')
+    Center.objects.update(display_name='')
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('endoreg_db', '0002_add_video_correction_models'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='center',
+            name='display_name',
+            field=models.CharField(blank=True, default='', max_length=255),
+        ),
+        migrations.RunPython(populate_display_name, reset_display_name),
+    ]

endoreg_db/models/administration/center/center.py

@@ -19,6 +19,7 @@ class Center(models.Model):
 
     # import_id = models.IntegerField(primary_key=True)
     name = models.CharField(max_length=255)
+    display_name = models.CharField(max_length=255, blank=True, default="")
 
     first_names = models.ManyToManyField(
         to="FirstName",
@@ -45,8 +46,13 @@ class Center(models.Model):
     def natural_key(self) -> tuple[str]:
         return (self.name,)
 
+    def save(self, *args, **kwargs):
+        if not self.display_name:
+            self.display_name = self.name
+        super().save(*args, **kwargs)
+
     def __str__(self) -> str:
-        return str(object=self.name)
+        return str(object=self.display_name or self.name)
 
     def get_first_names(self):
         return self.first_names.all()

endoreg_db/models/media/pdf/raw_pdf.py

@@ -383,37 +383,42 @@ class RawPdfFile(models.Model):
         new_file_name, _uuid = get_uuid_filename(file_path)
         logger.info(f"Generated new filename: {new_file_name}")
 
-        # Create model instance (without file initially)
-        raw_pdf = cls(
-            pdf_hash=pdf_hash,
-            center=center,
-        )
-
-        # Assign file using Django's File wrapper and save
+        # Create model instance via manager so creation can be intercepted/mocked during tests
         try:
             with file_path.open("rb") as f:
                 django_file = File(f, name=new_file_name)
-                raw_pdf.file = django_file  # type: ignore # Assign the file object
-                # Save the instance - Django storage handles the file copy/move
-                raw_pdf.save()
-                _file = raw_pdf.file
-                assert _file is not None
-                logger.info(f"Created and saved new RawPdfFile {raw_pdf.pk} with file {_file.name}")
-
-                # Verify file exists in storage after save
-                if not _file.storage.exists(_file.name):
-                    logger.error(f"File was not saved correctly to storage path {_file.name} after model save.")
-                    raise IOError(f"File not found at expected storage path after save: {_file.name}")
-                # Log the absolute path for debugging if possible (depends on storage)
-                try:
-                    logger.info(f"File saved to absolute path: {_file.path}")
-                except NotImplementedError:
-                    logger.info(f"File saved to storage path: {_file.name} (Absolute path not available from storage)")
+                raw_pdf = cls.objects.create(
+                    pdf_hash=pdf_hash,
+                    center=center,
+                    file=django_file,
+                )
+
+            _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
+            )
+
+            if not _file.storage.exists(_file.name):
+                logger.error(
+                    "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}"
+                )
+
+            try:
+                logger.info("File saved to absolute path: %s", _file.path)
+            except NotImplementedError:
+                logger.info(
+                    "File saved to storage path: %s (Absolute path not available from storage)",
+                    _file.name,
+                )
 
         except Exception as e:
-            logger.error(f"Error processing or saving file {file_path} for new record: {e}")
-            # If save failed, the instance might be partially created but not fully saved.
-            raise  # Re-raise the exception
+            logger.error("Error processing or saving file %s for new record: %s", file_path, e)
+            raise
 
         # Delete source file *after* successful save and verification
         if delete_source:

endoreg_db/models/media/video/create_from_file.py

@@ -6,7 +6,8 @@ from typing import TYPE_CHECKING, Optional, Type
 
 # Import the new exceptions from the correct path
 from endoreg_db.exceptions import InsufficientStorageError, TranscodingError
-from ...utils import VIDEO_DIR, TMP_VIDEO_DIR, data_paths
+from ...utils import VIDEO_DIR, TMP_VIDEO_DIR
+from importlib import import_module
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
@@ -170,6 +171,22 @@ def atomic_move_with_fallback(src_path: Path, dst_path: Path) -> bool:
         raise
 
 
+def _get_data_paths():
+    """Return the current data_paths mapping (supports patched instances in tests)."""
+    utils_module = import_module("endoreg_db.utils")
+    return getattr(utils_module, "data_paths")
+
+
+def _get_path(mapping, key, default):
+    """Access mapping by key using __getitem__ so MagicMocks with side effects work."""
+    if mapping is None:
+        return default
+    try:
+        return mapping[key]
+    except (KeyError, TypeError):
+        return default
+
+
 def _create_from_file(
     cls_model: Type["VideoFile"],
     file_path: Path,
@@ -199,8 +216,12 @@ def _create_from_file(
 
     try:
         # Ensure we operate under the canonical video path root
-        video_dir = data_paths.get("video", video_dir)
-        storage_root = Path(video_dir).parent
+        data_paths = _get_data_paths()
+        resolved_video_dir = _get_path(data_paths, "video", video_dir)
+        video_dir = Path(resolved_video_dir)
+        storage_root_default = Path(video_dir).parent
+        resolved_storage_root = _get_path(data_paths, "storage", storage_root_default)
+        storage_root = Path(resolved_storage_root)
         storage_root.mkdir(parents=True, exist_ok=True)
         
         # Check storage capacity before starting any work
@@ -300,7 +321,8 @@ def _create_from_file(
         # 8. Create the VideoFile instance
         logger.info("Creating new VideoFile instance with UUID: %s", uuid_val)
         # Store FileField path relative to storage root including the videos prefix
-        relative_name = (final_storage_path.relative_to(data_paths['storage'])).as_posix()
+        storage_base = Path(_get_path(data_paths, "storage", final_storage_path.parent))
+        relative_name = (final_storage_path.relative_to(storage_base)).as_posix()
         video = cls_model(
             uuid=uuid_val,
             raw_file=relative_name,

endoreg_db/models/media/video/video_file.py

@@ -7,6 +7,7 @@ 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
@@ -126,37 +127,37 @@ class VideoFile(models.Model):
 
     sensitive_meta = models.OneToOneField(
         "SensitiveMeta", on_delete=models.SET_NULL, null=True, blank=True, related_name="video_file"
-    )
-    center = models.ForeignKey("Center", on_delete=models.PROTECT)
+    ) # type: ignore
+    center = models.ForeignKey("Center", on_delete=models.PROTECT) # type: ignore
     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)
@@ -197,7 +198,9 @@ class VideoFile(models.Model):
         """
         from endoreg_db.models import FFMpegMeta
         if self.video_meta is not None:
-            return self.video_meta.ffmpeg_meta
+            if self.video_meta.ffmpeg_meta is not None:
+                return self.video_meta.ffmpeg_meta
+            raise AssertionError("Expected FFMpegMeta instance.")
         else:
             self.initialize_video_specs()
             ffmpeg_meta = self.video_meta.ffmpeg_meta if self.video_meta else None
@@ -216,20 +219,19 @@ class VideoFile(models.Model):
         Raises:
             Value Error if no active VideoFile is available.
         """
-        _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
+        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
     
     @property
-    def active_raw_file(self) -> File:
-        if self.has_raw:
-            return self.raw_file
-        else:
-            raise ValueError("Has no raw file")
+    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")
         
     @property
     def active_raw_file_url(self)-> str:
@@ -241,12 +243,10 @@ class VideoFile(models.Model):
         
         Returns:
         """
-        _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
+        raw = self.active_raw_file
+        if not raw.name:
+            raise ValueError("Active raw file has no associated name.")
+        return raw.url
         
 
     # Pipeline Functions
@@ -363,7 +363,7 @@ class VideoFile(models.Model):
     
 
     @property
-    def active_file(self) -> File:
+    def active_file(self) -> FieldFile:
         """
         Return the active video file, preferring the processed file if available.
         
@@ -373,12 +373,15 @@ class VideoFile(models.Model):
         Raises:
             ValueError: If neither a processed nor a raw file is available.
         """
-        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.")
+        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.")
         
 
     @property
@@ -393,13 +396,17 @@ class VideoFile(models.Model):
             ValueError: If neither a processed nor raw file is present.
         """
         active = self.active_file
-        if active == self.processed_file:
-            return _get_processed_file_path(self)
-        elif active == self.raw_file:
-            return _get_raw_file_path(self)
+        if active is self.processed_file:
+            path = _get_processed_file_path(self)
+        elif active is self.raw_file:
+            path = _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"]:
@@ -448,13 +455,14 @@ 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
-        logger.info(f"Deleting VideoFile: {self.uuid} - {self.active_file_path}")
-        
+        active_path = self.active_file_path
+        logger.info(f"Deleting VideoFile: {self.uuid} - {active_path}")
+
         # Delete associated files if they exist
-        if self.active_file_path.exists():
-            self.active_file_path.unlink(missing_ok=True)
+        if active_path.exists():
+            active_path.unlink(missing_ok=True)
         
         # Delete file storage
         if self.raw_file and self.raw_file.storage.exists(self.raw_file.name):
@@ -465,11 +473,23 @@ class VideoFile(models.Model):
         # Use proper database connection
         if using is None:
             using = 'default'
-        
+
+        raw_file_path = self.get_raw_file_path()
+        if raw_file_path:
+            raw_file_path = Path(raw_file_path)
+            lock_path = raw_file_path.with_suffix(raw_file_path.suffix + ".lock")
+            if lock_path.exists():
+                try:
+                    lock_path.unlink()
+                    logger.info(f"Removed processing lock: {lock_path}")
+                except Exception as e:
+                    logger.warning(f"Could not remove processing lock {lock_path}: {e}")
+                
         try:
             # Call parent delete with proper parameters
-            super().delete(using=using, keep_parents=keep_parents)
+            result = 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
@@ -572,15 +592,28 @@ class VideoFile(models.Model):
         super().save(*args, **kwargs)
 
     def get_or_create_state(self) -> "VideoState":
-        """
-        Return the related VideoState instance for this video, creating and assigning a new one if none exists.
-        
-        Returns:
-            VideoState: The associated VideoState instance.
-        """
-        if self.state is None:
-            self.state = VideoState.objects.create()
-        return self.state
+        """Ensure this video has a persisted ``VideoState`` and return it."""
+
+        state = self.state
+
+        # When tests reuse cached instances across database flushes, ``state`` may reference
+        # a row that no longer exists. Guard against that by validating persistence.
+        state_pk = getattr(state, "pk", None)
+        if state is not None and state_pk is not None:
+            if not VideoState.objects.filter(pk=state_pk).exists():
+                state = None
+
+        if state is None:
+            # Create a fresh state to avoid refresh_from_db() failures on unsaved instances.
+            state = VideoState.objects.create()
+            self.state = state
+
+            # Persist the relation immediately if the VideoFile already exists in the DB so
+            # later refreshes see the association without requiring additional saves.
+            if self.pk:
+                self.save(update_fields=["state"])
+
+        return state
 
     def get_or_create_sensitive_meta(self) -> "SensitiveMeta":
         """
@@ -592,8 +625,7 @@ class VideoFile(models.Model):
         from endoreg_db.models import SensitiveMeta
         if self.sensitive_meta is None:
             self.sensitive_meta = SensitiveMeta.objects.create(center = self.center)
-            # Mark as processed when creating new SensitiveMeta
-            self.get_or_create_state().mark_sensitive_meta_processed(save=True)
+            # Do not mark processed here; it will be set after extraction/validation steps
         return self.sensitive_meta
 
     def get_outside_segments(self, only_validated: bool = False) -> models.QuerySet["LabelVideoSegment"]:

endoreg_db/models/media/video/video_file_anonymize.py

@@ -12,6 +12,7 @@ from django.conf import settings
 
 from endoreg_db.utils.hashs import get_video_hash
 from endoreg_db.utils.validate_endo_roi import validate_endo_roi
+from endoreg_db.utils.paths import STORAGE_DIR
 from ....utils.video.ffmpeg_wrapper import assemble_video_from_frames
 from ...utils import anonymize_frame  # Import from models.utils
 from .video_file_segments import _get_outside_frames, _get_outside_frame_numbers
@@ -268,7 +269,7 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
             raise ValueError(f"Processed video hash {new_processed_hash} already exists for another video (Video: {video.uuid}).")
 
         video.processed_video_hash = new_processed_hash
-        video.processed_file.name = video.get_target_anonymized_video_path().relative_to(settings.MEDIA_ROOT).as_posix()
+        video.processed_file.name = video.get_target_anonymized_video_path().relative_to(STORAGE_DIR).as_posix()
 
         update_fields = [
             "processed_video_hash",

endoreg_db/models/media/video/video_file_frames/_manage_frame_range.py

@@ -97,6 +97,7 @@ def _extract_frame_range(
             return True  # Indicate success as frames are considered present
 
     frame_dir.mkdir(parents=True, exist_ok=True)
+    extracted_paths = []
 
     try:
         logger.info("Starting frame range extraction [%d, %d) for video %s to %s", start_frame, end_frame, video.uuid, frame_dir)
@@ -111,6 +112,17 @@ def _extract_frame_range(
 
         return True
 
+    except FileNotFoundError as err:
+        logger.error(
+            "Frame range extraction [%d, %d) failed for video %s: %s",
+            start_frame,
+            end_frame,
+            video.uuid,
+            err,
+            exc_info=True,
+        )
+        raise
+
     except Exception as e:
         logger.error("Frame range extraction [%d, %d) or DB update failed for video %s: %s", start_frame, end_frame, video.uuid, e, exc_info=True)
 

endoreg_db/models/media/video/video_file_io.py

@@ -32,13 +32,15 @@ def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
                 if sensitive_path.exists():
                     return sensitive_path.resolve()
                 
+                # Check direct raw_file.path if available
                 # Check direct raw_file.path if available
                 try:
                     direct_path = Path(video.raw_file.path)
                     if direct_path.exists():
                         return direct_path.resolve()
-                except Exception:
-                    pass  # Fallback to original behavior
+                except Exception as e:
+                    logger.debug("Could not access direct raw_file.path for video %s: %s", video.uuid, e)
+                    # Fallback to checking alternative paths
                 
                 # Check common alternative paths
                 alternative_paths = [