endoreg-db 0.6.4__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/views/raw_video_meta_validation_views.py

@@ -1,148 +0,0 @@
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
-from django.http import FileResponse, Http404
-import mimetypes
-import os
-from ..models import RawVideoFile
-from ..serializers.raw_video_meta_validation import VideoFileForMetaSerializer,SensitiveMetaUpdateSerializer
-from ..models import SensitiveMeta
-
-
-class VideoFileForMetaView(APIView):
-    """
-    API endpoint to fetch video metadata step-by-step.
-    Uses the serializer to get the first or next available video.
-    """
-
-    def get(self, request):
-        """
-        - Fetches the **first available video** if `last_id` is NOT provided.
-        - Fetches the **next available video** where `id > last_id` if provided.
-        - If no video is available, returns a structured error response.
-        """
-        last_id = request.GET.get("last_id")  # Get last_id from query params
-
-        #  Get the next video as a model instance
-        video_entry = VideoFileForMetaSerializer.get_next_video(last_id)
-
-        if video_entry is None:
-            return Response({"error": "No more videos available."}, status=status.HTTP_404_NOT_FOUND)
-
-        serialized_video = VideoFileForMetaSerializer(video_entry, context={'request': request})
-
-        # Check if required fields are missing
-        response_data = serialized_video.data
-        missing_fields = {}
-
-        if response_data.get('file') is None:
-            missing_fields['file'] = "No file associated with this entry."
-
-        if response_data.get('video_url') is None:
-            missing_fields['video_url'] = "Video file is missing."
-
-        if response_data.get('full_video_path') is None:
-            missing_fields['full_video_path'] = "No file path found on server."
-
-        if not response_data.get('patient_first_name'):
-            missing_fields['patient_first_name'] = "Patient first name is missing."
-
-        if not response_data.get('patient_last_name'):
-            missing_fields['patient_last_name'] = "Patient last name is missing."
-
-        if not response_data.get('patient_dob'):
-            missing_fields['patient_dob'] = "Patient date of birth is missing."
-
-        if not response_data.get('examination_date'):
-            missing_fields['examination_date'] = "Examination date is missing."
-
-        if response_data.get('duration') is None:
-            missing_fields['duration'] = "Unable to determine video duration. The file might be corrupted or unreadable."
-
-        if missing_fields:
-            return Response({"error": "Missing required data.", "details": missing_fields}, 
-                            status=status.HTTP_400_BAD_REQUEST)
-
-        return Response(serialized_video.data, status=status.HTTP_200_OK)
-
-    def serve_video_file(self, video_entry):
-        """
-        Streams the video file dynamically.
-        """
-        try:
-            full_video_path = video_entry.file.path  #  Get file path
-
-            if not os.path.exists(full_video_path):
-                raise Http404("Video file not found.")
-
-            mime_type, _ = mimetypes.guess_type(full_video_path)  # Detects file type
-            response = FileResponse(open(full_video_path, "rb"), content_type=mime_type or "video/mp4")
-
-            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_video_path)}"'  # Allows direct streaming
-
-            return response  # Sends the video file as a stream
-
-        except Exception as e:
-            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-        
-
-    def patch(self, request, *args, **kwargs):
-        """
-        Calls the serializer to update `SensitiveMeta` data.
-        """
-
-        # Ensure all required fields are provided
-        required_fields = ["sensitive_meta_id", "patient_first_name", "patient_last_name", "patient_dob", "examination_date"]
-        missing_fields = [field for field in required_fields if field not in request.data]
-
-        if missing_fields:
-            return Response({"error": "Missing required fields", "missing_fields": missing_fields}, status=status.HTTP_400_BAD_REQUEST)
-
-        #  Call serializer for validation
-        serializer = SensitiveMetaUpdateSerializer(data=request.data, partial=True)
-
-        if serializer.is_valid():
-            #  Get the instance and update it
-            sensitive_meta = SensitiveMeta.objects.get(id=request.data["sensitive_meta_id"])
-            updated_instance = serializer.update(sensitive_meta, serializer.validated_data)
-
-            return Response({
-                "message": "Patient information updated successfully.",
-                "updated_data": SensitiveMetaUpdateSerializer(updated_instance).data
-            }, status=status.HTTP_200_OK)
-
-        #  Return validation errors
-        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
-    
-
-    """
-    await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
-const updatePatientInfo = async () => {
-    const updatedData = {
-        sensitive_meta_id: 2,
-        patient_first_name: "Placeholder",
-        patient_last_name: "Placeholder",
-        patient_dob: "1994-06-15",
-        examination_date: "2024-06-15"
-    };
-
-    try {
-        const response = await axios.patch("http://localhost:8000/api/video/update_sensitivemeta/", updatedData, {
-            headers: { "Content-Type": "application/json" }
-        });
-
-        console.log("Update Success:", response.data);
-        alert("Patient information updated successfully!");
-
-        return response.data;  
-    } catch (error) {
-        console.error("Update Error:", error.response?.data || error);
-        alert("Failed to update patient information.");
-        return error.response?.data || { error: "Unknown error" };  
-    }
-};
-
-
-updatePatientInfo().then(response => console.log("Final Response:", response));
-
-    """

endoreg_db/views/report_views.py

@@ -1,96 +0,0 @@
-from django.shortcuts import render
-from django.contrib.admin.views.decorators import staff_member_required
-
-@staff_member_required  # Ensures only staff members can access the page
-def start_examination(request):
-    return render(request, 'admin/start_examination.html')  # Loads the simple HTML page
-
-from django.shortcuts import render
-#from ..models.patient.patient_finding_location import PatientFindingLocation
-from ..models import FindingLocationClassification, FindingLocationClassificationChoice  # Correct models
-
-
-#need to implement one with json data after tesing whethe rthis works or not
-"""def get_location_choices(request, location_id):
-   
-    try:
-        # Ensure the location exists
-        location = FindingLocationClassification.objects.get(id=location_id)
-        # Get only choices related to the selected location classification
-        #location_choices = FindingLocationClassificationChoice.objects.filter(location_classification=location)
-        #its many to may relation so
-        location_choices = location.choices.all()
-        
-    except FindingLocationClassification.DoesNotExist:
-        location_choices = []
-
-    # Get previously selected values to retain them after reloading
-    selected_location = int(location_id) if location_id else None
-
-    return render(request, 'admin/patient_finding_intervention.html', {
-        "location_choices": location_choices,  # Pass updated choices to the template
-        "selected_location": location_id,  # Keep previous selection
-    })
-"""
-from django.shortcuts import render
-from rest_framework import viewsets
-from ..models import Patient
-from ..serializers import PatientSerializer
-from rest_framework.permissions import IsAuthenticatedOrReadOnly
-
-class PatientViewSet(viewsets.ModelViewSet):
-    """API endpoint for managing patients."""
-    queryset = Patient.objects.all()
-    serializer_class = PatientSerializer
-    permission_classes = [IsAuthenticatedOrReadOnly] 
-
-    def perform_create(self, serializer):
-        serializer.save()
-
-from django.http import JsonResponse
-from ..models import FindingLocationClassification, FindingLocationClassificationChoice
-
-def get_location_choices(request, location_id):
-    """
-    Fetch location choices dynamically based on the selected FindingLocationClassification (Location).
-    """
-    try:
-        location = FindingLocationClassification.objects.get(id=location_id)
-        location_choices = location.choices.all()  # Get choices via Many-to-Many relationship
-        data = [{"id": choice.id, "name": choice.name} for choice in location_choices]
-    except FindingLocationClassification.DoesNotExist:
-        data = []
-
-    return JsonResponse({"location_choices": data})
-
-from django.http import JsonResponse
-from ..models import FindingMorphologyClassification, FindingMorphologyClassificationChoice, FindingMorphologyClassificationType
-from django.core.exceptions import ObjectDoesNotExist
-
-
-
-def get_morphology_choices(request, morphology_id):
-    """
-    Fetch morphology choices dynamically based on the selected FindingMorphologyClassification.
-    """
-    try:
-        # Find the selected Morphology Classification
-        morphology_classification = FindingMorphologyClassification.objects.get(id=morphology_id)
-
-        # Fetch choices from FindingMorphologyClassificationType using classification_type_id
-        morphology_choices = FindingMorphologyClassificationType.objects.filter(
-            id=morphology_classification.classification_type_id
-        )
-
-        #  Cpnvert QuerySet to JSON
-        data = [{"id": choice.id, "name": choice.name} for choice in morphology_choices]
-
-        return JsonResponse({"morphology_choices": data})  #  Always return JSON
-
-    except ObjectDoesNotExist:
-        return JsonResponse({"error": "Morphology classification not found", "morphology_choices": []}, status=404)
-
-    except Exception as e:
-        print(f"Error fetching morphology choices: {e}")  # Debugging Log
-        return JsonResponse({"error": "Internal server error", "morphology_choices": []}, status=500)
-

endoreg_db/views/video_segmentation_views.py

@@ -1,166 +0,0 @@
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
-from django.http import FileResponse, Http404
-from ..models import RawVideoFile, Label
-from ..serializers.video_segmentation import VideoFileSerializer,VideoListSerializer,LabelSerializer
-import mimetypes
-import os
-
-
-class VideoView(APIView):
-    """
-    API endpoint to:
-    - Fetch video metadata (JSON)
-    - Serve the actual video file dynamically
-    """
-
-    def get(self, request, video_id=None):
-        """
-        Handles GET requests:
-        - If no `video_id` is provided, return a list of all videos for frontend dropdown.
-        - If `Accept: application/json` is in the request headers, return metadata for a specific video.
-        - Otherwise, return the video file.
-        """
-        if video_id is None:
-            return self.get_all_videos()
-        return self.get_video_details(request, video_id)
-
-    def get_all_videos(self):
-        """
-        Returns a list of all available videos along with available labels.
-        Used to populate the video selection dropdown in Vue.js.
-        """
-        
-        videos = RawVideoFile.objects.all()
-        labels = Label.objects.all()  # Fetch all labels
-
-        if not videos.exists():
-            return Response({"error": "No videos found in the database."}, status=status.HTTP_404_NOT_FOUND)
-
-
-        video_serializer = VideoListSerializer(videos, many=True)
-        label_serializer = LabelSerializer(labels, many=True)  # Serialize labels
-
-        return Response({
-            "videos": video_serializer.data,  # List of videos
-            "labels": label_serializer.data  # List of labels
-        }, status=status.HTTP_200_OK)
-
-    def get_video_details(self, request, video_id):
-        """
-        Returns metadata for a specific video if `Accept: application/json` is set.
-        Otherwise, streams the video file.
-        """
-        try:
-            video_entry = RawVideoFile.objects.get(id=video_id)
-            serializer = VideoFileSerializer(video_entry, context={'request': request})
-
-            accept_header = request.headers.get('Accept', '')
-
-            if "application/json" in accept_header:
-                return Response(serializer.data, status=status.HTTP_200_OK)
-
-            return self.serve_video_file(video_entry)
-
-        except RawVideoFile.DoesNotExist:
-            return Response({"error": "Video not found in the database."}, status=status.HTTP_404_NOT_FOUND)
-        except Exception as e:
-            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def serve_video_file(self, video_entry):
-        """
-        Serves the video file dynamically.
-        """
-        try:
-            full_video_path = video_entry.file.path  # Get the correct file path
-
-            if not os.path.exists(full_video_path):
-                raise Http404("Video file not found.")
-
-            mime_type, _ = mimetypes.guess_type(full_video_path)  # Determine the content type (e.g., video/mp4, video/avi)
-            response = FileResponse(open(full_video_path, "rb"), content_type=mime_type or "video/mp4")
-
-            # Enable video streaming and CORS
-            response["Access-Control-Allow-Origin"] = "*"  # Allow frontend access
-            response["Access-Control-Allow-Credentials"] = "true"
-            response["Accept-Ranges"] = "bytes"  # Enable seeking in video player
-            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_video_path)}"'  # Instructs the browser to play the video instead of downloading it.
-
-            return response
-
-        except Exception as e:
-            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-
-from ..serializers.video_segmentation import VideoFileSerializer
-
-class VideoLabelView(APIView):
-    """
-    API to fetch time segments (start & end times in seconds) for a specific label.
-    """
-
-    def get(self, request, video_id, label_name):
-        """
-        Handles GET request to return:
-        - Time segments for the selected label.
-        - Frame-wise predictions within those segments.
-        """
-        try:
-            video_entry = RawVideoFile.objects.get(id=video_id)
-            
-            serializer = VideoFileSerializer(video_entry, context={'request': request})
-            label_data = serializer.get_label_time_segments(video_entry)
-
-            # Ensure the requested label exists
-            if label_name not in label_data:
-                return Response({"error": f"Label '{label_name}' not found"}, status=status.HTTP_404_NOT_FOUND)
-
-            return Response({
-                "label": label_name,
-                "time_segments": label_data[label_name]["time_ranges"],
-                "frame_predictions": label_data[label_name]["frame_predictions"]
-            }, status=status.HTTP_200_OK)
-
-        except RawVideoFile.DoesNotExist:
-            return Response({"error": "Video not found"}, status=status.HTTP_404_NOT_FOUND)
-
-        except Exception as e:
-            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-from ..serializers.video_segmentation import LabelSegmentUpdateSerializer, LabelSegmentSerializer
-
-class UpdateLabelSegmentsView(APIView):
-    """
-    API to update or create label segments for a video.
-    """
-
-    def put(self, request, video_id, label_id):
-        """
-        Updates segments for a given video & label.
-        """
-
-        # Ensure required fields are provided
-        required_fields = ["video_id", "label_id", "segments"]
-        missing_fields = [field for field in required_fields if field not in request.data]
-
-        if missing_fields:
-            return Response({"error": "Missing required fields", "missing": missing_fields}, status=status.HTTP_400_BAD_REQUEST)
-
-        # Validate input data
-        serializer = LabelSegmentUpdateSerializer(data=request.data, partial=True)
-
-        if not serializer.is_valid():
-            return Response({"error": "Invalid segment data", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
-
-        # Process and save segment updates
-        result = serializer.save()
-
-        return Response({
-            "message": "Segments updated successfully.",
-            "updated_segments": result["updated_segments"],
-            "new_segments": result["new_segments"],
-            "deleted_segments": result["deleted_segments"]
-        }, status=status.HTTP_200_OK)

endoreg_db-0.6.4.dist-info/METADATA

@@ -1,161 +0,0 @@
-Metadata-Version: 2.4
-Name: endoreg-db
-Version: 0.6.4
-Summary: EndoReg Db Django App
-Project-URL: Homepage, https://info.coloreg.de
-Project-URL: Repository, https://github.com/wg-lux/endoreg-db
-Author: Max Hild, Hamza Zahid, Peter Kowalczyk
-Author-email: "Thomas J. Lux" <lux_t1@ukw.de>
-Maintainer: Max Hild, Hamza Zahid, Peter Kowalczyk
-Maintainer-email: "Thomas J. Lux" <lux_t1@ukw.de>
-License-File: LICENSE
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
-Requires-Python: >=3.11
-Requires-Dist: agl-report-reader>=0.4.0
-Requires-Dist: django-bootstrap5>=24.3
-Requires-Dist: django-cors-headers>=4.7.0
-Requires-Dist: django-extensions>=3.2.3
-Requires-Dist: django>=5.1.3
-Requires-Dist: djangorestframework>=3.15.2
-Requires-Dist: faker>=32.1.0
-Requires-Dist: icecream>=2.1.4
-Requires-Dist: numpy>=2.1.3
-Requires-Dist: opencv-python>=4.10.0.84
-Requires-Dist: pandas>=2.2.3
-Requires-Dist: pillow>=11.0.0
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: pytesseract>=0.3.13
-Requires-Dist: python-ffmpeg>=2.0.12
-Requires-Dist: pytorch-lightning>=2.4.0
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: scikit-learn>=1.5.2
-Requires-Dist: scipy>=1.14.1
-Requires-Dist: tesseract>=0.1.3
-Requires-Dist: tqdm>=4.67.0
-Requires-Dist: urllib3>=2.2.3
-Description-Content-Type: text/markdown
-
-# EndoregDB - Professional Data Infrastructure for Clinical Research
-
-EndoregDB is a comprehensive database framework designed to manage medical and research-related data for clinical trials. This repository focuses on efficient data processing, automated deployment, security, and reproducibility, offering a flexible setup for local development environments as well as distributed systems. It supports the integration of AI/ML tools and advanced image and report processing.
-
-This infrastructure was originally designed for clinical research studies and is optimized for handling large data volumes, including:
-
-- Medical reports,
-- Patient imaging and video data,
-- Clinical product and treatment data,
-  and more.
-
-## 🚀 Key Features
-
-### System Architecture
-
-- **Modular Design**: Built on scalable and reusable components to simplify integration into various environments.
-- **Multi-System Support**: Manages configurations for local workstations and production servers.
-- **Role-Specific Configuration**: Predefined roles for common use cases:
-  - Medical data processing systems
-  - AI/ML model deployment
-  - Research workstation configuration
-
-### Security & Data Management
-
-- **Data Encryption**: All sensitive data is encrypted, and privacy policies are enforced.
-- **Impermanence**: Stateless system configuration with persistence for critical data.
-- **Access Control**: Role-based access and identity management integration.
-
-### Data and Processing Environment
-
-- **Data Processing**: Optimized for processing medical datasets with preprocessing tools.
-- **AI/ML Support**:
-  - Integration of machine learning tools for predictive analysis.
-  - TensorFlow, PyTorch, and other frameworks supported for model training.
-- **Image/Video Processing**: Support for analyzing patient images and clinical videos.
-
-### Development Tools & Infrastructure
-
-- **Data Science Toolchains**: Pre-configured environments for data processing, analysis, and visualization.
-- **Monitoring & Logging**: Setup for continuous monitoring and logging to ensure system stability and performance.
-
----
-
-## 🛠 Getting Started
-
-### Prerequisites
-
-- A Linux-based system (Ubuntu/Debian recommended) or NixOS
-- Hardware with sufficient storage for data processing (at least 1 TB recommended)
-
-### Quick Start
-
-1. Clone the repository:
-
-   ```bash
-   git clone https://github.com/wg-lux/endoreg-db.git
-   cd endoreg-db
-   ```
-
-2. Set up your Python environment:
-   _TODO_: Explain Devenv / point to other docs
-
-   ```bash
-   direnv allow
-   ```
-
-3. Run tests:
-   Call Devenv Script to run tests
-
-   ```bash
-   runtests
-   ```
-
----
-
-## 📁 Repository Structure
-
-```
-endoreg-db/
-├── endoreg_db/                # Main Django app for medical data
-│   ├── case_generator/        # Sample case generator
-│   ├── data/                  # Medical knowledge base
-│   ├── management/            # Data wrangling operations
-│   ├── models/                # Data models
-│   ├── migrations/            # Database migrations
-│   └── serializers/           # Serializers for data
-├── .gitignore                 # Git ignore file for unnecessary files
-└── README.md                  # Project description and setup instructions
-```
-
----
-
-## 🔒 Security Features
-
-- **Data Encryption**: All sensitive patient data is encrypted.
-- **Role-Based Access Control**: Configurable roles for managing access to various parts of the system.
-- **Logging & Auditing**: Comprehensive logging system that tracks user activities and data changes.
-
----
-
-## 🖥️ Supported Systems
-
-- **Workstations**: Local development or research workstations with low data processing demands.
-- **Servers**: Scalable server infrastructure for processing large data volumes, integrated with cloud services for scalability.
-
----
-
-## 🛟 Support
-
-For issues and questions:
-
-- Create an issue in the repository
-- Review the Deployment Guide for common issues
-
----
-
-## 📜 License
-
-MIT - see LICENSE
-
----