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

endoreg_db/utils/ai/multilabel_classification_net.py

@@ -1,10 +1,22 @@
+import logging
+from pathlib import Path
+
 import torch
 from torchvision import models
 import torch.nn as nn
 from pytorch_lightning import LightningModule
 import numpy as np
+from safetensors.torch import load_file
 from sklearn.metrics import precision_score, recall_score, f1_score
 
+try:  # Torchvision >= 0.13 exposes explicit weight enums
+    from torchvision.models import EfficientNet_B4_Weights, RegNet_X_800MF_Weights
+except ImportError:  # pragma: no cover - compatibility with older torchvision
+    EfficientNet_B4_Weights = None
+    RegNet_X_800MF_Weights = None
+
+logger = logging.getLogger(__name__)
+
 METRICS_ON_STEP = False
 
 
@@ -41,6 +53,29 @@ def calculate_metrics(pred, target, threshold=0.5):
     }
 
 
+def _load_torchvision_backbone(factory, *, weights_enum=None, load_pretrained=False):
+    """Instantiate a torchvision model without triggering unwanted downloads."""
+    if weights_enum is not None:
+        try:
+            weights = weights_enum.DEFAULT if load_pretrained else None
+            return factory(weights=weights)
+        except (TypeError, AttributeError):
+            # Fall back to legacy keyword on older torchvision versions
+            pass
+
+    try:
+        return factory(pretrained=load_pretrained)
+    except TypeError:
+        # Newer torchvision versions removed the pretrained kwarg; call without hints
+        try:
+            return factory()
+        except Exception as exc:  # pragma: no cover - surfaced to caller for visibility
+            raise RuntimeError(
+                "Failed to instantiate torchvision backbone with load_pretrained="
+                f"{load_pretrained}."
+            ) from exc
+
+
 class MultiLabelClassificationNet(LightningModule):
     def __init__(
         self,
@@ -49,26 +84,40 @@ class MultiLabelClassificationNet(LightningModule):
         weight_decay=0.001,
         pos_weight=2,
         model_type="EfficientNetB4",
+        load_imagenet_weights: bool = False,
+        track_hparams: bool = True,
     ):
         super().__init__()
-        self.save_hyperparameters()
-        self.model_type = "RegNetX800MF"  # model_type
-        self.labels = labels
-        self.n_classes = len(labels)
-        self.val_preds = []
-        self.val_targets = []
+        if track_hparams:
+            self.save_hyperparameters()
+        if labels is None:
+            raise ValueError("labels must be provided to initialize MultiLabelClassificationNet")
+
+        self.model_type = model_type
+        self.labels = list(labels)
+        self.n_classes = len(self.labels)
+        self.val_preds: list[np.ndarray] = []
+        self.val_targets: list[np.ndarray] = []
         self.pos_weight = pos_weight
         self.weight_decay = weight_decay
         self.lr = lr
         self.sigm = nn.Sigmoid()
 
         if model_type == "EfficientNetB4":
-            self.model = models.efficientnet_b4(pretrained=True)
+            self.model = _load_torchvision_backbone(
+                models.efficientnet_b4,
+                weights_enum=EfficientNet_B4_Weights,
+                load_pretrained=load_imagenet_weights,
+            )
             num_ftrs = self.model.classifier[1].in_features
             self.model.classifier[1] = nn.Linear(num_ftrs, len(labels))
 
         elif model_type == "RegNetX800MF":
-            self.model = models.regnet_x_800mf(pretrained=True)
+            self.model = _load_torchvision_backbone(
+                models.regnet_x_800mf,
+                weights_enum=RegNet_X_800MF_Weights,
+                load_pretrained=load_imagenet_weights,
+            )
             num_ftrs = self.model.fc.in_features
             self.model.fc = nn.Linear(num_ftrs, len(labels))
 
@@ -78,10 +127,47 @@ class MultiLabelClassificationNet(LightningModule):
 
     @classmethod
     def load_from_checkpoint(cls, checkpoint_path, *args, **kwargs):
-        instance = super(MultiLabelClassificationNet, cls).load_from_checkpoint(
+        path = Path(checkpoint_path)
+        suffix = path.suffix.lower()
+
+        if suffix == ".safetensors":
+            map_location = kwargs.pop("map_location", "cpu")
+            strict = kwargs.pop("strict", True)
+            labels = kwargs.pop("labels", None)
+            if not labels:
+                raise ValueError("labels must be provided when loading .safetensors checkpoints")
+            model_type = kwargs.pop("model_type", None) or "EfficientNetB4"
+            load_imagenet = kwargs.pop("load_imagenet_weights", False)
+
+            device = torch.device(map_location) if map_location is not None else torch.device("cpu")
+            if isinstance(device, torch.device):
+                device_hint = f"{device.type}:{device.index}" if device.index is not None else device.type
+            else:
+                device_hint = device
+
+            state_dict = load_file(path, device=device_hint)
+
+            instance = cls(
+                labels=labels,
+                model_type=model_type,
+                load_imagenet_weights=load_imagenet,
+                track_hparams=False,
+                *args,
+                **kwargs,
+            )
+            missing, unexpected = instance.load_state_dict(state_dict, strict=strict)
+
+            if missing:
+                logger.warning("Missing parameters when loading %s: %s", path, missing)
+            if unexpected:
+                logger.warning("Unexpected parameters when loading %s: %s", path, unexpected)
+
+            instance.to(device)
+            return instance
+
+        return super(MultiLabelClassificationNet, cls).load_from_checkpoint(
             checkpoint_path, *args, **kwargs
         )
-        return instance
 
     def forward(self, x):  # pylint: disable=arguments-differ
         x = self.model(x)
@@ -113,18 +199,24 @@ class MultiLabelClassificationNet(LightningModule):
 
     def validation_epoch_end(self, _outputs):
         """Called at the end of validation to aggregate outputs"""
-        self.val_preds = np.concatenate([_ for _ in self.val_preds])
-        self.val_targets = np.concatenate([_ for _ in self.val_targets])
-
-        metrics = calculate_metrics(self.val_preds, self.val_targets, threshold=0.5)
-        for key, value in metrics.items():
-            value = value.tolist()
-            if isinstance(value, list):
-                for i, _value in enumerate(value):
+        val_preds_np = np.concatenate(self.val_preds)
+        val_targets_np = np.concatenate(self.val_targets)
+
+        metrics = calculate_metrics(val_preds_np, val_targets_np, threshold=0.5)
+        for key, metric_value in metrics.items():
+            if isinstance(metric_value, np.ndarray):
+                processed_value = metric_value.tolist()
+            elif isinstance(metric_value, (list, tuple)):
+                processed_value = list(metric_value)
+            else:
+                processed_value = float(metric_value)
+
+            if isinstance(processed_value, list):
+                for i, single_value in enumerate(processed_value):
                     name = "val/" + f"{key}/{self.labels[i]}"
                     self.log(
                         name,
-                        _value,
+                        float(single_value),
                         on_epoch=True,
                         on_step=METRICS_ON_STEP,
                         prog_bar=False,
@@ -132,7 +224,11 @@ class MultiLabelClassificationNet(LightningModule):
             else:
                 name = "val/" + f"{key}"
                 self.log(
-                    name, value, on_epoch=True, on_step=METRICS_ON_STEP, prog_bar=True
+                    name,
+                    float(processed_value),
+                    on_epoch=True,
+                    on_step=METRICS_ON_STEP,
+                    prog_bar=True,
                 )
 
         self.val_preds = []

endoreg_db/utils/case_generator/__init__.py

@@ -0,0 +1,3 @@
+"""Legacy case generator utilities based on deprecated case templates."""
+
+__all__: list[str] = []

endoreg_db/utils/dataloader.py

@@ -3,7 +3,6 @@ import yaml
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import OperationalError, transaction
 
-
 def load_model_data_from_yaml(command, model_name, metadata, verbose):
     """
     Load model data from YAML files.
@@ -20,6 +19,7 @@ def load_model_data_from_yaml(command, model_name, metadata, verbose):
     dir_path = metadata["dir"]
     foreign_keys = metadata["foreign_keys"]
     foreign_key_models = metadata["foreign_key_models"]
+    validators = metadata.get("validators", [])
 
     _files = [f for f in os.listdir(dir_path) if f.endswith(".yaml")]
     # sort
@@ -29,12 +29,18 @@ def load_model_data_from_yaml(command, model_name, metadata, verbose):
             yaml_data = yaml.safe_load(file)
 
         load_data_with_foreign_keys(
-            command, model, yaml_data, foreign_keys, foreign_key_models, verbose
+            command, model, yaml_data, foreign_keys, foreign_key_models, validators, verbose
         )
 
 
 def load_data_with_foreign_keys(
-    command, model, yaml_data, foreign_keys, foreign_key_models, verbose
+    command,
+    model,
+    yaml_data,
+    foreign_keys,
+    foreign_key_models,
+    validators,
+    verbose,
 ):
     """
     Load YAML data into Django model instances with FK and M2M support.
@@ -52,13 +58,34 @@ def load_data_with_foreign_keys(
         yaml_data: A list of dictionaries representing YAML entries.
         foreign_keys: A list of foreign key field names to process from each entry.
         foreign_key_models: The corresponding Django model classes for each foreign key.
+        validators: A sequence of callables invoked before persisting each entry. Each
+            validator receives a shallow copy of the entry's field dictionary along with
+            the original entry and model for context.
         verbose: If True, prints detailed output and warnings during processing.
     """
     for entry in yaml_data:
-        fields = entry.get("fields", {})
+        raw_fields = entry.get("fields", {})
+
+        for validator in validators:
+            validator(dict(raw_fields), entry=entry, model=model)
+
+        fields = dict(raw_fields)
         name = fields.pop("name", None)
 
 
+        if getattr(model, "_meta", None) and model._meta.model_name == "requirement":
+            requirement_types = fields.get("requirement_types", [])
+            operators = fields.get("operators", [])
+        
+            if not requirement_types:
+                raise ValueError(
+                    f"Requirement '{name}' must define at least one requirement_types entry."
+                )
+            if not operators:
+                raise ValueError(
+                    f"Requirement '{name}' must define at least one operators entry."
+                )
+                      
         ####################
         #TODO REMOVE AFTER TRANSLATION SUPPORT IS ADDED
         SKIP_NAMES=[
@@ -73,7 +100,7 @@ def load_data_with_foreign_keys(
         for skip_name in SKIP_NAMES:
             if skip_name in fields:
                 fields.pop(skip_name)
-        ########################
+        # ########################
 
         m2m_relationships = {}  # Store many-to-many relationships
         # print(entry)
@@ -113,19 +140,60 @@ def load_data_with_foreign_keys(
                     related_objects.append(obj)
                 m2m_relationships[fk_field] = related_objects
             else:  # Single foreign key relationship
-                try:
-                    obj = fk_model.objects.get_by_natural_key(target_keys)
-                except ObjectDoesNotExist:
-                    if verbose:
-                        command.stdout.write(
-                            command.style.WARNING(
-                                f"{fk_model.__name__} with key {target_keys} not found"
+                if (
+                    model.__name__ == "ModelMeta"
+                    and fk_field == "labelset"
+                ):
+                    labelset_version = fields.pop("labelset_version", None)
+
+                    if isinstance(target_keys, (tuple, list)):
+                        labelset_name = target_keys[0] if target_keys else None
+                        if len(target_keys) > 1 and labelset_version in (None, ""):
+                            labelset_version = target_keys[1]
+                    else:
+                        labelset_name = target_keys
+
+                    if not labelset_name:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING("LabelSet name missing for ModelMeta entry")
                             )
-                        )
-                    continue
-                fields[fk_field] = obj
+                        continue
+
+                    queryset = fk_model.objects.filter(name=labelset_name)
+                    if labelset_version not in (None, "", -1):
+                        try:
+                            version_value = int(labelset_version)
+                        except (TypeError, ValueError):
+                            version_value = labelset_version
+                        queryset = queryset.filter(version=version_value)
+
+                    obj = queryset.order_by("-version").first()
+                    if obj is None:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING(
+                                    f"LabelSet '{labelset_name}' (version={labelset_version}) not found"
+                                )
+                            )
+                        continue
+                    fields[fk_field] = obj
+                else:
+                    try:
+                        obj = fk_model.objects.get_by_natural_key(target_keys)
+                    except ObjectDoesNotExist:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING(
+                                    f"{fk_model.__name__} with key {target_keys} not found"
+                                )
+                            )
+                        continue
+                    fields[fk_field] = obj
 
         # Create or update the main object (avoid update_or_create to prevent SQLite locks)
+        version_value = fields.get("version")
+
         def _save_instance():
             if name is None:
                 # Try to find an existing object by all provided fields
@@ -136,7 +204,11 @@ def load_data_with_foreign_keys(
                 else:
                     created = False
             else:
-                obj = model.objects.filter(name=name).first()
+                lookup_kwargs = {"name": name}
+                if model.__name__ == "LabelSet" and version_value is not None:
+                    lookup_kwargs["version"] = version_value
+
+                obj = model.objects.filter(**lookup_kwargs).first()
                 if obj is None:
                     obj = model.objects.create(name=name, **fields)
                     created = True

endoreg_db/utils/defaults/set_default_center.py

@@ -0,0 +1,32 @@
+import subprocess
+from endoreg_db.models.administration.center import center
+
+# Start process with interactive pipes
+proc = subprocess.Popen(
+    ["python3", "-i"],  # or your target program
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE,
+    stderr=subprocess.STDOUT,
+    text=True,
+    bufsize=1
+)
+
+proc.stdin.write("print('Trying to extract...')\n")
+proc.stdin.flush()
+
+try:
+    subprocess.run(["python", "manage.py", "load_center_data"], check=True)
+    proc.stdout.write("print('found center')")
+except subprocess.CalledProcessError as e:
+    proc.stdout.write("print('Didn't find center. Please add it to endoreg_db luxnix or via export DEFAULT_CENTER")
+# """
+# Future Implementation using dialogue
+#"""
+# # Send commands as if from terminal
+# proc.stdin.write("print('You dont have a default center set up yet. Please enter one here.')\n\nprint('Rule: use_this_format_and_connect_words_with_underscore')")
+# proc.stdin.flush()
+
+# # Read responses
+# for _ in range(3):
+#     line = proc.stdout.readline()
+#     print("Selected >>", line.strip())

endoreg_db/utils/names.py

@@ -55,22 +55,28 @@ def create_mock_patient_name(gender: str) -> tuple[str, str]:
 
 
 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.
-    """
+    """Return a normalized gender slug (male|female|unknown) for the given name.
 
-    from endoreg_db.models import Gender
+    Uses :mod:`gender_guesser` to infer gender without touching the database. All
+    detector outputs are mapped onto our canonical slugs so callers can perform
+    their own model lookups or fall back safely.
+    """
 
     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
+    try:
+        detected = detector.get_gender(name or "")
+    except Exception:  # pragma: no cover - defensive, detector is pure-Python
+        detected = None
+
+    if not detected:
+        return "unknown"
+
+    normalized = detected.lower()
+    if normalized in {"male", "mostly_male"}:
+        return "male"
+    if normalized in {"female", "mostly_female"}:
+        return "female"
+
+    # gender-guesser returns "andy" for androgynous names and "unknown" for
+    # unrecognised inputs – both should map to our "unknown" slug.
+    return "unknown"

endoreg_db/utils/permissions.py

@@ -7,7 +7,7 @@ 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 rest_framework.decorators import permission_classes as drf_permission_classes
 from functools import wraps
 import logging
 import os
@@ -50,6 +50,7 @@ def dynamic_permission_classes(force_auth=None):
             - None: Use environment-based logic (default)
     """
     def decorator(view_func):
+        from rest_framework.decorators import permission_classes as drf_permission_classes
         @wraps(view_func)
         def wrapper(*args, **kwargs):
             return view_func(*args, **kwargs)

endoreg_db/utils/pipelines/process_video_dir.py

@@ -20,7 +20,7 @@ DEFAULT_DIR = Path(__file__).resolve().parent.parent.parent.parent / "data/study
 CENTER_NAME = os.environ.get("CENTER_NAME", "university_hospital_wuerzburg")
 ENDOSCOPY_PROCESSOR_NAME = os.environ.get("ENDOSCOPY_PROCESSOR_NAME", "olympus_cv_1500")
 MODEL_NAME = "image_multilabel_classification_colonoscopy_default"
-MODEL_WEIGHTS_PATH = "./tests/assets/colo_segmentation_RegNetX800MF_6.ckpt"
+MODEL_WEIGHTS_PATH = "./tests/assets/colo_segmentation_RegNetX800MF_6.safetensors"
 ic(DEFAULT_DIR)