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

endoreg_db/management/commands/setup_endoreg_db.py

@@ -8,8 +8,10 @@ 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.
@@ -119,6 +121,15 @@ 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:
@@ -137,12 +148,11 @@ 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 = [
@@ -162,10 +172,8 @@ class Command(BaseCommand):
                 return path
 
         self.stdout.write("Model weights file not found in standard locations")
-        
-        return None
-    
 
+        return None
 
     def _verify_setup(self):
         """Verify that the setup was successful."""
@@ -205,5 +213,81 @@ 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/management/commands/validate_ai_models.py

@@ -0,0 +1,124 @@
+"""
+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")

endoreg_db/models/metadata/model_meta_logic.py

@@ -18,18 +18,14 @@ 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
@@ -84,24 +80,17 @@ 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}' "
-                f"already exists. Use bump_if_exists=True to increment."
+                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' 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()
@@ -111,10 +100,7 @@ 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
 
@@ -233,22 +219,14 @@ 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
@@ -266,9 +244,7 @@ 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",
@@ -317,9 +293,7 @@ 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.
     """
@@ -333,11 +307,7 @@ def setup_default_from_huggingface_logic(
     )
 
     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,
@@ -352,3 +322,99 @@ def setup_default_from_huggingface_logic(
         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

@@ -55,7 +55,18 @@ class VideoImportService():
             self.project_root = Path(__file__).parent.parent.parent.parent
         
         # Track processed files to prevent duplicates
-        self.processed_files = set(str(Path(ANONYM_VIDEO_DIR) / file) for file in os.listdir(ANONYM_VIDEO_DIR))
+        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()
                     
         # Central video instance and processing context
         self.current_video: Optional[VideoFile] = None
@@ -146,6 +157,9 @@ 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, 
@@ -182,7 +196,12 @@ class VideoImportService():
             return self.current_video
             
         except Exception as e:
-            self.logger.error(f"Video import and anonymization failed for {file_path}: {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._cleanup_on_error()
             raise
         finally:
@@ -969,6 +988,10 @@ 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.3.9.dist-info → endoreg_db-0.8.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.3.9
+Version: 0.8.4.1
 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.3.9.dist-info → endoreg_db-0.8.4.1.dist-info}/RECORD

@@ -290,10 +290,11 @@ 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=efOXE6IQs4ey84tIncf6zXI2VVVRd7CYXbeuACFgkgI,9095
+endoreg_db/management/commands/setup_endoreg_db.py,sha256=v9QgbxAONChZNqm-TVPQGj7AEjZdSA01zC7gImkJEkY,12989
 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
@@ -464,7 +465,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=6w1YX8hVq40UXbVN1fvDO9OljwekBZaDVHEjVZecoV8,12252
+endoreg_db/models/metadata/model_meta_logic.py,sha256=R2VqcmJb3LmMMM37RMBWpRmfD_GVP3FsmgpAXAoyQPs,15810
 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
@@ -602,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=PNAHHZHzge2TYDaZP63CL-sslj01CxFky6sEi6Twavg,46045
+endoreg_db/services/video_import.py,sha256=5a73s0Au0kgZFbrsD4WUqmDAqhQmuf9_wqs79SI-byE,47356
 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
@@ -786,7 +787,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.3.9.dist-info/METADATA,sha256=ByxNYCIC-wIFfuG-7mfsrJ6KJumFz0K17X3-ABUuhCs,14758
-endoreg_db-0.8.3.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-endoreg_db-0.8.3.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-endoreg_db-0.8.3.9.dist-info/RECORD,,
+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,,