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

endoreg_db/tasks/upload_tasks.py

@@ -1,12 +1,12 @@
-import os
 import logging
+import os
 from typing import Optional
-from celery_app import shared_task
+
 from django.core.files.storage import default_storage
 
-from endoreg_db.models.upload_job import UploadJob
+from celery_app import shared_task
 from endoreg_db.models import SensitiveMeta, VideoFile
-
+from endoreg_db.models.upload_job import UploadJob
 
 logger = logging.getLogger(__name__)
 
@@ -14,8 +14,8 @@ logger = logging.getLogger(__name__)
 @shared_task(bind=True)
 def process_upload_job(self, job_id: str) -> dict:
     """
-    Process an uploaded file (PDF or video) asynchronously.
-    
+    Process an uploaded file (report or video) asynchronously.
+
     This task:
     1. Updates job status to 'processing'
     2. Determines file type and routes to appropriate processor
@@ -23,10 +23,10 @@ def process_upload_job(self, job_id: str) -> dict:
     4. For videos: Uses VideoFile.create_from_file_initialized() and processing pipeline
     5. Links the created SensitiveMeta to the job and marks as 'anonymized'
     6. On error: marks job as 'error' with details
-    
+
     Args:
         job_id: UUID string of the UploadJob to process
-        
+
     Returns:
         dict: Processing result with status and details
     """
@@ -37,69 +37,71 @@ def process_upload_job(self, job_id: str) -> dict:
         except UploadJob.DoesNotExist:
             error_msg = f"UploadJob with id {job_id} not found"
             logger.error(error_msg)
-            return {'status': 'error', 'error': error_msg}
-        
+            return {"status": "error", "error": error_msg}
+
         # Mark as processing
         upload_job.mark_processing()
         logger.info(f"Started processing upload job {job_id}")
-        
+
         # Get file path
         file_path = upload_job.file.path
         if not os.path.exists(file_path):
             error_msg = f"Uploaded file not found at {file_path}"
             upload_job.mark_error(error_msg)
             logger.error(error_msg)
-            return {'status': 'error', 'error': error_msg}
-        
+            return {"status": "error", "error": error_msg}
+
         # Route to appropriate processor based on content type
         sensitive_meta = None
-        
-        if upload_job.content_type == 'application/pdf':
+
+        if upload_job.content_type == "application/pdf":
             sensitive_meta = _process_pdf_file(upload_job, file_path)
-        elif upload_job.content_type.startswith('video/'):
+        elif upload_job.content_type.startswith("video/"):
             sensitive_meta = _process_video_file(upload_job, file_path)
         else:
             error_msg = f"Unsupported content type: {upload_job.content_type}"
             upload_job.mark_error(error_msg)
             logger.error(error_msg)
-            return {'status': 'error', 'error': error_msg}
-        
+            return {"status": "error", "error": error_msg}
+
         if sensitive_meta:
             # Mark job as completed with the created SensitiveMeta
             upload_job.mark_completed(sensitive_meta)
-            logger.info(f"Successfully processed upload job {job_id}, created SensitiveMeta {sensitive_meta.id}")
+            logger.info(
+                f"Successfully processed upload job {job_id}, created SensitiveMeta {sensitive_meta.id}"
+            )
             return {
-                'status': 'anonymized',
-                'sensitive_meta_id': sensitive_meta.id,
-                'job_id': job_id
+                "status": "anonymized",
+                "sensitive_meta_id": sensitive_meta.id,
+                "job_id": job_id,
             }
         else:
             error_msg = "Processing completed but no SensitiveMeta was created"
             upload_job.mark_error(error_msg)
             logger.error(f"Upload job {job_id}: {error_msg}")
-            return {'status': 'error', 'error': error_msg}
-            
+            return {"status": "error", "error": error_msg}
+
     except Exception as e:
         error_msg = f"Unexpected error processing upload job {job_id}: {str(e)}"
         logger.exception(error_msg)
-        
+
         try:
             upload_job = UploadJob.objects.get(id=job_id)
             upload_job.mark_error(error_msg)
         except Exception as inner_e:
             logger.error(f"Failed to update job status after error: {inner_e}")
-        
-        return {'status': 'error', 'error': error_msg}
+
+        return {"status": "error", "error": error_msg}
 
 
 def _process_pdf_file(upload_job: UploadJob, file_path: str) -> Optional[SensitiveMeta]:
     """
-    Process a PDF file using ReportReader.
-    
+    Process a report file using ReportReader.
+
     Args:
         upload_job: The UploadJob instance
-        file_path: Path to the uploaded PDF file
-        
+        file_path: Path to the uploaded report file
+
     Returns:
         SensitiveMeta instance if successful, None otherwise
     """
@@ -108,100 +110,107 @@ def _process_pdf_file(upload_job: UploadJob, file_path: str) -> Optional[Sensiti
         try:
             from lx_anonymizer.report_reader import ReportReader
         except ImportError as e:
-            raise ImportError(f"Could not import ReportReader: {e}. Make sure lx-anonymizer is available.")
-        
-        logger.info(f"Processing PDF file: {file_path}")
-        
+            raise ImportError(
+                f"Could not import ReportReader: {e}. Make sure lx-anonymizer is available."
+            )
+
+        logger.info(f"Processing report file: {file_path}")
+
         # Create ReportReader instance
-        reader = ReportReader(
-            locale="de_DE",
-            text_date_format="%d.%m.%Y"
-        )
-        
+        reader = ReportReader(locale="de_DE", text_date_format="%d.%m.%Y")
+
         # Process the report
         original_text, anonymized_text, metadata = reader.process_report(
             pdf_path=file_path,
             use_ensemble=False,  # Can be made configurable
             verbose=False,
-            use_llm_extractor=None  # Use default extractor
+            use_llm_extractor=None,  # Use default extractor
         )
-        
+
         if not metadata:
-            raise ValueError("No metadata extracted from PDF")
-        
+            raise ValueError("No metadata extracted from report")
+
         # Create SensitiveMeta from extracted metadata
         sensitive_meta = SensitiveMeta.create_from_dict(metadata)
         sensitive_meta.save()
-        
-        logger.info(f"Created SensitiveMeta {sensitive_meta.id} from PDF processing")
+
+        logger.info(f"Created SensitiveMeta {sensitive_meta.id} from report processing")
         return sensitive_meta
-        
+
     except Exception as e:
-        logger.exception(f"Error processing PDF file {file_path}: {e}")
+        logger.exception(f"Error processing report file {file_path}: {e}")
         raise
 
 
-def _process_video_file(upload_job: UploadJob, file_path: str) -> Optional[SensitiveMeta]:
+def _process_video_file(
+    upload_job: UploadJob, file_path: str
+) -> Optional[SensitiveMeta]:
     """
     Process a video file using VideoFile creation and processing pipeline.
-    
+
     Args:
         upload_job: The UploadJob instance
         file_path: Path to the uploaded video file
-        
+
     Returns:
         SensitiveMeta instance if successful, None otherwise
     """
     try:
         logger.info(f"Processing video file: {file_path}")
-        
+
         # Get the relative path for storage
         relative_path = os.path.relpath(file_path, default_storage.location)
-        
+
         # Create VideoFile instance using the existing method
         video_file = VideoFile.create_from_file_initialized(
             file_path=relative_path,
             skip_frame_extraction=False,  # Extract frames for processing
-            skip_meta_extraction=False,   # Extract metadata
+            skip_meta_extraction=False,  # Extract metadata
         )
-        
+
         if not video_file:
             raise ValueError("Failed to create VideoFile instance")
-        
+
         # Run the video processing pipeline (pipe_1)
         try:
             # Import the processing function
             from endoreg_db.management.commands.import_video import pipe_1
-            
+
             # Run processing pipeline
             pipe_1(
                 video_file=video_file,
                 skip_frame_extraction=False,
                 skip_meta_extraction=False,
-                skip_anonymization=False
+                skip_anonymization=False,
             )
-            
+
         except Exception as e:
-            logger.warning(f"Video processing pipeline failed, but VideoFile was created: {e}")
+            logger.warning(
+                f"Video processing pipeline failed, but VideoFile was created: {e}"
+            )
             # Continue anyway - we might still have usable metadata
-        
+
         # Get the associated SensitiveMeta
-        if hasattr(video_file, 'sensitive_meta') and video_file.sensitive_meta:
+        if hasattr(video_file, "sensitive_meta") and video_file.sensitive_meta:
             sensitive_meta = video_file.sensitive_meta
-            logger.info(f"Found SensitiveMeta {sensitive_meta.id} from video processing")
+            logger.info(
+                f"Found SensitiveMeta {sensitive_meta.id} from video processing"
+            )
             return sensitive_meta
         else:
             # Create a basic SensitiveMeta if none exists
             sensitive_meta = SensitiveMeta.objects.create()
-            
+
             # Link it to the video if possible
-            if hasattr(video_file, 'sensitive_meta'):
+            if hasattr(video_file, "sensitive_meta"):
                 video_file.sensitive_meta = sensitive_meta
-                video_file.save(update_fields=['sensitive_meta'])
-            
-            logger.info(f"Created basic SensitiveMeta {sensitive_meta.id} for video file")
+                video_file.save(update_fields=["sensitive_meta"])
+
+            logger.info(
+                f"Created basic SensitiveMeta {sensitive_meta.id} for video file"
+            )
             return sensitive_meta
-            
+
     except Exception as e:
         logger.exception(f"Error processing video file {file_path}: {e}")
-        raise
+        raise

endoreg_db/tasks/video_ingest.py

@@ -63,15 +63,19 @@ def run_import_video(file_path: str, center_name: Optional[str] = None,
             }
         
         # Use settings defaults if not provided
-        center_name = center_name or getattr(settings, 'DEFAULT_CENTER', 'university_hospital_wuerzburg')
-        processor_name = processor_name or getattr(settings, 'DEFAULT_PROCESSOR', 'olympus_cv_1500')
-        
+        if not isinstance(center_name, str):
+            getattr(settings, 'DEFAULT_CENTER', 'university_hospital_wuerzburg')
+            assert(center_name is str)
+        if not isinstance(processor_name, str):
+            assert(processor_name is str)
+            getattr(settings, 'DEFAULT_PROCESSOR', 'olympus_cv_1500')
+
         logger.info(f"Starting import for video: {file_path}")
         logger.info(f"Using center: {center_name}, processor: {processor_name}")
         
         # Try to use the service first
         try:
-            from endoreg_db.services import video_import
+            from endoreg_db.services.__old import video_import
             
             video_file_obj = video_import.import_and_anonymize(
                 file_path=file_path,

endoreg_db/urls/__init__.py

@@ -17,18 +17,8 @@ from .anonymization import url_patterns as anonymization_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
-
-# 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 .requirements import urlpatterns as requirements_url_patterns
 from .stats import url_patterns as stats_url_patterns
 from .upload import urlpatterns as upload_url_patterns
@@ -38,9 +28,6 @@ api_urls += classification_url_patterns
 api_urls += anonymization_url_patterns
 api_urls += auth_url_patterns
 api_urls += examination_url_patterns
-api_urls += files_url_patterns
-api_urls += label_video_segments_url_patterns
-api_urls += label_video_segment_validate_url_patterns 
 api_urls += media_url_patterns
 api_urls += upload_url_patterns
 api_urls += requirements_url_patterns
@@ -49,7 +36,6 @@ api_urls += stats_url_patterns
 
 router = DefaultRouter()
 router.register(r"examinations", ExaminationViewSet)
-
 router.register(r"findings", FindingViewSet)
 router.register(r"classifications", FindingClassificationViewSet)
 router.register(r"patient-findings", PatientFindingViewSet)

endoreg_db/urls/ai.py

@@ -0,0 +1,32 @@
+from django.urls import path
+from endoreg_db.views.ai import (label_list, add_label, delete_label, update_label)
+
+url_patterns=[
+    # Label interface
+    # GET, Returns list of labels
+    path(   
+        "ai/label-list",
+        label_list,
+        name="label-list"
+        ),
+    # POST, updates label by deleting old one and adding new one
+    path(
+        "ai/label-update",
+        update_label,
+        name="label-update"
+    ),
+    # DELETE, deletes a label
+    path(
+        "ai/label-delete",
+        delete_label,
+        name="label-delete"
+    ),
+    # POST, allows adding a new label
+    path(
+        "ai/label-add",
+        add_label,
+        name="label-add"
+    )  
+    
+
+]

endoreg_db/urls/media.py

@@ -1,35 +1,37 @@
 from django.urls import path
 
 from endoreg_db.views import VideoStreamView
+from endoreg_db.views.ai import label_list
 from endoreg_db.views.media import (
     PdfMediaView,  # Alias to avoid conflict with legacy pdf.PDFMediaView
     VideoMediaView,
+    get_sensitive_metadata_pk,
     pdf_sensitive_metadata,
     pdf_sensitive_metadata_list,
     pdf_sensitive_metadata_verify,
     sensitive_metadata_list,
+    video_sensitive_metadata,
+    video_sensitive_metadata_verify,
+)
+from endoreg_db.views.report.reimport import ReportReimportView
+from endoreg_db.views.report.report_stream import ReportStreamView
+from endoreg_db.views.video import (
+    VideoReimportView,
     video_segment_detail,
     video_segment_validate,
-    video_segments_by_pk,
     video_segments_by_video,
     video_segments_collection,
     video_segments_stats,
     video_segments_validate_bulk,
     video_segments_validation_status,
-    video_sensitive_metadata,
-    video_sensitive_metadata_verify,
-    get_sensitive_metadata_pk
 )
-from endoreg_db.views.pdf.pdf_stream import PdfStreamView
-from endoreg_db.views.pdf.reimport import PdfReimportView
 from endoreg_db.views.video.correction import (
     VideoApplyMaskView,
     VideoCorrectionView,
-    VideoMetadataView,
+    VideoMetadataStatsView,
     VideoProcessingHistoryView,
     VideoRemoveFramesView,
 )
-from endoreg_db.views.video.reimport import VideoReimportView
 
 # ---------------------------------------------------------------------------------------
 # ANNOTATION API ENDPOINTS
@@ -43,9 +45,9 @@ from endoreg_db.views.video.reimport import VideoReimportView
 
 urlpatterns = [
     path(
-        "media/sensitive-media-id/<int:pk>/<str:mediaType>/", 
+        "media/sensitive-media-id/<int:pk>/<str:mediaType>/",
         get_sensitive_metadata_pk,
-        name="sm-pk"
+        name="sm-pk",
     ),
     # Video media endpoints
     path("media/videos/", VideoMediaView.as_view(), name="video-list"),
@@ -90,7 +92,7 @@ urlpatterns = [
     # Returns analysis results (sensitive frame count, ratio, frame IDs)
     path(
         "media/videos/<int:pk>/metadata/",
-        VideoMetadataView.as_view(),
+        VideoMetadataStatsView.as_view(),
         name="video-metadata",
     ),
     # Video Processing History API
@@ -123,14 +125,9 @@ urlpatterns = [
         VideoRemoveFramesView.as_view(),
         name="video-remove-frames",
     ),
+    path("media/videos/labels/list/", label_list, name="get_lvs_list"),
     # ---------------------------------------------------------------------------------------
     # VIDEO SEGMENT API ENDPOINTS (Modern Media Framework - October 14, 2025)
-    #
-    # Unified segment management endpoints replacing legacy /api/video-segments/
-    # Collection: GET/POST all segments across videos
-    # Video-scoped: GET/POST segments for specific video
-    # Detail: GET/PATCH/DELETE individual segment
-    # ---------------------------------------------------------------------------------------
     # Video Segments Collection API
     # GET/POST /api/media/videos/segments/
     # List all video segments across videos or create new segment
@@ -220,9 +217,9 @@ urlpatterns = [
         video_sensitive_metadata_verify,
         name="video-sensitive-metadata-verify",
     ),
-    # PDF Sensitive Metadata (Resource-Scoped)
+    # report Sensitive Metadata (Resource-Scoped)
     # GET/PATCH /api/media/pdfs/<pk>/sensitive-metadata/
-    # Get or update sensitive patient data for a PDF
+    # Get or update sensitive patient data for a report
     path(
         "media/pdfs/<int:pk>/sensitive-metadata/",
         pdf_sensitive_metadata,
@@ -252,17 +249,17 @@ urlpatterns = [
         pdf_sensitive_metadata_list,
         name="pdf-sensitive-metadata-list",
     ),
-    # PDF media endpoints
+    # report 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/", PdfStreamView.as_view(), name="pdf-stream"
+        "media/pdfs/<int:pk>/stream/", ReportStreamView.as_view(), name="pdf-stream"
     ),  # Support ?type=raw|anonymized params
-    # PDF Re-import API endpoint (modern media framework)
+    # report 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
+    # Re-imports a report file to regenerate metadata when OCR failed or data is incomplete
     path(
-        "media/pdfs/<int:pk>/reimport/", PdfReimportView.as_view(), name="pdf-reimport"
+        "media/pdfs/<int:pk>/reimport/", ReportReimportView.as_view(), name="report-reimport"
     ),
 ]
 # ---------------------------------------------------------------------------------------