endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/utils/requirement_operator_logic/new_operator_logic.py

@@ -0,0 +1,97 @@
+from typing import TYPE_CHECKING, Any, Dict, Tuple, Union
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Patient, PatientExamination, Requirement
+    from endoreg_db.models.requirement.requirement_operator import OperatorInstructions, RequirementOperator
+
+
+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

@@ -60,13 +60,13 @@ class SetupConfig:
             "huggingface_fallback": {
                 "enabled": True,
                 "repo_id": "wg-lux/colo_segmentation_RegNetX800MF_base",
-                "filename": "colo_segmentation_RegNetX800MF_base.ckpt",
+                "filename": "colo_segmentation_RegNetX800MF_base.safetensors",
                 "labelset_name": "multilabel_classification_colonoscopy_default",
             },
             "weights_search_patterns": [
-                "colo_segmentation_RegNetX800MF_*.ckpt",
-                "image_multilabel_classification_colonoscopy_default_*.ckpt",
-                "*_colonoscopy_*.ckpt",
+                "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": {
@@ -95,7 +95,10 @@ class SetupConfig:
 
     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"])
+        return self._config.get(
+            "weights_search_patterns",
+            ["colo_segmentation_RegNetX800MF_*.safetensors", "*_colonoscopy_*.safetensors"],
+        )
 
     def get_weights_search_dirs(self) -> List[Path]:
         """

endoreg_db/utils/storage.py

@@ -0,0 +1,115 @@
+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/validate_endo_roi.py

@@ -1,9 +1,15 @@
-def validate_endo_roi(endo_roi_dict:dict):
+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}"
@@ -16,4 +22,4 @@ def validate_endo_roi(endo_roi_dict:dict):
         else:
             raise ValueError(f"Endoscope ROI key {key} not recognized")
 
-    return True
+    return True