endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/utils/requirement_operator_logic/new_operator_logic.py

@@ -0,0 +1,114 @@
+from typing import TYPE_CHECKING, Any, Tuple, Union
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Patient, PatientExamination, Requirement
+    from endoreg_db.models.requirement.requirement_operator import OperatorInstructions
+
+
+def fetch_input_target(
+    input_object: Union["Patient", "PatientExamination"],
+    operator_instructions: "OperatorInstructions",
+) -> Tuple[str, Any]:
+    input_target_names = operator_instructions.input_targets
+
+    # Iterate over targets and stop with first successful fetch
+    for input_target in input_target_names:
+        # separate input_target using "." for nested attributes
+        attributes = input_target.split(".")
+        current_value = input_object
+        try:
+            for attr in attributes:
+                current_value = getattr(current_value, attr)
+            return (input_target, current_value)
+        except AttributeError:
+            continue  # Try next input target
+
+    raise AttributeError(
+        f"None of the input targets {input_target_names} could be resolved on the input object."
+    )
+
+
+def fetch_requirement_targets(
+    requirement: "Requirement",
+    operator_instructions: "OperatorInstructions",
+):
+    attribute_target_names = operator_instructions.requirement_targets
+    target_values = {}
+
+    for target_name in attribute_target_names:
+        try:
+            target_value = getattr(requirement, target_name)
+            target_values[target_name] = target_value
+        except AttributeError:
+            raise AttributeError(
+                f"Requirement does not have attribute '{target_name}'."
+            )
+        target_values[target_name] = target_value
+
+    return target_values
+
+
+def model_attribute_set_any(
+    input_object: Any,
+    operator_instructions: "OperatorInstructions",
+    requirement: "Requirement",
+) -> bool:
+    input_target_name, input_value = fetch_input_target(
+        input_object, operator_instructions
+    )
+
+    if not input_value:
+        return False
+    else:
+        return True
+
+
+def model_attribute_numeric_in_range(
+    input_object: Any,
+    operator_instructions: "OperatorInstructions",
+    requirement: "Requirement",
+) -> bool:
+    input_target_name, input_value = fetch_input_target(
+        input_object, operator_instructions
+    )
+
+    # make sure, input_value is numeric
+    try:
+        numeric_value = float(input_value)
+    except (TypeError, ValueError):
+        raise ValueError(
+            f"Input value for target '{input_target_name}' is not numeric: {input_value}"
+        )
+
+    _min = requirement.numeric_value_min
+    _max = requirement.numeric_value_max
+
+    assert _min is not None and _max is not None, (
+        "Numeric range requires both min and max values to be set."
+    )
+
+    return_value = _min <= numeric_value <= _max
+    return return_value
+
+
+def model_attribute_is_among_values(
+    input_object: Any,
+    operator_instructions: "OperatorInstructions",
+    requirement: "Requirement",
+) -> bool:
+    input_target_name, input_value = fetch_input_target(
+        input_object, operator_instructions
+    )
+    target_values = fetch_requirement_targets(requirement, operator_instructions)
+
+    for target_name, target_values in target_values.items():
+        if input_value in target_values:
+            return True
+    return False
+
+
+REQUIREMENT_OPERATORS = {
+    "model_attribute_set_any": model_attribute_set_any,
+    "model_attribute_numeric_in_range": model_attribute_numeric_in_range,
+    "model_attribute_is_among_values": model_attribute_is_among_values,
+}

endoreg_db/utils/setup_config.py

@@ -0,0 +1,196 @@
+"""
+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.safetensors",
+                "labelset_name": "multilabel_classification_colonoscopy_default",
+            },
+            "weights_search_patterns": [
+                "colo_segmentation_RegNetX800MF_*.safetensors",
+                "image_multilabel_classification_colonoscopy_default_*.safetensors",
+                "*_colonoscopy_*.safetensors",
+            ],
+            "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_*.safetensors",
+                "*_colonoscopy_*.safetensors",
+            ],
+        )
+
+    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/storage.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import shutil
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Iterator, Optional
+
+from django.core.files import File
+from django.db.models.fields.files import FieldFile
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_CHUNK_SIZE = 1024 * 1024  # 1 MiB
+
+
+def _has_field_file(field_file: Optional[FieldFile]) -> bool:
+    return bool(field_file and getattr(field_file, "name", None))
+
+
+def _resolve_local_path(field_file: FieldFile) -> Optional[Path]:
+    try:
+        return Path(field_file.path)
+    except (NotImplementedError, AttributeError, ValueError):
+        return None
+
+
+def file_exists(field_file: Optional[FieldFile]) -> bool:
+    if not _has_field_file(field_file):
+        return False
+    try:
+        return field_file.storage.exists(field_file.name)
+    except Exception as exc:  # pragma: no cover - storage backend failure
+        logger.warning("Failed to check file existence for %s: %s", field_file, exc)
+        return False
+
+
+@contextlib.contextmanager
+def ensure_local_file(
+    field_file: FieldFile,
+    *,
+    suffix: str | None = None,
+    chunk_size: int = _DEFAULT_CHUNK_SIZE,
+) -> Iterator[Path]:
+    if not _has_field_file(field_file):
+        raise FileNotFoundError("FieldFile is empty or has no associated storage name.")
+
+    local_path = _resolve_local_path(field_file)
+    if local_path is not None and local_path.exists():
+        yield local_path
+        return
+
+    suffix = suffix or Path(field_file.name).suffix
+    tmp_file: NamedTemporaryFile
+    with NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
+        temp_path = Path(tmp_file.name)
+        try:
+            with field_file.storage.open(field_file.name, "rb") as source:
+                shutil.copyfileobj(source, tmp_file, length=chunk_size)
+        except Exception as exc:
+            temp_path.unlink(missing_ok=True)
+            raise IOError(
+                f"Could not download {field_file.name} from storage to a local file"
+            ) from exc
+
+    try:
+        yield temp_path
+    finally:
+        temp_path.unlink(missing_ok=True)
+
+
+def delete_field_file(
+    field_file: Optional[FieldFile],
+    *,
+    missing_ok: bool = True,
+    save: bool = False,
+) -> bool:
+    if not _has_field_file(field_file):
+        return False
+    try:
+        field_file.delete(save=save)
+        return True
+    except FileNotFoundError:
+        if missing_ok:
+            return False
+        raise
+    except Exception as exc:  # pragma: no cover - backend specific errors
+        if missing_ok:
+            logger.warning("Failed to delete %s from storage: %s", field_file, exc)
+            return False
+        raise
+
+
+def save_local_file(
+    field_file: FieldFile,
+    source_path: Path,
+    *,
+    name: Optional[str] = None,
+    save: bool = False,
+    chunk_size: int = _DEFAULT_CHUNK_SIZE,
+) -> str:
+    if not source_path.exists():
+        raise FileNotFoundError(f"Source path does not exist: {source_path}")
+
+    filename = name or source_path.name
+    with source_path.open("rb") as source:
+        django_file = File(source, name=filename)
+        return field_file.save(filename, django_file, save=save)
+
+
+__all__ = [
+    "delete_field_file",
+    "ensure_local_file",
+    "file_exists",
+    "save_local_file",
+]

endoreg_db/utils/translation.py

@@ -0,0 +1,31 @@
+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,5 @@
+import uuid
+
+
+def get_uuid():
+    return uuid.uuid4()

endoreg_db/utils/validate_endo_roi.py

@@ -0,0 +1,33 @@
+from typing import Dict, Union
+
+
+def validate_endo_roi(endo_roi_dict: Union[Dict[str, int], None]):
+    """
+    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.
+    """
+    if not endo_roi_dict:
+        return False
+
+    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

endoreg_db/utils/validate_subcategory_dict.py

@@ -0,0 +1,93 @@
+from endoreg_db.models import Unit
+
+
+def validate_subcategory_dict(self, subcategory_dict: dict = None):
+    if subcategory_dict is None:
+        return False
+
+    if not isinstance(subcategory_dict, dict):
+        return False
+
+    # check if key choices exists and is a list of strings
+    if "choices" not in subcategory_dict:
+        return False
+
+    if not isinstance(subcategory_dict["choices"], list):
+        return False
+
+    for choice in subcategory_dict["choices"]:
+        if not isinstance(choice, str):
+            return False
+
+    # check if key default exists and is a string
+    if "default" not in subcategory_dict:
+        return False
+
+    if not isinstance(subcategory_dict["default"], str):
+        return False
+
+    # check if default is in choices
+    if subcategory_dict["default"] not in subcategory_dict["choices"]:
+        return False
+
+    if not subcategory_dict["required"]:
+        return False
+
+    return True
+
+
+def validate_numerical_descriptor(self, numerical_descriptor_dict: dict = None):
+    # Check if numerical_descriptor_dict is None
+    error_message = ""
+    if numerical_descriptor_dict is None:
+        error_message = "numerical_descriptor_dict is None"
+        return False, error_message
+
+    # Check if numerical_descriptor_dict is a dictionary
+    if not isinstance(numerical_descriptor_dict, dict):
+        error_message = "numerical_descriptor_dict is not a dictionary"
+        return False, error_message
+
+    # if key unit exists and is a string and Unit object with that name exists
+    if "unit" not in numerical_descriptor_dict:
+        error_message = "unit key does not exist in numerical_descriptor_dict"
+        return False, error_message
+
+    elif not isinstance(numerical_descriptor_dict["unit"], str):
+        error_message = "unit key is not a string"
+        return False, error_message
+
+    elif not Unit.objects.filter(name=numerical_descriptor_dict["unit"]).exists():
+        error_message = "Unit object with that name does not exist"
+        return False, error_message
+
+    if "required" not in numerical_descriptor_dict:
+        error_message = "required key does not exist in numerical_descriptor_dict"
+        return False, error_message
+
+    elif not isinstance(numerical_descriptor_dict["required"], bool):
+        error_message = "required key is not a boolean"
+        return False, error_message
+
+    # check if min, max, mean, std exist and are either None or float
+    for key in ["min", "max", "mean", "std", "default"]:
+        if key not in numerical_descriptor_dict:
+            error_message = f"{key} key does not exist in numerical_descriptor_dict"
+            return False, error_message
+
+        if numerical_descriptor_dict[key] is not None and not isinstance(
+            numerical_descriptor_dict[key], float
+        ):
+            error_message = f"{key} key is not a float"
+            return False, error_message
+
+    # check if distribution exists and is either "normal" or "uniform"
+    if "distribution" not in numerical_descriptor_dict:
+        error_message = "distribution key does not exist in numerical_descriptor_dict"
+        return False, error_message
+
+    if numerical_descriptor_dict["distribution"] not in ["normal", "uniform"]:
+        error_message = "distribution key is not either 'normal' or 'uniform'"
+        return False, error_message
+
+    return True, None