endoreg-db 0.8.2.4__tar.gz → 0.8.2.7__tar.gz

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/.env.example

@@ -86,4 +86,14 @@ TEST_RUN_FRAME_NUMBER=1000
 RUST_BACKTRACE=1
 DJANGO_FFMPEG_EXTRACT_FRAME_BATCHSIZE=500
 VIDEO_ALLOW_FPS_FALLBACK=True
-VIDEO_DEFAULT_FPS=50
+VIDEO_DEFAULT_FPS=50
+
+# Caching optimization for huggingface, ollama, etc. 
+# CAUTION: SETUP ASSUMES LUXNIX USER 'admin' WITH HOME /home/admin
+
+HF_HOME=/home/admin/.cache/huggingface
+HF_HUB_CACHE=/home/admin/.cache/huggingface/hub
+HF_HUB_ENABLE_HF_TRANSFER=1
+OLLAMA_KEEP_ALIVE=4h
+OLLAMA_MODELS=/home/admin/.ollama/models
+TRANSFORMERS_CACHE=/home/admin/.cache/huggingface/hub

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/.vscode/settings.json

@@ -13,5 +13,5 @@
   "python.defaultInterpreterPath": "${workspaceFolder}/.devenv/state/venv/bin/python",
   "python.pythonPath": "${workspaceFolder}/.devenv/state/venv/bin/python",
   "python.testing.pytestPath": "${workspaceFolder}/.devenv/state/venv/bin/pytest",
-  "python.envFile": "${workspaceFolder}/.env"
+  "python.envFile": "${workspaceFolder}/.env",
 }

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.2.4
+Version: 0.8.2.7
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db
@@ -10,7 +10,6 @@ Maintainer: Max Hild, Hamza Zahid, Peter Kowalczyk
 Maintainer-email: "Thomas J. Lux" <lux_t1@ukw.de>
 License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: <3.13,>=3.12
@@ -33,7 +32,7 @@ Requires-Dist: gunicorn>=23.0.0
 Requires-Dist: icecream>=2.1.4
 Requires-Dist: librosa==0.11.0
 Requires-Dist: llvmlite>=0.44.0
-Requires-Dist: lx-anonymizer[llm,ocr]>=0.8.2.1
+Requires-Dist: lx-anonymizer[llm,ocr]>=0.8.5
 Requires-Dist: moviepy==2.2.1
 Requires-Dist: mypy>=1.16.0
 Requires-Dist: numpy>=2.2.3

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/docs/VIDEO_CORRECTION_MODULES.md

@@ -476,7 +476,7 @@ class VideoProcessingHistoryView(APIView):
 
 ---
 
-### VideoAnalyzeView
+### VideoAnalyzeView (TODO: CURRENTLY NEEDS REWORK SINCE METHOD DEPRECATED IN LX ANONYMIZER)
 
 **Endpoint:** `POST /api/video-analyze/<id>/`
 
@@ -758,55 +758,30 @@ class VideoRemoveFramesView(APIView):
 
 ---
 
-### VideoReprocessView
-
-**Endpoint:** `POST /api/video-reprocess/<id>/`
-
-**Purpose:** Triggers full re-anonymization pipeline (resets state, clears metadata).
-
-**Implementation:**
-```python
-class VideoReprocessView(APIView):
-    def post(self, request, id):
-        video = get_object_or_404(VideoFile, pk=id)
-        
-        # Create processing history
-        VideoProcessingHistory.objects.create(
-            video=video,
-            operation=VideoProcessingHistory.OPERATION_REPROCESSING,
-            status=VideoProcessingHistory.STATUS_PENDING,
-            config={}
-        )
-        
-        # Reset video state
-        if video.state:
-            video.state.anonymization_status = 'processing_anonymization'
-            video.state.save()
-        
-        # Clear existing metadata
-        VideoMetadata.objects.filter(video=video).delete()
-        
-        # TODO Phase 1.2: Trigger Celery task
-        # task = reprocess_video_task.delay(video.id)
-        # return Response({'task_id': task.id, 'message': 'Reprocessing started'})
-        
-        return Response({
-            'message': 'Reprocessing started',
-            'status': 'processing_anonymization'
-        })
-```
-
-**Response Example:**
-```json
-{
-  "message": "Reprocessing started",
-  "status": "processing_anonymization"
-}
-```
-
-**Use Case:** User wants to completely re-run anonymization (e.g., after mask config changes).
-
----
+### VideoReimportView
+
+"""
+VideoReimportView provides an API endpoint for re-importing a video file and regenerating its metadata, particularly SensitiveMeta. This is intended for cases where OCR or metadata extraction failed or was incomplete during the initial import.
+
+Features:
+- Validates the provided video ID (pk) and checks for the existence of the video and its raw file.
+- Ensures the video has an associated center and required relationships.
+- Clears any existing SensitiveMeta and deletes the old record to force regeneration.
+- Re-initializes video specifications and frames.
+- Runs OCR and AI processing (Pipe 1) to extract new metadata.
+- Ensures minimum patient data is present.
+- Uses VideoImportService to anonymize and process the video file.
+- Handles errors gracefully, including storage issues and processing failures.
+- Returns detailed status and metadata about the re-import operation.
+
+Methods:
+- post(request, pk): Handles the re-import process for the video with the given primary key.
+    - Args:
+        - request: The HTTP request object.
+        - pk (int): Primary key of the VideoFile to re-import.
+    - Returns:
+        - Response: JSON response indicating success or failure, with relevant metadata.
+"""
 
 ## URL Configuration
 
@@ -816,10 +791,8 @@ class VideoReprocessView(APIView):
 from endoreg_db.views.video import (
     VideoMetadataView,
     VideoProcessingHistoryView,
-    VideoAnalyzeView,
     VideoApplyMaskView,
     VideoRemoveFramesView,
-    VideoReprocessView,
 )
 
 urlpatterns = [
@@ -831,7 +804,6 @@ urlpatterns = [
     path('video-analyze/<int:id>/', VideoAnalyzeView.as_view(), name='video_analyze'),
     path('video-apply-mask/<int:id>/', VideoApplyMaskView.as_view(), name='video_apply_mask'),
     path('video-remove-frames/<int:id>/', VideoRemoveFramesView.as_view(), name='video_remove_frames'),
-    path('video-reprocess/<int:id>/', VideoReprocessView.as_view(), name='video_reprocess'),
 ]
 ```
 
@@ -841,7 +813,6 @@ urlpatterns = [
 - `POST /api/video-analyze/<id>/`
 - `POST /api/video-apply-mask/<id>/`
 - `POST /api/video-remove-frames/<id>/`
-- `POST /api/video-reprocess/<id>/`
 
 ---
 
@@ -1113,7 +1084,6 @@ def update_segments_after_frame_removal(video, removed_frames):
 # views/video/__init__.py
 from .correction import (
     VideoMetadataView,
-    VideoAnalyzeView,
     # ...
 )
 ```

endoreg_db-0.8.2.7/docs/test_suite_blueprint.md

@@ -0,0 +1,58 @@
+# Test Suite Standardization Blueprint (Draft)
+
+_Date: 2025-10-18_
+
+## Goals
+- Consistent test layout and naming across all domains.
+- Predictable fixture hierarchy that makes scope explicit and minimises global state.
+- Single cache interface with explicit lifecycle for expensive resources (DB seeds, video assets, ML models).
+- Clear integration guidance for new tests and suites.
+
+## Directory & Naming Conventions
+- **Top-level folders:** maintain domain grouping (`tests/<domain>/`) but enforce suffixes: `test_*.py` files only.
+- **Class naming:** use `Test<Subject>` for unit-style suites, `<Feature>Tests` reserved for integration/system cases.
+- **Function naming:** `test_<scenario>_<expected>` pattern; leverage parametrization for variant coverage instead of bespoke fixtures.
+- **Helper modules:** move shared builders/factories under `tests/helpers/` with explicit exports through `__all__`.
+
+## Fixture Hierarchy
+- **Session scope (`conftest.py` or plugin):**
+  - `base_data`: loads taxonomy/seed data exactly once, returns immutable context object.
+  - `cache`: provides namespaced cache manager (see Caching Layer) with `get/set/clear` API.
+  - `env_settings`: applies test-specific overrides (MEDIA_ROOT, Celery eager) in a context manager.
+- **Module scope:** domain-specific heavy resources (e.g., processed video file) keyed via cache fixture to avoid duplication.
+- **Function scope:** lightweight factories, API clients, data builders; avoid mutating session objects directly.
+- Use `pytest_plugins = ["tests.plugins.cache", "tests.plugins.fixtures"]` to centralise definitions.
+
+## Parametrization & Markers
+- Prefer `@pytest.mark.parametrize` over hand-written loops.
+- Define common markers: `slow`, `video`, `integration`, `requires_gpu`. Document skip conditions in `pytest.ini`.
+- Implement marker-aware skip logic in fixtures rather than environment variable spaghetti.
+
+## Caching Layer Design
+- Introduce `tests/plugins/cache.py` defining a `CacheManager` with:
+  - `get(namespace, key, default=None)` / `set(namespace, key, value)` APIs.
+  - Lazy initialisation backed by `functools.lru_cache` for in-memory usage plus optional `diskcache` fallback if available.
+  - `invalidate(namespace, key=None)` hooks invoked via pytest `request.addfinalizer` to avoid cross-test leaks.
+- Session-scoped `cache` fixture returns a manager instance; module/functional fixtures request namespaces (`cache.namespace("video")`).
+- Provide helper `cache.memoize(namespace)` decorator to wrap expensive factory functions (e.g., processed video creation).
+- Replace module-level globals (`_base_data_loaded`, `_session_video_file`) by storing state under deterministic keys, e.g. `cache.set("video", "processed_default", value)`.
+- Emit debug logging when cache hits/misses occur during `-vv` runs to aid troubleshooting.
+
+## Documentation & Governance
+- Document expectations in `docs/testing/TEST_GUIDELINES.md` (to be created).
+- Add pre-commit lint to fail if non-conforming test module names detected.
+- Establish codeowners for `tests/` to review adherence.
+
+## Next Steps
+1. Implement prototype cache manager and fixtures (Step 3 of action plan).
+  - Create `tests/plugins/cache.py` and `tests/plugins/__init__.py` exporting `pytest_plugins`.
+  - Update `pytest.ini` to register default markers (`slow`, `video`, `integration`, `requires_gpu`).
+  - Refactor `tests/conftest.py` to consume the new `cache` fixture and remove global caches.
+2. Migrate `tests/media/video` to new fixture hierarchy as pilot (Step 4).
+  - Introduce module-scoped fixtures leveraging `cache.namespace("video")` and ensure cleanup via invalidation hooks.
+  - Wire helper modules such as `tests/helpers/optimized_video_fixtures.py` into dedicated namespaces via `configure_cache` to eliminate legacy globals.
+  - ✅ Segment CRUD suite now runs against a lightweight cached video stub; validate similar patterns for services tests next.
+  - ✅ Base data loader now provisions stub AI model metadata (behind `USE_STUB_MODEL_META=true`) so `load_default_ai_model` no longer copies large checkpoints during fast suites.
+  - Current end-to-end runtime still ~660 s; profile durations to locate the next hotspots.
+  - Measure runtime improvements and document findings in `docs/testing/TEST_GUIDELINES.md`.
+3. Update developer guide with blueprint summary once pilot validated.

endoreg_db-0.8.2.7/docs/test_suite_review.md

@@ -0,0 +1,31 @@
+# Test Suite Review (2025-10-18)
+
+## Module Inventory Snapshot
+- `tests/administration/*`: CRUD/admin scenarios for centers, shifts, qualifications.
+- `tests/assets/*`: Large artefact fixtures (models, JSON) consumed by video/import suites.
+- `tests/dataloader/test_dataloader.py`: Exercises custom dataset ingestion helpers.
+- `tests/environment/test_env.py`: Validates env wiring and settings overrides.
+- `tests/examination/*`: Domain tests for examination models and serializers.
+- `tests/fileserver/*`: Covers WhiteNoise static file handling.
+- `tests/finding/*`: Disease/finding taxonomy loading and serializer behaviour.
+- `tests/helpers/*`: Fixture factories plus integration smoke tests for helper modules.
+- `tests/legacy/*`: Regression coverage for legacy data migration utilities.
+- `tests/media/video/*`: Heavy video import/anonymization flows (long runtime, GPU/ffmpeg dependencies).
+- `tests/models/*`: ORM and state machine regression coverage.
+- `tests/pipelines/*`: Orchestration pipelines and process directory flows.
+- `tests/requirement/*`: Requirement rule matrix validation; high combinatorial count.
+- `tests/services/*`: Service-layer orchestration smoke tests (RQ, anonymizer, imports).
+
+## Shared Fixture & Caching Landscape
+- `tests/conftest.py` defines global caches (`_session_cache`, `_session_video_file`, `_base_data_loaded`) implemented via module-level globals; invalidation is implicit and hard to reason about during parametrised runs.
+- Base taxonomy loaders (`load_*`) execute inside `base_db_data` fixture with a function scope guard backed by `global _base_data_loaded`, mixing fixture scopes and custom caching.
+- Video fixtures (`sample_video_file`, `processed_video_file`) key off environment flags (`RUN_VIDEO_TESTS`, `SKIP_EXPENSIVE_TESTS`) with ad-hoc globals; repeated suite invocations in the same process can leak cached state.
+- Session-level DB optimisations (`optimize_database_queries`) execute per-test (autouse) rather than establishing a single shared connection configuration.
+- `_session_cache` remains unused across the suite, and several modules re-create expensive assets (e.g., YAML loads, JSON fixtures) without a shared cache hook.
+
+## Pain Points Observed During Full-Suite Runs
+- Environment flag handling (`RUN_VIDEO_TESTS`) is inconsistent: default expression evaluates to `False` even when explicitly enabling, leading to skipped media tests locally but executed in CI.
+- Global caches are not namespaced by test parameters; when parametrised tests mutate cached video objects, downstream tests see dirty state, causing non-deterministic failures in full runs.
+- Multiple suites duplicate fixture logic (e.g., default center/processor creation) instead of relying on `tests.helpers.default_objects`, increasing setup time and risking drift.
+- Several long-running suites (`tests/media/video`, `tests/pipelines`) hit the filesystem repeatedly because cached paths live outside a central storage coordinator; temp directories are re-created per module.
+- Lack of a documented test layout encourages bespoke fixtures per module, making it difficult to standardise teardown behaviour and to introduce suite-wide caching.

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/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-0.8.2.4 → endoreg_db-0.8.2.7}/endoreg_db/management/commands/import_video.py

@@ -294,10 +294,11 @@ 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_file_obj=video_file_obj,  # Pass VideoFile object to store metadata
-                    report_reader=report_reader,
-                    device_name=processor_name
+                    video_path=Path(video_file_obj.raw_file.path),
+                    endoscope_roi=video_file_obj.processor.get_roi_endoscope_image() if video_file_obj.processor else None,
+                    endoscope_data_roi_nested=video_file_obj.processor.get_rois() 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-0.8.2.4 → endoreg_db-0.8.2.7}/endoreg_db/models/__init__.py

@@ -60,12 +60,10 @@ from .media import (
     AnonymHistologyReport,
     ReportReaderConfig,
     ReportReaderFlag,
+    VideoMetadata,
+    VideoProcessingHistory,
 )
 
-####### Video Correction (Phase 1.1) ########
-from .video_metadata import VideoMetadata
-from .video_processing import VideoProcessingHistory
-
 ######## Medical ########
 from .medical import (
     Disease,
@@ -241,6 +239,8 @@ __all__ = [
     "AnonymHistologyReport",
     'ReportReaderConfig',
     'ReportReaderFlag',
+    'VideoMetadata',
+    'VideoProcessingHistory',
 
 
     ######## Medical ########

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/endoreg_db/models/media/__init__.py

@@ -1,4 +1,4 @@
-from .video import VideoFile
+from .video import VideoFile, VideoMetadata, VideoProcessingHistory
 from .frame import Frame
 from .pdf import RawPdfFile, DocumentType, AnonymExaminationReport, ReportReaderConfig, ReportReaderFlag, AnonymHistologyReport
 
@@ -11,4 +11,6 @@ __all__ = [
     "AnonymHistologyReport",
     'ReportReaderConfig',
     'ReportReaderFlag',
+    'VideoMetadata',
+    'VideoProcessingHistory',
 ]

endoreg_db-0.8.2.7/endoreg_db/models/media/video/__init__.py

@@ -0,0 +1,8 @@
+from .video_file import VideoFile
+from .video_metadata import VideoMetadata
+from .video_processing import VideoProcessingHistory
+__all__ = [
+    "VideoFile",
+    "VideoMetadata",
+    "VideoProcessingHistory",
+]

{endoreg_db-0.8.2.4 → endoreg_db-0.8.2.7}/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
@@ -127,36 +128,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)
+    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):
@@ -479,8 +487,9 @@ class VideoFile(models.Model):
                 
         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