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

endoreg_db/services/examination_evaluation.py

@@ -1,13 +1,17 @@
 # app/services/evaluation.py
 from __future__ import annotations
-from typing import Dict, List, Set, Tuple
-from django.db.models import Prefetch
+from typing import List, Set, Tuple
 
-from endoreg_db.schemas.examination_evaluation import ExaminationEvalReport, RequirementSetEval, RequirementEval
+from endoreg_db.schemas.examination_evaluation import (
+    ExaminationEvalReport,
+    RequirementSetEval,
+    RequirementEval,
+)
 from endoreg_db.models.medical.patient.patient_examination import PatientExamination
 from endoreg_db.models.requirement.requirement_set import RequirementSet
 import endoreg_db.services.lookup_service
 
+
 def _get_requirement_sets_for_exam(exam: PatientExamination) -> List[RequirementSet]:
     """
     Decide how an examination maps to requirement sets.
@@ -25,7 +29,10 @@ def _get_requirement_sets_for_exam(exam: PatientExamination) -> List[Requirement
                 sets.append(link.requirement_set)
     return sets
 
-def _eval_requirement(requirement, input_object, mode="loose") -> Tuple[bool, str | None]:
+
+def _eval_requirement(
+    requirement, input_object, mode="loose"
+) -> Tuple[bool, str | None]:
     """
     Evaluate a single Requirement and return (bool, message).
     The `message` can be None or contain a short explanation.
@@ -36,12 +43,19 @@ def _eval_requirement(requirement, input_object, mode="loose") -> Tuple[bool, st
     # Example: msg = requirement.last_reason if hasattr(requirement, "last_reason") else None
     return ok, msg
 
+
 def _reduce_bools(bools: List[bool], set_type_name: str | None) -> bool:
-    from endoreg_db.models.requirement.requirement_set import REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP
+    from endoreg_db.models.requirement.requirement_set import (
+        REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP,
+    )
+
     func = REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP.get(set_type_name or "all", all)
     return bool(func(bools))
 
-def _eval_set_tree(root: RequirementSet, input_object, visited: Set[int]) -> RequirementSetEval:
+
+def _eval_set_tree(
+    root: RequirementSet, input_object, visited: Set[int]
+) -> RequirementSetEval:
     """
     Recursively evaluate a RequirementSet node and linked children.
     Protect against cycles with visited set.
@@ -52,10 +66,12 @@ def _eval_set_tree(root: RequirementSet, input_object, visited: Set[int]) -> Req
         return RequirementSetEval(
             id=root.pk,
             name=root.name,
-            type=(root.requirement_set_type.name if root.requirement_set_type else None),
+            type=(
+                root.requirement_set_type.name if root.requirement_set_type else None
+            ),
             is_satisfied=True,
             requirements=[],
-            linked_sets=[]
+            linked_sets=[],
         )
 
     visited.add(root.pk)
@@ -81,7 +97,9 @@ def _eval_set_tree(root: RequirementSet, input_object, visited: Set[int]) -> Req
 
     # Combine booleans
     bools = [re.satisfied for re in req_evals] + [ce.is_satisfied for ce in child_evals]
-    set_type_name = root.requirement_set_type.name if root.requirement_set_type else "all"
+    set_type_name = (
+        root.requirement_set_type.name if root.requirement_set_type else "all"
+    )
     satisfied = _reduce_bools(bools, set_type_name)
 
     return RequirementSetEval(
@@ -92,20 +110,19 @@ def _eval_set_tree(root: RequirementSet, input_object, visited: Set[int]) -> Req
         requirements=req_evals,
         linked_sets=child_evals,
     )
-    
 
 
 def evaluate_examination(request: dict) -> ExaminationEvalReport:
     """
     Communicates with: components/RequirementGenerator
     Evaluates a PatientExamination by its Lookup. The frontend sends this structure:
-    
-    
+
+
         requirement_set_ids: plainRequirementSetIds,
         lookup_token: lookupToken,
         patient_examination_id: patientExaminationId
     };
-    
+
     And expects a response to be processed like this:
 
             const response = await axiosInstance.post('/api/evaluate-requirements/', payload);
@@ -125,9 +142,9 @@ def evaluate_examination(request: dict) -> ExaminationEvalReport:
             examination_id=None,
             summary={"is_satisfied": True, "failed_count": 0, "total_sets": 0},
             sets=[],
-            errors=["No patient_examination_id provided in request."]
+            errors=["No patient_examination_id provided in request."],
         )
-    
+
     # Use the dedicated loader function from the lookup service.
     exam = endoreg_db.services.lookup_service.load_patient_exam_for_eval(pk=exam_id)
 
@@ -135,7 +152,9 @@ def evaluate_examination(request: dict) -> ExaminationEvalReport:
     sets = _get_requirement_sets_for_exam(exam)
 
     visited: Set[int] = set()
-    set_evals: List[RequirementSetEval] = [_eval_set_tree(s, exam, visited) for s in sets]
+    set_evals: List[RequirementSetEval] = [
+        _eval_set_tree(s, exam, visited) for s in sets
+    ]
 
     # Aggregate summary
     overall = all(se.is_satisfied for se in set_evals) if set_evals else True
@@ -143,7 +162,11 @@ def evaluate_examination(request: dict) -> ExaminationEvalReport:
 
     return ExaminationEvalReport(
         examination_id=exam.pk,
-        summary={"is_satisfied": overall, "failed_count": failed, "total_sets": len(set_evals)},
+        summary={
+            "is_satisfied": overall,
+            "failed_count": failed,
+            "total_sets": len(set_evals),
+        },
         sets=set_evals,
         errors=[],  # fill with any global issues you detect
     )

endoreg_db/services/model_meta_from_hf.py

@@ -0,0 +1,76 @@
+# endoreg_db/services/model_meta_from_hf.py
+
+from django.core.files.base import ContentFile
+from huggingface_hub import hf_hub_download
+
+from endoreg_db.models import AiModel, LabelSet, ModelMeta
+
+
+def ensure_model_meta_from_hf(
+    *,
+    model_id: str,
+    model_name: str,
+    labelset_name: str,
+    meta_version: str = "1",
+    labelset_version: int | None = None,
+) -> ModelMeta:
+    """
+    Download weights from Hugging Face (if needed) and ensure a ModelMeta
+    exists for the given configuration. Returns the ModelMeta.
+    """
+    # Download the model weights
+    weights_path = hf_hub_download(
+        repo_id=model_id,
+        filename="colo_segmentation_RegNetX800MF_base.safetensors",
+        local_dir="/tmp",
+    )
+
+    # Get or create AI model
+    ai_model, _ = AiModel.objects.get_or_create(
+        name=model_name, defaults={"description": f"Model from {model_id}"}
+    )
+
+    # Get labelset
+    labelset_qs = LabelSet.objects.filter(name=labelset_name)
+    if labelset_version is not None:
+        labelset_qs = labelset_qs.filter(version=labelset_version)
+    labelset = labelset_qs.order_by("-version").first()
+    if labelset is None:
+        raise ValueError(
+            f"LabelSet '{labelset_name}'"
+            + (f" v{labelset_version}" if labelset_version is not None else "")
+            + " not found"
+        )
+
+    # Create or get ModelMeta
+    model_meta, _ = ModelMeta.objects.get_or_create(
+        name=model_name,
+        model=ai_model,
+        version=meta_version,
+        defaults={
+            "labelset": labelset,
+            "activation": "sigmoid",
+            "mean": "0.45211223,0.27139644,0.19264949",
+            "std": "0.31418097,0.21088019,0.16059452",
+            "size_x": 716,
+            "size_y": 716,
+            "axes": "2,0,1",
+            "batchsize": 16,
+            "num_workers": 0,
+            "description": f"Downloaded from {model_id}",
+        },
+    )
+
+    # If weights file not yet saved, save it
+    if not model_meta.weights:
+        with open(weights_path, "rb") as f:
+            model_meta.weights.save(
+                f"{model_name}_v{meta_version}.safetensors",
+                ContentFile(f.read()),
+            )
+
+    # Set as active meta
+    ai_model.active_meta = model_meta
+    ai_model.save(update_fields=["active_meta"])
+
+    return model_meta

endoreg_db/services/polling_coordinator.py

@@ -9,50 +9,57 @@ from datetime import timedelta
 
 logger = logging.getLogger(__name__)
 
+
 class PollingCoordinator:
     """
     Service to prevent duplicate polling operations on the same media items.
     Uses Django cache and thread-safe operations to coordinate polling requests.
     """
-    
+
     # Class-level lock for thread safety
     _lock = threading.Lock()
-    
+
     # Cache key prefixes
     PROCESSING_PREFIX = "polling_processing:"
     LAST_CHECK_PREFIX = "polling_last_check:"
-    
+
     # Default timeouts
     PROCESSING_TIMEOUT = 300  # 5 minutes
-    CHECK_COOLDOWN = 10       # 10 seconds minimum between checks
-    
+    CHECK_COOLDOWN = 10  # 10 seconds minimum between checks
+
     @classmethod
-    def acquire_processing_lock(cls, file_id: int, file_type: str = "video", timeout: Optional[int] = None) -> bool:
+    def acquire_processing_lock(
+        cls, file_id: int, file_type: str = "video", timeout: Optional[int] = None
+    ) -> bool:
         """
         Acquire a processing lock for a media file to prevent duplicate processing.
-        
+
         Args:
             file_id: ID of the media file
             file_type: Type of media (video, pdf)
             timeout: Lock timeout in seconds (default: 5 minutes)
-            
+
         Returns:
             True if lock acquired, False if already locked
         """
         if timeout is None:
             timeout = cls.PROCESSING_TIMEOUT
-            
+
         cache_key = f"{cls.PROCESSING_PREFIX}{file_type}:{file_id}"
-        
+
         with cls._lock:
             # Try to acquire lock atomically
-            lock_acquired = cache.add(cache_key, {
-                "locked_at": timezone.now().isoformat(),
-                "file_id": file_id,
-                "file_type": file_type,
-                "thread_id": threading.get_ident()
-            }, timeout)
-            
+            lock_acquired = cache.add(
+                cache_key,
+                {
+                    "locked_at": timezone.now().isoformat(),
+                    "file_id": file_id,
+                    "file_type": file_type,
+                    "thread_id": threading.get_ident(),
+                },
+                timeout,
+            )
+
             if lock_acquired:
                 logger.info(f"Processing lock acquired for {file_type}:{file_id}")
                 return True
@@ -60,102 +67,116 @@ class PollingCoordinator:
                 # Check if existing lock is stale
                 existing_lock = cache.get(cache_key)
                 if existing_lock:
-                    logger.warning(f"Processing lock already exists for {file_type}:{file_id}: {existing_lock}")
+                    logger.warning(
+                        f"Processing lock already exists for {file_type}:{file_id}: {existing_lock}"
+                    )
                 else:
-                    logger.warning(f"Failed to acquire processing lock for {file_type}:{file_id}")
+                    logger.warning(
+                        f"Failed to acquire processing lock for {file_type}:{file_id}"
+                    )
                 return False
-    
+
     @classmethod
     def release_processing_lock(cls, file_id: int, file_type: str = "video") -> bool:
         """
         Release a processing lock for a media file.
-        
+
         Args:
             file_id: ID of the media file
             file_type: Type of media (video, pdf)
-            
+
         Returns:
             True if lock released, False if lock didn't exist
         """
         cache_key = f"{cls.PROCESSING_PREFIX}{file_type}:{file_id}"
-        
+
         with cls._lock:
             if cache.delete(cache_key):
                 logger.info(f"Processing lock released for {file_type}:{file_id}")
                 return True
             else:
-                logger.warning(f"No processing lock found to release for {file_type}:{file_id}")
+                logger.warning(
+                    f"No processing lock found to release for {file_type}:{file_id}"
+                )
                 return False
-    
+
     @classmethod
     def is_processing_locked(cls, file_id: int, file_type: str = "video") -> bool:
         """
         Check if a media file is currently processing locked.
-        
+
         Args:
             file_id: ID of the media file
             file_type: Type of media (video, pdf)
-            
+
         Returns:
             True if locked, False otherwise
         """
         cache_key = f"{cls.PROCESSING_PREFIX}{file_type}:{file_id}"
         return cache.get(cache_key) is not None
-    
+
     @classmethod
     def can_check_status(cls, file_id: int, file_type: str = "video") -> bool:
         """
         Check if enough time has passed since last status check to prevent spam.
-        
+
         Args:
             file_id: ID of the media file
             file_type: Type of media (video, pdf)
-            
+
         Returns:
             True if status check is allowed, False if still in cooldown
         """
         cache_key = f"{cls.LAST_CHECK_PREFIX}{file_type}:{file_id}"
         last_check = cache.get(cache_key)
-        
+
         if last_check is None:
             # First check or cooldown expired - allowed
             cls._record_status_check(file_id, file_type)
             return True
-        
+
         # Check if cooldown period has passed
-        last_check_time = timezone.datetime.fromisoformat(last_check.replace('Z', '+00:00'))
+        last_check_time = timezone.datetime.fromisoformat(
+            last_check.replace("Z", "+00:00")
+        )
         cooldown_end = last_check_time + timedelta(seconds=cls.CHECK_COOLDOWN)
-        
+
         if timezone.now() > cooldown_end:
             cls._record_status_check(file_id, file_type)
             return True
         else:
             remaining_cooldown = (cooldown_end - timezone.now()).total_seconds()
-            logger.debug(f"Status check cooldown active for {file_type}:{file_id}, {remaining_cooldown:.1f}s remaining")
+            logger.debug(
+                f"Status check cooldown active for {file_type}:{file_id}, {remaining_cooldown:.1f}s remaining"
+            )
             return False
-    
+
     @classmethod
-    def get_remaining_cooldown_seconds(cls, file_id: int, file_type: str = "video") -> int:
+    def get_remaining_cooldown_seconds(
+        cls, file_id: int, file_type: str = "video"
+    ) -> int:
         """
         Get the remaining cooldown seconds for a status check.
-        
+
         Args:
             file_id: ID of the media file
             file_type: Type of media (video, pdf)
-            
+
         Returns:
             Remaining cooldown in seconds (0 if no cooldown active)
         """
         cache_key = f"{cls.LAST_CHECK_PREFIX}{file_type}:{file_id}"
         last_check = cache.get(cache_key)
-        
+
         if last_check is None:
             return 0
-        
+
         # Check if cooldown period has passed
-        last_check_time = timezone.datetime.fromisoformat(last_check.replace('Z', '+00:00'))
+        last_check_time = timezone.datetime.fromisoformat(
+            last_check.replace("Z", "+00:00")
+        )
         cooldown_end = last_check_time + timedelta(seconds=cls.CHECK_COOLDOWN)
-        
+
         if timezone.now() > cooldown_end:
             return 0
         else:
@@ -168,47 +189,49 @@ class PollingCoordinator:
         """Record the time of a status check"""
         cache_key = f"{cls.LAST_CHECK_PREFIX}{file_type}:{file_id}"
         cache.set(cache_key, timezone.now().isoformat(), cls.CHECK_COOLDOWN + 5)
-    
+
     @classmethod
     def get_processing_locks_info(cls) -> Dict[str, any]:
         """
         Get information about all currently active processing locks.
         Useful for debugging and monitoring.
-        
+
         Returns:
             Dictionary with lock information
         """
         # Note: This is a simplified version since Django cache doesn't support pattern scanning
         # In production, consider using Redis with SCAN command for better performance
-        
+
         info = {
             "coordinator_status": "active",
             "config": {
                 "processing_timeout": cls.PROCESSING_TIMEOUT,
-                "check_cooldown": cls.CHECK_COOLDOWN
+                "check_cooldown": cls.CHECK_COOLDOWN,
             },
-            "note": "Active locks info requires Redis backend for pattern scanning"
+            "note": "Active locks info requires Redis backend for pattern scanning",
         }
-        
+
         return info
-    
+
     @classmethod
     def clear_all_locks(cls, file_type: Optional[str] = None) -> int:
         """
         Emergency function to clear all processing locks.
         Use with caution - only for debugging/recovery scenarios.
-        
+
         Args:
             file_type: Optionally clear locks only for specific file type
-            
+
         Returns:
             Number of locks cleared (approximation)
         """
-        logger.warning("clear_all_locks called - this should only be used for debugging/recovery")
-        
+        logger.warning(
+            "clear_all_locks called - this should only be used for debugging/recovery"
+        )
+
         # This is a simplified implementation
         # In production with Redis, you'd use SCAN to find and delete matching keys
-        if hasattr(cache, 'clear'):
+        if hasattr(cache, "clear"):
             cache.clear()
             return -1  # Unknown count
         else:
@@ -220,38 +243,44 @@ class PollingCoordinator:
 def processing_coordination(file_id_param: str = "file_id", file_type: str = "video"):
     """
     Decorator to add automatic processing coordination to views.
-    
+
     Args:
         file_id_param: Name of the parameter containing file ID
         file_type: Type of media file
     """
+
     def decorator(view_func):
         def wrapper(request, *args, **kwargs):
             # Extract file_id from kwargs or request
             file_id = kwargs.get(file_id_param) or request.data.get(file_id_param)
-            
+
             if file_id is None:
-                logger.error(f"No {file_id_param} found in request for processing coordination")
+                logger.error(
+                    f"No {file_id_param} found in request for processing coordination"
+                )
                 from rest_framework.response import Response
                 from rest_framework import status
+
                 return Response(
-                    {"error": f"Missing {file_id_param} parameter"}, 
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": f"Missing {file_id_param} parameter"},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
-            
+
             # Check if processing is already locked
             if PollingCoordinator.is_processing_locked(file_id, file_type):
                 from rest_framework.response import Response
                 from rest_framework import status
+
                 return Response(
-                    {"detail": "File is currently being processed by another request"}, 
-                    status=status.HTTP_409_CONFLICT
+                    {"detail": "File is currently being processed by another request"},
+                    status=status.HTTP_409_CONFLICT,
                 )
-            
+
             # Proceed with the view
             return view_func(request, *args, **kwargs)
-        
+
         return wrapper
+
     return decorator
 
 
@@ -259,7 +288,7 @@ def processing_coordination(file_id_param: str = "file_id", file_type: str = "vi
 class ProcessingLockContext:
     """
     Context manager for automatic processing lock acquisition and release.
-    
+
     Usage:
         with ProcessingLockContext(file_id, "video") as lock:
             if lock.acquired:
@@ -269,19 +298,21 @@ class ProcessingLockContext:
                 # Handle lock acquisition failure
                 pass
     """
-    
-    def __init__(self, file_id: int, file_type: str = "video", timeout: Optional[int] = None):
+
+    def __init__(
+        self, file_id: int, file_type: str = "video", timeout: Optional[int] = None
+    ):
         self.file_id = file_id
         self.file_type = file_type
         self.timeout = timeout
         self.acquired = False
-    
+
     def __enter__(self):
         self.acquired = PollingCoordinator.acquire_processing_lock(
             self.file_id, self.file_type, self.timeout
         )
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         if self.acquired:
             PollingCoordinator.release_processing_lock(self.file_id, self.file_type)