endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__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/dataloader.py

@@ -1,11 +1,13 @@
 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.
@@ -19,74 +21,155 @@ def load_model_data_from_yaml(command, model_name, metadata, verbose):
     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')]
+    _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') as file:
+        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_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 data handling foreign keys and many-to-many relationships.
+    Load YAML data into Django model instances with FK and M2M support.
     
-    Args:
-        command: Command object for stdout writing.
-        model: The Django model for the data.
-        yaml_data: Data loaded from YAML.
-        foreign_keys: List of foreign keys.
-        foreign_key_models: Corresponding models for the foreign keys.
-        verbose: Boolean indicating whether to print verbose output.
+    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)
+        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)
+        # print(entry)
 
         # Handle foreign keys and many-to-many relationships
         for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
-            print(fk_field, fk_model)
+            # 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"))
+                    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:
-                    obj, created = fk_model.objects.get_or_create(name=key)
-                    if created and verbose:
-                        command.stdout.write(command.style.SUCCESS(f"Created {fk_model.__name__} {key}"))
+                    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:
-                    if model == "endoreg_db.case_template_rule":
-                        print(fk_model, target_keys)
                     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"))
+                        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
-        if name is None:
-            obj, created = model.objects.get_or_create(**fields)
-        else:
-            obj, created = model.objects.update_or_create(defaults=fields, name=name)
+
+        # 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}'))
+            command.stdout.write(
+                command.style.SUCCESS(f"Created {model.__name__} {name}")
+            )
         elif verbose:
-            command.stdout.write(command.style.WARNING(f'Skipped {model.__name__} {name}, already exists'))
+            pass
 
         # Set many-to-many relationships
         for field_name, related_objs in m2m_relationships.items():
-            getattr(obj, field_name).set(related_objs)
+            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"
+