endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/management/commands/check_auth.py

@@ -0,0 +1,125 @@
+"""
+Management command to check and configure authentication settings.
+"""
+
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from rest_framework.permissions import IsAuthenticated, AllowAny
+import os
+
+
+class Command(BaseCommand):
+    help = 'Check and configure authentication settings based on environment'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--mode',
+            choices=['check', 'dev', 'prod'],
+            default='check',
+            help='Mode: check current settings, set dev mode, or set prod mode'
+        )
+        parser.add_argument(
+            '--show-permissions',
+            action='store_true',
+            help='Show which permission classes will be used'
+        )
+
+    def handle(self, *args, **options):
+        mode = options['mode']
+        
+        if mode == 'check':
+            self.check_current_settings()
+        elif mode == 'dev':
+            self.set_dev_mode()
+        elif mode == 'prod':
+            self.set_prod_mode()
+            
+        if options['show_permissions']:
+            self.show_permission_classes()
+
+    def check_current_settings(self):
+        """Check current authentication configuration."""
+        debug_mode = getattr(settings, 'DEBUG', False)
+        settings_module = os.environ.get('DJANGO_SETTINGS_MODULE', 'Unknown')
+        
+        self.stdout.write("\n" + "="*50)
+        self.stdout.write("🔍 AUTHENTICATION CONFIGURATION CHECK")
+        self.stdout.write("="*50)
+        
+        self.stdout.write(f"Settings Module: {settings_module}")
+        self.stdout.write(f"DEBUG Mode: {debug_mode}")
+        
+        if debug_mode:
+            self.stdout.write(self.style.WARNING("🔓 Authentication: DISABLED (AllowAny)"))
+            self.stdout.write("   - All API endpoints are accessible without login")
+            self.stdout.write("   - Suitable for development and testing")
+        else:
+            self.stdout.write(self.style.SUCCESS("🔒 Authentication: ENABLED (IsAuthenticated)"))
+            self.stdout.write("   - API endpoints require valid authentication")
+            self.stdout.write("   - Suitable for production deployment")
+            
+        # Check if Keycloak is configured
+        keycloak_server = getattr(settings, 'KEYCLOAK_SERVER_URL', None)
+        if keycloak_server:
+            self.stdout.write(f"Keycloak Server: {keycloak_server}")
+        else:
+            self.stdout.write(self.style.WARNING("⚠️  Keycloak not configured"))
+            
+        self.stdout.write("="*50 + "\n")
+
+    def set_dev_mode(self):
+        """Instructions for setting development mode."""
+        self.stdout.write(self.style.SUCCESS("\n🛠️  DEVELOPMENT MODE SETUP"))
+        self.stdout.write("To enable development mode with disabled authentication:")
+        self.stdout.write("")
+        self.stdout.write("1. Use dev settings:")
+        self.stdout.write("   export DJANGO_SETTINGS_MODULE=dev.dev_settings")
+        self.stdout.write("   python manage.py runserver")
+        self.stdout.write("")
+        self.stdout.write("2. Or run with explicit settings:")
+        self.stdout.write("   python manage.py runserver --settings=dev.dev_settings")
+        self.stdout.write("")
+        self.stdout.write("This will set DEBUG=True and disable authentication requirements.")
+
+    def set_prod_mode(self):
+        """Instructions for setting production mode."""
+        self.stdout.write(self.style.SUCCESS("\n🏭 PRODUCTION MODE SETUP"))
+        self.stdout.write("To enable production mode with authentication:")
+        self.stdout.write("")
+        self.stdout.write("1. Use production settings:")
+        self.stdout.write("   export DJANGO_SETTINGS_MODULE=prod_settings")
+        self.stdout.write("   python manage.py runserver --settings=prod_settings")
+        self.stdout.write("")
+        self.stdout.write("2. Set required environment variables:")
+        self.stdout.write("   export DJANGO_SECRET_KEY='your-secure-secret-key'")
+        self.stdout.write("   export KEYCLOAK_CLIENT_SECRET='your-keycloak-secret'")
+        self.stdout.write("")
+        self.stdout.write("This will set DEBUG=False and enable authentication requirements.")
+
+    def show_permission_classes(self):
+        """Show which permission classes are being used."""
+        debug_mode = getattr(settings, 'DEBUG', False)
+        
+        self.stdout.write("\n" + "="*40)
+        self.stdout.write("🔐 PERMISSION CLASSES IN USE")
+        self.stdout.write("="*40)
+        
+        if debug_mode:
+            permission_class = "AllowAny"
+            icon = "🔓"
+        else:
+            permission_class = "IsAuthenticated"
+            icon = "🔒"
+            
+        self.stdout.write(f"{icon} Current Mode: {permission_class}")
+        self.stdout.write("")
+        self.stdout.write("Views using dynamic permissions:")
+        self.stdout.write("  • video_segments_view")
+        self.stdout.write("  • VideoViewSet")
+        self.stdout.write("  • Other API endpoints")
+        self.stdout.write("")
+        self.stdout.write("Views always requiring authentication:")
+        self.stdout.write("  • video_segment_detail_view")
+        self.stdout.write("  • video_segments_by_label_id_view")
+        self.stdout.write("  • video_segments_by_label_name_view")
+        self.stdout.write("="*40 + "\n")

endoreg_db/management/commands/create_model_meta_from_huggingface.py

@@ -0,0 +1,115 @@
+"""
+Django management command to create ModelMeta from Hugging Face model.
+"""
+
+from pathlib import Path
+
+from django.core.files.base import ContentFile
+from django.core.management.base import BaseCommand
+from huggingface_hub import hf_hub_download
+
+from endoreg_db.models import AiModel, LabelSet, ModelMeta
+
+
+class Command(BaseCommand):
+    help = "Create ModelMeta by downloading model from Hugging Face"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--model_id",
+            type=str,
+            default="wg-lux/colo_segmentation_RegNetX800MF_base",
+            help="Hugging Face model ID",
+        )
+        parser.add_argument(
+            "--model_name",
+            type=str,
+            default="image_multilabel_classification_colonoscopy_default",
+            help="Name for the AI model",
+        )
+        parser.add_argument(
+            "--labelset_name",
+            type=str,
+            default="multilabel_classification_colonoscopy_default",
+            help="Name of the labelset",
+        )
+        parser.add_argument(
+            "--meta_version",
+            type=str,
+            default="1",
+            help="Version for the model meta",
+        )
+
+    def handle(self, *args, **options):
+        model_id = options["model_id"]
+        model_name = options["model_name"]
+        labelset_name = options["labelset_name"]
+        version = options["meta_version"]
+
+        self.stdout.write(f"Downloading model {model_id} from Hugging Face...")
+
+        try:
+            # Download the model weights
+            weights_path = hf_hub_download(
+                repo_id=model_id,
+                filename="colo_segmentation_RegNetX800MF_base.ckpt",
+                local_dir="/tmp",
+            )
+            self.stdout.write(f"Downloaded weights to: {weights_path}")
+
+            # Get or create AI model
+            ai_model, created = AiModel.objects.get_or_create(
+                name=model_name, defaults={"description": f"Model from {model_id}"}
+            )
+            if created:
+                self.stdout.write(f"Created AI model: {ai_model.name}")
+
+            # Get labelset
+            try:
+                labelset = LabelSet.objects.get(name=labelset_name)
+            except LabelSet.DoesNotExist:
+                self.stdout.write(
+                    self.style.ERROR(f"LabelSet '{labelset_name}' not found")
+                )
+                return
+
+            # Create ModelMeta
+            model_meta, created = ModelMeta.objects.get_or_create(
+                name=model_name,
+                model=ai_model,
+                version=version,
+                defaults={
+                    "labelset": labelset,
+                    "activation": "sigmoid",
+                    "mean": "0.45211223,0.27139644,0.19264949",
+                    "std": "0.31418097,0.21088019,0.16059452",
+                    "size_x": 716,
+                    "size_y": 716,
+                    "axes": "2,0,1",
+                    "batchsize": 16,
+                    "num_workers": 0,
+                    "description": f"Downloaded from {model_id}",
+                },
+            )
+
+            # Save the weights file to the model
+            with open(weights_path, "rb") as f:
+                model_meta.weights.save(
+                    f"{model_name}_v{version}_pytorch_model.bin", ContentFile(f.read())
+                )
+
+            # Set as active meta
+            ai_model.active_meta = model_meta
+            ai_model.save()
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Successfully {'created' if created else 'updated'} ModelMeta: {model_meta}"
+                )
+            )
+
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"Error creating ModelMeta: {e}"))
+            import traceback
+
+            traceback.print_exc()

endoreg_db/management/commands/create_multilabel_model_meta.py

@@ -0,0 +1,214 @@
+"""
+This script creates a new ModelMeta object for a multilabel classification model.
+"""
+
+from pathlib import Path
+from django.core.management import BaseCommand
+from endoreg_db.models import LabelSet, AiModel, ModelMeta
+
+
+# Example usage:
+# python manage.py create_multilabel_model_meta --model_path "./data/models/colo_segmentation_RegNetX800MF_6.ckpt"
+# python manage.py create_multilabel_model_meta --model_path "./libs/endoreg-db/tests/assets/colo_segmentation_RegNetX800MF_6.ckpt"
+
+FPS = 50
+SMOOTH_WINDOW_SIZE_S = 1
+MIN_SEQ_LEN_S = 0.5
+crop_template = [0, 1080, 550, 1920 - 20]  # [top, bottom, left, right]
+
+
+class Command(BaseCommand):
+    help = """
+        Creates a new ModelMeta object for a multilabel classification model.
+        1. Validates the existence of the specified LabelSet and AiModel
+        2. Checks that the model file exists on disk
+        3. Creates or updates a ModelMeta entry with the specified parameters
+    """
+
+    def add_arguments(self, parser):
+        """
+        Adds command-line arguments for configuring model meta creation.
+        
+        This method defines all necessary arguments for specifying model details, label set selection, normalization parameters, image dimensions, axes configuration, batch size, worker count, and versioning options for the Django management command.
+        """
+        parser.add_argument(
+            "--model_name",
+            type=str,
+            default="image_multilabel_classification_colonoscopy_default",
+            help="Name of the model to use for segmentation",
+        )
+
+        # model_path
+        parser.add_argument(
+            "--model_path",
+            type=str,
+            #default="./data/models/colo_segmentation_RegNetX800MF_6.ckpt", #model not yet here
+            default="./tests/assets/colo_segmentation_RegNetX800MF_6.ckpt", # model currently still here
+            help="Path to the model file",
+        )
+
+        # model_meta_version: int = 1
+        parser.add_argument(
+            "--model_meta_version",
+            type=int,
+            default=1,
+            help="Version of the model meta",
+        )
+
+        parser.add_argument(
+            "--image_classification_labelset_name",
+            type=str,
+            default="multilabel_classification_colonoscopy_default",
+            help="Name of the LabelSet for image classification",
+        )
+
+        parser.add_argument(
+            "--image_classification_labelset_version",
+            type=int,
+            default=-1,
+            help="Version of the LabelSet for image classification, default is -1 which invokes the highest version",
+        )
+
+        # activation: str = "sigmoid"
+        parser.add_argument(
+            "--activation_function_name",
+            type=str,
+            default="sigmoid",
+            help="Activation function for the model",
+        )
+
+        # mean: str = "0.45211223,0.27139644,0.19264949"
+        parser.add_argument(
+            "--mean",
+            type=str,
+            default="0.45211223,0.27139644,0.19264949",
+            help="Mean for normalization",
+        )
+
+        parser.add_argument(
+            "--std",
+            type=str,
+            default="0.31418097,0.21088019,0.16059452",
+            help="Std for normalization",
+        )
+
+        # size_x: int = 716
+        parser.add_argument(
+            "--size_x",
+            type=int,
+            default=716,
+            help="Size of the image in x direction",
+        )
+
+        # size_y: int = 716
+        parser.add_argument(
+            "--size_y",
+            type=int,
+            default=716,
+            help="Size of the image in y direction",
+        )
+
+        parser.add_argument(
+            "--axes",
+            type=str,
+            default="2,0,1",
+            help="Axes of the image",
+        )
+
+        # batchsize: int = 16
+        parser.add_argument(
+            "--batchsize",
+            type=int,
+            default=16,
+            help="Batchsize for the model",
+        )
+
+        # num_workers: int = 0
+        parser.add_argument(
+            "--num_workers",
+            type=int,
+            default=0,
+            help="Number of workers for the model",
+        )
+
+        # bump_version: bool = False
+        parser.add_argument(
+            "--bump_version",
+            action="store_true",
+            help="Bump the version of the model",
+        )
+
+    def handle(self, *args, **options):
+        """
+        Processes command-line arguments to create or update a ModelMeta object for a multilabel classification model.
+        
+        Retrieves and validates the specified LabelSet and AiModel, ensures the model file exists, and invokes ModelMeta.create_from_file with the provided configuration. Raises a ValueError if the requested LabelSet does not exist.
+        """
+        model_name = options["model_name"]
+
+        model_path = options["model_path"]
+        activation_function_name = options["activation_function_name"]
+
+        mean = options["mean"]
+        std = options["std"]
+
+        size_x = options["size_x"]
+        size_y = options["size_y"]
+
+        axes = options["axes"]
+
+        image_classification_labelset_name = options[
+            "image_classification_labelset_name"
+        ]
+
+        image_classification_labelset_version = options[
+            "image_classification_labelset_version"
+        ]
+        if image_classification_labelset_version == -1:
+            # If version is -1, we want the latest version of the labelset
+            labelset = LabelSet.objects.filter(
+                name=image_classification_labelset_name
+            ).order_by("-version").first()
+            if labelset:
+                image_classification_labelset_version = labelset.version
+            else:
+                raise ValueError(
+                    f"No LabelSet found with name: {image_classification_labelset_name}"
+                )
+        else:
+            # If a specific version is provided, we use that
+            labelset = LabelSet.objects.filter(
+                name=image_classification_labelset_name,
+                version=image_classification_labelset_version
+            ).first()
+            if not labelset:
+                raise ValueError(
+                    f"No LabelSet found with name: {image_classification_labelset_name} and version: {image_classification_labelset_version}"
+                )
+
+        # assert model exists
+        db_ai_model = AiModel.objects.filter(name=model_name).first()
+        assert db_ai_model, f"Model not found: {model_name}"
+
+        model_path = Path(model_path).expanduser().resolve().as_posix()
+
+        assert Path(model_path).exists(), f"Model file not found: {model_path}"
+
+        _model_meta = ModelMeta.create_from_file(
+            meta_name=model_name,  # Name of the new metadata object
+            model_name=model_name,  # name of the ai_model to use; This also defines the models VideoSegmentationLabelSet
+            labelset_name=image_classification_labelset_name,
+            weights_file=model_path,
+            # Use the correct keyword arguments matching the method signature
+            requested_version=options["model_meta_version"],
+            bump_if_exists=options["bump_version"],
+            # Pass other options via **kwargs
+            activation=activation_function_name,
+            mean=mean,
+            std=std,
+            size_x=size_x,
+            size_y=size_y,
+            axes=axes,
+            batchsize=options["batchsize"],
+            num_workers=options["num_workers"],
+        )

endoreg_db/management/commands/fix_missing_patient_data.py

@@ -0,0 +1,172 @@
+"""
+Management command to fix missing patient data in existing videos.
+Fills in default values for videos that have incomplete SensitiveMeta.
+"""
+
+from django.core.management.base import BaseCommand
+from django.db import transaction
+from datetime import date
+from endoreg_db.models import VideoFile, SensitiveMeta
+
+
+class Command(BaseCommand):
+    help = """
+    Fixes missing patient data in existing VideoFile entries.
+    This command will:
+    1. Find all videos with missing or incomplete SensitiveMeta
+    2. Create default SensitiveMeta for videos without any
+    3. Fill in missing fields (first_name, last_name, DOB, examination_date)
+    """
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--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',
+        )
+
+    def handle(self, *args, **options):
+        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"))
+        
+        # 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=''
+        )
+        
+        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")
+        
+        if count_without_meta == 0 and count_incomplete == 0:
+            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...")
+            
+            for video in videos_without_meta:
+                if verbose:
+                    self.stdout.write(f"Creating SensitiveMeta for video {video.uuid}")
+                
+                if not dry_run:
+                    try:
+                        with transaction.atomic():
+                            default_data = {
+                                "patient_first_name": "Patient",
+                                "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"
+                            }
+                            
+                            sensitive_meta = SensitiveMeta.create_from_dict(default_data)
+                            video.sensitive_meta = 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}")
+                        )
+                else:
+                    created_count += 1
+        
+        # Process videos with incomplete SensitiveMeta
+        if count_incomplete > 0:
+            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)}"
+                        )
+                    
+                    if not dry_run:
+                        try:
+                            with transaction.atomic():
+                                video.sensitive_meta.update_from_dict(update_data)
+                                fixed_count += 1
+                        except Exception as e:
+                            self.stdout.write(
+                                self.style.ERROR(f"Failed to update SensitiveMeta for video {video.uuid}: {e}")
+                            )
+                    else:
+                        fixed_count += 1
+        
+        # Summary
+        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}")
+        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.")