endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/management/commands/init_default_ai_model.py

@@ -1,112 +0,0 @@
-"""
-Django management command to initialize the default AI model with metadata.
-This command ensures that a default AI model exists with proper ModelMeta records.
-"""
-
-from django.core.management.base import BaseCommand
-from django.core.management import call_command
-from pathlib import Path
-#FIXME
-from endoreg_db.data.ai_model_meta import (
-    default_multilabel_classification
-)
-
-from endoreg_db.models import AiModel
-from endoreg_db.helpers.data_loader import (
-    load_ai_model_label_data,
-    load_ai_model_data,
-)
-
-
-class Command(BaseCommand):
-    help = """
-    Initialize the default AI model with metadata.
-    This command ensures that the default segmentation model exists with proper ModelMeta records.
-    """
-
-    def add_arguments(self, parser):
-        """
-        Adds the --force command-line argument to control metadata recreation.
-        
-        The --force flag, when specified, forces the recreation of model metadata even if it already exists.
-        """
-        parser.add_argument(
-            '--force',
-            action='store_true',
-            help='Force recreation of the model metadata even if it exists',
-        )
-
-    def handle(self, *args, **options):
-        """
-        Initializes the default AI model and its metadata, creating or updating as needed.
-        
-        Loads required AI model label and model data, ensures the presence of a default AI model, and creates associated model metadata if it does not already exist or if the `--force` flag is specified. Generates a dummy weights file if necessary and invokes the metadata creation command. Verifies successful creation and outputs status messages throughout the process.
-        """
-        force = options.get('force', False)
-        default_multilabel_classification()
-        # First ensure the basic AI model data is loaded
-        self.stdout.write("Loading AI model label data...")
-        load_ai_model_label_data()
-        
-        self.stdout.write("Loading AI model data...")
-        load_ai_model_data()
-
-        # Check if default model exists
-        default_model_name = "image_multilabel_classification_colonoscopy_default"
-        
-        try:
-            ai_model = AiModel.objects.get(name=default_model_name)
-            self.stdout.write(f"Found AI model: {ai_model.name}")
-        except AiModel.DoesNotExist:
-            self.stdout.write(
-                self.style.ERROR(f"AI model '{default_model_name}' not found. Make sure AI model data is loaded.")
-            )
-            return
-
-        # Check if model metadata exists
-        existing_meta = ai_model.metadata_versions.first()
-        if existing_meta and not force:
-            self.stdout.write(
-                self.style.SUCCESS(f"Model metadata already exists for {ai_model.name}. Use --force to recreate.")
-            )
-            return
-
-        # Create default model metadata
-        self.stdout.write("Creating default model metadata...")
-        
-        # Use a dummy weights file path for now - in production this should point to actual model weights
-        dummy_weights_path = Path(__file__).parent.parent.parent / "assets" / "dummy_model.ckpt"
-        
-        # Create the dummy weights file if it doesn't exist
-        dummy_weights_path.parent.mkdir(parents=True, exist_ok=True)
-        if not dummy_weights_path.exists():
-            dummy_weights_path.write_bytes(b"dummy weights content")
-            self.stdout.write(f"Created dummy weights file at {dummy_weights_path}")
-
-        try:
-            # Create ModelMeta using the create_multilabel_model_meta command
-            call_command(
-                "create_multilabel_model_meta",
-                "--model_path", str(dummy_weights_path),
-                "--model_name", default_model_name,
-                "--image_classification_labelset_name", "multilabel_classification_colonoscopy",
-                "--activation_function_name", "sigmoid",
-                "--model_meta_version", "1",
-            )
-            
-            self.stdout.write(
-                self.style.SUCCESS(f"Successfully created model metadata for {default_model_name}")
-            )
-            
-            # Verify the model can be retrieved
-            from endoreg_db.helpers.default_objects import get_latest_segmentation_model
-            model_meta = get_latest_segmentation_model()
-            self.stdout.write(
-                self.style.SUCCESS(f"Verified: Model metadata can be retrieved: {model_meta}")
-            )
-            
-        except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f"Failed to create model metadata: {e}")
-            )
-            raise

endoreg_db/management/commands/reset_celery_schedule.py

@@ -1,9 +0,0 @@
-from django.core.management.base import BaseCommand
-from django_celery_beat.models import PeriodicTask
-
-class Command(BaseCommand):
-    help = 'Deletes all periodic tasks from the database to reset the schedule'
-
-    def handle(self, *args, **kwargs):
-        PeriodicTask.objects.all().delete()
-        self.stdout.write(self.style.SUCCESS('Successfully deleted all periodic tasks.'))

endoreg_db/management/commands/validate_video.py

@@ -1,204 +0,0 @@
-from django.core.management.base import BaseCommand
-from endoreg_db.models import VideoFile
-from endoreg_db.helpers.default_objects import get_latest_segmentation_model
-from django.db.models import Q # Add this import
-
-# VideoFile instances have a related 'state' (a VideoState object).
-# VideoState uses boolean fields (e.g., state.anonymized, state.initial_prediction_completed)
-# to track the processing status, rather than a single status field with choices.
-# This command interprets combinations of these boolean fields to determine
-# if a video is considered "validated" or "anonymized".
-# The VideoState model itself is defined in endoreg_db/models/state/video.py (or similar)
-# and does not contain an enum like the previously assumed 'VideoFileStateChoices'.
-
-class Command(BaseCommand):
-    help = "Data extraction and validation of video files in the database and updating their states accordingly."
-    
-    def add_arguments(self, parser):
-        """
-        Adds command-line arguments for verbose output, forced revalidation, and anonymization.
-        
-        This method configures the management command to accept optional flags:
-        --verbose for detailed output, --force to revalidate all videos regardless of status,
-        and --anonymize to anonymize video files during processing.
-        """
-        parser.add_argument(
-            "--verbose",
-            action="store_true",
-            help="Display verbose output",
-        )
-        parser.add_argument(
-            "--force",
-            action="store_true",
-            help="Force revalidation of all video files, even if they are already validated.",
-        )
-        parser.add_argument(
-            "--anonymize",
-            action="store_true",
-            help="Anonymize video files.",
-        )
-
-    def handle(self, *args, **options):
-        """
-        Validates video files stored in the database and updates their validation states.
-        
-        This method processes video files according to the provided command-line options,
-        such as verbose output, forced revalidation, or anonymization.
-        It interprets the boolean flags in the related VideoState object to determine
-        if a video is 'validated' (e.g., initial_prediction_completed and lvs_created are True)
-        or 'anonymized' (e.g., anonymized is True).
-        """
-        #TODO @maxhild here is some ai generated code for now, not validated yet
-        verbose = options["verbose"]
-        force = options["force"]
-        anonymize_option = options["anonymize"]
-
-        if verbose:
-            self.stdout.write(self.style.SUCCESS("Starting video validation and/or anonymization process..."))
-
-        # Eager load related state if VideoFile.state is a ForeignKey or OneToOneField
-        videos_query = VideoFile.objects.select_related('state').all()
-
-        # Define conditions for "validated" and "anonymized" based on VideoState boolean fields
-        # Validated: initial_prediction_completed = True AND lvs_created = True
-        q_validated = Q(state__initial_prediction_completed=True, state__lvs_created=True)
-        # Anonymized: anonymized = True
-        q_anonymized = Q(state__anonymized=True)
-
-        if not force:
-            if anonymize_option:
-                # If anonymization is the goal, process videos not yet anonymized.
-                videos_query = videos_query.exclude(q_anonymized)
-            else:
-                # If only validation is the goal, process videos not yet validated or anonymized.
-                videos_query = videos_query.exclude(q_validated | q_anonymized)
-        
-        videos_to_process = list(videos_query)
-
-        if not videos_to_process:
-            if verbose:
-                self.stdout.write(self.style.SUCCESS("No videos found requiring processing with the current options."))
-            return
-
-        processed_count = 0
-        failed_count = 0
-        model_name_for_pipe1 = None
-
-        try:
-            # Attempt to get the model for pipe_1. This might be optional for pipe_1.
-            ai_model_meta = get_latest_segmentation_model()
-            model_name_for_pipe1 = ai_model_meta.model.name
-            if verbose:
-                self.stdout.write(self.style.SUCCESS(f"Using model '{model_name_for_pipe1}' for pipe_1 processing."))
-        except Exception as e:
-            self.stdout.write(self.style.WARNING(f"Could not retrieve segmentation model: {e}. pipe_1 might proceed without a specific model or use a default."))
-            # model_name_for_pipe1 can remain None if pipe_1 handles it, or set a default if known.
-
-        for video in videos_to_process:
-            state_summary = "N/A"
-            if hasattr(video, 'state') and video.state:
-                s = video.state
-                state_summary = f"anonymized={s.anonymized}, predicted={s.initial_prediction_completed}, lvs_created={s.lvs_created}"
-            
-            if verbose:
-                self.stdout.write(f"Processing video: {video.uuid} (Current state: {state_summary})")
-            
-            try:
-                # Determine if pipe_1 needs to run
-                needs_pipe_1 = force
-                if not force and hasattr(video, 'state') and video.state:
-                    s = video.state
-                    is_validated = s.initial_prediction_completed and s.lvs_created
-                    is_anonymized = s.anonymized
-                    if not (is_validated or is_anonymized):
-                        needs_pipe_1 = True
-                elif not force: # No state object, assume it needs processing
-                    needs_pipe_1 = True
-
-
-                if needs_pipe_1:
-                    if verbose:
-                        self.stdout.write(f"Running pipe_1 for video {video.uuid} (force={force})...")
-                    if not model_name_for_pipe1 and verbose:
-                         self.stdout.write(self.style.WARNING(f"Attempting pipe_1 for {video.uuid} without a specific model name."))
-                    
-                    success_pipe_1 = video.pipe_1(model_name=model_name_for_pipe1)
-                    video.refresh_from_db() 
-
-                    new_state_summary = "N/A"
-                    if hasattr(video, 'state') and video.state:
-                        s = video.state
-                        new_state_summary = f"anonymized={s.anonymized}, predicted={s.initial_prediction_completed}, lvs_created={s.lvs_created}"
-
-                    if not success_pipe_1:
-                        raise Exception(f"pipe_1 validation failed for video {video.uuid}. State after attempt: {new_state_summary}")
-                    
-                    if verbose:
-                        self.stdout.write(self.style.SUCCESS(f"Video {video.uuid} successfully passed pipe_1. New state: {new_state_summary}"))
-                elif verbose:
-                    self.stdout.write(f"Video {video.uuid} already meets validation criteria or is anonymized, skipping pipe_1 (force=False).")
-
-                # Anonymization step
-                if anonymize_option:
-                    should_anonymize = False
-                    current_state_summary_for_anonym = "N/A"
-                    if hasattr(video, 'state') and video.state:
-                        s = video.state
-                        current_state_summary_for_anonym = f"anonymized={s.anonymized}, predicted={s.initial_prediction_completed}, lvs_created={s.lvs_created}"
-                        is_validated_for_anonymization = s.initial_prediction_completed and s.lvs_created
-                        is_currently_anonymized = s.anonymized
-                        if force or (is_validated_for_anonymization and not is_currently_anonymized):
-                            should_anonymize = True
-                    elif force: # No state, but force anonymize
-                        should_anonymize = True
-
-
-                    if should_anonymize:
-                        if verbose:
-                            self.stdout.write(f"Attempting to anonymize video: {video.uuid} (force={force}, current_state_before_anonym={current_state_summary_for_anonym}).")
-                        
-                        if hasattr(video, 'anonymize_video_content'): 
-                            video.anonymize_video_content() 
-                            video.refresh_from_db() 
-                        else:
-                            self.stdout.write(self.style.ERROR(f"Video model does not have 'anonymize_video_content' method. Skipping anonymization for {video.uuid}."))
-                            # Potentially raise an error or handle as a failure
-
-                        post_anonym_state_summary = "N/A"
-                        is_now_anonymized = False
-                        if hasattr(video, 'state') and video.state:
-                            s = video.state
-                            post_anonym_state_summary = f"anonymized={s.anonymized}, predicted={s.initial_prediction_completed}, lvs_created={s.lvs_created}"
-                            is_now_anonymized = s.anonymized
-
-                        if is_now_anonymized:
-                            if verbose:
-                                self.stdout.write(self.style.SUCCESS(f"Video {video.uuid} successfully anonymized. New state: {post_anonym_state_summary}"))
-                        else:
-                            if hasattr(video, 'anonymize_video_content'): # Only raise if we attempted
-                                raise Exception(f"Anonymization called but video is not marked as anonymized for video {video.uuid}. Current state: {post_anonym_state_summary}")
-                    
-                    elif hasattr(video, 'state') and video.state and video.state.anonymized and verbose: # Already anonymized
-                        self.stdout.write(f"Video {video.uuid} is already anonymized.")
-                    elif verbose: 
-                        self.stdout.write(f"Skipping anonymization for video {video.uuid} (not validated for anonymization, or already anonymized and not forced).")
-                
-                processed_count += 1
-            except Exception as e:
-                failed_count += 1
-                video.refresh_from_db() 
-                error_state_summary = "N/A"
-                if hasattr(video, 'state') and video.state:
-                    s = video.state
-                    error_state_summary = f"anonymized={s.anonymized}, predicted={s.initial_prediction_completed}, lvs_created={s.lvs_created}"
-                self.stdout.write(self.style.ERROR(f"Error processing video {video.uuid}: {e}. State after error: {error_state_summary}"))
-                # Optionally, explicitly set an error state if the methods don't do it reliably:
-                # if hasattr(video, 'state') and video.state: # Further checks would depend on how an error state is defined with booleans
-                #     # video.state.set_status(VideoFile.VideoFileStateChoices.ERROR, message=f"Validation command error: {str(e)[:250]}") # Old way
-                #     # video.state.save() # New way would involve setting specific boolean flags to indicate error
-                pass
-
-
-        if verbose:
-            self.stdout.write(self.style.SUCCESS(f"Video processing finished. Succeeded: {processed_count}, Failed: {failed_count}."))
-

endoreg_db/migrations/0002_add_video_correction_models.py

@@ -1,52 +0,0 @@
-# Generated by Django 5.2.5 on 2025-10-09 10:12
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('endoreg_db', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='VideoMetadata',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('sensitive_frame_count', models.IntegerField(blank=True, help_text='Number of frames detected as containing sensitive information', null=True)),
-                ('sensitive_ratio', models.FloatField(blank=True, help_text='Ratio of sensitive frames to total frames (0.0-1.0)', null=True)),
-                ('sensitive_frame_ids', models.TextField(blank=True, help_text='JSON array of sensitive frame indices (0-based)', null=True)),
-                ('analyzed_at', models.DateTimeField(auto_now=True, help_text='Timestamp of last analysis')),
-                ('video', models.OneToOneField(help_text='Video file this metadata belongs to', on_delete=django.db.models.deletion.CASCADE, related_name='metadata', to='endoreg_db.videofile')),
-            ],
-            options={
-                'verbose_name': 'Video Metadata',
-                'verbose_name_plural': 'Video Metadata',
-                'db_table': 'video_metadata',
-            },
-        ),
-        migrations.CreateModel(
-            name='VideoProcessingHistory',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('operation', models.CharField(choices=[('mask_overlay', 'Mask Overlay'), ('frame_removal', 'Frame Removal'), ('analysis', 'Sensitivity Analysis'), ('reprocessing', 'Full Reprocessing')], help_text='Type of processing operation', max_length=50)),
-                ('status', models.CharField(choices=[('pending', 'Pending'), ('running', 'Running'), ('success', 'Success'), ('failure', 'Failure'), ('cancelled', 'Cancelled')], default='pending', help_text='Current status of the operation', max_length=20)),
-                ('config', models.JSONField(default=dict, help_text='Operation configuration (mask settings, frame list, etc.)')),
-                ('output_file', models.CharField(blank=True, help_text='Path to output file (relative to MEDIA_ROOT)', max_length=500)),
-                ('details', models.TextField(blank=True, help_text='Additional details or error messages')),
-                ('task_id', models.CharField(blank=True, help_text='Celery task ID for progress tracking', max_length=100)),
-                ('created_at', models.DateTimeField(auto_now_add=True, help_text='When the operation was started')),
-                ('completed_at', models.DateTimeField(blank=True, help_text='When the operation completed (success or failure)', null=True)),
-                ('video', models.ForeignKey(help_text='Video file this operation was performed on', on_delete=django.db.models.deletion.CASCADE, related_name='processing_history', to='endoreg_db.videofile')),
-            ],
-            options={
-                'verbose_name': 'Video Processing History',
-                'verbose_name_plural': 'Video Processing Histories',
-                'db_table': 'video_processing_history',
-                'ordering': ['-created_at'],
-                'indexes': [models.Index(fields=['video', '-created_at'], name='video_proce_video_i_98ffe0_idx'), models.Index(fields=['task_id'], name='video_proce_task_id_ec8b15_idx'), models.Index(fields=['status'], name='video_proce_status_6f71fd_idx')],
-            },
-        ),
-    ]

endoreg_db/migrations/0003_add_center_display_name.py

@@ -1,30 +0,0 @@
-from django.db import migrations, models
-
-
-def populate_display_name(apps, schema_editor):
-    Center = apps.get_model('endoreg_db', 'Center')
-    for center in Center.objects.all():
-        if not center.display_name:
-            center.display_name = center.name
-            center.save(update_fields=['display_name'])
-
-
-def reset_display_name(apps, schema_editor):
-    Center = apps.get_model('endoreg_db', 'Center')
-    Center.objects.update(display_name='')
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('endoreg_db', '0002_add_video_correction_models'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='center',
-            name='display_name',
-            field=models.CharField(blank=True, default='', max_length=255),
-        ),
-        migrations.RunPython(populate_display_name, reset_display_name),
-    ]

endoreg_db/models/administration/permissions/__init__.py

@@ -1,44 +0,0 @@
-# from django.contrib.contenttypes.models import ContentType
-# from django.contrib.auth.models import Permission
-# from endoreg_db.models import *  # Import your models here
-# from django.db import transaction
-
-# # Step 1: Define model to category mappings
-# # Assuming every model class name is unique across your entire Django project
-# model_categories = {
-#     'SensitiveModel1': 'sensitive',
-#     'SensitiveModel2': 'sensitive',
-#     'DevelopmentModel1': 'development',
-#     'DevelopmentModel2': 'development',
-#     # Add all models you have, mapping them to either 'sensitive', 'development', or 'all'
-# }
-
-# # Step 2: Define permissions for each category
-# category_permissions = {
-#     'sensitive': ['view', 'edit', 'delete'],
-#     'development': ['view', 'edit'],
-#     'all': ['view'],
-# }
-
-# @transaction.atomic
-# def create_permissions_for_all_models():
-#     for model_class_name, category in model_categories.items():
-#         model_class = globals().get(model_class_name)
-#         if model_class is None:
-#             print(f"Model {model_class_name} not found.")
-#             continue
-        
-#         content_type = ContentType.objects.get_for_model(model_class)
-#         permissions = category_permissions.get(category, [])
-
-#         for permission_codename in permissions:
-#             permission_name = f"Can {permission_codename} {model_class_name}"
-#             permission, created = Permission.objects.get_or_create(
-#                 codename=f"{permission_codename}_{model_class_name.lower()}",
-#                 defaults={'name': permission_name, 'content_type': content_type},
-#             )
-#             if created:
-#                 print(f"Created permission: {permission_name}")
-
-# # Run the function to create and assign permissions based on categories
-# create_permissions_for_all_models()

endoreg_db/models/rule/__init__.py

@@ -1,13 +0,0 @@
-from .rule_type import RuleType
-from .rule import Rule
-from .ruleset import Ruleset
-from .rule_attribute_dtype import RuleAttributeDType
-from .rule_applicator import RuleApplicator
-
-__all__ = [
-    "RuleType",
-    "Rule",
-    "Ruleset",
-    "RuleAttributeDType",
-    "RuleApplicator",
-]

endoreg_db/models/rule/rule.py

@@ -1,27 +0,0 @@
-from django.db import models
-
-class RuleManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Rule(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    description = models.TextField(blank=True, null=True)
-    attribute_key = models.CharField(max_length=255)
-    rule_type = models.ForeignKey("RuleType", on_delete=models.CASCADE)
-    attribute_dtype = models.ForeignKey("RuleAttributeDType", on_delete=models.CASCADE)
-
-    objects = RuleManager()
-
-    class Meta:
-        verbose_name = 'Rule'
-        verbose_name_plural = 'Rules'
-
-    def natural_key(self):
-        """
-        Return a tuple representing the natural key for this Rule instance.
-        
-        Returns:
-            tuple: A one-element tuple containing the Rule's unique name.
-        """
-        return (self.name,)