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

endoreg_db/data/requirement_operator/model_operators.yaml

@@ -1,96 +0,0 @@
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_all"
-    name_de: "Modelle existieren"
-    name_en: "Models exist"
-    description: "Make sure that all the provided Foreign Key models exist."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_any"
-    name_de: "Mindestens ein Modell existiert"
-    name_en: "At least one model exists"
-    description: "Make sure that at least one of the provided Foreign Key models exist."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_none"
-    name_de: "Kein Modell existiert"
-    name_en: "No model exists"
-    description: "Make sure that none of the provided Foreign Key models exist."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_n"
-    name_de: " Exakt n Modelle existieren"
-    name_en: "Exactly n models exist"
-    description: "Make sure that exactly n of the provided Foreign Key models exist. The number n is defined using the numeric_value_min field."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_n_or_more"
-    name_de: "Mindestens n Modelle existieren"
-    name_en: "At least n models exist"
-    description: "Make sure that at least n of the provided Foreign Key models exist. The number n is defined using the numeric_value_min field."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_n_or_less"
-    name_de: "Höchstens n Modelle existieren"
-    name_en: "At most n models exist"
-    description: "Make sure that at most n of the provided Foreign Key models exist. The number n is defined using the numeric_value_min field."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_count_in_range"
-    name_de: "Anzahl der Modelle liegt im angegebenen Bereich"
-    name_en: "Number of models is in the given range"
-    description: "Make sure that the number of provided Foreign Key models is in the given range. The range is defined using numeric_value_min and numeric_value_max."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_any_in_timeframe"
-    name_de: "Mindestens ein Modell existiert im angegebenen Zeitraum"
-    name_en: "At least one model exists in the given timeframe"
-    description: "Make sure that at least one of the provided Foreign Key models exist and its associated date falls within the specified timeframe. Timeframe is defined by numeric_value_min, numeric_value_max, and unit on the Requirement."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_all_in_timeframe"
-    name_de: "Modelle existieren im angegebenen Zeitraum"
-    name_en: "Models exist in the given timeframe"
-    description: "Make sure that all the provided Foreign Key models have a date within the given timeframe. The timeframe is defined using numeric_value_min and numeric_value_max and setting the unit to a fitting one (e.g. week)."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_none_in_timeframe"
-    name_de: "Kein Modell existiert im angegebenen Zeitraum"
-    name_en: "No model exists in the given timeframe"
-    description: "Make sure that none of the provided Foreign Key models have a date within the given timeframe. The timeframe is defined using numeric_value_min and numeric_value_max and setting the unit to a fitting one (e.g. week)."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_n_in_timeframe"
-    name_de: "Exakt n Modelle existieren im angegebenen Zeitraum"
-    name_en: "Exactly n models exist in the given timeframe"
-    description: "Make sure that exactly n of the provided Foreign Key models have a date within the given timeframe. The timeframe is defined using numeric_value_min and numeric_value_max and setting the unit to a fitting one (e.g. week). The number n is defined using the numeric_value_min field."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_n_or_more_in_timeframe"
-    name_de: "Mindestens n Modelle existieren im angegebenen Zeitraum"
-    name_en: "At least n models exist in the given timeframe"
-    description: "Make sure that at least n of the provided Foreign Key models have a date within the given timeframe. The timeframe is defined using numeric_value_min and numeric_value_max and setting the unit to a fitting one (e.g. week). The number n is defined using the numeric_value_min field."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "models_match_n_or_less_in_timeframe"
-    name_de: "Höchstens n Modelle existieren im angegebenen Zeitraum"
-    name_en: "At most n models exist in the given timeframe"
-    description: "Make sure that at most n of the provided Foreign Key models have a date within the given timeframe. The timeframe is defined using numeric_value_min and numeric_value_max and setting the unit to a fitting one (e.g. week). The number n is defined using the numeric_value_min field."
-
-- model: endoreg_db.requirement_operator
-  fields:
-    name: "patient_medication_schedule_matches_template"
-    description: "Checks if any PatientMedication in the input PatientMedicationSchedule matches the profile (medication, dose, unit, intake times) of any MedicationSchedule template linked to the requirement."
-    evaluation_function_name: "_evaluate_patient_medication_schedule_matches_template"

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.safetensors"
-        
-        # 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_requirementset_depends_on.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.2.7 on 2025-11-21 15:19
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('endoreg_db', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='requirementset',
-            name='depends_on',
-            field=models.ManyToManyField(blank=True, help_text="Andere RequirementSets, die zuerst erfüllt sein müssen, bevor dieses Set geprüft wird ('after').", related_name='dependents', to='endoreg_db.requirementset'),
-        ),
-    ]