endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/utils/case_generator/case_generator.py

@@ -0,0 +1,159 @@
+from endoreg_db.models import CaseTemplate, CaseTemplateRule, CaseTemplateRuleType
+from endoreg_db.case_generator.lab_sample_factory import LabSampleFactory
+
+DEFAULT_CASE_TEMPLATE_NAME = "pre_default_screening_colonoscopy"
+
+class CaseGenerator:
+    """
+    Provides methods to generate cases based on a template.
+    """
+
+    def __init__(self, template: CaseTemplate = None):
+        """
+        Initializes the CaseGenerator with a template.
+
+        Args:
+            template (CaseTemplate, optional): The template to use for case generation. Defaults to the predefined template.
+        """
+        self.template = template or CaseTemplate.objects.get(name=DEFAULT_CASE_TEMPLATE_NAME)
+        self.lab_sample_factory = LabSampleFactory()
+
+        # Define available rule types
+        rule_type_names = [
+            "create-object",
+            "set-field-default",
+            "set-field-by-distribution",
+            "set-field-by-value",
+            "set-field-single-choice",
+            "set-field-multiple-choice",
+        ]
+        self.available_rule_types = CaseTemplateRuleType.objects.filter(name__in=rule_type_names)
+
+    def _validate_rule_type(self, rule_type: CaseTemplateRuleType):
+        """
+        Validates if the rule type is supported.
+
+        Args:
+            rule_type (CaseTemplateRuleType): The rule type to validate.
+
+        Raises:
+            ValueError: If the rule type is not supported.
+        """
+        if rule_type not in self.available_rule_types:
+            raise ValueError(f"Rule type {rule_type} is not supported.")
+
+    def _apply_create_object(self, rule: CaseTemplateRule, parent=None):
+        """
+        Applies a create-object rule to generate a model instance.
+
+        Args:
+            rule (CaseTemplateRule): The rule to apply.
+            parent (Optional[Model]): The parent object for the rule.
+
+        Returns:
+            Model: The created model instance.
+        """
+        target_model = rule.get_target_model()
+        extra_params = rule.extra_parameters or {}
+        create_method_info = extra_params.get("create_method", {})
+
+        assert create_method_info, "Create method must be set for a create-object rule."
+
+        create_method = getattr(target_model, create_method_info["name"])
+        kwargs = create_method_info.get("kwargs", {})
+
+        if parent:
+            kwargs[rule.parent_field] = parent
+
+        target_instance = create_method(**kwargs)
+        target_instance.save()
+
+        for action in extra_params.get("actions", []):
+            action_method = getattr(target_instance, action["name"])
+            action_kwargs = action.get("kwargs", {})
+            action_method(**action_kwargs)
+
+        for chained_rule in rule.chained_rules.all():
+            self.apply_rule(chained_rule, parent=target_instance)
+
+        return target_instance
+
+    def _apply_set_field_by_distribution(self, rule: CaseTemplateRule, parent):
+        """
+        Applies a set-field-by-distribution rule.
+
+        Args:
+            rule (CaseTemplateRule): The rule to apply.
+            parent (Model): The parent object for the rule.
+
+        Returns:
+            Model: The updated parent object.
+        """
+        assert parent, "Parent must be provided for set-field-by-distribution rules."
+        assert rule.target_field, "Target field must be specified for the rule."
+
+        distribution = rule.get_distribution()
+        value = distribution.generate_value()
+
+        setattr(parent, rule.target_field, value)
+        parent.save()
+        return parent
+
+    def apply_rule(self, rule: CaseTemplateRule, parent=None):
+        """
+        Applies a rule based on its type to generate a case.
+
+        Args:
+            rule (CaseTemplateRule): The rule to apply.
+            parent (Optional[Model]): The parent object for the rule.
+
+        Returns:
+            Model: The case by applying the rule.
+        """
+        self._validate_rule_type(rule.rule_type)
+
+        if rule.rule_type.name == "create-object":
+            return self._apply_create_object(rule, parent)
+
+        if rule.rule_type.name == "set-field-by-distribution":
+            return self._apply_set_field_by_distribution(rule, parent)
+
+        raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
+
+    def generate_case(self, case_template: CaseTemplate = None):
+        """
+        Generates a case based on the provided or default template.
+
+        Args:
+            case_template (CaseTemplate, optional): The template to use for case generation. Defaults to None.
+
+        Returns:
+            Tuple[Model, Model]: The generated patient and medication schedule.
+        """
+        case_template = case_template or CaseTemplate.objects.get(name=DEFAULT_CASE_TEMPLATE_NAME)
+
+        create_patient_rule = case_template.get_create_patient_rule()
+        patient = self.apply_rule(create_patient_rule)
+
+        medication_schedule_rule = case_template.get_create_patient_medication_schedule_rule()
+        medication_schedule = self.apply_rule(medication_schedule_rule, parent=patient)
+
+        return patient, medication_schedule
+
+        # if not create_new_patient:
+        #     raise NotImplementedError("Only new patients are supported at the moment.")
+        # else:
+        #     # TODO Implement patient rules
+        #     patient_rules = None # all rules of type "create_patient"
+        #     patient = self.generate_patient(patient_rules)
+
+        # # Generate case based on template
+        # rules = self.template.get_rules()
+        # chained_rules = set()
+
+        # for rule in rules:
+        #     rule_chain = rule.get_all_downward_chained_rules()
+        #     chained_rules.add(rule)
+        #     chained_rules.update(rule_chain)
+
+        # return chained_rules

endoreg_db/utils/case_generator/lab_sample_factory.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timezone
+from endoreg_db.models import Patient, PatientLabSample, PatientLabSampleType
+
+class LabSampleFactory:
+    """
+    Provides methods to generate lab samples.
+    """
+
+    def __init__(self):
+        """
+        Initializes the LabSampleFactory.
+        """
+        pass
+
+    def create_generic_lab_sample(self, patient: Patient):
+        """
+        Generates a generic lab sample for a given patient.
+
+        Args:
+            patient (Patient): The patient for whom the lab sample is generated.
+
+        Returns:
+            PatientLabSample: The created lab sample instance.
+        """
+        sample_type = PatientLabSampleType.objects.get(name="generic")
+
+        lab_sample = PatientLabSample.objects.create(
+            patient=patient,
+            sample_type=sample_type,
+            date=datetime.now(tz=timezone.utc)
+        )
+
+        return lab_sample

endoreg_db/utils/case_generator/utils.py

@@ -0,0 +1,30 @@
+from endoreg_db.models import CaseTemplate
+from endoreg_db.case_generator.case_generator import CaseGenerator
+
+# TEMPLATE_NAME = "pre_endo-anticoagulation-af-low_risk"
+TEMPLATE_NAME = "pre_default_screening_colonoscopy"
+
+def fetch_template(template_name: str = DEFAULT_TEMPLATE_NAME) -> CaseTemplate:
+    """
+    Fetches a CaseTemplate by name.
+
+    Args:
+        template_name (str): The name of the template to fetch. Defaults to DEFAULT_TEMPLATE_NAME.
+
+    Returns:
+        CaseTemplate: The fetched CaseTemplate instance.
+    """
+    return CaseTemplate.objects.get(name=template_name)
+
+def initialize_case_generator(template_name: str = DEFAULT_TEMPLATE_NAME) -> CaseGenerator:
+    """
+    Initializes a CaseGenerator with the specified template.
+
+    Args:
+        template_name (str): The name of the template to use. Defaults to DEFAULT_TEMPLATE_NAME.
+
+    Returns:
+        CaseGenerator: An instance of CaseGenerator initialized with the template.
+    """
+    template = fetch_template(template_name)
+    return CaseGenerator(template)

endoreg_db/utils/check_video_files.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Simple video file existence checker and path corrector for VideoFile records.
+"""
+
+import os
+import sys
+from pathlib import Path
+import argparse
+
+# Parse command-line arguments and environment variables for configuration
+parser = argparse.ArgumentParser(description="Simple video file existence checker and path corrector for VideoFile records.")
+parser.add_argument('--django-base', type=str, default=os.environ.get('ENDOREG_DJANGO_PROJECT_PATH', str(Path(__file__).resolve().parent.parent.parent)),
+                    help='Path to the Django project base (default: env ENDOREG_DJANGO_PROJECT_PATH or project root)')
+parser.add_argument('--django-settings', type=str, default=os.environ.get('DJANGO_SETTINGS_MODULE', 'dev.dev_settings'),
+                    help='Django settings module (default: env DJANGO_SETTINGS_MODULE or dev.dev_settings)')
+parser.add_argument('--storage-dir', type=str, default=os.environ.get('ENDOREG_STORAGE_DIR', './storage'),
+                    help='Path to the storage directory (default: ./storage or $ENDOREG_STORAGE_DIR)')
+args, unknown = parser.parse_known_args()
+
+sys.path.insert(0, args.django_base)
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', args.django_settings)
+
+try:
+    import django
+    django.setup()
+    from endoreg_db.models import VideoFile
+    DJANGO_AVAILABLE = True
+except Exception as e:
+    print(f"Django not available: {e}")
+    DJANGO_AVAILABLE = False
+
+def find_video_files():
+    """Find all video files in storage directory."""
+    storage_dir = Path(args.storage_dir)
+    video_files = []
+    
+    for pattern in ['**/*.mp4', '**/*.avi', '**/*.mov', '**/*.mkv']:
+        video_files.extend(storage_dir.glob(pattern))
+    
+    return video_files
+
+def check_video_file_accessibility(file_path):
+    """Check if a video file is accessible and valid."""
+    try:
+        if not file_path.exists():
+            return False, "File does not exist"
+        
+        if file_path.stat().st_size == 0:
+            return False, "File is empty (0 bytes)"
+        
+        if not os.access(file_path, os.R_OK):
+            return False, "File is not readable"
+        
+        # Try to read first few bytes to check if it's actually a file
+        with open(file_path, 'rb') as f:
+            header = f.read(8)
+            if len(header) < 8:
+                return False, "File too small or corrupted"
+        
+        return True, f"OK - {file_path.stat().st_size / (1024*1024):.1f} MB"
+        
+    except Exception as e:
+        return False, f"Error checking file: {e}"
+
+def main():
+    print("🔍 VIDEO FILE EXISTENCE CHECKER")
+    print("=" * 40)
+    
+    # Find all video files
+    print("1. Scanning for video files...")
+    video_files = find_video_files()
+    print(f"Found {len(video_files)} video files in storage directory")
+    
+    if not video_files:
+        print("❌ No video files found in storage directory!")
+        return
+    
+    # Check each file
+    print("\n2. Checking file accessibility...")
+    accessible_files = []
+    
+    for video_file in video_files[:10]:  # Check first 10
+        accessible, message = check_video_file_accessibility(video_file)
+        status = "✅" if accessible else "❌"
+        print(f"{status} {video_file.name}: {message}")
+        
+        if accessible:
+            accessible_files.append(video_file)
+    
+    if not accessible_files:
+        print("\n❌ No accessible video files found!")
+        return
+    
+    print(f"\n✅ Found {len(accessible_files)} accessible video files")
+    
+    # If Django is available, check database records
+    if DJANGO_AVAILABLE:
+        print("\n3. Checking database records...")
+        try:
+            video_5 = VideoFile.objects.get(pk=5)
+            print(f"📋 Video ID 5 found in database:")
+            print(f"   UUID: {video_5.uuid}")
+            
+            # Check different file path attributes
+            for attr in ['raw_file', 'processed_file']:
+                if hasattr(video_5, attr):
+                    file_field = getattr(video_5, attr)
+                    if file_field:
+                        try:
+                            file_path = Path(file_field.path)
+                            accessible, message = check_video_file_accessibility(file_path)
+                            status = "✅" if accessible else "❌"
+                            print(f"   {attr}: {status} {file_path} ({message})")
+                        except Exception as e:
+                            print(f"   {attr}: ❌ Error accessing path: {e}")
+                    else:
+                        print(f"   {attr}: ❌ No file set")
+            
+            # Check if UUID matches any found files
+            uuid_str = str(video_5.uuid)
+            matching_files = [f for f in accessible_files if uuid_str in str(f)]
+            
+            if matching_files:
+                print(f"\n💡 Found matching files for UUID {uuid_str}:")
+                for match in matching_files:
+                    accessible, message = check_video_file_accessibility(match)
+                    print(f"   ✅ {match} ({message})")
+                    
+                print(f"\n🔧 SOLUTION: Update VideoFile record to use:")
+                print(f"   {matching_files[0]}")
+                print(f"\n🐍 Django command to fix:")
+                print(f"   video = VideoFile.objects.get(pk=5)")
+                print(f"   video.raw_file.name = '{matching_files[0].relative_to(Path(args.storage_dir))}'")
+                print(f"   video.save()")
+            else:
+                print(f"\n❌ No files found matching UUID {uuid_str}")
+                
+        except Exception as e:
+            print(f"❌ Error checking database: {e}")
+    
+    print(f"\n4. 🎯 QUICK TEST RECOMMENDATION:")
+    print(f"   Use this accessible file for testing:")
+    print(f"   {accessible_files[0]}")
+    print(f"   Size: {accessible_files[0].stat().st_size / (1024*1024):.1f} MB")
+
+if __name__ == "__main__":
+    main()

endoreg_db/utils/cropping.py

@@ -0,0 +1,29 @@
+from PIL import Image
+
+def crop_and_insert(image:Image, x, y, h, w, bg_color=(255, 255, 255)):
+    """
+    Crops a region from an inverted grayscale image and inserts it into a white image of the same size as the original.
+    
+    Parameters:
+    - fp: File path or a file object of the original image.
+    - x, y: The top-left coordinates of the rectangle to be cropped.
+    - h, w: The height and width of the rectangle to be cropped.
+    
+    Returns:
+    A PIL Image object containing the original image with the specified region replaced.
+    """
+    # Load the original image
+    original_image = image
+    
+    # Crop the specified region from the inverted image
+    crop_rectangle = (x, y, x + w, y + h)
+    cropped_content = original_image.crop(crop_rectangle)
+    
+    # Create a new white image of the same size as the original image
+    white_background = Image.new('RGB', original_image.size, bg_color)
+    
+    # Paste the cropped content onto the white image at the specified location
+    white_background.paste(cropped_content, (x, y))
+    
+    # The final image can be displayed or saved as needed
+    return white_background

endoreg_db/utils/dataloader.py

@@ -0,0 +1,175 @@
+import os
+import yaml
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import OperationalError, transaction
+
+
+def load_model_data_from_yaml(command, model_name, metadata, verbose):
+    """
+    Load model data from YAML files.
+
+    Args:
+        command: Command object for stdout writing.
+        model_name: Name of the model being loaded.
+        metadata: Metadata including directory and foreign key information.
+        verbose: Boolean indicating whether to print verbose output.
+    """
+    if verbose:
+        command.stdout.write(f"Start loading {model_name}")
+    model = metadata["model"]
+    dir_path = metadata["dir"]
+    foreign_keys = metadata["foreign_keys"]
+    foreign_key_models = metadata["foreign_key_models"]
+
+    _files = [f for f in os.listdir(dir_path) if f.endswith(".yaml")]
+    # sort
+    _files.sort()
+    for file in _files:
+        with open(os.path.join(dir_path, file), "r", encoding="utf-8") as file:
+            yaml_data = yaml.safe_load(file)
+
+        load_data_with_foreign_keys(
+            command, model, yaml_data, foreign_keys, foreign_key_models, verbose
+        )
+
+
+def load_data_with_foreign_keys(
+    command, model, yaml_data, foreign_keys, foreign_key_models, verbose
+):
+    """
+    Load YAML data into Django model instances with FK and M2M support.
+    
+    Processes each YAML entry to create or update a model instance. For each entry, the
+    function extracts field data and uses the presence of a 'name' field to decide whether
+    to update an existing instance or create a new one. Foreign key fields listed in
+    foreign_keys are handled by retrieving related objects via natural keys. When a field
+    contains a list, it is treated as a many-to-many relationship and the corresponding
+    objects are set after the instance is saved. Missing or unresolved foreign keys trigger
+    warnings if verbose output is enabled.
+    
+    Parameters:
+        model: The Django model class representing the data.
+        yaml_data: A list of dictionaries representing YAML entries.
+        foreign_keys: A list of foreign key field names to process from each entry.
+        foreign_key_models: The corresponding Django model classes for each foreign key.
+        verbose: If True, prints detailed output and warnings during processing.
+    """
+    for entry in yaml_data:
+        fields = entry.get("fields", {})
+        name = fields.pop("name", None)
+
+
+        ####################
+        #TODO REMOVE AFTER TRANSLATION SUPPORT IS ADDED
+        SKIP_NAMES=[
+            "name_de",  # German name, not used
+            "name_en",  # English name, not used
+            "description_de",  # German description
+            "description_en",  # English description
+        ]
+
+        
+        # Remove fields that are not needed
+        for skip_name in SKIP_NAMES:
+            if skip_name in fields:
+                fields.pop(skip_name)
+        ########################
+
+        m2m_relationships = {}  # Store many-to-many relationships
+        # print(entry)
+
+        # Handle foreign keys and many-to-many relationships
+        for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
+            # Skip fields that are not in the data
+            if fk_field not in fields:
+                continue
+
+            target_keys = fields.pop(fk_field, None)
+
+            # Ensure the foreign key exists
+            if target_keys is None:
+                if verbose:
+                    command.stdout.write(
+                        command.style.WARNING(
+                            f"Foreign key {fk_field} not found in fields"
+                        )
+                    )
+                continue  # Skip if no foreign key provided
+
+            # Process many-to-many fields or foreign keys
+            if isinstance(target_keys, list):  # Assume many-to-many relationship
+                related_objects = []
+                for key in target_keys:
+                    try:
+                        obj = fk_model.objects.get_by_natural_key(key)
+                    except ObjectDoesNotExist:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING(
+                                    f"{fk_model.__name__} with key {key} not found"
+                                )
+                            )
+                        continue
+                    related_objects.append(obj)
+                m2m_relationships[fk_field] = related_objects
+            else:  # Single foreign key relationship
+                try:
+                    obj = fk_model.objects.get_by_natural_key(target_keys)
+                except ObjectDoesNotExist:
+                    if verbose:
+                        command.stdout.write(
+                            command.style.WARNING(
+                                f"{fk_model.__name__} with key {target_keys} not found"
+                            )
+                        )
+                    continue
+                fields[fk_field] = obj
+
+        # Create or update the main object (avoid update_or_create to prevent SQLite locks)
+        def _save_instance():
+            if name is None:
+                # Try to find an existing object by all provided fields
+                obj = model.objects.filter(**fields).first()
+                if obj is None:
+                    obj = model.objects.create(**fields)
+                    created = True
+                else:
+                    created = False
+            else:
+                obj = model.objects.filter(name=name).first()
+                if obj is None:
+                    obj = model.objects.create(name=name, **fields)
+                    created = True
+                else:
+                    # Update fields
+                    for k, v in fields.items():
+                        setattr(obj, k, v)
+                    obj.save()
+                    created = False
+            return obj, created
+
+        try:
+            # Attempt save inside a transaction for consistency
+            with transaction.atomic():
+                obj, created = _save_instance()
+        except OperationalError:
+            # Retry once on SQLite lock
+            obj, created = _save_instance()
+
+        if created and verbose:
+            command.stdout.write(
+                command.style.SUCCESS(f"Created {model.__name__} {name}")
+            )
+        elif verbose:
+            pass
+
+        # Set many-to-many relationships
+        for field_name, related_objs in m2m_relationships.items():
+            if related_objs:  # Only set if there are objects to set
+                getattr(obj, field_name).set(related_objs)
+                if verbose:
+                    command.stdout.write(
+                        command.style.SUCCESS(
+                            f"Set {len(related_objs)} {field_name} for {model.__name__} {name}"
+                        )
+                    )

endoreg_db/utils/dates.py

@@ -0,0 +1,60 @@
+from datetime import datetime, date, timedelta
+from random import randint
+from calendar import monthrange
+from django.utils import timezone
+import datetime
+
+# TODO replace used random_day_by_year function implementation when
+# creating pseudo patients with new function "random date by age_at_date and examination_date"
+
+
+def random_day_by_age_at_date(age_at_date: int, examination_date: date) -> date:
+    """
+    Return a random birth day for a patient with the specified age at the specified examination date.
+    """
+    examination_year = examination_date.year
+    latest_birthdate = examination_date.replace(year=examination_year - age_at_date)
+    valid_dates = [latest_birthdate - timedelta(days=i) for i in range(365)]
+
+    select = randint(0, len(valid_dates) - 1)
+    birth_date = valid_dates[select]
+
+    return birth_date
+
+
+def random_day_by_year(year: int) -> date:
+    """
+    Return a random birth day within the specified year.
+    """
+    month = randint(1, 12)
+    day = randint(1, monthrange(year, month)[1])
+
+    return date(year, month, day)
+
+
+def random_day_by_month_year(month: int, year) -> date:
+    """
+    Return a random birth day within the specified month and year.
+    """
+
+    day = randint(1, monthrange(year, month)[1])
+    return date(year, month, day)
+
+
+def ensure_aware_datetime(dt):
+    """
+    Ensures a datetime object is timezone-aware.
+    If the datetime is naive (has no timezone info), the current timezone is applied.
+    
+    Args:
+        dt: A datetime object that may be naive
+        
+    Returns:
+        A timezone-aware datetime object
+    """
+    if dt is None:
+        return None
+        
+    if isinstance(dt, datetime.datetime) and timezone.is_naive(dt):
+        return timezone.make_aware(dt)
+    return dt

endoreg_db/utils/env.py

@@ -0,0 +1,33 @@
+import os
+
+DEBUG = os.getenv("DEBUG", "false").lower() == "true"
+
+def get_env_var(var_name: str, default: str = None) -> str | None:
+    """
+    Get the value of an environment variable, with an optional default value.
+    If the environment variable is set, we need to remove flanking quotation marks and spaces.
+    if the environment variable is not set, we set it to the default value.
+    :param var_name: The name of the environment variable.
+    :param default: The default value to return if the environment variable is not set.
+    :return: The value of the environment variable or the default value.
+    """
+    value = os.environ.get(var_name)
+    if value:
+        value = value.strip('"\'')  # Strip both single and double quotes
+        if DEBUG:
+            print(f"Environment variable {var_name}: {value}")
+        return value
+    return default
+
+def set_env_var(var_name: str, value: str) -> None:
+    """
+    Set the value of an environment variable.
+    :param var_name: The name of the environment variable.
+    :param value: The value to set.
+    """
+    os.environ[var_name] = value
+    if DEBUG:
+        print(f"Set environment variable {var_name}: {value}")
+
+DJANGO_SETTINGS_MODULE = get_env_var("DJANGO_SETTINGS_MODULE") or "endoreg_db.settings_dev"
+