endoreg-db 0.8.4.3__tar.gz → 0.8.4.4__tar.gz

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/CONFIGURATION_GUIDE.md

@@ -65,33 +65,6 @@ The command automatically detects your cache configuration:
 
 Use `--skip-ai-setup` if AI video processing features are not needed, or `--force-recreate` to recreate AI metadata.
 
-### AI Model Validation and Troubleshooting
-
-If you encounter "No model metadata found for this model" errors during video processing, use the dedicated validation command:
-
-```bash
-# Check AI model metadata status without making changes
-python manage.py validate_ai_models --dry-run
-
-# Fix AI model metadata issues automatically  
-python manage.py validate_ai_models
-
-# View detailed help
-python manage.py validate_ai_models --help
-```
-
-The validation command automatically:
-- Checks all AI models for proper metadata configuration
-- Creates missing metadata with sensible defaults (ImageNet normalization, etc.)
-- Sets active metadata for models that don't have it assigned
-- Validates that all models can access their latest versions
-
-Common scenarios this fixes:
-- **"No model metadata found"** errors in pipe_1 video processing
-- AI models exist but have no `active_meta` set
-- Models have metadata versions but none are marked as active
-- Missing ModelMeta records for classification/segmentation models
-
 This repo standalone (local):
 - Development server: DJANGO_SETTINGS_MODULE=config.settings.dev python manage.py runserver
 - Tests (persistent test DB): pytest --reuse-db --create-db

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.4.3
+Version: 0.8.4.4
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db
@@ -29,7 +29,6 @@ Requires-Dist: dotenv>=0.9.9
 Requires-Dist: faker>=37.6.0
 Requires-Dist: flake8>=7.3.0
 Requires-Dist: gunicorn>=23.0.0
-Requires-Dist: huggingface-hub>=0.35.3
 Requires-Dist: icecream>=2.1.4
 Requires-Dist: librosa==0.11.0
 Requires-Dist: llvmlite>=0.44.0

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/endoreg_db/models/metadata/model_meta_logic.py

@@ -3,6 +3,7 @@ from logging import getLogger
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional, Type
 
+from django.core.files import File
 from django.db import transaction
 from huggingface_hub import hf_hub_download
 
@@ -326,99 +327,3 @@ def setup_default_from_huggingface_logic(cls, model_id: str, labelset_name: str
         size_y=meta["size_y"],
         description=meta["description"],
     )
-
-
-def validate_and_fix_ai_model_metadata_logic():
-    """
-    Validates that all AI models have proper active metadata and fixes any issues.
-    This prevents the "No model metadata found for this model" error.
-
-    Returns:
-        dict: Summary of fixes applied
-    """
-    from ..administration.ai.ai_model import AiModel
-    from ..label.label_set import LabelSet
-
-    summary = {"models_checked": 0, "models_fixed": 0, "metadata_created": 0, "active_meta_set": 0, "errors": []}
-
-    try:
-        all_models = AiModel.objects.all()
-        summary["models_checked"] = all_models.count()
-
-        for model in all_models:
-            logger.info(f"Validating model: {model.name}")
-
-            # Check if model has metadata versions
-            metadata_count = model.metadata_versions.count()
-
-            if metadata_count == 0:
-                # Create metadata for models that don't have any
-                logger.info(f"Creating metadata for {model.name}")
-
-                # Use existing labelset or create default
-                labelset = LabelSet.objects.first()
-                if not labelset:
-                    labelset = LabelSet.objects.create(name="default_colonoscopy_labels", description="Default colonoscopy classification labels")
-
-                # Import here to avoid circular imports
-                from .model_meta import ModelMeta
-
-                # Create basic metadata
-                meta = ModelMeta.objects.create(
-                    name=model.name,
-                    version="1.0",
-                    model=model,
-                    labelset=labelset,
-                    activation="sigmoid" if "classification" in model.name else "sigmoid",
-                    mean="0.485,0.456,0.406",  # ImageNet defaults
-                    std="0.229,0.224,0.225",  # ImageNet defaults
-                    size_x=224,
-                    size_y=224,
-                    axes="CHW",
-                    batchsize=32,
-                    num_workers=4,
-                    description=f"Auto-generated metadata for {model.name}",
-                )
-
-                model.active_meta = meta
-                model.save()
-                summary["models_fixed"] += 1
-                summary["metadata_created"] += 1
-                logger.info(f"Created and set metadata for {model.name}")
-
-            elif not model.active_meta:
-                # Model has metadata but no active meta set
-                first_meta = model.metadata_versions.first()
-                if first_meta:
-                    logger.info(f"Setting active metadata for {model.name}")
-                    model.active_meta = first_meta
-                    model.save()
-                    summary["models_fixed"] += 1
-                    summary["active_meta_set"] += 1
-                    logger.info(f"Set active metadata: {first_meta.name} v{first_meta.version}")
-                else:
-                    error_msg = f"No metadata versions available for {model.name}"
-                    logger.warning(error_msg)
-                    summary["errors"].append(error_msg)
-
-            else:
-                logger.info(f"Model {model.name} has valid active metadata: {model.active_meta}")
-
-        # Verify all models can get latest version
-        logger.info("Testing model metadata access...")
-        for model in all_models:
-            try:
-                latest = model.get_latest_version()
-                logger.info(f"✅ {model.name}: {latest}")
-            except Exception as e:
-                error_msg = f"Model {model.name} metadata test failed: {e}"
-                logger.error(error_msg)
-                summary["errors"].append(error_msg)
-
-        return summary
-
-    except Exception as e:
-        error_msg = f"Validation failed: {e}"
-        logger.error(error_msg)
-        summary["errors"].append(error_msg)
-        return summary

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/endoreg_db/models/metadata/sensitive_meta_logic.py

@@ -80,9 +80,7 @@ def parse_any_date(s: str) -> Optional[date]:
         # Try dateparser with German locale preference
         import dateparser
 
-        dt = dateparser.parse(
-            s, settings={"DATE_ORDER": "DMY", "PREFER_DAY_OF_MONTH": "first"}
-        )
+        dt = dateparser.parse(s, settings={"DATE_ORDER": "DMY", "PREFER_DAY_OF_MONTH": "first"})
         return dt.date() if dt else None
     except Exception as e:
         logger.debug(f"Dateparser fallback failed for '{s}': {e}")
@@ -172,9 +170,7 @@ def calculate_patient_hash(instance: "SensitiveMeta", salt: str = SECRET_SALT) -
     return sha256(hash_str.encode()).hexdigest()
 
 
-def calculate_examination_hash(
-    instance: "SensitiveMeta", salt: str = SECRET_SALT
-) -> str:
+def calculate_examination_hash(instance: "SensitiveMeta", salt: str = SECRET_SALT) -> str:
     """Calculates the examination hash for the instance."""
     dob = instance.patient_dob
     first_name = instance.patient_first_name
@@ -207,25 +203,17 @@ def create_pseudo_examiner_logic(instance: "SensitiveMeta") -> "Examiner":
     center = instance.center  # Should be set before calling save
 
     if not first_name or not last_name or not center:
-        logger.warning(
-            f"Incomplete examiner info for SensitiveMeta (pk={instance.pk}). Using default examiner."
-        )
+        logger.warning(f"Incomplete examiner info for SensitiveMeta (pk={instance.pk or 'new'}). Using default examiner.")
         # Ensure default center exists or handle appropriately
         try:
             default_center = Center.objects.get_by_natural_key("endoreg_db_demo")
         except Center.DoesNotExist:
-            logger.error(
-                "Default center 'endoreg_db_demo' not found. Cannot create default examiner."
-            )
+            logger.error("Default center 'endoreg_db_demo' not found. Cannot create default examiner.")
             raise ValueError("Default center 'endoreg_db_demo' not found.")
 
-        examiner, _created = Examiner.custom_get_or_create(
-            first_name="Unknown", last_name="Unknown", center=default_center
-        )
+        examiner, _created = Examiner.custom_get_or_create(first_name="Unknown", last_name="Unknown", center=default_center)
     else:
-        examiner, _created = Examiner.custom_get_or_create(
-            first_name=first_name, last_name=last_name, center=center
-        )
+        examiner, _created = Examiner.custom_get_or_create(first_name=first_name, last_name=last_name, center=center)
 
     return examiner
 
@@ -271,13 +259,11 @@ def get_or_create_pseudo_patient_examination_logic(
         pseudo_patient = get_or_create_pseudo_patient_logic(instance)
         instance.pseudo_patient_id = pseudo_patient.pk  # Assign FK directly
 
-    patient_examination, _created = (
-        PatientExamination.get_or_create_pseudo_patient_examination_by_hash(
-            patient_hash=instance.patient_hash,
-            examination_hash=instance.examination_hash,
-            # Optionally pass pseudo_patient if the method requires it
-            # pseudo_patient=instance.pseudo_patient
-        )
+    patient_examination, _created = PatientExamination.get_or_create_pseudo_patient_examination_by_hash(
+        patient_hash=instance.patient_hash,
+        examination_hash=instance.examination_hash,
+        # Optionally pass pseudo_patient if the method requires it
+        # pseudo_patient=instance.pseudo_patient
     )
     return patient_examination
 
@@ -294,14 +280,10 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
 
     # 1. Ensure DOB and Examination Date exist
     if not instance.patient_dob:
-        logger.debug(
-            f"SensitiveMeta (pk={instance.pk}): Patient DOB missing, generating random."
-        )
+        logger.debug(f"SensitiveMeta (pk={instance.pk or 'new'}): Patient DOB missing, generating random.")
         instance.patient_dob = generate_random_dob()
     if not instance.examination_date:
-        logger.debug(
-            f"SensitiveMeta (pk={instance.pk}): Examination date missing, generating random."
-        )
+        logger.debug(f"SensitiveMeta (pk={instance.pk or 'new'}): Examination date missing, generating random.")
         instance.examination_date = generate_random_examination_date()
 
     # 2. Ensure Center exists (should be set before calling save)
@@ -314,9 +296,7 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
         first_name = instance.patient_first_name or DEFAULT_UNKNOWN_NAME
         gender = guess_name_gender(first_name)
         if not gender:
-            raise ValueError(
-                "Patient gender could not be determined and must be set before saving."
-            )
+            raise ValueError("Patient gender could not be determined and must be set before saving.")
         instance.patient_gender = gender
 
     # 4. Calculate Hashes (depends on DOB, Exam Date, Center, Names)
@@ -344,16 +324,10 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     return examiner_instance
 
 
-def create_sensitive_meta_from_dict(
-    cls: Type["SensitiveMeta"], data: Dict[str, Any]
-) -> "SensitiveMeta":
+def create_sensitive_meta_from_dict(cls: Type["SensitiveMeta"], data: Dict[str, Any]) -> "SensitiveMeta":
     """Logic to create a SensitiveMeta instance from a dictionary."""
 
-    field_names = {
-        f.name
-        for f in cls._meta.get_fields()
-        if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)
-    }
+    field_names = {f.name for f in cls._meta.get_fields() if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)}
     selected_data = {k: v for k, v in data.items() if k in field_names}
 
     # --- Convert patient_dob if it's a date object ---
@@ -380,13 +354,9 @@ def create_sensitive_meta_from_dict(
             try:
                 import dateparser
 
-                parsed_dob = dateparser.parse(
-                    dob, languages=["de"], settings={"DATE_ORDER": "DMY"}
-                )
+                parsed_dob = dateparser.parse(dob, languages=["de"], settings={"DATE_ORDER": "DMY"})
                 if parsed_dob:
-                    aware_dob = timezone.make_aware(
-                        parsed_dob.replace(hour=0, minute=0, second=0, microsecond=0)
-                    )
+                    aware_dob = timezone.make_aware(parsed_dob.replace(hour=0, minute=0, second=0, microsecond=0))
                     selected_data["patient_dob"] = aware_dob
                     logger.debug(
                         "Parsed string patient_dob '%s' to aware datetime: %s",
@@ -440,9 +410,7 @@ def create_sensitive_meta_from_dict(
                         # Fall back to dateparser for complex formats
                         import dateparser
 
-                        parsed_date = dateparser.parse(
-                            exam_date, languages=["de"], settings={"DATE_ORDER": "DMY"}
-                        )
+                        parsed_date = dateparser.parse(exam_date, languages=["de"], settings={"DATE_ORDER": "DMY"})
                         if parsed_date:
                             selected_data["examination_date"] = parsed_date.date()
                             logger.debug(
@@ -460,9 +428,7 @@ def create_sensitive_meta_from_dict(
                     # Use dateparser for non-ISO formats
                     import dateparser
 
-                    parsed_date = dateparser.parse(
-                        exam_date, languages=["de"], settings={"DATE_ORDER": "DMY"}
-                    )
+                    parsed_date = dateparser.parse(exam_date, languages=["de"], settings={"DATE_ORDER": "DMY"})
                     if parsed_date:
                         selected_data["examination_date"] = parsed_date.date()
                         logger.debug(
@@ -508,34 +474,22 @@ def create_sensitive_meta_from_dict(
     elif isinstance(patient_gender_input, str):
         # Input is a string (gender name)
         try:
-            selected_data["patient_gender"] = Gender.objects.get(
-                name=patient_gender_input
-            )
+            selected_data["patient_gender"] = Gender.objects.get(name=patient_gender_input)
         except Gender.DoesNotExist:
-            logger.warning(
-                f"Gender with name '{patient_gender_input}' provided but not found. Attempting to guess or use default."
-            )
+            logger.warning(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
 
-    if not isinstance(
-        selected_data.get("patient_gender"), Gender
-    ):  # If not already a Gender object (e.g. was None, or string lookup failed)
+    if not isinstance(selected_data.get("patient_gender"), Gender):  # If not already a Gender object (e.g. was None, or string lookup failed)
         gender_name_to_use = guess_name_gender(first_name)
         if not gender_name_to_use:
-            logger.warning(
-                f"Could not guess gender for name '{first_name}'. Setting Gender to unknown."
-            )
+            logger.warning(f"Could not guess gender for name '{first_name}'. Setting Gender to unknown.")
             gender_name_to_use = "unknown"
         try:
-            selected_data["patient_gender"] = Gender.objects.get(
-                name=gender_name_to_use
-            )
+            selected_data["patient_gender"] = Gender.objects.get(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."
-            )
+            raise ValueError(f"Default or guessed gender '{gender_name_to_use}' does not exist in Gender table.")
 
     # Update name DB
     update_name_db(first_name, last_name)
@@ -549,20 +503,12 @@ def create_sensitive_meta_from_dict(
     return sensitive_meta
 
 
-def update_sensitive_meta_from_dict(
-    instance: "SensitiveMeta", data: Dict[str, Any]
-) -> "SensitiveMeta":
+def update_sensitive_meta_from_dict(instance: "SensitiveMeta", data: Dict[str, Any]) -> "SensitiveMeta":
     """Logic to update a SensitiveMeta instance from a dictionary."""
-    field_names = {
-        f.name
-        for f in instance._meta.get_fields()
-        if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)
-    }
+    field_names = {f.name for f in instance._meta.get_fields() if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)}
     # Exclude FKs that should not be updated directly from dict keys (handled separately or via save logic)
     excluded_fields = {"pseudo_patient", "pseudo_examination"}
-    selected_data = {
-        k: v for k, v in data.items() if k in field_names and k not in excluded_fields
-    }
+    selected_data = {k: v for k, v in data.items() if k in field_names and k not in excluded_fields}
 
     # Handle potential Center update
     center_name = data.get("center_name")
@@ -571,9 +517,7 @@ def update_sensitive_meta_from_dict(
             center = Center.objects.get_by_natural_key(center_name)
             instance.center = center  # Update center directly
         except Center.DoesNotExist as exc:
-            logger.warning(
-                f"Center '{center_name}' not found during update. Keeping existing center."
-            )
+            logger.warning(f"Center '{center_name}' not found during update. Keeping existing center.")
             selected_data.pop("center", None)  # Remove from dict if not found
 
     # Set examiner names if provided, before calling save
@@ -593,14 +537,10 @@ def update_sensitive_meta_from_dict(
             elif isinstance(patient_gender_input, str):
                 gender_input_clean = patient_gender_input.strip()
                 # Try direct case-insensitive DB lookup first
-                gender_obj = Gender.objects.filter(
-                    name__iexact=gender_input_clean
-                ).first()
+                gender_obj = Gender.objects.filter(name__iexact=gender_input_clean).first()
                 if gender_obj:
                     selected_data["patient_gender"] = gender_obj
-                    logger.debug(
-                        f"Successfully matched gender string '{patient_gender_input}' to Gender object via iexact lookup"
-                    )
+                    logger.debug(f"Successfully matched gender string '{patient_gender_input}' to Gender object via iexact lookup")
                 else:
                     # Use mapping helper for fallback
                     mapped = _map_gender_string_to_standard(gender_input_clean)
@@ -608,50 +548,30 @@ def update_sensitive_meta_from_dict(
                         gender_obj = Gender.objects.filter(name__iexact=mapped).first()
                         if gender_obj:
                             selected_data["patient_gender"] = gender_obj
-                            logger.info(
-                                f"Mapped gender '{patient_gender_input}' to '{mapped}' via fallback mapping"
-                            )
+                            logger.info(f"Mapped gender '{patient_gender_input}' to '{mapped}' via fallback mapping")
                         else:
-                            logger.warning(
-                                f"Mapped gender '{patient_gender_input}' to '{mapped}', but no such Gender in DB. Trying 'unknown'."
-                            )
-                            unknown_gender = Gender.objects.filter(
-                                name__iexact="unknown"
-                            ).first()
+                            logger.warning(f"Mapped gender '{patient_gender_input}' to '{mapped}', but no such Gender in DB. Trying 'unknown'.")
+                            unknown_gender = Gender.objects.filter(name__iexact="unknown").first()
                             if unknown_gender:
                                 selected_data["patient_gender"] = unknown_gender
-                                logger.warning(
-                                    f"Using 'unknown' gender as fallback for '{patient_gender_input}'"
-                                )
+                                logger.warning(f"Using 'unknown' gender as fallback for '{patient_gender_input}'")
                             else:
-                                logger.error(
-                                    f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update."
-                                )
+                                logger.error(f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update.")
                                 selected_data.pop("patient_gender", None)
                     else:
                         # Last resort: try to get 'unknown' gender
-                        unknown_gender = Gender.objects.filter(
-                            name__iexact="unknown"
-                        ).first()
+                        unknown_gender = Gender.objects.filter(name__iexact="unknown").first()
                         if unknown_gender:
                             selected_data["patient_gender"] = unknown_gender
-                            logger.warning(
-                                f"Using 'unknown' gender as fallback for '{patient_gender_input}' (no mapping)"
-                            )
+                            logger.warning(f"Using 'unknown' gender as fallback for '{patient_gender_input}' (no mapping)")
                         else:
-                            logger.error(
-                                f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update."
-                            )
+                            logger.error(f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update.")
                             selected_data.pop("patient_gender", None)
             else:
-                logger.warning(
-                    f"Unexpected patient_gender type {type(patient_gender_input)}: {patient_gender_input}. Skipping gender update."
-                )
+                logger.warning(f"Unexpected patient_gender type {type(patient_gender_input)}: {patient_gender_input}. Skipping gender update.")
                 selected_data.pop("patient_gender", None)
         except Exception as e:
-            logger.exception(
-                f"Error handling patient_gender '{patient_gender_input}': {e}. Skipping gender update."
-            )
+            logger.exception(f"Error handling patient_gender '{patient_gender_input}': {e}. Skipping gender update.")
             selected_data.pop("patient_gender", None)
 
     # Update other attributes from selected_data
@@ -668,9 +588,7 @@ def update_sensitive_meta_from_dict(
                 value_to_set = v
                 if k == "patient_dob":
                     if isinstance(v, date) and not isinstance(v, datetime):
-                        aware_dob = timezone.make_aware(
-                            datetime.combine(v, datetime.min.time())
-                        )
+                        aware_dob = timezone.make_aware(datetime.combine(v, datetime.min.time()))
                         value_to_set = aware_dob
                         logger.debug(
                             "Converted patient_dob from date to aware datetime during update: %s",
@@ -693,15 +611,9 @@ def update_sensitive_meta_from_dict(
                             try:
                                 import dateparser
 
-                                parsed_dob = dateparser.parse(
-                                    v, languages=["de"], settings={"DATE_ORDER": "DMY"}
-                                )
+                                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
-                                        )
-                                    )
+                                    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,
@@ -736,9 +648,7 @@ def update_sensitive_meta_from_dict(
                         try:
                             import dateparser
 
-                            parsed_date = dateparser.parse(
-                                v, languages=["de"], settings={"DATE_ORDER": "DMY"}
-                            )
+                            parsed_date = dateparser.parse(v, languages=["de"], settings={"DATE_ORDER": "DMY"})
                             if parsed_date:
                                 value_to_set = parsed_date.date()
                                 logger.debug(
@@ -762,18 +672,13 @@ def update_sensitive_meta_from_dict(
                 # --- End Conversion ---
 
                 # Check if patient name is changing
-                if (
-                    k in ["patient_first_name", "patient_last_name"]
-                    and getattr(instance, k) != value_to_set
-                ):
+                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(
-                    f"Error setting attribute '{k}' to '{v}': {e}. Skipping this field."
-                )
+                logger.error(f"Error setting attribute '{k}' to '{v}': {e}. Skipping this field.")
                 continue
 
     # Update name DB if patient names changed

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/endoreg_db/services/video_import.py

@@ -19,6 +19,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Union, Dict, Any, Optional, List, Tuple
 from django.db import transaction
+from lx_anonymizer import FrameCleaner
 from moviepy import video
 from endoreg_db.models import VideoFile, SensitiveMeta
 from endoreg_db.utils.paths import STORAGE_DIR, VIDEO_DIR, ANONYM_VIDEO_DIR
@@ -76,6 +77,8 @@ class VideoImportService:
 
         self.logger = logging.getLogger(__name__)
 
+        self.cleaner = None  # This gets instantiated in the perform_frame_cleaning method
+
     def _require_current_video(self) -> VideoFile:
         """Return the current VideoFile or raise if it has not been initialized."""
         if self.current_video is None:
@@ -826,7 +829,7 @@ class VideoImportService:
             from lx_anonymizer import FrameCleaner  # type: ignore[import]
 
             if FrameCleaner:
-                return True, FrameCleaner
+                return True, FrameCleaner()
 
         except Exception as e:
             self.logger.warning(f"Frame cleaning not available: {e} Please install or update lx_anonymizer.")
@@ -854,6 +857,8 @@ class VideoImportService:
         # Create temporary output path for cleaned video
         video_filename = self.processing_context.get("video_filename", Path(raw_video_path).name)
         cleaned_filename = f"cleaned_{video_filename}"
+        if not raw_video_path:
+            raise RuntimeError("raw_video_path is None after fallback, cannot construct cleaned_video_path")
         cleaned_video_path = Path(raw_video_path).parent / cleaned_filename
 
         # Clean video with ROI masking (heavy I/O operation)

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/pyproject.toml

@@ -14,7 +14,7 @@ maintainers = [
 ]
 name = "endoreg-db"
 readme = "README.md"
-version = "0.8.4.3"
+version = "0.8.4.4"
 
 classifiers = [
   "Development Status :: 3 - Alpha",
@@ -82,7 +82,6 @@ dependencies = [
   "build>=1.3.0",
   "flake8>=7.3.0",
   "twine>=6.2.0",
-  "huggingface-hub>=0.35.3",
 ]
 requires-python = ">=3.12,<3.13"
 

{endoreg_db-0.8.4.3 → endoreg_db-0.8.4.4}/uv.lock

@@ -771,7 +771,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/62/59/e47bbd0542d0e6f4c
 
 [[package]]
 name = "endoreg-db"
-version = "0.8.4.2"
+version = "0.8.4.4"
 source = { editable = "." }
 dependencies = [
     { name = "agl-report-reader" },
@@ -790,7 +790,6 @@ dependencies = [
     { name = "faker" },
     { name = "flake8" },
     { name = "gunicorn" },
-    { name = "huggingface-hub" },
     { name = "icecream" },
     { name = "librosa" },
     { name = "llvmlite" },
@@ -854,7 +853,6 @@ requires-dist = [
     { name = "faker", specifier = ">=37.6.0" },
     { name = "flake8", specifier = ">=7.3.0" },
     { name = "gunicorn", specifier = ">=23.0.0" },
-    { name = "huggingface-hub", specifier = ">=0.35.3" },
     { name = "icecream", specifier = ">=2.1.4" },
     { name = "librosa", specifier = "==0.11.0" },
     { name = "llvmlite", specifier = ">=0.44.0" },