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

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