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

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)