endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/management/commands/summarize_db_content.py

@@ -0,0 +1,189 @@
+from django.core.management.base import BaseCommand
+from django.apps import apps
+from django.db.models import Min, Max, Count, fields
+from django.utils.timezone import is_aware, make_naive
+import datetime
+import os
+from openpyxl import Workbook
+from django.conf import settings
+import csv
+
+class Command(BaseCommand):
+    help = 'Generates a structured report summarizing the database content of custom endoreg_db models and saves it to Excel and CSV files, excluding models with zero records from the files.' # Updated help text
+
+    def handle(self, *args, **options):
+        """
+        Generates a summary report of all models in the 'endoreg_db' app and exports the results to Excel and CSV files.
+        
+        For each model, counts the total number of records and includes only models with at least one record in the output files. For models with records, attempts to display the range of values for common date or datetime fields and provides value counts for up to three categorical or ForeignKey fields, using heuristics based on field type and name. Handles missing app configuration, file saving errors, and aggregation exceptions gracefully, outputting progress and warnings to the console. Creates a 'data' directory within the app if it does not exist and saves the reports there.
+        """
+        self.stdout.write(self.style.SUCCESS("Starting database content summarization for endoreg_db models..."))
+
+        try:
+            app_config = apps.get_app_config('endoreg_db')
+        except LookupError:
+            self.stdout.write(self.style.ERROR("Could not find the 'endoreg_db' app. Make sure it's correctly installed and configured."))
+            return
+
+        data_dir = os.path.join(app_config.path, 'data')
+        if not os.path.exists(data_dir):
+            os.makedirs(data_dir)
+            self.stdout.write(self.style.SUCCESS(f"Created directory: {data_dir}"))
+        
+        excel_file_path = os.path.join(data_dir, 'db_summary.xlsx')
+        csv_file_path = os.path.join(data_dir, 'db_summary.csv')
+
+        # --- Excel Setup ---
+        wb = Workbook()
+        ws = wb.active
+        ws.title = "DB Summary"
+        excel_headers = ["Model Name", "Total Records"]
+        ws.append(excel_headers)
+        # --- End Excel Setup ---
+
+        # --- CSV Setup ---
+        csv_data_for_file = [excel_headers] # Initialize with headers for CSV, will only store rows with count > 0
+        # --- End CSV Setup ---
+            
+        models = app_config.get_models()
+
+        if not models:
+            self.stdout.write(self.style.WARNING("No models found in the 'endoreg_db' app."))
+            try:
+                wb.save(excel_file_path) # wb will only have headers
+                self.stdout.write(self.style.SUCCESS(f"Empty summary report saved to {excel_file_path}"))
+                with open(csv_file_path, 'w', newline='') as f:
+                    writer = csv.writer(f)
+                    writer.writerows(csv_data_for_file) # csv_data_for_file will only contain headers
+                self.stdout.write(self.style.SUCCESS(f"Empty summary report saved to {csv_file_path}"))
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f"Error saving files: {e}"))
+            return
+
+        for model in models:
+            model_name = model.__name__
+            self.stdout.write(self.style.HTTP_INFO(f"\n--- Model: {model_name} ---"))
+
+            try:
+                count = model.objects.count()
+                self.stdout.write(f"  Total records: {count}")
+
+                if count == 0:
+                    self.stdout.write(self.style.NOTICE("  No records found for this model. Skipping from file output."))
+                    continue # Skip further processing for this model if count is 0 for file output
+
+                # --- Add to Excel (only if count > 0) ---
+                ws.append([model_name, count])
+                # --- End Add to Excel ---
+
+                # --- Add to CSV data list (only if count > 0) ---
+                csv_data_for_file.append([model_name, count])
+                # --- End Add to CSV data list ---
+                
+                # Attempt to get date ranges for common date/datetime fields
+                date_fields_to_check = ['created_at', 'updated_at', 'timestamp', 'date',
+                                        'start_time', 'end_time', 'examination_date',
+                                        'birth_date', 'record_date']
+                processed_date_field = False
+                for field_obj in model._meta.get_fields():
+                    if field_obj.name in date_fields_to_check and isinstance(field_obj, (fields.DateField, fields.DateTimeField)):
+                        try:
+                            aggregation = model.objects.aggregate(min_date=Min(field_obj.name), max_date=Max(field_obj.name))
+                            min_val = aggregation.get('min_date')
+                            max_val = aggregation.get('max_date')
+
+                            if min_val is not None and max_val is not None:
+                                if isinstance(min_val, datetime.datetime) and is_aware(min_val):
+                                    min_val = make_naive(min_val).strftime('%Y-%m-%d %H:%M:%S')
+                                elif isinstance(min_val, datetime.date):
+                                    min_val = min_val.strftime('%Y-%m-%d')
+                                
+                                if isinstance(max_val, datetime.datetime) and is_aware(max_val):
+                                    max_val = make_naive(max_val).strftime('%Y-%m-%d %H:%M:%S')
+                                elif isinstance(max_val, datetime.date):
+                                    max_val = max_val.strftime('%Y-%m-%d')
+
+                                self.stdout.write(f"  {field_obj.verbose_name.capitalize()} range: {min_val} to {max_val}")
+                                processed_date_field = True
+                                break # Process only the first found relevant date field for brevity
+                        except Exception as e:
+                            self.stdout.write(self.style.WARNING(f"  Could not aggregate date range for '{field_obj.name}': {e}"))
+                
+                # Attempt to get value counts for potential categorical/ForeignKey fields
+                categorical_fields_found = 0
+                MAX_CATEGORICAL_FIELDS_TO_ANALYZE = 3
+                MAX_DISTINCT_VALUES_TO_SHOW = 5
+
+                for field in model._meta.get_fields():
+                    if categorical_fields_found >= MAX_CATEGORICAL_FIELDS_TO_ANALYZE:
+                        break
+
+                    is_potential_categorical = False
+                    field_name_lower = field.name.lower()
+
+                    if field.many_to_one or field.one_to_one: # ForeignKey or OneToOneField
+                        if field.related_model:
+                            is_potential_categorical = True
+                    elif isinstance(field, (fields.CharField, fields.IntegerField, fields.BooleanField, fields.TextField)):
+                        # Heuristic for common categorical fields by name or type
+                        if 'type' in field_name_lower or \
+                           'status' in field_name_lower or \
+                           'gender' in field_name_lower or \
+                           'category' in field_name_lower or \
+                           isinstance(field, fields.BooleanField):
+                           is_potential_categorical = True
+                        # For CharField/TextField, also consider if it has few distinct values (expensive to check upfront for all)
+                        # We'll rely on the naming heuristic primarily or if it's a boolean.
+
+                    if is_potential_categorical:
+                        try:
+                            self.stdout.write(f"  Value counts for '{field.verbose_name.capitalize() if hasattr(field, 'verbose_name') else field.name}':")
+                            
+                            # QuerySet for distinct values and their counts
+                            values_qs = model.objects.values(field.name).annotate(count=Count(field.name)).order_by('-count')
+                            
+                            distinct_values_count = values_qs.count()
+
+                            if distinct_values_count == 0:
+                                self.stdout.write(f"    No distinct values found or field is often NULL.")
+                                continue
+
+                            for i, item in enumerate(values_qs):
+                                if i >= MAX_DISTINCT_VALUES_TO_SHOW:
+                                    self.stdout.write(f"    ... and {distinct_values_count - MAX_DISTINCT_VALUES_TO_SHOW} more distinct values.")
+                                    break
+                                val = item[field.name]
+                                val_display = str(val) if val is not None else "None/NULL"
+                                # Truncate long string values for display
+                                if isinstance(val, str) and len(val_display) > 50:
+                                    val_display = val_display[:47] + "..."
+                                self.stdout.write(f"    - {val_display}: {item['count']}")
+                            
+                            categorical_fields_found += 1
+
+                        except Exception as e:
+                            # Some fields (like generic relations or complex custom fields) might not support this directly
+                            self.stdout.write(self.style.WARNING(f"  Could not get value counts for '{field.name}': {e}"))
+            
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f"  Error processing model {model_name}: {e}"))
+
+        # --- Save Excel File ---
+        try:
+            wb.save(excel_file_path)
+            self.stdout.write(self.style.SUCCESS(f"\nDatabase summary report saved to {excel_file_path}"))
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"\nError saving Excel file: {e}"))
+        # --- End Save Excel File ---
+
+        # --- Save CSV File ---
+        try:
+            with open(csv_file_path, 'w', newline='') as f:
+                writer = csv.writer(f)
+                writer.writerows(csv_data_for_file)
+            self.stdout.write(self.style.SUCCESS(f"Database summary report saved to {csv_file_path}"))
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"Error saving CSV file: {e}"))
+        # --- End Save CSV File ---
+
+        self.stdout.write(self.style.SUCCESS("\nDatabase content summarization finished."))

endoreg_db/management/commands/validate_video.py

@@ -0,0 +1,204 @@
+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/management/commands/validate_video_files.py

@@ -0,0 +1,161 @@
+"""
+Django management command to validate video file existence and accessibility.
+"""
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models import VideoFile
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = 'Validate video file existence and accessibility'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--video-id',
+            type=int,
+            help='Check specific video ID',
+        )
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Enable verbose output',
+        )
+        parser.add_argument(
+            '--fix-missing',
+            action='store_true',
+            help='Mark videos with missing files as inactive',
+        )
+
+    def handle(self, *args, **options):
+        """Validate video files and their accessibility."""
+        verbose = options['verbose']
+        video_id = options.get('video_id')
+        fix_missing = options['fix_missing']
+
+        if verbose:
+            self.stdout.write(self.style.SUCCESS("Starting video validation..."))
+
+        # Query videos
+        if video_id:
+            try:
+                videos = [VideoFile.objects.get(pk=video_id)]
+                self.stdout.write(f"Checking specific video ID: {video_id}")
+            except VideoFile.DoesNotExist:
+                self.stdout.write(self.style.ERROR(f"Video with ID {video_id} not found"))
+                return
+        else:
+            videos = VideoFile.objects.all()
+            self.stdout.write(f"Checking {videos.count()} videos...")
+
+        missing_files = []
+        accessible_files = []
+        corrupted_files = []
+
+        for video in videos:
+            video_status = self.check_video_file(video, verbose)
+            
+            if video_status['status'] == 'missing':
+                missing_files.append(video_status)
+            elif video_status['status'] == 'corrupted':
+                corrupted_files.append(video_status)
+            else:
+                accessible_files.append(video_status)
+
+        # Report results
+        self.stdout.write("\n" + "="*60)
+        self.stdout.write(self.style.SUCCESS("VALIDATION COMPLETE"))
+        self.stdout.write("="*60)
+        
+        self.stdout.write(f"✅ Accessible videos: {len(accessible_files)}")
+        self.stdout.write(f"❌ Missing files: {len(missing_files)}")
+        self.stdout.write(f"⚠️  Potentially corrupted: {len(corrupted_files)}")
+
+        if missing_files:
+            self.stdout.write(self.style.WARNING("\nMISSING FILES:"))
+            for file_info in missing_files:
+                self.stdout.write(f"  - Video ID {file_info['video_id']}: {file_info['error']}")
+                if fix_missing:
+                    self.stdout.write("    → Marking as inactive (if applicable)")
+
+        if corrupted_files:
+            self.stdout.write(self.style.WARNING("\nPOTENTIALLY CORRUPTED FILES:"))
+            for file_info in corrupted_files:
+                self.stdout.write(f"  - Video ID {file_info['video_id']}: {file_info['error']}")
+
+        if verbose and accessible_files:
+            self.stdout.write(self.style.SUCCESS("\nACCESSIBLE FILES:"))
+            for file_info in accessible_files[:10]:  # Show first 10
+                self.stdout.write(f"  ✅ Video ID {file_info['video_id']}: {file_info['path']} ({file_info['size_mb']:.1f} MB)")
+            
+            if len(accessible_files) > 10:
+                self.stdout.write(f"  ... and {len(accessible_files) - 10} more")
+
+    def check_video_file(self, video, verbose=False):
+        """
+        Check a single video file for existence and basic accessibility.
+        
+        Returns:
+            dict: Status information about the video file
+        """
+        video_info = {
+            'video_id': video.id,
+            'video_uuid': str(video.uuid) if hasattr(video, 'uuid') else 'N/A',
+            'status': 'unknown',
+            'path': None,
+            'size_mb': 0,
+            'error': None
+        }
+
+        # Helper to check a file attribute
+        def _check_file_attr(obj, attr, path_getter=None, label=None):
+            if not hasattr(obj, attr):
+                return None
+            file_field = getattr(obj, attr)
+            if not file_field:
+                return None
+            try:
+                file_path = Path(path_getter(file_field) if path_getter else file_field)
+                info = video_info.copy()
+                info['path'] = str(file_path)
+                if not file_path.exists():
+                    info['status'] = 'missing'
+                    info['error'] = f"{label or attr.replace('_', ' ').title()} does not exist: {file_path}"
+                    return info
+                file_size = file_path.stat().st_size
+                info['size_mb'] = file_size / (1024 * 1024)
+                if file_size == 0:
+                    info['status'] = 'corrupted'
+                    info['error'] = f"{label or attr.replace('_', ' ').title()} exists but has zero size"
+                else:
+                    info['status'] = 'accessible'
+                return info
+            except (ValueError, OSError) as e:
+                info = video_info.copy()
+                info['path'] = str(getattr(file_field, 'path', file_field))
+                info['status'] = 'corrupted'
+                info['error'] = f"Cannot access {label or attr.replace('_', ' ').title()}: {e}"
+                return info
+
+        # Try each file attribute in order of preference
+        result = None
+        # active_file_path: direct path string
+        result = _check_file_attr(video, 'active_file_path', label='Active file path')
+        if result: return result
+        # active_file: Django FileField
+        result = _check_file_attr(video, 'active_file', path_getter=lambda f: f.path, label='Active file')
+        if result: return result
+        # raw_file: Django FileField
+        result = _check_file_attr(video, 'raw_file', path_getter=lambda f: f.path, label='Raw file')
+        if result: return result
+        # processed_file: Django FileField
+        result = _check_file_attr(video, 'processed_file', path_getter=lambda f: f.path, label='Processed file')
+        if result: return result
+
+        # If none found
+        video_info['status'] = 'missing'
+        video_info['error'] = "No video file paths found (no active_file, raw_file, or processed_file)"
+        return video_info

endoreg_db/management/commands/video_validation.py

@@ -0,0 +1,22 @@
+from endoreg_db.models import VideoPredictionMeta
+from typing import TYPE_CHECKING
+from django.core.management.base import BaseCommand
+
+"""
+This command handles the video validation as seen in tests _pipe_1
+"""
+
+if TYPE_CHECKING:
+    from endoreg_db.models import VideoFile, VideoState
+    
+class Command(BaseCommand):
+    help = "Data extraction and validation of video files in the database and updating their states accordingly."
+
+    def handle(self, *args, **options):
+        """
+        Validates video files stored in the database and updates their states based on validation results.
+        
+        This method is intended to be executed as a Django management command to ensure the integrity and correct status of video file records.
+        """
+        
+    

endoreg_db/mermaid/Overall_flow_patient_finding_intervention.md

@@ -0,0 +1,10 @@
+```mermaid
+graph TD;
+
+    %% Main Patient Workflow
+    A[Patient: John] --> B[Examination: Colonoscopy]
+    B --> C[Finding: Colon Polyp]
+    C --> D[Finding Location: Colonoscopy Default - Right Flexure]
+    D --> E[Finding Morphology: Colon Lesion Planarity Default - Colon Lesion Planarity Excavated]
+    E --> F[Intervention: Colon Lesion Polypectomy - Hot Snare]
+    F --> G[Report Generation]

endoreg_db/mermaid/anonymized_image_annotation.md

@@ -0,0 +1,20 @@
+```mermaid
+graph TD;
+
+    %% File Handling Process
+    A[**Uploaded File**] -->|Original File Uploaded| B[**Anonymized File**]
+    B -->|File Anonymized & Stored| C[**Anonymous Image Annotation**]
+
+    %% Image Annotation & Processing
+    C -->|Label Assigned| D[**Anonymized Image Label**]
+    C -->|Detected Personal Info Removed| E[**Dropped Name**]
+
+    %% Relationships & Processing
+    E -->|Stored for Record-Keeping| C;
+    D -->|Predefined Labels Used| C;
+
+    %% Example Data (Corrected & Meaningful)
+    X1(["**Example: Uploaded colonoscopy.jpg**"]) -.-> A;
+    X2(["**Example: anonymized_colonoscopy.jpg**"]) -.-> B;
+    X3(["**Example: Label - 'Polyp Detected'**"]) -.-> D;
+    X4(["**Example: Name 'John Doe' removed**"]) -.-> E;

endoreg_db/mermaid/binary_classification_annotation.md

@@ -0,0 +1,50 @@
+```mermaid
+graph TD;
+
+  
+
+%% Step 1: Image Classification (Start)
+
+A[**Image Classification**] -->|Uses| B[**Label**];
+
+  
+
+%% Step 2: Video Segmentation
+
+A -->|Segments Stored In| C[**Video Segmentation**];
+
+  
+
+%% Step 3: Automatic Segmentation Detection
+
+D["**find_segments_in_prediction_array()**"] -->|Detects & Segments| C;
+
+  
+
+%% Step 4: Fetching Unclassified Frames for Annotation
+
+E["get_legacy_binary_classification_annotation_tasks_by_label()"] -->|Finds Frames Needing Annotation| F;
+
+  
+
+%% Step 5: Binary Classification Task Management
+
+F[**Binary Classification Task**] -->|Assigned To| G[**Frame**];
+
+F -->|Assigned To| H[**Legacy Frame**];
+
+F -->|Uses| B;
+
+%% Step 6: Task Completion & Cleanup (End)
+
+I["clear_finished_legacy_tasks()"] -->|Removes Completed Tasks| F;
+
+  
+
+%% Example Data
+
+X1(["Example: Frame classified as 'Polyp Present'"]) -.-> A;
+
+X2(["Example: Video segment marked from 100s to 200s"]) -.-> C;
+
+X3(["Example: 10 unclassified frames found"]) -.-> F;

endoreg_db/mermaid/classification.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Finding Location Classification"] --> B["Store in endoreg_db_findinglocationclassification"]
+    B --> C["Retrieve Available Choices"]
+    C --> D["Save Selected Location in endoreg_db_patientfinding_locations"]
+    D --> E["Link Location to Patient Finding via Foreign Key"]
+    E --> F["Finding Location Process Completed"]