endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/requirement/lookup.py

@@ -0,0 +1,380 @@
+# api/viewsets/lookup.py
+import logging
+from ast import literal_eval
+from collections.abc import Mapping
+
+from django.core.cache import cache
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
+from rest_framework.response import Response
+
+# Use module import so tests can monkeypatch functions on the module
+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:"
+
+logger = logging.getLogger(__name__)
+
+
+class LookupViewSet(viewsets.ViewSet):
+    """
+    Django REST Framework ViewSet for managing lookup sessions.
+
+    This ViewSet provides REST API endpoints for the lookup system, which
+    evaluates medical examination requirements against patient data. It uses
+    token-based sessions stored in Django cache to maintain state across
+    multiple client requests.
+
+    Key features:
+    - Session initialization with patient examination data
+    - Retrieval of lookup data by token
+    - Partial updates to session data with automatic recomputation
+    - Manual recomputation of derived data
+    - Automatic session recovery for expired tokens
+
+    The API supports both internal service tokens and public client tokens,
+    with origin mapping to enable session restart functionality.
+
+    Endpoints:
+    - POST /init: Initialize new lookup session
+    - GET /{token}/all: Retrieve complete session data
+    - GET/PATCH /{token}/parts: Get/update partial session data
+    - POST /{token}/recompute: Manually trigger recomputation
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+    parser_classes = (JSONParser, FormParser, MultiPartParser)
+    INPUT_KEYS = {
+        "patient_examination_id",
+        "selectedRequirementSetIds",
+        "selectedChoices",
+    }
+
+    user_tags = Tag
+
+    @action(detail=False, methods=["post"])
+    def init(self, request):
+        """
+        Initialize a new lookup session for a patient examination.
+
+        Creates a new token-based session containing initial lookup data
+        for the specified patient examination. Handles malformed payloads
+        and supports multiple initialization requests for the same examination
+        by issuing fresh public tokens while maintaining internal state.
+
+        Request body:
+            patient_examination_id: Integer ID of the patient examination
+
+        Returns:
+            JSON response with session token
+
+        Raises:
+            400: Invalid patient_examination_id or creation failure
+        """
+        try:
+            debug_data = getattr(request, "data", None)
+            raw_post = getattr(getattr(request, "_request", None), "POST", None)
+            body_preview = None
+            try:
+                body = getattr(getattr(request, "_request", None), "body", b"")
+                body_preview = body[:200]
+
+            except Exception:
+                body_preview = None
+            logger.debug(
+                "lookup.init incoming: data=%r POST=%r body[:200]=%r",
+                debug_data,
+                raw_post,
+                body_preview,
+            )
+
+        except Exception:
+            pass
+        # Prefer DRF data
+        raw_pe = (
+            request.data.get("patient_examination_id")
+            if hasattr(request, "data")
+            else None
+        )
+        # Fallback: parse malformed form payload where the entire dict was sent as a single key string
+
+        if raw_pe is None:
+            for candidate in (
+                getattr(getattr(request, "_request", None), "POST", None),
+                request.data if hasattr(request, "data") else None,
+            ):
+                try:
+                    if isinstance(candidate, Mapping) and len(candidate.keys()) == 1:
+                        only_key = next(iter(candidate.keys()))
+                        if (
+                            isinstance(only_key, str)
+                            and only_key.startswith("{")
+                            and only_key.endswith("}")
+                        ):
+                            try:
+                                parsed = literal_eval(only_key)
+                                if (
+                                    isinstance(parsed, dict)
+                                    and "patient_examination_id" in parsed
+                                ):
+                                    raw_pe = parsed.get("patient_examination_id")
+                                    logger.debug(
+                                        "lookup.init recovered pe_id from malformed payload: %r",
+                                        raw_pe,
+                                    )
+                                    break
+
+                            except Exception:
+                                pass
+
+                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")
+
+        logger.debug("lookup.init raw_pe=%r type=%s", raw_pe, type(raw_pe))
+
+        # Normalize potential list/tuple inputs (e.g., from form submissions)
+        if isinstance(raw_pe, (list, tuple)):
+            raw_pe = raw_pe[0] if raw_pe else None
+
+        if raw_pe in (None, ""):
+            return Response(
+                {"detail": "patient_examination_id must be an integer"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Coerce to int robustly
+        try:
+            pe_id = int(str(raw_pe))
+
+        except (TypeError, ValueError):
+            logger.warning("lookup.init failed to int() raw_pe=%r", raw_pe)
+            return Response(
+                {"detail": "patient_examination_id must be an integer"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if pe_id <= 0:
+            return Response(
+                {"detail": "patient_examination_id must be positive"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            # Create internal session via service (may seed its own token/cache)
+            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}"
+
+            issued_count = cache.get(issued_key, 0)
+
+            if issued_count == 0:
+                # First issuance: return the service token directly
+
+                token_to_return = internal_token
+
+                cache.set(issued_key, 1, DEFAULT_TTL_SECONDS)
+
+            else:
+                # Subsequent inits for same internal token: issue a fresh public token seeded with internal data
+
+                public_store = LookupStore()
+
+                token_to_return = public_store.init(
+                    initial=internal_data, ttl=DEFAULT_TTL_SECONDS
+                )
+
+                cache.set(issued_key, issued_count + 1, DEFAULT_TTL_SECONDS)
+
+            # Persist origin mapping so we can restart expired sessions
+
+            cache.set(
+                f"{ORIGIN_MAP_PREFIX}{token_to_return}", pe_id, DEFAULT_TTL_SECONDS
+            )
+
+        except Exception as e:
+            return Response({"detail": str(e)}, status=status.HTTP_400_BAD_REQUEST)
+
+        return Response({"token": token_to_return}, status=status.HTTP_201_CREATED)
+
+    @action(detail=True, methods=["get"], url_path="all")
+    def get_all(self, request, pk=None):
+        """
+        Retrieve complete lookup data for a session token.
+
+        Returns all stored data for the given token. If data is not found,
+        attempts automatic session recovery using persisted origin mapping.
+
+        Args:
+            pk: Session token
+
+        Returns:
+            Complete lookup data dictionary
+
+        Raises:
+            404: Token not found and recovery failed
+        """
+
+        if not pk:
+            return Response(
+                {"detail": "Token required"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        store = LookupStore(token=pk)
+
+        try:
+            validated_data = store.validate_and_recover_data(pk)
+
+        except Exception:
+            validated_data = None
+
+        if validated_data is None:
+            # Try automatic restart once using persisted origin mapping
+
+            pe_id = cache.get(f"{ORIGIN_MAP_PREFIX}{pk}")
+
+            if pe_id:
+                try:
+                    internal_token = ls.create_lookup_token_for_pe(int(pe_id))
+
+                    new_data = LookupStore(token=internal_token).get_all()
+
+                    if not new_data:
+                        return Response(
+                            {
+                                "error": "Lookup data not available after restart",
+                                "token": pk,
+                            },
+                            status=status.HTTP_404_NOT_FOUND,
+                        )
+
+                    # 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
+
+            return Response(
+                {"error": "Lookup data not found or expired", "token": pk},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        return Response(store.get_all())
+
+    @action(detail=True, methods=["get", "patch"], url_path="parts")
+    def parts(self, request, pk=None):
+        """
+        Get or update partial lookup data for a session.
+
+        GET: Retrieve specific keys from the session data.
+        PATCH: Update session data and trigger recomputation if input keys changed.
+
+        GET query params:
+            keys: Comma-separated list of keys to retrieve
+
+        PATCH body:
+            updates: Dictionary of key-value pairs to update
+
+        Args:
+            pk: Session token
+
+        Returns:
+            GET: Dictionary with requested keys
+            PATCH: Success confirmation
+
+        Raises:
+            404: Token not found
+            400: Invalid request parameters
+        """
+
+        if not pk:
+            return Response(
+                {"detail": "Token required"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        store = LookupStore(token=pk)
+
+        if request.method == "GET":
+            keys_param = request.query_params.get("keys", "")
+
+            keys = [k.strip() for k in keys_param.split(",") if k.strip()]
+
+            if not keys:
+                return Response(
+                    {"detail": "Provide ?keys=key1,key2"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            try:
+                return Response(store.get_many(keys))
+
+            except Exception:
+                return Response(
+                    {"detail": "Lookup data not found or expired"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+        # PATCH
+
+        updates = request.data.get("updates", {})
+
+        if not isinstance(updates, dict) or not updates:
+            return Response(
+                {"detail": "updates must be a non-empty object"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        store.set_many(updates)
+
+        if any(key in self.INPUT_KEYS for key in updates.keys()):
+            try:
+                ls.recompute_lookup(pk)
+
+            except Exception as e:
+                import logging
+
+                logging.getLogger(__name__).error(
+                    "Failed to recompute after patch for token %s: %s", pk, e
+                )
+
+        return Response({"ok": True, "token": pk}, status=status.HTTP_200_OK)
+
+    @action(detail=True, methods=["post"], url_path="recompute")
+    def recompute(self, request, pk=None):
+        """Recompute lookup data based on current PatientExamination and user selections"""
+
+        if not pk:
+            return Response(
+                {"detail": "Token required"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        try:
+            updates = ls.recompute_lookup(pk)
+
+            return Response(
+                {"ok": True, "token": pk, "updates": updates}, status=status.HTTP_200_OK
+            )
+
+        except ValueError as e:
+            return Response({"detail": str(e)}, status=status.HTTP_404_NOT_FOUND)
+
+        except Exception as e:
+            return Response({"detail": str(e)}, status=status.HTTP_400_BAD_REQUEST)

endoreg_db/views/requirement/lookup_store.py

@@ -0,0 +1,183 @@
+# services/lookup_store.py
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, Dict, Iterable, Optional
+
+from django.conf import settings
+from django.core.cache import cache
+
+
+# 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)
+    )
+
+
+except Exception:
+    DEFAULT_TTL_SECONDS = 60 * 30  # 30 minutes fallback
+
+
+class LookupStore:
+    """
+
+    Server-side lookup dictionary stored in Django cache.
+
+    Return a token to the client; later requests use that token to get/update parts.
+
+    """
+
+    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:
+        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()
+
+        data.update(updates)
+
+        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",
+            "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}"
+            )
+
+            # Try to recover patient_examination_id from token or related data
+
+            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
+
+                    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.
+
+        This should be implemented with logic to find the ID based on the token or other data.
+
+        """
+
+        # In a real implementation, you might query a database or another service.
+
+        # For now, we return None as recovery logic is not defined.
+
+        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")
+
+        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
+
+        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())

endoreg_db/views/requirement/requirement_utils.py

@@ -0,0 +1,87 @@
+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, **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/stats/__init__.py

@@ -0,0 +1,13 @@
+from .stats_views import (
+    ExaminationStatsView,
+    VideoSegmentStatsView,
+    SensitiveMetaStatsView,
+    GeneralStatsView,
+)
+
+__all__ = [
+    "ExaminationStatsView",
+    "VideoSegmentStatsView",
+    "SensitiveMetaStatsView",
+    "GeneralStatsView",
+]