endoreg-db 0.8.4.1__py3-none-any.whl → 0.8.4.2__py3-none-any.whl

endoreg_db/management/commands/setup_endoreg_db.py

@@ -8,10 +8,8 @@ from pathlib import Path
 
 from django.core.management import call_command
 from django.core.management.base import BaseCommand
-
 from endoreg_db.models import ModelMeta
 
-
 class Command(BaseCommand):
     help = """
     Complete setup for EndoReg DB when used as an embedded app.
@@ -121,15 +119,6 @@ class Command(BaseCommand):
                 self.stdout.write(self.style.ERROR(f"❌ Failed to create AI model metadata: {e}"))
                 return
 
-            # Step 5.5: Validate and fix AI model active metadata
-            self.stdout.write("\n🔧 Step 5.5: Validating AI model active metadata...")
-            try:
-                self._validate_and_fix_ai_model_metadata()
-                self.stdout.write(self.style.SUCCESS("✅ AI model metadata validation completed"))
-            except Exception as e:
-                self.stdout.write(self.style.ERROR(f"❌ Failed to validate AI model metadata: {e}"))
-                return
-
         # Step 6: Verification
         self.stdout.write("\n🔍 Step 6: Verifying setup...")
         try:
@@ -148,11 +137,12 @@ class Command(BaseCommand):
     def _find_model_weights_file(self):
         """Find the model weights file in various possible locations."""
         # Check common locations for model weights
-
+        
         if not ModelMeta.objects.exists():
             print("📦 No model metadata found — creating from Hugging Face...")
             ModelMeta.setup_default_from_huggingface(
-                "wg-lux/colo_segmentation_RegNetX800MF_base", labelset_name="multilabel_classification_colonoscopy_default"
+                "wg-lux/colo_segmentation_RegNetX800MF_base",
+                labelset_name="multilabel_classification_colonoscopy_default"
             )
             print("✅ Default ModelMeta created.")
         possible_paths = [
@@ -172,8 +162,10 @@ class Command(BaseCommand):
                 return path
 
         self.stdout.write("Model weights file not found in standard locations")
-
+        
         return None
+    
+
 
     def _verify_setup(self):
         """Verify that the setup was successful."""
@@ -213,81 +205,5 @@ class Command(BaseCommand):
             self.stdout.write(f"Found {meta_count} model metadata record(s)")
 
         self.stdout.write("Setup verification passed")
+        
 
-    def _validate_and_fix_ai_model_metadata(self):
-        """
-        Validate that all AI models have proper active metadata and fix if necessary.
-        This addresses the "No model metadata found for this model" error.
-        """
-        from endoreg_db.models import AiModel, LabelSet, ModelMeta
-
-        all_models = AiModel.objects.all()
-        fixed_count = 0
-
-        for model in all_models:
-            self.stdout.write(f"Checking model: {model.name}")
-
-            # Check if model has metadata versions
-            metadata_count = model.metadata_versions.count()
-            self.stdout.write(f"  Metadata versions: {metadata_count}")
-
-            if metadata_count == 0:
-                # Create metadata for models that don't have any
-                self.stdout.write(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")
-
-                # 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()
-                fixed_count += 1
-                self.stdout.write(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:
-                    self.stdout.write(f"  Setting active metadata for {model.name}...")
-                    model.active_meta = first_meta
-                    model.save()
-                    fixed_count += 1
-                    self.stdout.write(f"  ✅ Set active metadata: {first_meta.name} v{first_meta.version}")
-                else:
-                    self.stdout.write(f"  ⚠️  No metadata versions available for {model.name}")
-
-            else:
-                self.stdout.write(f"  ✅ Model {model.name} has active metadata: {model.active_meta}")
-
-        # Verify all models can get latest version
-        self.stdout.write("\nTesting model metadata access...")
-        for model in all_models:
-            try:
-                latest = model.get_latest_version()
-                self.stdout.write(f"  ✅ {model.name}: {latest}")
-            except Exception as e:
-                self.stdout.write(f"  ❌ {model.name}: {e}")
-                raise Exception(f"Model {model.name} still has metadata issues: {e}")
-
-        if fixed_count > 0:
-            self.stdout.write(f"Fixed metadata for {fixed_count} model(s)")
-        else:
-            self.stdout.write("All models already had proper metadata")

endoreg_db/models/metadata/model_meta_logic.py

@@ -2,7 +2,7 @@ import shutil
 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
 
@@ -18,14 +18,18 @@ if TYPE_CHECKING:
     from .model_meta import ModelMeta  # Import ModelMeta for type hinting
 
 
-def get_latest_version_number_logic(cls: Type["ModelMeta"], meta_name: str, model_name: str) -> int:
+def get_latest_version_number_logic(
+    cls: Type["ModelMeta"], meta_name: str, model_name: str
+) -> int:
     """
     Finds the highest numerical version for a given meta_name and model_name.
     Iterates through all versions, attempts to parse them as integers,
     and returns the maximum integer found. If no numeric versions are found,
     returns 0.
     """
-    versions_qs = cls.objects.filter(name=meta_name, model__name=model_name).values_list("version", flat=True)
+    versions_qs = cls.objects.filter(
+        name=meta_name, model__name=model_name
+    ).values_list("version", flat=True)
 
     max_v = 0
     found_numeric_version = False
@@ -80,17 +84,24 @@ def create_from_file_logic(
 
     if requested_version:
         target_version = str(requested_version)
-        existing = cls.objects.filter(name=meta_name, model=ai_model, version=target_version).first()
+        existing = cls.objects.filter(
+            name=meta_name, model=ai_model, version=target_version
+        ).first()
         if existing and not bump_if_exists:
             raise ValueError(
-                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' already exists. Use bump_if_exists=True to increment."
+                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' "
+                f"already exists. Use bump_if_exists=True to increment."
             )
         elif existing and bump_if_exists:
             target_version = str(latest_version_num + 1)
-            logger.info(f"Bumping version for {meta_name}/{model_name} to {target_version}")
+            logger.info(
+                f"Bumping version for {meta_name}/{model_name} to {target_version}"
+            )
     else:
         target_version = str(latest_version_num + 1)
-        logger.info(f"Setting next version for {meta_name}/{model_name} to {target_version}")
+        logger.info(
+            f"Setting next version for {meta_name}/{model_name} to {target_version}"
+        )
 
     # --- Prepare Weights File ---
     source_weights_path = Path(weights_file).resolve()
@@ -100,7 +111,10 @@ def create_from_file_logic(
     # Construct destination path within MEDIA_ROOT/WEIGHTS_DIR
     weights_filename = source_weights_path.name
     # Relative path for the FileField upload_to
-    relative_dest_path = Path(WEIGHTS_DIR.relative_to(STORAGE_DIR)) / f"{meta_name}_v{target_version}_{weights_filename}"
+    relative_dest_path = (
+        Path(WEIGHTS_DIR.relative_to(STORAGE_DIR))
+        / f"{meta_name}_v{target_version}_{weights_filename}"
+    )
     # Full path for shutil.copy
     full_dest_path = STORAGE_DIR / relative_dest_path
 
@@ -113,6 +127,8 @@ def create_from_file_logic(
         logger.info(f"Copied weights from {source_weights_path} to {full_dest_path}")
     except Exception as e:
         raise IOError(f"Failed to copy weights file: {e}") from e
+    
+
 
     # --- Create/Update ModelMeta Instance ---
     defaults = {
@@ -130,6 +146,11 @@ def create_from_file_logic(
         version=target_version,
         defaults=defaults,
     )
+    
+    with open(full_dest_path, "rb") as f:
+        model_meta.weights.save(relative_dest_path.name, File(f), save=False)
+    model_meta.save()
+
 
     if created:
         logger.info(f"Created new ModelMeta: {model_meta}")
@@ -219,14 +240,22 @@ def get_model_meta_by_name_version_logic(
         try:
             return cls.objects.get(name=meta_name, model=ai_model, version=version)
         except Exception as exc:
-            raise cls.DoesNotExist(f"ModelMeta '{meta_name}' version '{version}' for model '{model_name}' not found.") from exc
+            raise cls.DoesNotExist(
+                f"ModelMeta '{meta_name}' version '{version}' for model '{model_name}' not found."
+            ) from exc
     else:
         # Get latest version
-        latest = cls.objects.filter(name=meta_name, model=ai_model).order_by("-date_created").first()
+        latest = (
+            cls.objects.filter(name=meta_name, model=ai_model)
+            .order_by("-date_created")
+            .first()
+        )
         if latest:
             return latest
         else:
-            raise cls.DoesNotExist(f"No ModelMeta found for '{meta_name}' and model '{model_name}'.")
+            raise cls.DoesNotExist(
+                f"No ModelMeta found for '{meta_name}' and model '{model_name}'."
+            )
 
 
 import re
@@ -244,7 +273,9 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     """
 
     if not (info := model_info(model_id)):
-        logger.info(f"Could not retrieve model info for {model_id}, using ColoReg segmentation defaults.")
+        logger.info(
+            f"Could not retrieve model info for {model_id}, using ColoReg segmentation defaults."
+        )
         return {
             "name": "wg-lux/colo_segmentation_RegNetX800MF_base",
             "activation": "sigmoid",
@@ -293,7 +324,9 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     }
 
 
-def setup_default_from_huggingface_logic(cls, model_id: str, labelset_name: str | None = None):
+def setup_default_from_huggingface_logic(
+    cls, model_id: str, labelset_name: str | None = None
+):
     """
     Downloads model weights from Hugging Face and auto-fills ModelMeta fields.
     """
@@ -307,7 +340,11 @@ def setup_default_from_huggingface_logic(cls, model_id: str, labelset_name: str
     )
 
     ai_model, _ = AiModel.objects.get_or_create(name=meta["name"])
-    labelset = LabelSet.objects.first() if not labelset_name else LabelSet.objects.get(name=labelset_name)
+    labelset = (
+        LabelSet.objects.first()
+        if not labelset_name
+        else LabelSet.objects.get(name=labelset_name)
+    )
 
     return create_from_file_logic(
         cls,
@@ -322,99 +359,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/services/video_import.py

@@ -18,6 +18,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
@@ -55,18 +56,7 @@ class VideoImportService():
             self.project_root = Path(__file__).parent.parent.parent.parent
         
         # Track processed files to prevent duplicates
-        try:
-            # Ensure anonym_video directory exists before listing files
-            anonym_video_dir = Path(ANONYM_VIDEO_DIR)
-            if anonym_video_dir.exists():
-                self.processed_files = set(str(anonym_video_dir / file) for file in os.listdir(ANONYM_VIDEO_DIR))
-            else:
-                logger.info(f"Creating anonym_videos directory: {anonym_video_dir}")
-                anonym_video_dir.mkdir(parents=True, exist_ok=True)
-                self.processed_files = set()
-        except Exception as e:
-            logger.warning(f"Failed to initialize processed files tracking: {e}")
-            self.processed_files = set()
+        self.processed_files = set(str(Path(ANONYM_VIDEO_DIR) / file) for file in os.listdir(ANONYM_VIDEO_DIR))
                     
         # Central video instance and processing context
         self.current_video: Optional[VideoFile] = None
@@ -75,6 +65,8 @@ class VideoImportService():
         self.delete_source = True
         
         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."""
@@ -157,9 +149,6 @@ class VideoImportService():
         High-level helper that orchestrates the complete video import and anonymization process.
         Uses the central video instance pattern for improved state management.
         """
-        # DEFENSIVE: Initialize processing_context immediately to prevent KeyError crashes
-        self.processing_context = {'file_path': Path(file_path)}
-        
         try:
             # Initialize processing context
             self._initialize_processing_context(file_path, center_name, processor_name, 
@@ -196,12 +185,7 @@ class VideoImportService():
             return self.current_video
             
         except Exception as e:
-            # Safe file path access - handles cases where processing_context wasn't initialized
-            safe_file_path = getattr(self, 'processing_context', {}).get('file_path', file_path)
-            # Debug: Log context state for troubleshooting
-            context_keys = list(getattr(self, 'processing_context', {}).keys())
-            self.logger.debug(f"Context keys during error: {context_keys}")
-            self.logger.error(f"Video import and anonymization failed for {safe_file_path}: {e}")
+            self.logger.error(f"Video import and anonymization failed for {file_path}: {e}")
             self._cleanup_on_error()
             raise
         finally:
@@ -840,7 +824,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.")
@@ -869,10 +853,13 @@ class VideoImportService():
 
                 
         # Create temporary output path for cleaned video
-        video_filename = self.processing_context.get('video_filename', Path(raw_video_path).name)
+        video_filename = self.processing_context.get('video_filename', Path(raw_video_path).name if raw_video_path else "video.mp4")
         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)
@@ -988,10 +975,6 @@ class VideoImportService():
         This method is always called in the finally block of import_and_anonymize()
         to ensure the file lock is released even if processing fails.
         """
-        # DEFENSIVE: Ensure processing_context exists before accessing it
-        if not hasattr(self, 'processing_context'):
-            self.processing_context = {}
-            
         try:
             # Release file lock if it was acquired
             lock_context = self.processing_context.get('_lock_context')

{endoreg_db-0.8.4.1.dist-info → endoreg_db-0.8.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.4.1
+Version: 0.8.4.2
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db

{endoreg_db-0.8.4.1.dist-info → endoreg_db-0.8.4.2.dist-info}/RECORD

@@ -290,11 +290,10 @@ endoreg_db/management/commands/load_unit_data.py,sha256=tcux-iL-ByT2ApgmHEkLllZS
 endoreg_db/management/commands/load_user_groups.py,sha256=D7SK2FvZEHoE4TIXNGCjDw5_12MH9bpGZvoS7eEv0Os,1031
 endoreg_db/management/commands/register_ai_model.py,sha256=KixTfuQR6TUfRmzB5GOos16BFOz7NL4TzLzBkgtPPgE,2510
 endoreg_db/management/commands/reset_celery_schedule.py,sha256=U-m_FNRTw6LAwJoT9RUE4qrhmQXm7AyFToPcHYyJpIE,386
-endoreg_db/management/commands/setup_endoreg_db.py,sha256=v9QgbxAONChZNqm-TVPQGj7AEjZdSA01zC7gImkJEkY,12989
+endoreg_db/management/commands/setup_endoreg_db.py,sha256=efOXE6IQs4ey84tIncf6zXI2VVVRd7CYXbeuACFgkgI,9095
 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
@@ -465,7 +464,7 @@ 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=R2VqcmJb3LmMMM37RMBWpRmfD_GVP3FsmgpAXAoyQPs,15810
+endoreg_db/models/metadata/model_meta_logic.py,sha256=pcpKf9J5DUiEG-D-VhOPcnFjBznkx5jK7EGv0zDMQm8,12440
 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
@@ -603,7 +602,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=5a73s0Au0kgZFbrsD4WUqmDAqhQmuf9_wqs79SI-byE,47356
+endoreg_db/services/video_import.py,sha256=0eeY5etJ4rg6uxC-uUis_yoa6cvGgwY2VaiD3mVFosg,46369
 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
@@ -787,7 +786,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.1.dist-info/METADATA,sha256=TmIf-CR3u-Mx2h06sKN1XHpfDx8vh5R3hbrsDZDgJPw,14758
-endoreg_db-0.8.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-endoreg_db-0.8.4.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-endoreg_db-0.8.4.1.dist-info/RECORD,,
+endoreg_db-0.8.4.2.dist-info/METADATA,sha256=xSaPMvzzc7HovOmkl2Gn0lYVoRNTPk4yqIBFcz0kc70,14758
+endoreg_db-0.8.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+endoreg_db-0.8.4.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+endoreg_db-0.8.4.2.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")