endoreg-db 0.8.4.3__py3-none-any.whl → 0.8.4.4__py3-none-any.whl

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/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/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.dist-info → endoreg_db-0.8.4.4.dist-info}/METADATA

@@ -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.dist-info → endoreg_db-0.8.4.4.dist-info}/RECORD

@@ -295,7 +295,6 @@ endoreg_db/management/commands/setup_endoreg_db.py,sha256=C0ooVVmrzX-_ksoma3s3rZ
 endoreg_db/management/commands/start_filewatcher.py,sha256=3jESBqRiYPa9f35--zd70qQaYnyT0tzRO_b_HJuyteQ,4093
 endoreg_db/management/commands/storage_management.py,sha256=NpToX59ndwTFNmnSoeppmiPdMvpjSHH7mAdIe4SvUoI,22396
 endoreg_db/management/commands/summarize_db_content.py,sha256=pOIz3qbY4Ktmh0zV_DKFx971VD0pPx027gCD7a47EL0,10766
-endoreg_db/management/commands/validate_ai_models.py,sha256=Z7Ga-PndTFVG8GnkYbS58h8ofiyhnxZDcyP5Qqpl1c8,4684
 endoreg_db/management/commands/validate_video.py,sha256=cns_kNgztyp6XTeXuDeLEet8vAATkpxZwJuSWuQ5Olk,11302
 endoreg_db/management/commands/validate_video_files.py,sha256=0lvA0Z8BKiibjyqc4ueI646IIc5bKI3sIOxiiF5_bTk,6509
 endoreg_db/management/commands/video_validation.py,sha256=xnAoCPB44dmnRbn6FqUjqRXQ-ZhDPNX1T5kCpAU8sgc,771
@@ -466,10 +465,10 @@ endoreg_db/models/medical/risk/risk_type.py,sha256=kEugcaWSTEWH_Vxq4dcF80Iv1L4_K
 endoreg_db/models/metadata/__init__.py,sha256=8I6oLj3YTmeaPGJpL0AWG5gLwp38QzrEggxSkTisv7c,474
 endoreg_db/models/metadata/frame_ocr_result.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 endoreg_db/models/metadata/model_meta.py,sha256=F_r-PTLeNi4J-4EaGCQkGIguhdl7Bwba7_i56ZAjc-4,7589
-endoreg_db/models/metadata/model_meta_logic.py,sha256=wESdSRvnA0SthaZD2W29nbMGrichRCwaKQGnE5uCAao,16046
+endoreg_db/models/metadata/model_meta_logic.py,sha256=OhPImTQaB_a3p-h7iaxNNQkip5aaDDIOMXCV2TEyNmk,12215
 endoreg_db/models/metadata/pdf_meta.py,sha256=BTmpSgqxmPKi0apcNjyrZAS4AFKCPXVdBd6VBeyyv6E,3174
 endoreg_db/models/metadata/sensitive_meta.py,sha256=ekLHrW-b5uYcjfkRd0EW5ncx5ef8Bu-K6msDkpWCAbk,13034
-endoreg_db/models/metadata/sensitive_meta_logic.py,sha256=by3eCW8CgglK1SHiDOepHhTOGaugswxJhkH0BZp7-gs,33909
+endoreg_db/models/metadata/sensitive_meta_logic.py,sha256=XN3x3p0cqLlzPSZl7e35JBUXr_QKYSq48vwF1N60N4U,32134
 endoreg_db/models/metadata/video_meta.py,sha256=c6xWdLW3uNqJ5VPJXHCxXA3mbXw-b0uR54-TOS3qL2Q,14966
 endoreg_db/models/metadata/video_prediction_logic.py,sha256=j5N82mHtiomeeIaf1HA65kT5d0htQfJmbI2bJb8mpxQ,7677
 endoreg_db/models/metadata/video_prediction_meta.py,sha256=EyfctAAAVcW9L0gf76ZBc9-G8MLMcD-tc2kkjaaLH4w,10592
@@ -604,7 +603,7 @@ endoreg_db/services/pseudonym_service.py,sha256=CJhbtRa6K6SPbphgCZgEMi8AFQtB18CU
 endoreg_db/services/requirements_object.py,sha256=290zf8AEbVtCoHhW4Jr7_ud-RvrqYmb1Nz9UBHtTnc0,6164
 endoreg_db/services/segment_sync.py,sha256=YgHvIHkbW4mqCu0ACf3zjRSZnNfxWwt4gh5syUVXuE0,6400
 endoreg_db/services/storage_aware_video_processor.py,sha256=kKFK64vXLeBSVkp1YJonU3gFDTeXZ8C4qb9QZZB99SE,13420
-endoreg_db/services/video_import.py,sha256=FTFXb4A7cGp6uphDds5hyjdOcXnWAV-3LbjSIfaswvg,46241
+endoreg_db/services/video_import.py,sha256=quQ1z_hqJFcrq5pOeq74pqqmnS2I9ybJIh5D0v8qtOk,46514
 endoreg_db/tasks/upload_tasks.py,sha256=OJq7DhNwcbWdXzHY8jz5c51BCVkPN5gSWOz-6Fx6W5M,7799
 endoreg_db/tasks/video_ingest.py,sha256=kxFuYkHijINV0VabQKCFVpJRv6eCAw07tviONurDgg8,5265
 endoreg_db/tasks/video_processing_tasks.py,sha256=rZ7Kr49bAR4Q-vALO2SURebrhcJ5hSFGwjF4aULrOao,14089
@@ -789,7 +788,7 @@ endoreg_db/views/video/video_meta.py,sha256=C1wBMTtQb_yzEUrhFGAy2UHEWMk_CbU75WXX
 endoreg_db/views/video/video_processing_history.py,sha256=mhFuS8RG5GV8E-lTtuD0qrq-bIpnUFp8vy9aERfC-J8,770
 endoreg_db/views/video/video_remove_frames.py,sha256=2FmvNrSPM0fUXiBxINN6vBUUDCqDlBkNcGR3WsLDgKo,1696
 endoreg_db/views/video/video_stream.py,sha256=kLyuf0ORTmsLeYUQkTQ6iRYqlIQozWhMMR3Lhfe_trk,12148
-endoreg_db-0.8.4.3.dist-info/METADATA,sha256=KnYipnhERrjdiE4CzHQjRa9sPk9NYl62tJ3UY3cIgZk,14758
-endoreg_db-0.8.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-endoreg_db-0.8.4.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-endoreg_db-0.8.4.3.dist-info/RECORD,,
+endoreg_db-0.8.4.4.dist-info/METADATA,sha256=GGQH5jWgXwF4K0rTdGb5jxxeVfRbbMdtmLf9b7MO_M0,14719
+endoreg_db-0.8.4.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+endoreg_db-0.8.4.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+endoreg_db-0.8.4.4.dist-info/RECORD,,

endoreg_db/management/commands/validate_ai_models.py

@@ -1,124 +0,0 @@
-"""
-Django management command to validate and fix AI model metadata issues.
-This command addresses the "No model metadata found for this model" error.
-"""
-
-from django.core.management.base import BaseCommand
-
-from endoreg_db.models.metadata.model_meta_logic import validate_and_fix_ai_model_metadata_logic
-
-
-class Command(BaseCommand):
-    help = """
-    Validate and fix AI model metadata to prevent processing errors.
-    
-    This command:
-    - Checks all AI models for proper metadata configuration
-    - Creates missing metadata with sensible defaults
-    - Sets active metadata for models that don't have it
-    - Validates that all models can access their latest versions
-    
-    Use this command to fix "No model metadata found for this model" errors.
-    """
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--dry-run",
-            action="store_true",
-            help="Show what would be fixed without making changes",
-        )
-        parser.add_argument(
-            "--force",
-            action="store_true",
-            help="Force recreation of existing metadata",
-        )
-
-    def handle(self, *args, **options):
-        dry_run = options.get("dry_run", False)
-        force = options.get("force", False)
-
-        self.stdout.write(self.style.SUCCESS("🔍 Validating AI model metadata..."))
-
-        if dry_run:
-            self.stdout.write(self.style.WARNING("🧪 DRY RUN MODE - No changes will be made"))
-
-        try:
-            if dry_run:
-                # In dry run, we just check and report issues
-                summary = self._check_ai_models_dry_run()
-            else:
-                # Actually fix the issues
-                summary = validate_and_fix_ai_model_metadata_logic()
-
-            # Report results
-            self._report_summary(summary)
-
-            if summary["errors"]:
-                self.stdout.write(self.style.ERROR("❌ Validation completed with errors"))
-                for error in summary["errors"]:
-                    self.stdout.write(self.style.ERROR(f"  - {error}"))
-                return
-
-            self.stdout.write(self.style.SUCCESS("✅ AI model metadata validation completed successfully"))
-
-        except Exception as e:
-            self.stdout.write(self.style.ERROR(f"❌ Validation failed: {e}"))
-            raise
-
-    def _check_ai_models_dry_run(self):
-        """Check AI models without making changes."""
-        from endoreg_db.models import AiModel
-
-        summary = {"models_checked": 0, "models_fixed": 0, "metadata_created": 0, "active_meta_set": 0, "errors": []}
-
-        all_models = AiModel.objects.all()
-        summary["models_checked"] = all_models.count()
-
-        for model in all_models:
-            self.stdout.write(f"Checking model: {model.name}")
-
-            metadata_count = model.metadata_versions.count()
-            self.stdout.write(f"  Metadata versions: {metadata_count}")
-
-            if metadata_count == 0:
-                self.stdout.write(f"  🔧 Would create metadata for {model.name}")
-                summary["models_fixed"] += 1
-                summary["metadata_created"] += 1
-
-            elif not model.active_meta:
-                self.stdout.write(f"  🔧 Would set active metadata for {model.name}")
-                summary["models_fixed"] += 1
-                summary["active_meta_set"] += 1
-
-            else:
-                self.stdout.write(f"  ✅ Model {model.name} has valid active metadata")
-
-            # Test metadata access
-            try:
-                latest = model.get_latest_version()
-                self.stdout.write(f"  ✅ Can access latest version: {latest}")
-            except Exception as e:
-                error_msg = f"Model {model.name} metadata test failed: {e}"
-                self.stdout.write(self.style.ERROR(f"  ❌ {error_msg}"))
-                summary["errors"].append(error_msg)
-
-        return summary
-
-    def _report_summary(self, summary):
-        """Report the validation summary."""
-        self.stdout.write("\n📊 Validation Summary:")
-        self.stdout.write(f"  Models checked: {summary['models_checked']}")
-
-        if summary["models_fixed"] > 0:
-            self.stdout.write(f"  Models fixed: {summary['models_fixed']}")
-
-        if summary["metadata_created"] > 0:
-            self.stdout.write(f"  Metadata created: {summary['metadata_created']}")
-
-        if summary["active_meta_set"] > 0:
-            self.stdout.write(f"  Active metadata set: {summary['active_meta_set']}")
-
-        if summary["errors"]:
-            self.stdout.write(f"  Errors encountered: {len(summary['errors'])}")
-        else:
-            self.stdout.write("  No errors found")