endoreg-db 0.3.6__py3-none-any.whl → 0.8.6.1__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

@@ -1,29 +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
+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