endoreg-db 0.8.9.2__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/management/commands/create_multilabel_model_meta.py

@@ -172,7 +172,9 @@ class Command(BaseCommand):
             raise CommandError(str(exc)) from exc
 
         self.stdout.write(
-            self.style.SUCCESS(f"ModelMeta ready: {model_meta.name} (v{model_meta.version}) for {model_meta.model.name}")
+            self.style.SUCCESS(
+                f"ModelMeta ready: {model_meta.name} (v{model_meta.version}) for {model_meta.model.name}"
+            )
         )
 
     def _create_from_local_file(self, options: Dict[str, Any]) -> ModelMeta:
@@ -213,15 +215,21 @@ class Command(BaseCommand):
 
         meta_name = fields.get("name") or options["model_name"]
         model_name = fields.get("model") or options["model_name"]
-        labelset_name = fields.get("labelset") or options["image_classification_labelset_name"]
-        labelset_version = fields.get("labelset_version", options.get("image_classification_labelset_version"))
+        labelset_name = (
+            fields.get("labelset") or options["image_classification_labelset_name"]
+        )
+        labelset_version = fields.get(
+            "labelset_version", options.get("image_classification_labelset_version")
+        )
 
         self._ensure_ai_model_exists(model_name)
         labelset = self._resolve_labelset(labelset_name, labelset_version)
 
         requested_version = options.get("model_meta_version") or fields.get("version")
         if not requested_version:
-            raise CommandError("Provide --model_meta_version or include a 'version' in the template entry.")
+            raise CommandError(
+                "Provide --model_meta_version or include a 'version' in the template entry."
+            )
 
         hf_config = entry.get("setup_config", {}).get("huggingface_fallback", {})
         repo_id = hf_config.get("repo_id")
@@ -233,7 +241,9 @@ class Command(BaseCommand):
             )
 
         if not filename.endswith(".safetensors"):
-            raise CommandError("Only .safetensors files are supported when downloading from Hugging Face.")
+            raise CommandError(
+                "Only .safetensors files are supported when downloading from Hugging Face."
+            )
 
         token = options.get("huggingface_token")
 
@@ -273,7 +283,9 @@ class Command(BaseCommand):
         elif template_name:
             resolved = (AI_MODEL_META_DATA_DIR / f"{template_name}.yaml").resolve()
         else:  # pragma: no cover - guarded by caller
-            raise CommandError("Template mode requires --template_path or --template_name.")
+            raise CommandError(
+                "Template mode requires --template_path or --template_name."
+            )
 
         if not resolved.exists():
             raise CommandError(f"Template file not found: {resolved}")
@@ -290,16 +302,22 @@ class Command(BaseCommand):
         if isinstance(data, list):
             return [entry for entry in data if isinstance(entry, dict)]
 
-        raise CommandError(f"Template {template_path} must define a mapping or list of mappings.")
+        raise CommandError(
+            f"Template {template_path} must define a mapping or list of mappings."
+        )
 
-    def _select_template_entry(self, entries: Iterable[Dict[str, Any]], options: Dict[str, Any]) -> Dict[str, Any]:
+    def _select_template_entry(
+        self, entries: Iterable[Dict[str, Any]], options: Dict[str, Any]
+    ) -> Dict[str, Any]:
         target = options.get("template_entry_name") or options.get("model_name")
 
         for entry in entries:
             fields = entry.get("fields", {})
             if not fields:
                 continue
-            if target and (fields.get("name") == target or fields.get("model") == target):
+            if target and (
+                fields.get("name") == target or fields.get("model") == target
+            ):
                 return entry
 
         entries = list(entries)
@@ -325,20 +343,33 @@ class Command(BaseCommand):
             }
         )
 
-    def _collect_template_kwargs(self, fields: Dict[str, Any], options: Dict[str, Any]) -> Dict[str, Any]:
+    def _collect_template_kwargs(
+        self, fields: Dict[str, Any], options: Dict[str, Any]
+    ) -> Dict[str, Any]:
         def numeric(value):
             return int(value) if value is not None else value
 
         return self._filter_none(
             {
-                "activation": fields.get("activation") or options.get("activation_function_name"),
-                "mean": self._normalise_sequence(fields.get("mean")) or options.get("mean"),
-                "std": self._normalise_sequence(fields.get("std")) or options.get("std"),
-                "size_x": numeric(fields.get("size_x")) if fields.get("size_x") is not None else options.get("size_x"),
-                "size_y": numeric(fields.get("size_y")) if fields.get("size_y") is not None else options.get("size_y"),
+                "activation": fields.get("activation")
+                or options.get("activation_function_name"),
+                "mean": self._normalise_sequence(fields.get("mean"))
+                or options.get("mean"),
+                "std": self._normalise_sequence(fields.get("std"))
+                or options.get("std"),
+                "size_x": numeric(fields.get("size_x"))
+                if fields.get("size_x") is not None
+                else options.get("size_x"),
+                "size_y": numeric(fields.get("size_y"))
+                if fields.get("size_y") is not None
+                else options.get("size_y"),
                 "axes": fields.get("axes") or options.get("axes"),
-                "batchsize": numeric(fields.get("batchsize")) if fields.get("batchsize") is not None else options.get("batchsize"),
-                "num_workers": numeric(fields.get("num_workers")) if fields.get("num_workers") is not None else options.get("num_workers"),
+                "batchsize": numeric(fields.get("batchsize"))
+                if fields.get("batchsize") is not None
+                else options.get("batchsize"),
+                "num_workers": numeric(fields.get("num_workers"))
+                if fields.get("num_workers") is not None
+                else options.get("num_workers"),
                 "description": fields.get("description") or options.get("description"),
             }
         )
@@ -367,7 +398,9 @@ class Command(BaseCommand):
     @staticmethod
     def _ensure_ai_model_exists(model_name: str) -> None:
         if not AiModel.objects.filter(name=model_name).exists():
-            raise CommandError(f"AiModel not found: {model_name}. Load ai model data before running this command.")
+            raise CommandError(
+                f"AiModel not found: {model_name}. Load ai model data before running this command."
+            )
 
     @staticmethod
     def _resolve_labelset(name: str, version: Any) -> LabelSet:
@@ -379,6 +412,8 @@ class Command(BaseCommand):
             labelset = queryset.filter(version=version).first()
 
         if not labelset:
-            raise CommandError(f"LabelSet not found for name='{name}' and version='{version}'.")
+            raise CommandError(
+                f"LabelSet not found for name='{name}' and version='{version}'."
+            )
 
         return labelset

endoreg_db/management/commands/fix_missing_patient_data.py

@@ -3,10 +3,12 @@ Management command to fix missing patient data in existing videos.
 Fills in default values for videos that have incomplete SensitiveMeta.
 """
 
+from datetime import date
+
 from django.core.management.base import BaseCommand
 from django.db import transaction
-from datetime import date
-from endoreg_db.models import VideoFile, SensitiveMeta
+
+from endoreg_db.models import SensitiveMeta, VideoFile
 
 
 class Command(BaseCommand):
@@ -20,128 +22,152 @@ class Command(BaseCommand):
 
     def add_arguments(self, parser):
         parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be changed without making actual changes',
+            "--dry-run",
+            action="store_true",
+            help="Show what would be changed without making actual changes",
         )
         parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Show detailed output',
+            "--verbose",
+            action="store_true",
+            help="Show detailed output",
         )
 
     def handle(self, *args, **options):
-        dry_run = options['dry_run']
-        verbose = options['verbose']
-        
+        dry_run = options["dry_run"]
+        verbose = options["verbose"]
+
         self.stdout.write(self.style.SUCCESS("Starting patient data repair..."))
-        
+
         if dry_run:
-            self.stdout.write(self.style.WARNING("DRY RUN MODE - No changes will be made"))
-        
+            self.stdout.write(
+                self.style.WARNING("DRY RUN MODE - No changes will be made")
+            )
+
         # Find videos without SensitiveMeta
         videos_without_meta = VideoFile.objects.filter(sensitive_meta__isnull=True)
         count_without_meta = videos_without_meta.count()
-        
+
         # Find videos with incomplete SensitiveMeta
-        videos_with_incomplete_meta = VideoFile.objects.filter(
-            sensitive_meta__isnull=False
-        ).filter(
-            # At least one of these fields is missing
-            sensitive_meta__patient_first_name__isnull=True
-        ) | VideoFile.objects.filter(
-            sensitive_meta__isnull=False,
-            sensitive_meta__patient_last_name__isnull=True
-        ) | VideoFile.objects.filter(
-            sensitive_meta__isnull=False,
-            sensitive_meta__patient_dob__isnull=True
-        ) | VideoFile.objects.filter(
-            sensitive_meta__isnull=False,
-            sensitive_meta__examination_date__isnull=True
-        ) | VideoFile.objects.filter(
-            sensitive_meta__isnull=False,
-            sensitive_meta__patient_first_name__exact=''
-        ) | VideoFile.objects.filter(
-            sensitive_meta__isnull=False,
-            sensitive_meta__patient_last_name__exact=''
+        videos_with_incomplete_meta = (
+            VideoFile.objects.filter(sensitive_meta__isnull=False).filter(
+                # At least one of these fields is missing
+                sensitive_meta__patient_first_name__isnull=True
+            )
+            | VideoFile.objects.filter(
+                sensitive_meta__isnull=False,
+                sensitive_meta__patient_last_name__isnull=True,
+            )
+            | VideoFile.objects.filter(
+                sensitive_meta__isnull=False, sensitive_meta__patient_dob__isnull=True
+            )
+            | VideoFile.objects.filter(
+                sensitive_meta__isnull=False,
+                sensitive_meta__examination_date__isnull=True,
+            )
+            | VideoFile.objects.filter(
+                sensitive_meta__isnull=False,
+                sensitive_meta__patient_first_name__exact="",
+            )
+            | VideoFile.objects.filter(
+                sensitive_meta__isnull=False,
+                sensitive_meta__patient_last_name__exact="",
+            )
         )
-        
+
         count_incomplete = videos_with_incomplete_meta.count()
-        
+
         self.stdout.write(f"Found {count_without_meta} videos without SensitiveMeta")
-        self.stdout.write(f"Found {count_incomplete} videos with incomplete SensitiveMeta")
-        
+        self.stdout.write(
+            f"Found {count_incomplete} videos with incomplete SensitiveMeta"
+        )
+
         if count_without_meta == 0 and count_incomplete == 0:
-            self.stdout.write(self.style.SUCCESS("No repairs needed - all videos have complete patient data!"))
+            self.stdout.write(
+                self.style.SUCCESS(
+                    "No repairs needed - all videos have complete patient data!"
+                )
+            )
             return
-        
+
         fixed_count = 0
         created_count = 0
-        
+
         # Process videos without SensitiveMeta
         if count_without_meta > 0:
-            self.stdout.write(f"\nProcessing {count_without_meta} videos without SensitiveMeta...")
-            
+            self.stdout.write(
+                f"\nProcessing {count_without_meta} videos without SensitiveMeta..."
+            )
+
             for video in videos_without_meta:
                 if verbose:
-                    self.stdout.write(f"Creating SensitiveMeta for video {video.uuid}")
-                
+                    self.stdout.write(
+                        f"Creating SensitiveMeta for video {video.video_hash}"
+                    )
+
                 if not dry_run:
                     try:
                         with transaction.atomic():
                             default_data = {
                                 "patient_first_name": "Patient",
-                                "patient_last_name": "Unknown", 
+                                "patient_last_name": "Unknown",
                                 "patient_dob": date(1990, 1, 1),
                                 "examination_date": date.today(),
-                                "center_name": video.center.name if video.center else "university_hospital_wuerzburg"
+                                "center_name": video.center.name
+                                if video.center
+                                else "university_hospital_wuerzburg",
                             }
-                            
-                            sensitive_meta = SensitiveMeta.create_from_dict(default_data)
+
+                            sensitive_meta = SensitiveMeta.create_from_dict(
+                                default_data
+                            )
                             video.sensitive_meta = sensitive_meta
-                            video.save(update_fields=['sensitive_meta'])
+                            video.save(update_fields=["sensitive_meta"])
                             created_count += 1
-                            
+
                     except Exception as e:
                         self.stdout.write(
-                            self.style.ERROR(f"Failed to create SensitiveMeta for video {video.uuid}: {e}")
+                            self.style.ERROR(
+                                f"Failed to create SensitiveMeta for video {video.video_hash}: {e}"
+                            )
                         )
                 else:
                     created_count += 1
-        
+
         # Process videos with incomplete SensitiveMeta
         if count_incomplete > 0:
-            self.stdout.write(f"\nProcessing {count_incomplete} videos with incomplete SensitiveMeta...")
-            
+            self.stdout.write(
+                f"\nProcessing {count_incomplete} videos with incomplete SensitiveMeta..."
+            )
+
             for video in videos_with_incomplete_meta:
                 if not video.sensitive_meta:
                     continue  # Skip if somehow None (already handled above)
-                
+
                 update_data = {}
                 missing_fields = []
-                
+
                 if not video.sensitive_meta.patient_first_name:
                     update_data["patient_first_name"] = "Patient"
                     missing_fields.append("first_name")
-                    
+
                 if not video.sensitive_meta.patient_last_name:
                     update_data["patient_last_name"] = "Unknown"
                     missing_fields.append("last_name")
-                    
+
                 if not video.sensitive_meta.patient_dob:
                     update_data["patient_dob"] = date(1990, 1, 1)
                     missing_fields.append("dob")
-                    
+
                 if not video.sensitive_meta.examination_date:
                     update_data["examination_date"] = date.today()
                     missing_fields.append("examination_date")
-                
+
                 if update_data:
                     if verbose:
                         self.stdout.write(
-                            f"Updating video {video.uuid} - missing fields: {', '.join(missing_fields)}"
+                            f"Updating video {video.video_hash} - missing fields: {', '.join(missing_fields)}"
                         )
-                    
+
                     if not dry_run:
                         try:
                             with transaction.atomic():
@@ -149,24 +175,32 @@ class Command(BaseCommand):
                                 fixed_count += 1
                         except Exception as e:
                             self.stdout.write(
-                                self.style.ERROR(f"Failed to update SensitiveMeta for video {video.uuid}: {e}")
+                                self.style.ERROR(
+                                    f"Failed to update SensitiveMeta for video {video.video_hash}: {e}"
+                                )
                             )
                     else:
                         fixed_count += 1
-        
+
         # Summary
-        self.stdout.write("\n" + "="*50)
+        self.stdout.write("\n" + "=" * 50)
         if dry_run:
             self.stdout.write(self.style.SUCCESS("DRY RUN SUMMARY:"))
             self.stdout.write(f"Would create SensitiveMeta for: {created_count} videos")
             self.stdout.write(f"Would update incomplete data for: {fixed_count} videos")
-            self.stdout.write(f"Total videos that would be fixed: {created_count + fixed_count}")
+            self.stdout.write(
+                f"Total videos that would be fixed: {created_count + fixed_count}"
+            )
         else:
             self.stdout.write(self.style.SUCCESS("REPAIR COMPLETED:"))
             self.stdout.write(f"Created SensitiveMeta for: {created_count} videos")
             self.stdout.write(f"Updated incomplete data for: {fixed_count} videos")
             self.stdout.write(f"Total videos fixed: {created_count + fixed_count}")
-        
+
         if not dry_run and (created_count > 0 or fixed_count > 0):
-            self.stdout.write(self.style.SUCCESS("\n✅ Patient data repair completed successfully!"))
-            self.stdout.write("All videos now have the minimum required patient data for annotation.")
+            self.stdout.write(
+                self.style.SUCCESS("\n✅ Patient data repair completed successfully!")
+            )
+            self.stdout.write(
+                "All videos now have the minimum required patient data for annotation."
+            )

endoreg_db/management/commands/fix_video_paths.py

@@ -1,77 +1,82 @@
 """
 Django management command to fix video file paths in the database.
 """
+
+import logging
+import os
+from pathlib import Path
+
 from django.core.management.base import BaseCommand
 from django.db import transaction
+
 from endoreg_db.models import VideoFile
-from pathlib import Path
-import logging
-import os
 
 logger = logging.getLogger(__name__)
 
 
 class Command(BaseCommand):
-    help = 'Fix video file paths in the database to match actual file locations'
+    help = "Fix video file paths in the database to match actual file locations"
 
     def add_arguments(self, parser):
         parser.add_argument(
-            '--video-id',
+            "--video-id",
             type=int,
-            help='Fix specific video ID only',
+            help="Fix specific video ID only",
         )
         parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be changed without making changes',
+            "--dry-run",
+            action="store_true",
+            help="Show what would be changed without making changes",
         )
         parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Enable verbose output',
+            "--verbose",
+            action="store_true",
+            help="Enable verbose output",
         )
         parser.add_argument(
-            '--storage-dir',
+            "--storage-dir",
             type=str,
             default=None,
-            help='Path to the storage directory (default: $ENDOREG_STORAGE_DIR or ./storage)'
+            help="Path to the storage directory (default: $ENDOREG_STORAGE_DIR or ./storage)",
         )
 
     def handle(self, *args, **options):
         """
         Synchronizes video file paths in the database with actual files on disk, updating broken or missing paths as needed.
-        
+
         Scans the specified storage directory for video files, matches them to database records by UUID, and updates the `raw_file` field for videos whose stored path is missing or incorrect. Supports dry-run and verbose modes, and can process all videos or a specific video by ID.
         """
-        dry_run = options['dry_run']
-        verbose = options['verbose']
-        video_id = options.get('video_id')
+        dry_run = options["dry_run"]
+        verbose = options["verbose"]
+        video_id = options.get("video_id")
 
         # Determine storage_dir from argument, env, or fallback
-        storage_dir = options.get('storage_dir') or \
-            os.environ.get('ENDOREG_STORAGE_DIR') or \
-            './storage'
+        storage_dir = (
+            options.get("storage_dir")
+            or os.environ.get("ENDOREG_STORAGE_DIR")
+            or "./storage"
+        )
         storage_dir = Path(storage_dir)
-        
+
         # Find all actual video files
         actual_files = {}
-        for pattern in ['**/*.mp4', '**/*.avi', '**/*.mov', '**/*.mkv']:
+        for pattern in ["**/*.mp4", "**/*.avi", "**/*.mov", "**/*.mkv"]:
             for file_path in storage_dir.glob(pattern):
                 if file_path.is_file() and file_path.stat().st_size > 0:
                     # Extract UUID from filename
                     filename = file_path.name
                     # UUID is typically the first part before underscore or the whole name
-                    if '_' in filename:
-                        uuid_part = filename.split('_')[0]
+                    if "_" in filename:
+                        uuid_part = filename.split("_")[0]
                     else:
-                        uuid_part = filename.split('.')[0]
-                    
+                        uuid_part = filename.split(".")[0]
+
                     # Store relative path from storage directory
                     relative_path = file_path.relative_to(storage_dir)
                     actual_files[uuid_part] = {
-                        'absolute_path': file_path,
-                        'relative_path': relative_path,
-                        'size_mb': file_path.stat().st_size / (1024*1024)
+                        "absolute_path": file_path,
+                        "relative_path": relative_path,
+                        "size_mb": file_path.stat().st_size / (1024 * 1024),
                     }
 
         self.stdout.write(f"Found {len(actual_files)} video files in storage")
@@ -82,7 +87,9 @@ class Command(BaseCommand):
                 videos = [VideoFile.objects.get(pk=video_id)]
                 self.stdout.write(f"Processing specific video ID: {video_id}")
             except VideoFile.DoesNotExist:
-                self.stdout.write(self.style.ERROR(f"Video with ID {video_id} not found"))
+                self.stdout.write(
+                    self.style.ERROR(f"Video with ID {video_id} not found")
+                )
                 return
         else:
             videos = VideoFile.objects.all()
@@ -94,52 +101,64 @@ class Command(BaseCommand):
 
         for video in videos:
             try:
-                uuid_str = str(video.uuid)
-                
+                uuid_str = str(video.video_hash)
+
                 # Check if we have a matching file
                 if uuid_str in actual_files:
                     file_info = actual_files[uuid_str]
-                    
+
                     # Check current file path
                     current_path_exists = False
                     current_path = None
-                    
-                    if hasattr(video, 'raw_file') and video.raw_file:
+
+                    if hasattr(video, "raw_file") and video.raw_file:
                         try:
                             current_path = Path(video.raw_file.path)
                             current_path_exists = current_path.exists()
                         except (ValueError, AttributeError, OSError):
                             current_path_exists = False
-                    
+
                     if not current_path_exists:
                         # File path is broken, fix it
                         if verbose:
                             self.stdout.write(f"Video {video.id} ({uuid_str}):")
-                            self.stdout.write(f"  Current: {current_path or 'None'} (broken)")
-                            self.stdout.write(f"  Found: {file_info['absolute_path']} ({file_info['size_mb']:.1f} MB)")
-                        
+                            self.stdout.write(
+                                f"  Current: {current_path or 'None'} (broken)"
+                            )
+                            self.stdout.write(
+                                f"  Found: {file_info['absolute_path']} ({file_info['size_mb']:.1f} MB)"
+                            )
+
                         if not dry_run:
                             with transaction.atomic():
                                 # Update the raw_file path
-                                video.raw_file.name = str(file_info['relative_path'])
-                                video.save(update_fields=['raw_file'])
-                                
+                                video.raw_file.name = str(file_info["relative_path"])
+                                video.save(update_fields=["raw_file"])
+
                             self.stdout.write(
-                                self.style.SUCCESS(f"✅ Fixed video {video.id}: {file_info['relative_path']}")
+                                self.style.SUCCESS(
+                                    f"✅ Fixed video {video.id}: {file_info['relative_path']}"
+                                )
                             )
                         else:
                             self.stdout.write(
-                                self.style.WARNING(f"🔄 Would fix video {video.id}: {file_info['relative_path']}")
+                                self.style.WARNING(
+                                    f"🔄 Would fix video {video.id}: {file_info['relative_path']}"
+                                )
                             )
-                        
+
                         fixed_count += 1
                     else:
                         if verbose:
-                            self.stdout.write(f"✅ Video {video.id} ({uuid_str}) already has correct path")
+                            self.stdout.write(
+                                f"✅ Video {video.id} ({uuid_str}) already has correct path"
+                            )
                         skipped_count += 1
                 else:
                     if verbose:
-                        self.stdout.write(f"❌ Video {video.id} ({uuid_str}): No matching file found")
+                        self.stdout.write(
+                            f"❌ Video {video.id} ({uuid_str}): No matching file found"
+                        )
                     error_count += 1
 
             except Exception as e:
@@ -149,17 +168,19 @@ class Command(BaseCommand):
                 error_count += 1
 
         # Summary
-        self.stdout.write(f"\n{'='*50}")
+        self.stdout.write(f"\n{'=' * 50}")
         self.stdout.write(self.style.SUCCESS("SUMMARY"))
-        self.stdout.write(f"{'='*50}")
-        
+        self.stdout.write(f"{'=' * 50}")
+
         action_word = "Would fix" if dry_run else "Fixed"
         self.stdout.write(f"🔧 {action_word}: {fixed_count} videos")
         self.stdout.write(f"✅ Already correct: {skipped_count} videos")
         self.stdout.write(f"❌ Errors/Missing files: {error_count} videos")
-        
+
         if dry_run and fixed_count > 0:
             self.stdout.write("\n💡 Run without --dry-run to apply changes")
         elif not dry_run and fixed_count > 0:
-            self.stdout.write(f"\n🎉 Successfully fixed {fixed_count} video file paths!")
-            self.stdout.write("🔄 Restart your Django server to reload file paths")
+            self.stdout.write(
+                f"\n🎉 Successfully fixed {fixed_count} video file paths!"
+            )
+            self.stdout.write("🔄 Restart your Django server to reload file paths")