endoreg-db 0.8.3.7__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/urls/__init__.py

@@ -1,36 +1,39 @@
-from django.urls import path, include
 from django.conf import settings
 from django.conf.urls.static import static
+from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
-# Phase 1.2: Media Management URLs ✅ IMPLEMENTED  
-from .media import urlpatterns as media_url_patterns
-
 from endoreg_db.views import (
-    VideoViewSet,
     ExaminationViewSet,
-    VideoExaminationViewSet,
+    FindingClassificationViewSet,
     FindingViewSet,
-    FindingClassificationViewSet, 
+    PatientExaminationViewSet,
     PatientFindingViewSet,
-    PatientExaminationViewSet
+    VideoExaminationViewSet,
+    VideoViewSet,
 )
 
 from .anonymization import url_patterns as anonymization_url_patterns
-from .classification import url_patterns as classification_url_patterns
 from .auth import urlpatterns as auth_url_patterns
+from .classification import url_patterns as classification_url_patterns
 from .examination import urlpatterns as examination_url_patterns
 from .files import urlpatterns as files_url_patterns
+from .label_video_segment_validate import (
+    url_patterns as label_video_segment_validate_url_patterns,
+)
 from .label_video_segments import url_patterns as label_video_segments_url_patterns
-from .label_video_segment_validate import url_patterns as label_video_segment_validate_url_patterns
+
+# Phase 1.2: Media Management URLs ✅ IMPLEMENTED
+from .media import urlpatterns as media_url_patterns
+from .patient import urlpatterns as patient_url_patterns
+
 # TODO Phase 1.2: Implement VideoMediaView and PDFMediaView before enabling
 # from .media import urlpatterns as media_url_patterns
 from .report import url_patterns as report_url_patterns
-from .upload import urlpatterns as upload_url_patterns
-from .video import url_patterns as video_url_patterns
 from .requirements import urlpatterns as requirements_url_patterns
-from .patient import urlpatterns as patient_url_patterns
 from .stats import url_patterns as stats_url_patterns
+from .upload import urlpatterns as upload_url_patterns
+from .video import url_patterns as video_url_patterns
 
 api_urls = []
 api_urls += classification_url_patterns
@@ -50,21 +53,31 @@ api_urls += patient_url_patterns
 api_urls += stats_url_patterns
 
 router = DefaultRouter()
-router.register(r'videos', VideoViewSet, basename='videos')  
-router.register(r'examinations', ExaminationViewSet)
-router.register(r'video-examinations', VideoExaminationViewSet, basename='video-examinations')
-router.register(r'findings', FindingViewSet)
-router.register(r'classifications', FindingClassificationViewSet)
-router.register(r'patient-findings', PatientFindingViewSet)
-router.register(r'patient-examinations', PatientExaminationViewSet)
+router.register(r"videos", VideoViewSet, basename="videos")
+router.register(r"examinations", ExaminationViewSet)
+router.register(
+    r"video-examinations", VideoExaminationViewSet, basename="video-examinations"
+)
+router.register(r"findings", FindingViewSet)
+router.register(r"classifications", FindingClassificationViewSet)
+router.register(r"patient-findings", PatientFindingViewSet)
+router.register(r"patient-examinations", PatientExaminationViewSet)
+
+# Additional custom video examination routes
+# Frontend expects: GET /api/video/{id}/examinations/
+video_examinations_list = VideoExaminationViewSet.as_view({"get": "by_video"})
 
 # Export raw API urlpatterns (no prefix). The project-level endoreg_db/urls.py mounts these under /api/.
 urlpatterns = [
-    path('', include(api_urls)),  # Specific routes first
-    path('', include(router.urls)),  # Generic router routes second
+    path(
+        "video/<int:video_id>/examinations/",
+        video_examinations_list,
+        name="video-examinations-by-video",
+    ),
+    path("", include(api_urls)),  # Specific routes first
+    path("", include(router.urls)),  # Generic router routes second
 ]
 
 if settings.DEBUG:
     urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
     urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
-

endoreg_db/urls/label_video_segments.py

@@ -8,6 +8,8 @@ from endoreg_db.views import (
     get_lvs_by_name_and_video_id
 )
 
+
+
 url_patterns = [
     path(
         "lvs/by-label-name/<str:label_name>/by-video-id/<int:video_id>/",

endoreg_db/urls/media.py

@@ -1,3 +1,4 @@
+from PIL.PdfParser import PdfStream
 from django.urls import path
 
 from endoreg_db.views.media import (
@@ -22,6 +23,7 @@ from endoreg_db.views import (
     VideoStreamView,
 )
 from endoreg_db.views.pdf.reimport import PdfReimportView
+from endoreg_db.views.pdf.pdf_stream import PdfStreamView
 from endoreg_db.views.video.reimport import VideoReimportView
 from endoreg_db.views.video.correction import (
     VideoMetadataView,
@@ -216,8 +218,7 @@ urlpatterns = [
     # PDF media endpoints
     path("media/pdfs/", PdfMediaView.as_view(), name="pdf-list"),
     path("media/pdfs/<int:pk>/", PdfMediaView.as_view(), name="pdf-detail"),
-    path("media/pdfs/<int:pk>/stream/", PdfMediaView.as_view(), name="pdf-stream"),
-
+    path("media/pdfs/<int:pk>/stream/", PdfStreamView.as_view(), name="pdf-stream"),  # Support ?type=raw|anonymized params
     # PDF Re-import API endpoint (modern media framework)
     # POST /api/media/pdfs/<int:pk>/reimport/
     # Re-imports a PDF file to regenerate metadata when OCR failed or data is incomplete

endoreg_db/utils/setup_config.py

@@ -0,0 +1,177 @@
+"""
+Configuration loader for EndoReg DB setup.
+Handles loading and parsing of setup configuration from YAML files.
+"""
+
+import glob
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+class SetupConfig:
+    """
+    Handles loading and accessing setup configuration from YAML files.
+    Provides methods to get model names, search patterns, and fallback configurations.
+    """
+
+    def __init__(self, config_file: Optional[Path] = None):
+        """
+        Initialize the setup configuration.
+
+        Args:
+            config_file: Path to the setup configuration YAML file.
+                        If None, uses default location.
+        """
+        if config_file is None:
+            # Default to setup_config.yaml in data directory
+            config_file = Path(__file__).parent.parent / "data" / "setup_config.yaml"
+
+        self.config_file = config_file
+        self._config = self._load_config()
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from YAML file."""
+        try:
+            if self.config_file.exists():
+                with open(self.config_file, "r") as f:
+                    config = yaml.safe_load(f)
+                    logger.info(f"Loaded setup configuration from {self.config_file}")
+                    return config or {}
+            else:
+                logger.warning(f"Setup config file not found: {self.config_file}")
+                return self._get_default_config()
+        except Exception as e:
+            logger.error(f"Error loading setup config: {e}")
+            return self._get_default_config()
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Return default configuration if file is not available."""
+        return {
+            "default_models": {
+                "primary_classification_model": "image_multilabel_classification_colonoscopy_default",
+                "primary_labelset": "multilabel_classification_colonoscopy_default",
+            },
+            "huggingface_fallback": {
+                "enabled": True,
+                "repo_id": "wg-lux/colo_segmentation_RegNetX800MF_base",
+                "filename": "colo_segmentation_RegNetX800MF_base.ckpt",
+                "labelset_name": "multilabel_classification_colonoscopy_default",
+            },
+            "weights_search_patterns": [
+                "colo_segmentation_RegNetX800MF_*.ckpt",
+                "image_multilabel_classification_colonoscopy_default_*.ckpt",
+                "*_colonoscopy_*.ckpt",
+            ],
+            "weights_search_dirs": ["tests/assets", "assets", "data/storage/model_weights", "${STORAGE_DIR}/model_weights"],
+            "auto_generation_defaults": {
+                "activation": "sigmoid",
+                "mean": "0.485,0.456,0.406",
+                "std": "0.229,0.224,0.225",
+                "size_x": 224,
+                "size_y": 224,
+                "axes": "CHW",
+                "batchsize": 32,
+                "num_workers": 4,
+            },
+        }
+
+    def get_primary_model_name(self) -> str:
+        """Get the primary classification model name."""
+        return self._config.get("default_models", {}).get("primary_classification_model", "image_multilabel_classification_colonoscopy_default")
+
+    def get_primary_labelset_name(self) -> str:
+        """Get the primary labelset name."""
+        return self._config.get("default_models", {}).get("primary_labelset", "multilabel_classification_colonoscopy_default")
+
+    def get_huggingface_config(self) -> Dict[str, Any]:
+        """Get HuggingFace fallback configuration."""
+        return self._config.get("huggingface_fallback", {})
+
+    def get_weights_search_patterns(self) -> List[str]:
+        """Get weight file search patterns."""
+        return self._config.get("weights_search_patterns", ["colo_segmentation_RegNetX800MF_*.ckpt", "*_colonoscopy_*.ckpt"])
+
+    def get_weights_search_dirs(self) -> List[Path]:
+        """
+        Get weight file search directories with environment variable substitution.
+        """
+        dirs = self._config.get("weights_search_dirs", [])
+        resolved_dirs = []
+
+        for dir_str in dirs:
+            # Handle environment variable substitution
+            if "${" in dir_str:
+                dir_str = os.path.expandvars(dir_str)
+
+            resolved_dirs.append(Path(dir_str))
+
+        return resolved_dirs
+
+    def get_auto_generation_defaults(self) -> Dict[str, Any]:
+        """Get default values for auto-generated metadata."""
+        return self._config.get("auto_generation_defaults", {})
+
+    def find_model_weights_files(self) -> List[Path]:
+        """
+        Find model weight files using configured search patterns and directories.
+
+        Returns:
+            List of paths to found weight files
+        """
+        found_files = []
+        search_dirs = self.get_weights_search_dirs()
+        search_patterns = self.get_weights_search_patterns()
+
+        for search_dir in search_dirs:
+            if not search_dir.exists():
+                continue
+
+            for pattern in search_patterns:
+                # Use glob to find files matching pattern
+                pattern_path = search_dir / pattern
+                matches = glob.glob(str(pattern_path))
+                for match in matches:
+                    path = Path(match)
+                    if path.exists() and path not in found_files:
+                        found_files.append(path)
+                        logger.info(f"Found weight file: {path}")
+
+        return found_files
+
+    def get_model_specific_config(self, model_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get model-specific configuration from YAML metadata files.
+
+        Args:
+            model_name: Name of the model to get config for
+
+        Returns:
+            Model-specific setup configuration if found
+        """
+        # This would need to parse the ai_model_meta YAML files
+        # and extract setup_config sections for the specified model
+        try:
+            from endoreg_db.data import AI_MODEL_META_DATA_DIR
+
+            for yaml_file in AI_MODEL_META_DATA_DIR.glob("*.yaml"):
+                with open(yaml_file, "r") as f:
+                    data = yaml.safe_load(f)
+
+                if isinstance(data, list):
+                    for item in data:
+                        if item.get("fields", {}).get("name") == model_name or item.get("fields", {}).get("model") == model_name:
+                            return item.get("setup_config", {})
+        except Exception as e:
+            logger.warning(f"Error loading model-specific config for {model_name}: {e}")
+
+        return None
+
+
+# Global instance for easy access
+setup_config = SetupConfig()

endoreg_db/views/__init__.py

@@ -108,8 +108,8 @@ from .patient_finding_classification import (
 )
 
 from .pdf import (
-    ClosingFileWrapper,
-    PDFMediaView,
+    PdfReimportView,
+    PdfStreamView,
 )
 
 from .report import (
@@ -240,7 +240,9 @@ __all__ = [
     "create_patient_finding_classification",
 
     # PDF
-    "ClosingFileWrapper",
+    "PdfMediaView",
+    "PdfReimportView",
+    "PdfStreamView",
 
     # Report
     "ReportListView",

endoreg_db/views/media/pdf_media.py

@@ -13,6 +13,7 @@ from django.http import Http404, FileResponse
 from rest_framework import status
 from rest_framework.response import Response
 from rest_framework.views import APIView
+from django.views.decorators.clickjacking import xframe_options_exempt
 from django.db.models import Q
 
 from endoreg_db.models import RawPdfFile
@@ -133,7 +134,8 @@ class PdfMediaView(APIView):
                 {"error": "Failed to retrieve PDF details"},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR
             )
-
+            
+    @xframe_options_exempt
     def _stream_pdf(self, pk):
         """
         Stream PDF file content for viewing/download.

endoreg_db/views/media/video_media.py

@@ -30,7 +30,7 @@ class VideoMediaView(APIView):
     - GET /api/media/videos/ - List all videos with filtering
     - GET /api/media/videos/{id}/ - Get video details
     - PATCH /api/media/videos/{id}/ - Update video metadata (future)
-    - DELETE /api/media/videos/{id}/ - Delete video (future)
+    - DELETE /api/media/videos/{id}/ - Delete video 
     
     Query Parameters:
     - status: Filter by processing status (not_started, processing, done, failed, validated)