endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/utils/requirement_operator_logic/model_evaluators.py

@@ -0,0 +1,368 @@
+import datetime # Add import
+from datetime import timedelta # Add import
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.utils.links.requirement_link import RequirementLinks
+    from endoreg_db.models.requirement.requirement import Requirement
+    # from endoreg_db.models import Unit # Potentially needed for dynamic unit handling
+
+
+# Helper function to check if a date is within the timeframe specified by a Requirement
+def _is_date_in_timeframe(date_to_check: datetime.date | None, requirement: "Requirement") -> bool:
+    """
+    Checks if a given date falls within the timeframe specified by a Requirement.
+
+    The timeframe is defined by `numeric_value_min` and `numeric_value_max` on the
+    Requirement, interpreted relative to the current date.
+
+    Currently, this function only supports timeframes specified in "days".
+    If the Requirement's unit is not "days", a NotImplementedError will be raised.
+
+    Args:
+        date_to_check: The date to evaluate. If None, returns False.
+        requirement: The Requirement instance containing timeframe definitions
+                     (unit, numeric_value_min, numeric_value_max).
+
+    Returns:
+        True if the date_to_check is within the defined timeframe, False otherwise.
+        Returns False if date_to_check is None or if the requirement lacks
+        necessary timeframe information (unit, min/max values).
+
+    Raises:
+        NotImplementedError: If the requirement.unit.name is not 'days' (case-insensitive).
+    """
+    if date_to_check is None:
+        return False
+    if not requirement.unit or requirement.numeric_value_min is None or requirement.numeric_value_max is None:
+        return False # Not enough information for timeframe evaluation
+
+    # For now, primarily supporting 'days'. Extend if other units are common.
+    if requirement.unit.name.lower() != "days":
+        raise NotImplementedError(
+            f"Timeframe unit '{requirement.unit.name}' is not supported. "
+            "Currently, only 'days' is implemented for timeframe checks."
+        )
+
+    today = datetime.date.today()
+    # numeric_value_min is typically negative for "days ago" (e.g., -30 for 30 days ago)
+    # numeric_value_max is typically 0 for "today"
+    timeframe_start_delta = int(requirement.numeric_value_min)
+    timeframe_end_delta = int(requirement.numeric_value_max)
+
+    start_date_bound = today + timedelta(days=timeframe_start_delta)
+    end_date_bound = today + timedelta(days=timeframe_end_delta)
+
+    return start_date_bound <= date_to_check <= end_date_bound
+
+
+def _evaluate_models_match_any(
+    requirement_links: "RequirementLinks",
+    input_links: "RequirementLinks",
+    **kwargs
+) -> bool:
+    """
+    Checks if the requirement_links matches any of the input_links.
+    
+    Args:
+        requirement_links: The reference set of requirement links to compare against.
+        input_links: The aggregated requirement links from the input objects.
+    
+    Returns:
+        True if the input set of requirement links matches according to requirement_links.match_any; otherwise, False.
+    """
+    return requirement_links.match_any(input_links)
+
+
+def _evaluate_models_match_any_in_timeframe(
+    requirement_links: "RequirementLinks",
+    input_links: "RequirementLinks",
+    requirement: "Requirement", # Explicitly pass Requirement
+    **kwargs # Keep for consistency, though 'requirement' is the main one used here
+) -> bool:
+    """
+    Checks if any relevant model in input_links matches a model specified in
+    requirement_links AND falls within the timeframe defined on the Requirement.
+
+    Currently focuses on PatientEvent instances and their dates.
+    """
+    active_req_links_dict = requirement_links.active()
+    if not active_req_links_dict:
+        # If the Requirement itself doesn't specify any models to match (e.g., requirement.events is empty),
+        # then it's vacuously true that "any" of these (non-existent) required models are matched.
+        # The timeframe aspect becomes irrelevant if no specific models are being checked.
+        return True
+
+    # --- Handle PatientEvents ---
+    # Check if the requirement is concerned with events
+    if requirement_links.events: # This list contains Event model instances
+        required_event_models = set(requirement_links.events) # Target Event models from the Requirement
+        
+        # input_links.patient_events contains PatientEvent instances provided as input
+        for patient_event_instance in input_links.patient_events:
+            # Check if the event of the current PatientEvent instance is one of the target events
+            if patient_event_instance.event in required_event_models:
+                # If it is, check if this PatientEvent's date is within the timeframe
+                if _is_date_in_timeframe(patient_event_instance.date, requirement):
+                    return True # Found a matching event within the timeframe
+
+    # --- Handle Other Model Types (Example: PatientLabValue) ---
+    # if requirement_links.lab_values:
+    #     required_lab_value_models = set(requirement_links.lab_values)
+    #     for plv_instance in input_links.patient_lab_values:
+    #         if plv_instance.lab_value in required_lab_value_models:
+    #             date_to_check = None
+    #             if hasattr(plv_instance, 'date_time_value') and plv_instance.date_time_value:
+    #                 date_to_check = plv_instance.date_time_value.date()
+    #             elif hasattr(plv_instance, 'date') and plv_instance.date: # If it had a simple date field
+    #                 date_to_check = plv_instance.date
+    #
+    #             if _is_date_in_timeframe(date_to_check, requirement):
+    #                 return True
+    
+    # If the code reaches here, no matching model within the timeframe was found
+    # for any of the categories specified in requirement_links.
+    return False
+
+
+def _evaluate_models_match_all(
+    requirement_links: "RequirementLinks",
+    input_links: "RequirementLinks",
+    **kwargs
+) -> bool:
+    """
+    Evaluates if all active links in requirement_links are present in input_links.
+
+    For each category of links in requirement_links (e.g., diseases, examinations),
+    all items specified in that category in requirement_links must be present in the
+    corresponding category in input_links.
+
+    Args:
+        requirement_links: The RequirementLinks object from the Requirement model.
+        input_links: The aggregated RequirementLinks object from the input arguments.
+        **kwargs: Additional keyword arguments (currently unused).
+
+    Returns:
+        True if all specified items in requirement_links are found in input_links,
+        False otherwise.
+    """
+    active_req_links = requirement_links.active() # Get dict of non-empty lists from requirement
+
+    if not active_req_links: # If the requirement specifies no actual items to link
+        return True # Vacuously true, as there are no conditions to fail
+
+    for link_category_name, req_items_list in active_req_links.items():
+        input_items_list = getattr(input_links, link_category_name, [])
+        
+        try:
+            set_input_items = set(input_items_list)
+            set_req_items = set(req_items_list)
+        except TypeError: 
+            for req_item in req_items_list:
+                if req_item not in input_items_list:
+                    return False 
+            continue 
+
+        if not set_req_items.issubset(set_input_items):
+            return False 
+            
+    return True
+
+def _evaluate_age_gte(
+    requirement_links: "RequirementLinks",
+    input_links: "RequirementLinks",
+    requirement: "Requirement",
+    **kwargs
+) -> bool:
+    """
+    Checks if any patient in the input has an age greater than or equal to the requirement's numeric_value.
+    
+    Args:
+        requirement_links: The RequirementLinks object from the Requirement model (not used for age checks).
+        input_links: The aggregated RequirementLinks object from the input arguments.
+        requirement: The Requirement instance containing the minimum age in numeric_value.
+        **kwargs: Additional keyword arguments, should contain 'original_input_args' with the original Patient instances.
+    
+    Returns:
+        True if any patient in the input has an age >= requirement.numeric_value, False otherwise.
+    """
+    from endoreg_db.models.administration.person.patient import Patient
+    import logging
+    
+    logger = logging.getLogger(__name__)
+    
+    if requirement.numeric_value is None:
+        logger.debug("age_gte: requirement.numeric_value is None, returning False")
+        return False  # Cannot evaluate without a minimum age requirement
+    
+    min_age = requirement.numeric_value
+    logger.debug(f"age_gte: Checking if any patient has age >= {min_age}")
+    
+    # Check if we have Patient instances in the original_input_args
+    original_args = kwargs.get('original_input_args', [])
+    logger.debug(f"age_gte: Found {len(original_args)} original input arguments: {[type(arg).__name__ for arg in original_args]}")
+    
+    for i, arg in enumerate(original_args):
+        logger.debug(f"age_gte: Checking argument {i}: {type(arg).__name__}")
+        if isinstance(arg, Patient):
+            patient_age = arg.age()
+            logger.debug(f"age_gte: Patient {arg} has age {patient_age}, comparing with min_age {min_age}")
+            if patient_age is not None and patient_age >= min_age:
+                logger.debug(f"age_gte: Patient age {patient_age} >= {min_age}, returning True")
+                return True
+            else:
+                logger.debug(f"age_gte: Patient age {patient_age} < {min_age} or is None")
+        # Handle QuerySets of patients
+        elif hasattr(arg, 'model') and issubclass(arg.model, Patient):
+            logger.debug(f"age_gte: Found Patient QuerySet with {arg.count()} patients")
+            for patient in arg:
+                patient_age = patient.age()
+                logger.debug(f"age_gte: Patient {patient} has age {patient_age}, comparing with min_age {min_age}")
+                if patient_age is not None and patient_age >= min_age:
+                    logger.debug(f"age_gte: Patient age {patient_age} >= {min_age}, returning True")
+                    return True
+        else:
+            logger.debug(f"age_gte: Argument {i} is not a Patient or Patient QuerySet: {type(arg)}")
+    
+    logger.debug(f"age_gte: No patient found with age >= {min_age}, returning False")
+    return False
+
+
+def _evaluate_age_lte(
+    requirement_links: "RequirementLinks",
+    input_links: "RequirementLinks", 
+    requirement: "Requirement",
+    **kwargs
+) -> bool:
+    """
+    Checks if any patient in the input has an age less than or equal to the requirement's numeric_value.
+    
+    Args:
+        requirement_links: The RequirementLinks object from the Requirement model (not used for age checks).
+        input_links: The aggregated RequirementLinks object from the input arguments.
+        requirement: The Requirement instance containing the maximum age in numeric_value.
+        **kwargs: Additional keyword arguments, should contain 'original_input_args' with the original Patient instances.
+    
+    Returns:
+        True if any patient in the input has an age <= requirement.numeric_value, False otherwise.
+    """
+    from endoreg_db.models.administration.person.patient import Patient
+    
+    if requirement.numeric_value is None:
+        return False  # Cannot evaluate without a maximum age requirement
+    
+    max_age = requirement.numeric_value
+    
+    # Check if we have Patient instances in the original_input_args
+    original_args = kwargs.get('original_input_args', [])
+    for arg in original_args:
+        if isinstance(arg, Patient):
+            patient_age = arg.age()
+            if patient_age is not None and patient_age <= max_age:
+                return True
+        # Handle QuerySets of patients
+        elif hasattr(arg, 'model') and issubclass(arg.model, Patient):
+            for patient in arg:
+                patient_age = patient.age()
+                if patient_age is not None and patient_age <= max_age:
+                    return True
+    
+    return False
+
+
+def dispatch_operator_evaluation(
+    operator_name: str,
+    requirement_links: "RequirementLinks",
+    input_links: "RequirementLinks",
+    **kwargs
+) -> bool:
+    """
+    Dispatches the evaluation to the appropriate function based on the operator name.
+    
+    Args:
+        operator_name: The name of the operator to evaluate.
+        requirement_links: The RequirementLinks object from the Requirement model.
+        input_links: The aggregated RequirementLinks object from the input arguments.
+        **kwargs: Additional keyword arguments for specific operator logic.
+                    For lab value operators, this includes 'requirement' (the Requirement model instance).
+
+    Returns:
+        True if the condition defined by the operator is met, False otherwise.
+        
+    Raises:
+        NotImplementedError: If the evaluation logic for the operator's name is not implemented.
+    """
+    from .lab_value_operators import LAB_VALUE_OPERATOR_FUNCTIONS
+    from endoreg_db.models.requirement.requirement import Requirement # Runtime import for isinstance
+
+    eval_func = None
+    requirement = kwargs.get("requirement") # Get requirement for operators that need it
+
+    if operator_name == "models_match_any":
+        eval_func = _evaluate_models_match_any
+        return eval_func(
+            requirement_links=requirement_links,
+            input_links=input_links,
+            **kwargs
+        )
+    elif operator_name == "models_match_all":
+        eval_func = _evaluate_models_match_all
+        return eval_func(
+            requirement_links=requirement_links,
+            input_links=input_links,
+            **kwargs
+        )
+    elif operator_name == "models_match_any_in_timeframe":
+        # 'requirement' is already extracted from kwargs via requirement = kwargs.get("requirement")
+        if not isinstance(requirement, Requirement): # Ensure requirement is present and correct type
+            raise ValueError("models_match_any_in_timeframe operator requires a valid 'requirement' instance in kwargs.")
+        
+        # Create a new kwargs dict for the call, excluding 'requirement' to avoid passing it twice,
+        # as it's already an explicit parameter for _evaluate_models_match_any_in_timeframe.
+        kwargs_for_eval = {k: v for k, v in kwargs.items() if k != 'requirement'}
+        
+        eval_func = _evaluate_models_match_any_in_timeframe
+        return eval_func(
+            requirement_links=requirement_links,
+            input_links=input_links,
+            requirement=requirement, # Pass the requirement instance explicitly
+            **kwargs_for_eval      # Pass the remaining kwargs
+        )
+    elif operator_name in LAB_VALUE_OPERATOR_FUNCTIONS:
+        if not isinstance(requirement, Requirement): # Ensure requirement is present and correct type
+            raise ValueError(f"Lab value operator \'{operator_name}\' requires a valid 'requirement' instance in kwargs.")
+        
+        eval_func = LAB_VALUE_OPERATOR_FUNCTIONS[operator_name]
+        return eval_func(
+            input_links=input_links,
+            requirement=requirement, 
+            operator_kwargs=kwargs
+        )
+    elif operator_name == "age_gte":
+        if not isinstance(requirement, Requirement):
+            raise ValueError("age_gte operator requires a valid 'requirement' instance in kwargs.")
+        
+        # Create a new kwargs dict for the call, excluding 'requirement' to avoid passing it twice
+        kwargs_for_eval = {k: v for k, v in kwargs.items() if k != 'requirement'}
+        
+        return _evaluate_age_gte(
+            requirement_links=requirement_links,
+            input_links=input_links,
+            requirement=requirement,
+            **kwargs_for_eval
+        )
+    elif operator_name == "age_lte":
+        if not isinstance(requirement, Requirement):
+            raise ValueError("age_lte operator requires a valid 'requirement' instance in kwargs.")
+        
+        # Create a new kwargs dict for the call, excluding 'requirement' to avoid passing it twice
+        kwargs_for_eval = {k: v for k, v in kwargs.items() if k != 'requirement'}
+        
+        return _evaluate_age_lte(
+            requirement_links=requirement_links,
+            input_links=input_links,
+            requirement=requirement,
+            **kwargs_for_eval
+        )
+    else:
+        raise NotImplementedError(f"Evaluation logic for operator '{operator_name}' is not implemented.")

endoreg_db/utils/setup_config.py

@@ -0,0 +1,177 @@
+"""
+Configuration loader for EndoReg DB setup.
+Handles loading and parsing of setup configuration from YAML files.
+"""
+
+import glob
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+class SetupConfig:
+    """
+    Handles loading and accessing setup configuration from YAML files.
+    Provides methods to get model names, search patterns, and fallback configurations.
+    """
+
+    def __init__(self, config_file: Optional[Path] = None):
+        """
+        Initialize the setup configuration.
+
+        Args:
+            config_file: Path to the setup configuration YAML file.
+                        If None, uses default location.
+        """
+        if config_file is None:
+            # Default to setup_config.yaml in data directory
+            config_file = Path(__file__).parent.parent / "data" / "setup_config.yaml"
+
+        self.config_file = config_file
+        self._config = self._load_config()
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from YAML file."""
+        try:
+            if self.config_file.exists():
+                with open(self.config_file, "r") as f:
+                    config = yaml.safe_load(f)
+                    logger.info(f"Loaded setup configuration from {self.config_file}")
+                    return config or {}
+            else:
+                logger.warning(f"Setup config file not found: {self.config_file}")
+                return self._get_default_config()
+        except Exception as e:
+            logger.error(f"Error loading setup config: {e}")
+            return self._get_default_config()
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Return default configuration if file is not available."""
+        return {
+            "default_models": {
+                "primary_classification_model": "image_multilabel_classification_colonoscopy_default",
+                "primary_labelset": "multilabel_classification_colonoscopy_default",
+            },
+            "huggingface_fallback": {
+                "enabled": True,
+                "repo_id": "wg-lux/colo_segmentation_RegNetX800MF_base",
+                "filename": "colo_segmentation_RegNetX800MF_base.ckpt",
+                "labelset_name": "multilabel_classification_colonoscopy_default",
+            },
+            "weights_search_patterns": [
+                "colo_segmentation_RegNetX800MF_*.ckpt",
+                "image_multilabel_classification_colonoscopy_default_*.ckpt",
+                "*_colonoscopy_*.ckpt",
+            ],
+            "weights_search_dirs": ["tests/assets", "assets", "data/storage/model_weights", "${STORAGE_DIR}/model_weights"],
+            "auto_generation_defaults": {
+                "activation": "sigmoid",
+                "mean": "0.485,0.456,0.406",
+                "std": "0.229,0.224,0.225",
+                "size_x": 224,
+                "size_y": 224,
+                "axes": "CHW",
+                "batchsize": 32,
+                "num_workers": 4,
+            },
+        }
+
+    def get_primary_model_name(self) -> str:
+        """Get the primary classification model name."""
+        return self._config.get("default_models", {}).get("primary_classification_model", "image_multilabel_classification_colonoscopy_default")
+
+    def get_primary_labelset_name(self) -> str:
+        """Get the primary labelset name."""
+        return self._config.get("default_models", {}).get("primary_labelset", "multilabel_classification_colonoscopy_default")
+
+    def get_huggingface_config(self) -> Dict[str, Any]:
+        """Get HuggingFace fallback configuration."""
+        return self._config.get("huggingface_fallback", {})
+
+    def get_weights_search_patterns(self) -> List[str]:
+        """Get weight file search patterns."""
+        return self._config.get("weights_search_patterns", ["colo_segmentation_RegNetX800MF_*.ckpt", "*_colonoscopy_*.ckpt"])
+
+    def get_weights_search_dirs(self) -> List[Path]:
+        """
+        Get weight file search directories with environment variable substitution.
+        """
+        dirs = self._config.get("weights_search_dirs", [])
+        resolved_dirs = []
+
+        for dir_str in dirs:
+            # Handle environment variable substitution
+            if "${" in dir_str:
+                dir_str = os.path.expandvars(dir_str)
+
+            resolved_dirs.append(Path(dir_str))
+
+        return resolved_dirs
+
+    def get_auto_generation_defaults(self) -> Dict[str, Any]:
+        """Get default values for auto-generated metadata."""
+        return self._config.get("auto_generation_defaults", {})
+
+    def find_model_weights_files(self) -> List[Path]:
+        """
+        Find model weight files using configured search patterns and directories.
+
+        Returns:
+            List of paths to found weight files
+        """
+        found_files = []
+        search_dirs = self.get_weights_search_dirs()
+        search_patterns = self.get_weights_search_patterns()
+
+        for search_dir in search_dirs:
+            if not search_dir.exists():
+                continue
+
+            for pattern in search_patterns:
+                # Use glob to find files matching pattern
+                pattern_path = search_dir / pattern
+                matches = glob.glob(str(pattern_path))
+                for match in matches:
+                    path = Path(match)
+                    if path.exists() and path not in found_files:
+                        found_files.append(path)
+                        logger.info(f"Found weight file: {path}")
+
+        return found_files
+
+    def get_model_specific_config(self, model_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get model-specific configuration from YAML metadata files.
+
+        Args:
+            model_name: Name of the model to get config for
+
+        Returns:
+            Model-specific setup configuration if found
+        """
+        # This would need to parse the ai_model_meta YAML files
+        # and extract setup_config sections for the specified model
+        try:
+            from endoreg_db.data import AI_MODEL_META_DATA_DIR
+
+            for yaml_file in AI_MODEL_META_DATA_DIR.glob("*.yaml"):
+                with open(yaml_file, "r") as f:
+                    data = yaml.safe_load(f)
+
+                if isinstance(data, list):
+                    for item in data:
+                        if item.get("fields", {}).get("name") == model_name or item.get("fields", {}).get("model") == model_name:
+                            return item.get("setup_config", {})
+        except Exception as e:
+            logger.warning(f"Error loading model-specific config for {model_name}: {e}")
+
+        return None
+
+
+# Global instance for easy access
+setup_config = SetupConfig()

endoreg_db/utils/translation.py

@@ -0,0 +1,27 @@
+def build_multilingual_response(obj, include_choices=False, classification_id=None):
+    """
+    Helper to build a multilingual response dict for an object.
+    If include_choices is True, adds a 'choices' key with multilingual dicts for each choice.
+    If classification_id is given, adds 'classificationId' to each choice.
+    """
+    data = {
+        'id': obj.id,
+        'name': getattr(obj, 'name', ''),
+        'name_de': getattr(obj, 'name_de', ''),
+        'name_en': getattr(obj, 'name_en', ''),
+        'description': getattr(obj, 'description', ''),
+        'description_de': getattr(obj, 'description_de', ''),
+        'description_en': getattr(obj, 'description_en', ''),
+    }
+    if hasattr(obj, 'required'):
+        data['required'] = getattr(obj, 'required', True)
+    if include_choices:
+        data['choices'] = [
+            build_multilingual_response(choice, include_choices=False, classification_id=classification_id or obj.id)
+            for choice in obj.get_choices()
+        ]
+        for choice_dict in data['choices']:
+            choice_dict['classificationId'] = classification_id or obj.id
+    if classification_id is not None and not include_choices:
+        data['classificationId'] = classification_id
+    return data

endoreg_db/utils/uuid.py

@@ -0,0 +1,4 @@
+import uuid
+
+def get_uuid():
+    return uuid.uuid4()

endoreg_db/utils/validate_endo_roi.py

@@ -0,0 +1,19 @@
+def validate_endo_roi(endo_roi_dict:dict):
+    """
+    Validate endoscope ROI dictionary. The dictionary must have the following
+    keys: x, y, width, height. The values must be greater than or equal to 0
+    for x and y, and greater than 0 for width and height.
+    """
+    for key, value in endo_roi_dict.items():
+        if key == "x":
+            assert value >= 0, f"Endoscope ROI x value must be greater than or equal to 0. Got {value}"
+        elif key == "y":
+            assert value >= 0, f"Endoscope ROI y value must be greater than or equal to 0. Got {value}"
+        elif key == "width":
+            assert value > 0, f"Endoscope ROI width value must be greater than 0. Got {value}"
+        elif key == "height":
+            assert value > 0, f"Endoscope ROI height value must be greater than 0. Got {value}"
+        else:
+            raise ValueError(f"Endoscope ROI key {key} not recognized")
+
+    return True