endoreg-db 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

endoreg_db/data/distribution/numeric/data.yaml

@@ -10,5 +10,5 @@
   fields:
     name: "uniform_high_x1.5"
     distribution_type: "uniform"
-    min_descriptor: "max_x_1"
+    min_descriptor: "min_x_1"
     max_descriptor: "max_x_1.5"

endoreg_db/mermaid/Overall_flow_patient_finding_intervention.md

@@ -0,0 +1,10 @@
+```mermaid
+graph TD;
+
+    %% Main Patient Workflow
+    A[Patient: John] --> B[Examination: Colonoscopy]
+    B --> C[Finding: Colon Polyp]
+    C --> D[Finding Location: Colonoscopy Default - Right Flexure]
+    D --> E[Finding Morphology: Colon Lesion Planarity Default - Colon Lesion Planarity Excavated]
+    E --> F[Intervention: Colon Lesion Polypectomy - Hot Snare]
+    F --> G[Report Generation]

endoreg_db/mermaid/anonymized_image_annotation.md

@@ -0,0 +1,20 @@
+```mermaid
+graph TD;
+
+    %% File Handling Process
+    A[**Uploaded File**] -->|Original File Uploaded| B[**Anonymized File**]
+    B -->|File Anonymized & Stored| C[**Anonymous Image Annotation**]
+
+    %% Image Annotation & Processing
+    C -->|Label Assigned| D[**Anonymized Image Label**]
+    C -->|Detected Personal Info Removed| E[**Dropped Name**]
+
+    %% Relationships & Processing
+    E -->|Stored for Record-Keeping| C;
+    D -->|Predefined Labels Used| C;
+
+    %% Example Data (Corrected & Meaningful)
+    X1(["**Example: Uploaded colonoscopy.jpg**"]) -.-> A;
+    X2(["**Example: anonymized_colonoscopy.jpg**"]) -.-> B;
+    X3(["**Example: Label - 'Polyp Detected'**"]) -.-> D;
+    X4(["**Example: Name 'John Doe' removed**"]) -.-> E;

endoreg_db/mermaid/binary_classification_annotation.md

@@ -0,0 +1,50 @@
+```mermaid
+graph TD;
+
+  
+
+%% Step 1: Image Classification (Start)
+
+A[**Image Classification**] -->|Uses| B[**Label**];
+
+  
+
+%% Step 2: Video Segmentation
+
+A -->|Segments Stored In| C[**Video Segmentation**];
+
+  
+
+%% Step 3: Automatic Segmentation Detection
+
+D["**find_segments_in_prediction_array()**"] -->|Detects & Segments| C;
+
+  
+
+%% Step 4: Fetching Unclassified Frames for Annotation
+
+E["get_legacy_binary_classification_annotation_tasks_by_label()"] -->|Finds Frames Needing Annotation| F;
+
+  
+
+%% Step 5: Binary Classification Task Management
+
+F[**Binary Classification Task**] -->|Assigned To| G[**Frame**];
+
+F -->|Assigned To| H[**Legacy Frame**];
+
+F -->|Uses| B;
+
+%% Step 6: Task Completion & Cleanup (End)
+
+I["clear_finished_legacy_tasks()"] -->|Removes Completed Tasks| F;
+
+  
+
+%% Example Data
+
+X1(["Example: Frame classified as 'Polyp Present'"]) -.-> A;
+
+X2(["Example: Video segment marked from 100s to 200s"]) -.-> C;
+
+X3(["Example: 10 unclassified frames found"]) -.-> F;

endoreg_db/mermaid/classification.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Finding Location Classification"] --> B["Store in endoreg_db_findinglocationclassification"]
+    B --> C["Retrieve Available Choices"]
+    C --> D["Save Selected Location in endoreg_db_patientfinding_locations"]
+    D --> E["Link Location to Patient Finding via Foreign Key"]
+    E --> F["Finding Location Process Completed"]

endoreg_db/mermaid/examination.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Record Examination"] --> B["Store in endoreg_db_examination"]
+    B --> C["Retrieve Patient ID"]
+    C --> D["Save in endoreg_db_patientexamination with Patient ID"]
+    D --> E["Link Patient to Examination via Foreign Key"]
+    E --> F["Examination Process Completed"]

endoreg_db/mermaid/findings.md

@@ -0,0 +1,7 @@
+```mermaid
+graph TD;
+    
+    A["Start: Identify Medical Finding"] --> B["Store in endoreg_db_finding"]
+    B --> C["Retrieve Patient Examination ID"]
+    C --> D["Save in endoreg_db_patientfinding with Examination ID (Link Finding to Examination via Foreign Key)"]
+    D --> E["Finding Process Completed"]

endoreg_db/mermaid/image_classification.md

@@ -0,0 +1,28 @@
+```mermaid
+graph TD;
+
+    %% Image Classification Process
+    A[**Image Classification Annotation**] -->|Attached to| B[**Frame**];
+    A -->|Attached to| C[**Legacy Frame**];
+    A -->|Attached to| D[**Legacy Image**];
+    A -->|Uses Predefined| E[**Label**];
+
+    %% Video Segmentation Process
+    F[**Abstract Label Video Segment**] -->|Base Class for| G[**Legacy Label Video Segment**];
+    F -->|Base Class for| H[**Label Video Segment**];
+
+    %% Video References
+    G -->|Segmentation of| I[**Legacy Video**];
+    H -->|Segmentation of| J[**Modern Video**];
+
+    %% Metadata & Prediction Handling
+    G -->|Uses Prediction Data| K[**Legacy Video Prediction Meta**];
+    H -->|Uses Prediction Data| L[**Video Prediction Meta**];
+
+    %% Automatic Segmentation Process
+    M["**find_segments_in_prediction_array()**"] -->|Detects & Segments Frames| F;
+
+    %% Example Data
+    X1(["**Example: Frame classified as 'Polyp Present'**"]) -.-> A;
+    X2(["**Example: Segment starts at frame 100, ends at frame 200**"]) -.-> F;
+    X3(["**Example: Legacy Video used for segmentation**"]) -.-> G;

endoreg_db/mermaid/interventions.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Intervention"] --> B["Store in endoreg_db_findingintervention"]
+    B --> C["Retrieve Patient Finding ID"]
+    C --> D["Save in endoreg_db_patientfindingintervention"]
+    D --> E["Link Intervention to Patient Finding via Foreign Key"]
+    E --> F["Intervention Process Completed"]

endoreg_db/mermaid/morphology.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Morphology Classification"] --> B["Store in endoreg_db_findingmorphologyclassification"]
+    B --> C["Retrieve Associated Classification Type"]
+    C --> D["Save in endoreg_db_patientfinding_morphology"]
+    D --> E["Link Morphology to Patient Finding via Foreign Key"]
+    E --> F["Morphology Process Completed"]

endoreg_db/mermaid/patient_creation.md

@@ -0,0 +1,14 @@
+```mermaid
+graph TD;
+    
+    A["Start: Create New Patient (John)"] --> B{"Does the Center Exist?"}
+    
+    B -- Yes --> C["Retrieve Existing Center ID"]
+    B -- No --> D["Create New Medical Center"]
+    
+    D --> E["Retrieve Newly Created Center ID"]
+    C --> F["Save Patient in endoreg_db_patient with Center ID"]
+    E --> F
+    
+    F --> G["Patient Registration Completed"]
+

endoreg_db/mermaid/video_segmentation_annotation.md

@@ -0,0 +1,17 @@
+```mermaid
+graph TD;
+
+    %% Label Management
+    A[**Video Segmentation Label**] -->|Used in| B[**Video Segmentation Annotation**];
+
+    %% Annotation Process
+    B -->|Assigned to| C[**Raw Video File**];
+
+    %% Attributes Breakdown
+    A -->|Has Fields| A1[**Name, Description, Color, Priority**];
+    B -->|Has Fields| B1[**Start Time, Stop Time, Validity**];
+    
+    %% Example Data (Placed Outside for Clarity)
+    X1(["Example: Label - 'Polyp Detected'"]) -.-> A;
+    X2(["Example: Video1.mp4, Start: 10s, Stop: 15s"]) -.-> B;
+

endoreg_db/models/ai_model/ai_model.py

@@ -7,7 +7,7 @@ import os
 from django.db import models
 from icecream import ic
 
-PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
+PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data"))).expanduser()
 
 STORAGE_LOCATION = PSEUDO_DIR
 WEIGHTS_DIR_NAME = "db_model_weights"

endoreg_db/models/ai_model/model_meta.py

@@ -14,7 +14,7 @@ from icecream import ic
 if TYPE_CHECKING:
     from endoreg_db.models import LabelSet, AiModel  # pylint: disable=import-outside-toplevel
 
-PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
+PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data"))).expanduser()
 
 STORAGE_LOCATION = PSEUDO_DIR
 WEIGHTS_DIR_NAME = "db_model_weights"

endoreg_db/models/data_file/base_classes/utils.py

@@ -10,7 +10,7 @@ import numpy as np
 DJANGO_NAME_SALT = os.environ.get("DJANGO_NAME_SALT", "default_salt")
 
 # Directory stuff
-PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
+PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data"))).expanduser()
 STORAGE_LOCATION = PSEUDO_DIR
 FRAME_DIR_NAME = os.environ.get("DJANGO_FRAME_DIR_NAME", "db_frames")
 RAW_FRAME_DIR_NAME = os.environ.get("DJANGO_RAW_FRAME_DIR_NAME", "db_raw_frames")

endoreg_db/serializers/raw_pdf_anony_text_validation.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+from ..models import RawPdfFile
+
+class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch PDF metadata along with `anonymized_text` from `RawPdfFile`.
+    Ensures Vue.js can process JSON efficiently.
+    """
+
+    pdf_url = serializers.SerializerMethodField()
+    full_pdf_path = serializers.SerializerMethodField()
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
+                  'sensitive_meta_id', 'anonymized_text']
+
+    @staticmethod
+    def get_next_pdf(last_id=None):
+        """
+        Retrieves the first available PDF if `last_id` is NOT provided.
+        Otherwise, fetches the next available PDF where `id > last_id`.
+        """
+        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by('id').first()
+        return pdf_entry  
+
+    def get_pdf_url(self, obj):
+        """
+        Generates the full URL where Vue.js can fetch and display the PDF.
+        """
+        request = self.context.get('request')
+        return request.build_absolute_uri(f"/api/pdf/anony_text/?id={obj.id}") if request and obj.file else None
+
+    def get_file(self, obj):
+        """
+        Returns the relative file path stored in the database.
+        """
+        return str(obj.file.name).strip() if obj.file else None  
+
+    def get_full_pdf_path(self, obj):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
+        """
+        if not obj.file:
+            return None
+        pdf_relative_path = str(obj.file.name)
+        full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
+        return str(full_path) if full_path.exists() else None  
+
+    def validate_anonymized_text(self, value):
+        """
+        Ensures the anonymized_text is not empty or too long.
+        """
+        if not value.strip():
+            raise serializers.ValidationError("Anonymized text cannot be empty.")
+        if len(value) > 5000:  # Arbitrary limit to prevent excessively long text
+            raise serializers.ValidationError("Anonymized text exceeds the maximum length of 5000 characters.")
+        return value
+
+    def update(self, instance, validated_data):
+        """
+        Updates only `anonymized_text` without modifying other fields.
+        """
+        instance.anonymized_text = validated_data.get('anonymized_text', instance.anonymized_text)
+        instance.save()
+        return instance
+
+
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const fetchPdfWithAnonymizedText = async (lastId = null) => {
+    const url = lastId 
+        ? `http://localhost:8000/api/pdf/anony_text/?last_id=${lastId}` 
+        : "http://localhost:8000/api/pdf/anony_text/";
+
+    try {
+        const response = await axios.get(url, { headers: { "Accept": "application/json" } });
+        console.log("PDF Data:", response.data);
+    } catch (error) {
+        console.error("Error fetching PDF:", error.response?.data || error);
+    }
+};
+
+fetchPdfWithAnonymizedText();
+
+"""
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const updateAnonymizedText = async (pdfId, newText) => {
+    try {
+        const response = await axios.patch("http://localhost:8000/api/pdf/update_anony_text/", {
+            id: pdfId,
+            anonymized_text: newText
+        }, { headers: { "Content-Type": "application/json" } });
+
+        console.log("Update Success:", response.data);
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+    }
+};
+
+updateAnonymizedText(1, "Updated anonymized text.");
+
+"""
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const updateAnonymizedText = async () => {
+    const updatedData = {
+        id: 1,
+        anonymized_text: "This is the updated anonymized text."
+    };
+
+    try {
+        const response = await axios.patch("http://localhost:8000/api/pdf/update_anony_text/", updatedData, {
+            headers: { "Content-Type": "application/json" }
+        });
+
+        console.log("Update Success:", response.data);
+        alert("Anonymized text updated successfully!");
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+        alert("Failed to update anonymized text.");
+    }
+};
+
+updateAnonymizedText();
+"""

endoreg_db/serializers/raw_pdf_meta_validation.py

@@ -0,0 +1,223 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+from ..models import RawPdfFile, SensitiveMeta
+
+
+class PDFFileForMetaSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch PDF metadata along with linked `SensitiveMeta` details.
+    Implements validation and ensures Vue.js can process errors easily.
+    """
+
+    # Fetch patient details from `SensitiveMeta`
+    patient_first_name = serializers.CharField(source="sensitive_meta.patient_first_name", read_only=True)
+    patient_last_name = serializers.CharField(source="sensitive_meta.patient_last_name", read_only=True)
+    patient_dob = serializers.CharField(source="sensitive_meta.patient_dob", read_only=True)
+    examination_date = serializers.CharField(source="sensitive_meta.examination_date", read_only=True)
+
+    # PDF file URL where Vue.js can fetch the document
+    pdf_url = serializers.SerializerMethodField()
+
+    # Full absolute path of the PDF file
+    full_pdf_path = serializers.SerializerMethodField()
+
+    # Direct file path from the database
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
+                  'sensitive_meta_id', 'patient_first_name', 
+                  'patient_last_name', 'patient_dob', 'examination_date']
+
+    @staticmethod
+    def get_next_pdf(last_id=None):
+        """
+        Retrieves the first available PDF if `last_id` is NOT provided.
+        Otherwise, fetches the next available PDF where `id > last_id`.
+        """
+        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+
+        # Get the next available PDF
+        pdf_entry = RawPdfFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+
+        return pdf_entry  # Returns a model instance or None
+
+    def get_pdf_url(self, obj):
+        """
+        Generates the full URL for Vue.js to fetch and display the PDF.
+        """
+        request = self.context.get('request')
+        print("---------------------here :",obj.file)
+        if request and obj.file:
+            return request.build_absolute_uri(f"/api/pdf/sensitivemeta/?id={obj.id}")  # Constructs full API endpoint
+        return None  # Return None if file is missing
+
+    def get_file(self, obj):
+        """
+        Returns the relative file path stored in the database.
+        """
+        if not obj.file:
+            return None  # No file linked
+        return str(obj.file.name).strip()  # Ensures clean output
+
+    def get_full_pdf_path(self, obj):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
+        """
+        if not obj.file:
+            return None  # No file linked
+
+        pdf_relative_path = str(obj.file.name)
+
+        full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
+
+        return str(full_path) if full_path.exists() else None  # Returns path or None if file is missing
+
+    def validate(self, data):
+        """
+        Ensures that the PDF file is valid and has required fields.
+        """
+        errors = {}
+
+        if 'file' in data and not data['file']:
+            errors['file'] = "A valid PDF file is required."
+
+        if 'sensitive_meta_id' in data and not SensitiveMeta.objects.filter(id=data['sensitive_meta_id']).exists():
+            errors['sensitive_meta_id'] = "The provided sensitive_meta_id does not exist."
+
+        if errors:
+            raise serializers.ValidationError(errors)  # Returns structured error response
+
+        return data  # Returns validated data
+
+
+from rest_framework import serializers
+from ..models import SensitiveMeta
+
+class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer for updating patient details in the `SensitiveMeta` table.
+    Allows partial updates.
+    """
+
+    sensitive_meta_id = serializers.IntegerField(write_only=True)  # Needed for lookup, not included in response
+
+    class Meta:
+        model = SensitiveMeta
+        fields = ['sensitive_meta_id', 'patient_first_name', 'patient_last_name', 'patient_dob', 'examination_date']
+
+    def validate(self, data):
+        """
+        Ensures valid input before updating.
+        """
+        errors = {}
+
+        if 'patient_first_name' in data and (not data['patient_first_name'].strip()):
+            errors['patient_first_name'] = "First name cannot be empty."
+
+        if 'patient_last_name' in data and (not data['patient_last_name'].strip()):
+            errors['patient_last_name'] = "Last name cannot be empty."
+
+        if 'patient_dob' in data and not data['patient_dob']:
+            errors['patient_dob'] = "Date of birth is required."
+
+        if 'examination_date' in data and not data['examination_date']:
+            errors['examination_date'] = "Examination date is required."
+
+        if errors:
+            raise serializers.ValidationError(errors)
+
+        return data
+
+    def update(self, instance, validated_data):
+        """
+        Updates only the provided fields dynamically.
+        """
+        validated_data.pop("sensitive_meta_id", None)  # Remove ID before updating
+
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)  # Dynamically update fields
+
+        instance.save()
+        return instance
+
+
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+const fetchPdfMeta = async (lastId = 1) => {
+    const url = lastId 
+        ? `http://localhost:8000/api/pdf/sensitivemeta/?last_id=${lastId}` 
+        : "http://localhost:8000/api/pdf/sensitivemeta/";
+
+    try {
+        const response = await axios.get(url);
+        console.log("PDF Metadata:", response.data);
+    } catch (error) {
+        console.error("Error fetching PDFs:", error.response?.data || error);
+    }
+};
+
+fetchPdfMeta(); // Fetch the first available PDF
+
+"""
+
+"""with header response"""
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const fetchPdfMeta = async (lastId = 1) => {
+    const url = lastId 
+        ? `http://localhost:8000/api/pdf/sensitivemeta/?last_id=${lastId}` 
+        : "http://localhost:8000/api/pdf/sensitivemeta/";
+
+    try {
+        const response = await axios.get(url, {
+            headers: {
+                "Accept": "application/json"  
+            }
+        });
+
+        console.log("PDF Metadata (JSON Expected):", response.data);
+    } catch (error) {
+        console.error("Error fetching PDFs:", error.response?.data || error);
+    }
+};
+
+fetchPdfMeta(); 
+"""
+
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const updatePatientInfo = async () => {
+    const updatedData = {
+        sensitive_meta_id: 1,
+        patient_first_name: "dummy value",
+        patient_last_name: "dummy value",
+        patient_dob: "1994-06-15",
+        examination_date: "2024-06-15"
+    };
+
+    try {
+        const response = await axios.patch("http://localhost:8000/api/pdf/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));
+
+"""