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

endoreg_db/views/requirement/lookup.py

@@ -13,6 +13,7 @@ from rest_framework.response import Response
 from endoreg_db.services import lookup_service as ls
 from endoreg_db.services.lookup_store import DEFAULT_TTL_SECONDS, LookupStore
 from endoreg_db.utils.permissions import EnvironmentAwarePermission
+from endoreg_db.models.other.tag import Tag
 
 ORIGIN_MAP_PREFIX = "lookup:origin:"
 ISSUED_MAP_PREFIX = "lookup:issued_for_internal:"
@@ -53,6 +54,8 @@ class LookupViewSet(viewsets.ViewSet):
         "selectedRequirementSetIds",
         "selectedChoices",
     }
+    
+    user_tags = Tag
 
     @action(detail=False, methods=["post"])
     def init(self, request):
@@ -131,7 +134,10 @@ class LookupViewSet(viewsets.ViewSet):
 
                 except Exception:
                     pass
-
+        
+        user_tags = request.data.get("user_tags", None)
+        if user_tags and not isinstance(user_tags, list):
+            user_tags = [user_tags]
         # Fallback to query params
         if raw_pe is None:
             raw_pe = request.query_params.get("patient_examination_id")
@@ -167,7 +173,11 @@ class LookupViewSet(viewsets.ViewSet):
 
         try:
             # Create internal session via service (may seed its own token/cache)
-            internal_token = ls.create_lookup_token_for_pe(pe_id)
+            service_kwargs = {}
+            if user_tags:
+                service_kwargs["user_tags"] = user_tags
+
+            internal_token = ls.create_lookup_token_for_pe(pe_id, **service_kwargs)
             internal_data = LookupStore(token=internal_token).get_all()
 
             issued_key = f"{ISSUED_MAP_PREFIX}{internal_token}"
@@ -254,7 +264,11 @@ class LookupViewSet(viewsets.ViewSet):
                             status=status.HTTP_404_NOT_FOUND,
                         )
 
-                    return Response(new_data, status=status.HTTP_200_OK)
+                    # Hydrate the original token with recovered data and refresh origin TTL
+                    store.set_many(new_data)
+                    cache.set(f"{ORIGIN_MAP_PREFIX}{pk}", pe_id, DEFAULT_TTL_SECONDS)
+                    return Response(store.get_all(), status=status.HTTP_200_OK)
+
 
                 except Exception:
                     pass

endoreg_db/views/requirement/lookup_store.py

@@ -3,36 +3,27 @@
 from __future__ import annotations
 
 import uuid
-
 from typing import Any, Dict, Iterable, Optional
 
-from django.core.cache import cache
-
-
 from django.conf import settings
+from django.core.cache import cache
 
 from endoreg_db.models.medical import PatientExamination
 
-
-
 # Align TTL with Django cache TIMEOUT for consistency in tests and runtime
 
 
 try:
-
-
-    DEFAULT_TTL_SECONDS = int(settings.CACHES.get('default', {}).get('TIMEOUT', 60 * 30))
+    DEFAULT_TTL_SECONDS = int(
+        settings.CACHES.get("default", {}).get("TIMEOUT", 60 * 30)
+    )
 
 
 except Exception:
-
-
     DEFAULT_TTL_SECONDS = 60 * 30  # 30 minutes fallback
 
 
-
 class LookupStore:
-
     """
 
     Server-side lookup dictionary stored in Django cache.
@@ -42,75 +33,48 @@ class LookupStore:
     """
 
     def __init__(self, token: Optional[str] = None):
-
         self.token = token or uuid.uuid4().hex
 
-
-
     @property
-
     def cache_key(self) -> str:
-
         return f"lookup:{self.token}"
 
-
-
-    def init(self, initial: Optional[Dict[str, Any]] = None, ttl: int = DEFAULT_TTL_SECONDS) -> str:
-
+    def init(
+        self, initial: Optional[Dict[str, Any]] = None, ttl: int = DEFAULT_TTL_SECONDS
+    ) -> str:
         cache.set(self.cache_key, initial or {}, ttl)
 
         return self.token
 
-
-
     def get_all(self) -> Dict[str, Any]:
-
         return cache.get(self.cache_key, {})
 
-
-
     def get_many(self, keys: Iterable[str]) -> Dict[str, Any]:
-
         data = self.get_all()
 
         return {k: data.get(k) for k in keys}
 
-
-
     def set_many(self, updates: Dict[str, Any], ttl: int = DEFAULT_TTL_SECONDS) -> None:
-
         data = self.get_all()
 
         data.update(updates)
 
         cache.set(self.cache_key, data, ttl)
 
-
-
     def get(self, key: str, default: Any = None) -> Any:
-
         return self.get_all().get(key, default)
 
-
-
     def set(self, key: str, value: Any, ttl: int = DEFAULT_TTL_SECONDS) -> None:
-
         data = self.get_all()
 
         data[key] = value
 
         cache.set(self.cache_key, data, ttl)
 
-
-
     def delete(self) -> None:
-
         cache.delete(self.cache_key)
 
-
-
     def patch(self, updates: Dict[str, Any], ttl: int = DEFAULT_TTL_SECONDS) -> None:
-
         """Patch existing data with updates."""
 
         data = self.get_all()
@@ -119,73 +83,56 @@ class LookupStore:
 
         cache.set(self.cache_key, data, ttl)
 
-
-
-
-
     def validate_and_recover_data(self, token):
-
         """Validate stored data and attempt recovery if corrupted"""
 
         data = self.get_all()
 
-
-
         if not data:
-
             return None
 
-
-
         # Check if required fields are present
 
-        required_fields = ['patient_examination_id', 'requirementsBySet', 'requirementStatus']
+        required_fields = [
+            "patient_examination_id",
+            "requirements_by_set",
+            "requirement_status",
+        ]
 
         missing_fields = [field for field in required_fields if field not in data]
 
-
-
         if missing_fields:
-
             import logging
 
             logger = logging.getLogger(__name__)
 
-            logger.warning(f"Missing fields in lookup data for token {token}: {missing_fields}")
-
-
+            logger.warning(
+                f"Missing fields in lookup data for token {token}: {missing_fields}"
+            )
 
             # Try to recover patient_examination_id from token or related data
 
-            if 'patient_examination_id' in missing_fields:
-
+            if "patient_examination_id" in missing_fields:
                 # Attempt to extract from token or find related examination
 
                 recovered_id = self._recover_patient_examination_id(token)
 
                 if recovered_id:
+                    data["patient_examination_id"] = recovered_id
 
-                    data['patient_examination_id'] = recovered_id
-
-                    logger.info(f"Recovered patient_examination_id {recovered_id} for token {token}")
-
-
+                    logger.info(
+                        f"Recovered patient_examination_id {recovered_id} for token {token}"
+                    )
 
             # Do not automatically recompute here to avoid loops
 
-
             # Recompute is only triggered by PATCH or explicit POST /recompute/
 
             # For now, just return the data as is
 
-
-
         return data
 
-
-
     def _recover_patient_examination_id(self, token: str) -> Optional[str]:
-
         """
 
         Placeholder for recovering patient_examination_id.
@@ -200,30 +147,21 @@ class LookupStore:
 
         return None
 
-
-
     def should_recompute(self, token):
-
         """Check if recomputation is needed based on data freshness"""
 
         data = self.get_all()
 
         if not data:
-
             return True
 
-
-
         # Check if we have a last_recompute timestamp
 
-        last_recompute = data.get('_last_recompute')
+        last_recompute = data.get("_last_recompute")
 
         if not last_recompute:
-
             return True
 
-
-
         # Only recompute if it's been more than 30 seconds since last recompute
 
         # This prevents excessive recomputation while allowing for updates
@@ -231,22 +169,16 @@ class LookupStore:
         from datetime import datetime, timedelta
 
         try:
-
             last_recompute_time = datetime.fromisoformat(last_recompute)
 
             return datetime.now() - last_recompute_time > timedelta(seconds=30)
 
         except (ValueError, TypeError):
-
             return True
 
-
-
     def mark_recompute_done(self):
-
         """Mark that recomputation has been completed"""
 
         from datetime import datetime
 
-        self.set('_last_recompute', datetime.now().isoformat())
-
+        self.set("_last_recompute", datetime.now().isoformat())

endoreg_db/views/requirement/requirement_utils.py

@@ -0,0 +1,89 @@
+import logging
+from typing import Any, Tuple, TYPE_CHECKING
+import json
+
+from endoreg_db.models.requirement.requirement_error import (
+    RequirementEvaluationError,
+)
+
+if TYPE_CHECKING:
+    from endoreg_db.models.requirement.requirement import Requirement
+
+logger = logging.getLogger(__name__)
+
+
+def safe_evaluate_requirement(
+    requirement: "Requirement",
+    *args: Any,
+    mode: str = "strict",
+    **kwargs: Any,
+) -> Tuple[bool, str, str | None]:
+    """
+    Wrapper für Requirement.evaluate / evaluate_with_details, der NIE Exceptions durchlässt.
+
+    Returns:
+        met: bool
+        details: human-readable explanation (für UI)
+        error: technischer Fehlerstring oder None
+    """
+
+    try:
+        if hasattr(requirement, "evaluate_with_details"):
+            met, details = requirement.evaluate_with_details(*args, mode=mode, **kwargs)
+        else:
+            met = requirement.evaluate(*args, mode=mode, **kwargs)
+            details = "Voraussetzung erfüllt" if met else "Voraussetzung nicht erfüllt"
+        error = None
+
+    except RequirementEvaluationError as e:
+        ctx = e.context
+        req_obj = ctx.requirement or requirement
+
+        # sprechbarer Name aus DB (Beschreibung bevorzugen, sonst name)
+        display_name = (
+            getattr(req_obj, "description", None)
+            or getattr(req_obj, "name", None)
+            or "unbekannte Voraussetzung"
+        )
+
+        # falls Exception schon eine user_message mitbringt: die nehmen
+        if ctx.user_message:
+            details = ctx.user_message
+        else:
+            details = (
+                f"Die Voraussetzung „{display_name}“ konnte nicht ausgewertet werden."
+            )
+
+        # technischer Fehlerstring für Logs/Debug
+        error = f"{ctx.code}: {ctx.technical_message}"
+        logger.warning(
+            "Requirement '%s' (code=%s) validation error: %s",
+            getattr(req_obj, "name", "unknown"),
+            ctx.code,
+            ctx.technical_message,
+        )
+
+        met = False
+
+    except Exception as e:
+        met = False
+        display_name = getattr(requirement, "description", None) or getattr(
+            requirement, "name", "unbekannte Voraussetzung"
+        )
+        details = (
+            f"Bei der Auswertung der Voraussetzung „{display_name}“ ist ein interner Fehler aufgetreten."
+        )
+        error = f"{e.__class__.__name__}: {e}"
+        logger.exception(
+            "Requirement '%s' unexpected error",
+            getattr(requirement, "name", "unknown"),
+        )
+
+    # normalize details to string
+    if not isinstance(details, str):
+        try:
+            details = json.dumps(details, ensure_ascii=False, default=str)
+        except Exception:
+            details = str(details)
+
+    return bool(met), details, error

endoreg_db/views/video/__init__.py

@@ -1,5 +1,4 @@
 from .correction import (
-    VideoMetadataView,
     VideoProcessingHistoryView,
     VideoApplyMaskView,
     VideoRemoveFramesView,
@@ -11,49 +10,49 @@ from ..media.video_media import VideoMediaView
 from .reimport import (
     VideoReimportView
 )
-
-from .segmentation import (
-    VideoViewSet,
-    VideoLabelView,
-    UpdateLabelSegmentsView,
-    rerun_segmentation,
-)
-
-# Phase 3.2: VideoStreamView moved to dedicated module
 from .video_stream import VideoStreamView
+from .video_examination_viewset import VideoExaminationViewSet
+from .video_meta_stats import VideoMetadataStatsView
 
-from .timeline import (
-    video_timeline_view
-)
 
-from .video_examination_viewset import VideoExaminationViewSet
+from .segments_crud import (
+    video_segments_collection,
+    video_segments_by_video,
+    video_segment_detail,
+    video_segments_stats,
+    video_segment_validate,
+    video_segments_validate_bulk,
+    video_segments_validation_status,
+)
+from ..ai.label import label_list
 
 __all__ = [
     # Video Correction (Phase 1.1) - Implemented
-    'VideoMetadataView',
     'VideoProcessingHistoryView',
     'VideoApplyMaskView',
     'VideoRemoveFramesView',
+    'VideoMetadataStatsView',
     
     'VideoMediaView',
     
     'VideoCorrectionView',
-    # 'TaskStatusView',
-    # 'VideoDownloadProcessedView',
 
     # Reimport views
     'VideoReimportView',
 
     # Segmentation views
-    'VideoViewSet',
     'VideoStreamView',
-    'VideoLabelView',
-    'UpdateLabelSegmentsView',
-    'rerun_segmentation',
-
-    # Timeline views
-    'video_timeline_view',
 
     # Video Examination ViewSet
     "VideoExaminationViewSet",
+    
+    'video_segments_collection',
+    'video_segments_by_video',
+    'video_segment_detail',
+    'video_segments_stats',
+    'video_segment_validate',
+    'video_segments_validate_bulk',
+    'video_segments_validation_status',
+    
+    'label_list',
 ]