endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/utils/links/requirement_link.py

@@ -0,0 +1,193 @@
+from typing import List, Optional, TYPE_CHECKING # Modified import
+
+from pydantic import BaseModel, Field
+
+from endoreg_db.models import (
+    PatientDisease, Disease, DiseaseClassificationChoice,
+    Event, 
+    PatientEvent, Examination, ExaminationIndication, ExaminationIndicationClassificationChoice,
+    PatientExamination, PatientExaminationIndication,
+    PatientFinding,
+    Finding, 
+    FindingIntervention, 
+    FindingClassification,
+    FindingClassificationChoice, 
+    LabValue,
+    PatientLabValue,
+    PatientLabSample,
+    PatientLabSampleType,
+    PatientMedication, # Added
+    PatientMedicationSchedule, # Added
+    Medication, # Added
+    MedicationIndication, # Added
+    MedicationIntakeTime, # Added
+    MedicationSchedule, # Added
+)
+if TYPE_CHECKING: # Added for Patient import
+    from endoreg_db.models.administration.person.patient import Patient
+
+class RequirementLinks(BaseModel):
+    """
+    A class representing a dictionary of models related to a requirement.
+
+    Attributes:
+        # requirement_types (List[RequirementType]): A List of requirement types.
+        # operators (List[RequirementOperator]): A List of operators.
+        # requirement_sets (List[RequirementSet]): A List of requirement sets.
+        examinations (List[Examination]): A List of examinations.
+        examination_indications (List[ExaminationIndication]): A List of examination indications.
+        lab_values (List[LabValue]): A List of lab values.
+        diseases (List[Disease]): A List of diseases.
+        disease_classification_choices (List[DiseaseClassificationChoice]): A List of disease classification choices.
+        events (List[Event]): A List of events.
+        findings (List[Finding]): A List of findings.
+        finding_morphology_classification_choices (List[FindingMorphologyClassificationChoice]): A List of finding morphology classification choices.
+        finding_location_classification_choices (List[FindingLocationClassificationChoice]): A List of finding location classification choices.
+        finding_interventions (List[FindingIntervention]): A List of finding interventions.
+    """
+    model_config = {"arbitrary_types_allowed": True}
+    # 
+    # requirement_types: Optional[List["RequirementType"]] = None
+    # operators: Optional[List["RequirementOperator"]] = None
+    # The following model import causes circular import
+    #requirement_sets: Optional[List["RequirementSet"]] = None
+    examinations: List["Examination"] = Field(default_factory=list)
+    examination_indications: List["ExaminationIndication"] = Field(default_factory=list)
+    examination_indication_classification_choices: List["ExaminationIndicationClassificationChoice"] = Field(default_factory=list)
+    patient_examinations: List["PatientExamination"] = Field(default_factory=list)
+    
+    patient_examination_indication: List["PatientExaminationIndication"] = Field(default_factory=list)
+    lab_values: List["LabValue"] = Field(default_factory=list)
+    patient_lab_values: List["PatientLabValue"] = Field(default_factory=list)
+    patient_lab_samples: List["PatientLabSample"] = Field(default_factory=list)
+    patient_diseases: List["PatientDisease"] = Field(default_factory=list)
+    diseases: List["Disease"] = Field(default_factory=list)
+    disease_classification_choices: List["DiseaseClassificationChoice"] = Field(default_factory=list)
+    events: List["Event"] = Field(default_factory=list)
+    patient_events: List["PatientEvent"] = Field(default_factory=list)
+    patient_findings: List["PatientFinding"] = Field(default_factory=list)
+    findings: List["Finding"] = Field(default_factory=list)
+    finding_classification_choices: List["FindingClassificationChoice"] = Field(default_factory=list)
+    finding_classifications: List["FindingClassification"] = Field(default_factory=list) # Added for direct classification checks if needed
+    finding_interventions: List["FindingIntervention"] = Field(default_factory=list)
+    patient_lab_sample_types: List["PatientLabSampleType"] = Field(default_factory=list)
+    patient_medications: List["PatientMedication"] = Field(default_factory=list) # Added
+    patient_medication_schedules: List["PatientMedicationSchedule"] = Field(default_factory=list) # Added
+    # Added direct medication-related fields
+    medications: List["Medication"] = Field(default_factory=list)
+    medication_indications: List["MedicationIndication"] = Field(default_factory=list)
+    medication_intake_times: List["MedicationIntakeTime"] = Field(default_factory=list)
+    medication_schedules: List["MedicationSchedule"] = Field(default_factory=list)
+
+    def get_first_patient(self) -> Optional["Patient"]:
+        """
+        Retrieves the first Patient instance found through the linked patient-specific models.
+        Iterates through various patient-related lists and returns the .patient attribute
+        from the first relevant object found.
+        """
+        if self.patient_lab_values:
+            for plv in self.patient_lab_values:
+                if hasattr(plv, 'sample') and plv.sample and \
+                   hasattr(plv.sample, 'patient') and plv.sample.patient:
+                    return plv.sample.patient
+        if self.patient_lab_samples:
+            for pls in self.patient_lab_samples:
+                if hasattr(pls, 'patient') and pls.patient:
+                    return pls.patient
+        if self.patient_examinations:
+            for pe in self.patient_examinations:
+                if hasattr(pe, 'patient') and pe.patient:
+                    return pe.patient
+        if self.patient_diseases:
+            for pd in self.patient_diseases:
+                if hasattr(pd, 'patient') and pd.patient:
+                    return pd.patient
+        if self.patient_events:
+            for pev in self.patient_events:
+                if hasattr(pev, 'patient') and pev.patient:
+                    return pev.patient
+        if self.patient_findings:
+            for pf in self.patient_findings:
+                if hasattr(pf, 'patient') and pf.patient:
+                    return pf.patient
+        # Check PatientMedication
+        if self.patient_medications:
+            for pm in self.patient_medications:
+                if hasattr(pm, 'patient') and pm.patient:
+                    return pm.patient
+        # Check PatientMedicationSchedule
+        if self.patient_medication_schedules:
+            for pms in self.patient_medication_schedules:
+                if hasattr(pms, 'patient') and pms.patient:
+                    return pms.patient
+        return None
+
+    @property
+    def data_model_dict(self):
+        """
+        Provides access to the data model dictionary used for requirement type parsing.
+        
+        Returns:
+            The `data_model_dict` imported from the requirement type parser module.
+        """
+        from endoreg_db.models.requirement.requirement_evaluation.requirement_type_parser import data_model_dict
+        return data_model_dict
+
+    @property
+    def data_model_dict_reverse(self):
+        """
+        Provides a reverse mapping dictionary for data model types used in requirement evaluation.
+        
+        Returns:
+            The `data_model_dict_reverse` dictionary imported from the requirement type parser module.
+        """
+        from endoreg_db.models.requirement.requirement_evaluation.requirement_type_parser import data_model_dict_reverse
+
+        return data_model_dict_reverse
+
+    def match_any(self, other:"RequirementLinks") -> bool:
+        """
+        Determines if any linked model in this instance is also present in another RequirementLinks instance.
+        
+        Compares each list attribute of both instances and returns True if any element in any list overlaps.
+        """
+        
+        other_dict = other.model_dump()
+        self_dict = self.model_dump()
+        for key in self_dict:
+            # print(f"Checking key: {key}") # This is a debug print, can be removed
+            if key in other_dict and self_dict[key] and other_dict[key]:
+                if any(item in other_dict[key] for item in self_dict[key]):
+                    return True
+        return False # Ensure False is returned if no match is found
+    
+    def active(self) -> dict[str, list]:
+        """
+        Returns a dictionary of all non-empty linked model lists.
+        
+        Only attributes with non-empty lists are included in the returned dictionary.
+        """
+        active_links_dict = {}
+        # Use model_dump() to iterate field data reliably (pydantic v2)
+        for field_name, field_value in self.model_dump().items():
+            if isinstance(field_value, list) and field_value:
+                active_links_dict[field_name] = field_value
+        return active_links_dict
+
+    def __repr__(self):
+        """
+        Returns a concise string summarizing the counts of each linked model list in the instance.
+        """
+        data = self.model_dump()
+        fields = [
+            'examinations', 'examination_indications', 'patient_examinations',
+            'lab_values', 'patient_lab_values', 'patient_diseases', 'diseases',
+            'disease_classification_choices', 'events', 'patient_events', 'findings',
+            'patient_findings', 'finding_classification_choices', 'finding_interventions',
+            'patient_medications', 'patient_medication_schedules', 'medications',
+            'medication_indications', 'medication_intake_times', 'medication_schedules'
+        ]
+        parts = [f"{f}={len(data.get(f, []))}" for f in fields]
+        return f"RequirementLinks({', '.join(parts)})"
+
+

endoreg_db/utils/names.py

@@ -0,0 +1,76 @@
+# Use faker library to generate fake names by gender
+# Use german names by default
+
+from faker import Faker
+import gender_guesser.detector as gender_detector
+
+
+def create_mock_examiner_name() -> tuple[str, str]:
+    """
+    Generate a mock examiner's name using the Faker library.
+    This function creates a tuple with a first name and a last name for a mock examiner. It utilizes the "de_DE" locale for generating German names.
+    Returns:
+        tuple[str, str]: A tuple containing the first name and the last name.
+    """
+
+    fake = Faker("de_DE")
+    first_name = fake.first_name()
+    last_name = fake.last_name()
+    return first_name, last_name
+
+
+def create_mock_patient_name(gender: str) -> tuple[str, str]:
+    """
+    Generate a mock patient's name based on the provided gender using the Faker library.
+    This function creates a tuple with a first name and a last name for a mock patient. It utilizes the "de_DE" locale for generating German names. When the input gender string is checked:
+    - If it contains "male", a male name is generated.
+    - If it contains "female", a female name is generated.
+    - Otherwise, a generic name is generated without considering gender.
+    Parameters:
+        gender (str): A string indicating the gender to be used for generating the name.
+    Returns:
+        tuple[str, str]: A tuple containing the first name and the last name.
+    """
+
+    fake = Faker("de_DE")
+
+    if "male" in gender.lower():
+        gender = "male"
+    elif "female" in gender.lower():
+        gender = "female"
+
+    if gender == "male":
+        first_name = fake.first_name_male()
+        last_name = fake.last_name_male()
+
+    elif gender == "female":
+        first_name = fake.first_name_female()
+        last_name = fake.last_name_female()
+
+    else:
+        first_name = fake.first_name()
+        last_name = fake.last_name()
+
+    return first_name, last_name
+
+
+def guess_name_gender(name: str) -> str:
+    """
+    Guesses the gender for a given name by using a gender detector and retrieving the corresponding Gender model instance.
+    Parameters:
+        name (str): The name for which the gender is to be determined.
+    Returns:
+        Gender: The Gender object corresponding to the detected gender name.
+    Raises:
+        Gender.DoesNotExist: If no Gender object matching the detected gender is found.
+        Exception: For any other exceptions that occur during gender detection or database lookup.
+    """
+
+    from endoreg_db.models import Gender
+
+    detector = gender_detector.Detector(case_sensitive=False)
+    gender_name = detector.get_gender(name)
+    gender = Gender.objects.get(name=gender_name)
+    if not gender:
+        gender = Gender.objects.get(name="unknown")
+    return gender

endoreg_db/utils/parse_and_generate_yaml.py

@@ -0,0 +1,46 @@
+import yaml
+from pathlib import Path
+
+# get this files path
+file_path = Path(__file__)
+module_root = file_path.parent.parent
+data_dir = module_root / "data"
+
+
+def collect_center_names(
+):
+    input_file_path = data_dir / "center/data.yaml"
+    fist_name_dir = data_dir / "names_first"
+    last_name_dir = data_dir / "names_last"
+    # Load the input YAML file
+    with open(input_file_path, 'r', encoding='utf-8') as file:
+        data = yaml.safe_load(file)
+    
+    # Containers for first and last names
+    first_names_set = set()
+    last_names_set = set()
+    
+    # Extract first and last names from the YAML data
+    for entry in data:
+        fields = entry.get('fields', {})
+        first_names_set.update(fields.get('first_names', []))
+        last_names_set.update(fields.get('last_names', []))
+    
+    # Create a list of dictionaries for first and last names
+    first_names_data = [
+        {"model": "endoreg_db.first_name", "fields": {"name": name}}
+        for name in sorted(first_names_set)
+    ]
+    last_names_data = [
+        {"model": "endoreg_db.last_name", "fields": {"name": name}}
+        for name in sorted(last_names_set)
+    ]
+    
+    # Write the data to separate YAML files
+    with open(fist_name_dir/"first_names.yaml", "w", encoding='utf-8') as first_file:
+        yaml.dump(first_names_data, first_file, allow_unicode=True, sort_keys=False)
+    
+    with open(last_name_dir/"last_names.yaml", "w", encoding='utf-8') as last_file:
+        yaml.dump(last_names_data, last_file, allow_unicode=True, sort_keys=False)
+
+    # print("Generated first_names.yaml and last_names.yaml successfully.")

endoreg_db/utils/paths.py

@@ -0,0 +1,95 @@
+"""
+Centralizes path management for the application.
+
+This module sets up all necessary directories for storage and import operations.
+It provides a unified dictionary 'data_paths' for accessing all path objects.
+"""
+
+from logging import getLogger
+
+from sphinx.search import no
+logger = getLogger(__name__)
+
+from pathlib import Path
+from typing import Dict
+import os
+# Alternative approach using env_path helper, deprecated since monorepo setup. Alright for single install, env is always preferred.
+#from endoreg_db.config.env import env_path
+
+STORAGE_DIR = Path(os.getenv("STORAGE_DIR", "storage"))
+
+storage_dir_env = os.getenv("STORAGE_DIR")
+if storage_dir_env is None:
+    raise RuntimeError("STORAGE_DIR environment variable is not set.")
+storage_dir_str = Path(storage_dir_env)
+STORAGE_DIR = storage_dir_str
+if not STORAGE_DIR.exists():
+    STORAGE_DIR.mkdir(parents=True, exist_ok=True)
+
+PREFIX_RAW = "raw_"
+IMPORT_DIR_NAME = "import"
+EXPORT_DIR_NAME = "export"
+
+VIDEO_DIR_NAME = "videos"
+ANONYM_VIDEO_DIR_NAME = "anonym_videos" # Added for processed videos
+FRAME_DIR_NAME = "frames"
+PDF_DIR_NAME = "pdfs" # Changed from reports
+WEIGHTS_DIR_NAME = "model_weights"
+EXAMINATION_DIR_NAME = "examinations"
+
+RAW_VIDEO_DIR_NAME = f"{PREFIX_RAW}videos"
+RAW_FRAME_DIR_NAME = f"{PREFIX_RAW}frames"
+RAW_PDF_DIR_NAME = f"{PREFIX_RAW}pdfs" # Changed from reports
+
+# Define data subdirectories under STORAGE_DIR
+VIDEO_DIR = STORAGE_DIR / VIDEO_DIR_NAME
+ANONYM_VIDEO_DIR = STORAGE_DIR / ANONYM_VIDEO_DIR_NAME # Added
+FRAME_DIR = STORAGE_DIR / FRAME_DIR_NAME
+PDF_DIR = STORAGE_DIR / PDF_DIR_NAME # Changed
+WEIGHTS_DIR = STORAGE_DIR / WEIGHTS_DIR_NAME
+RAW_VIDEO_DIR = STORAGE_DIR / RAW_VIDEO_DIR_NAME
+RAW_FRAME_DIR = STORAGE_DIR / RAW_FRAME_DIR_NAME
+RAW_PDF_DIR = STORAGE_DIR / RAW_PDF_DIR_NAME # Changed
+
+IMPORT_DIR = STORAGE_DIR / IMPORT_DIR_NAME
+VIDEO_IMPORT_DIR = IMPORT_DIR / VIDEO_DIR_NAME
+FRAME_IMPORT_DIR = IMPORT_DIR / FRAME_DIR_NAME
+PDF_IMPORT_DIR = IMPORT_DIR / PDF_DIR_NAME # Changed
+WEIGHTS_IMPORT_DIR = IMPORT_DIR / WEIGHTS_DIR_NAME
+
+EXPORT_DIR = STORAGE_DIR / EXPORT_DIR_NAME
+
+data_paths:Dict[str,Path] = {
+    "storage": STORAGE_DIR,
+    "video": VIDEO_DIR,
+    "anonym_video": ANONYM_VIDEO_DIR, # Added
+    "frame": FRAME_DIR,
+    "pdf": PDF_DIR, # Changed
+    "import": IMPORT_DIR,
+    "video_import": VIDEO_IMPORT_DIR,
+    "frame_import": FRAME_IMPORT_DIR,
+    "pdf_import": PDF_IMPORT_DIR, # Changed
+    "raw_video": RAW_VIDEO_DIR,
+    "raw_frame": RAW_FRAME_DIR,
+    "raw_pdf": RAW_PDF_DIR, # Changed
+    "weights": WEIGHTS_DIR,
+    "weights_import": WEIGHTS_IMPORT_DIR,
+    "export": EXPORT_DIR,
+    "video_export": EXPORT_DIR / VIDEO_DIR_NAME,
+    "anonym_video_export": EXPORT_DIR / ANONYM_VIDEO_DIR_NAME, # Added
+    "frame_export": EXPORT_DIR / FRAME_DIR_NAME,
+    "pdf_export": EXPORT_DIR / PDF_DIR_NAME, # Changed
+    "weights_export": EXPORT_DIR / WEIGHTS_DIR_NAME,
+    "examination_export": EXPORT_DIR / EXAMINATION_DIR_NAME,
+    "raw_video_export": EXPORT_DIR / RAW_VIDEO_DIR_NAME,
+    "raw_frame_export": EXPORT_DIR / RAW_FRAME_DIR_NAME,
+    "raw_pdf_export": EXPORT_DIR / RAW_PDF_DIR_NAME, # Changed
+}
+
+logger.info(f"Storage directory: {STORAGE_DIR.resolve()}")
+logger.info(f"Export directory: {EXPORT_DIR.resolve()}")
+
+# for key, path in data_paths.items():
+#     path.mkdir(parents=True, exist_ok=True)
+
+#     logger.info(f"{key.capitalize()} directory: {path.resolve()}")

endoreg_db/utils/permissions.py

@@ -0,0 +1,143 @@
+"""
+Dynamic permission utilities that adapt to environment settings.
+
+This module provides permission classes that automatically adjust based on
+the DEBUG setting and other environment configurations.
+"""
+
+from django.conf import settings
+from rest_framework.permissions import IsAuthenticated, AllowAny, BasePermission
+from rest_framework.decorators import permission_classes as drf_permission_classes
+from functools import wraps
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+class DynamicAuthPermission:
+    """
+    Permission class that adapts based on environment settings.
+    
+    - In DEBUG mode: Allows access without authentication
+    - In production (DEBUG=False): Requires authentication
+    """
+    
+    @staticmethod
+    def get_permission_classes():
+        """
+        Returns appropriate permission classes based on current settings.
+        
+        Returns:
+            list: Permission classes to use
+        """
+        if getattr(settings, 'DEBUG', False):
+            logger.info("DEBUG mode detected - allowing unauthenticated access")
+            return [AllowAny]
+        else:
+            logger.info("Production mode detected - requiring authentication")
+            return [IsAuthenticated]
+
+
+def dynamic_permission_classes(force_auth=None):
+    """
+    Decorator that applies permission classes based on environment settings.
+    
+    Args:
+        force_auth (bool, optional): 
+            - True: Always require authentication regardless of DEBUG
+            - False: Always allow access regardless of DEBUG  
+            - None: Use environment-based logic (default)
+    """
+    def decorator(view_func):
+        @wraps(view_func)
+        def wrapper(*args, **kwargs):
+            return view_func(*args, **kwargs)
+        
+        # Determine permission classes
+        if force_auth is True:
+            permission_cls = [IsAuthenticated]
+            logger.info(f"View {view_func.__name__} - forced authentication required")
+        elif force_auth is False:
+            permission_cls = [AllowAny]
+            logger.info(f"View {view_func.__name__} - forced public access")
+        else:
+            permission_cls = DynamicAuthPermission.get_permission_classes()
+            logger.info(f"View {view_func.__name__} - dynamic permissions: {permission_cls}")
+        
+        # Apply the permission classes decorator
+        return drf_permission_classes(permission_cls)(wrapper)
+    
+    return decorator
+
+
+def get_auth_required():
+    """
+    Simple function to check if authentication is required in current environment.
+    
+    Returns:
+        bool: True if authentication is required, False otherwise
+    """
+    return not getattr(settings, 'DEBUG', False)
+
+
+def is_debug_mode():
+    """
+    Robustly determine if debug mode is enabled, checking both Django settings and environment variable.
+    Also treats active pytest sessions as debug to simplify API tests.
+    """
+    truthy = {"1", "true", "yes", "on"}
+    env_debug = str(os.environ.get("DJANGO_DEBUG", "false")).lower() in truthy
+    settings_debug = bool(getattr(settings, 'DEBUG', False))
+    pytest_active = "PYTEST_CURRENT_TEST" in os.environ
+    result = settings_debug or env_debug or pytest_active
+    logger.info(f"is_debug_mode: env={env_debug}, settings={settings_debug}, pytest={pytest_active}, result={result}")
+    return result
+
+# Compute default permission classes each call to avoid stale values during tests
+
+def get_debug_permissions():
+    return [AllowAny] if is_debug_mode() else [IsAuthenticated]
+
+# Export a name for convenience, but prefer calling get_debug_permissions() in views
+DEBUG_PERMISSIONS = get_debug_permissions()
+ALWAYS_AUTH_PERMISSIONS = [IsAuthenticated]
+ALWAYS_PUBLIC_PERMISSIONS = [AllowAny]
+
+# Log the current permission mode
+if is_debug_mode():
+    logger.info("🔓 Authentication disabled for DEBUG mode (robust check)")
+else:
+    logger.info("🔒 Authentication required for production mode (robust check)")
+
+
+class EnvironmentAwarePermission(BasePermission):
+    """
+    Custom permission class that can be used directly in DRF views.
+    Honors both Django settings.DEBUG and DJANGO_DEBUG env var.
+    """
+    
+    def has_permission(self, request, view):
+        """
+        Check if the request has permission.
+        
+        Args:
+            request: The Django request object
+            view: The DRF view
+            
+        Returns:
+            bool: True if permission granted, False otherwise
+        """
+        if is_debug_mode():
+            logger.debug(f"DEBUG mode - granting access to {view.__class__.__name__}")
+            return True
+        # In production, require authentication
+        is_authenticated = bool(getattr(request, 'user', None) and request.user.is_authenticated)
+        logger.debug(f"Production mode - authentication check for {view.__class__.__name__}: {is_authenticated}")
+        return is_authenticated
+    
+    def has_object_permission(self, request, view, obj):
+        """
+        Object-level permission check.
+        """
+        return self.has_permission(request, view)