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

endoreg_db/utils/links/requirement_link.py

@@ -1,31 +1,39 @@
-from typing import List, Optional, TYPE_CHECKING # Modified import
+from typing import List, Optional, TYPE_CHECKING  # Modified import
 
 from pydantic import BaseModel, Field
 
 from endoreg_db.models import (
-    PatientDisease, Disease, DiseaseClassificationChoice,
-    Event, 
-    PatientEvent, Examination, ExaminationIndication, ExaminationIndicationClassificationChoice,
-    PatientExamination, PatientExaminationIndication,
+    PatientDisease,
+    Disease,
+    DiseaseClassificationChoice,
+    Event,
+    PatientEvent,
+    Examination,
+    ExaminationIndication,
+    ExaminationIndicationClassificationChoice,
+    PatientExamination,
+    PatientExaminationIndication,
     PatientFinding,
-    Finding, 
-    FindingIntervention, 
+    Finding,
+    FindingIntervention,
     FindingClassification,
-    FindingClassificationChoice, 
+    FindingClassificationChoice,
     LabValue,
     PatientLabValue,
     PatientLabSample,
     PatientLabSampleType,
-    PatientMedication, # Added
-    PatientMedicationSchedule, # Added
-    Medication, # Added
-    MedicationIndication, # Added
-    MedicationIntakeTime, # Added
-    MedicationSchedule, # Added
+    PatientMedication,  # Added
+    PatientMedicationSchedule,  # Added
+    Medication,  # Added
+    MedicationIndication,  # Added
+    MedicationIntakeTime,  # Added
+    MedicationSchedule,  # Added
 )
-if TYPE_CHECKING: # Added for Patient import
+
+if TYPE_CHECKING:  # Added for Patient import
     from endoreg_db.models.administration.person.patient import Patient
 
+
 class RequirementLinks(BaseModel):
     """
     A class representing a dictionary of models related to a requirement.
@@ -45,34 +53,49 @@ class RequirementLinks(BaseModel):
         finding_location_classification_choices (List[FindingLocationClassificationChoice]): A List of finding location classification choices.
         finding_interventions (List[FindingIntervention]): A List of finding interventions.
     """
+
     model_config = {"arbitrary_types_allowed": True}
-    # 
+    #
     # requirement_types: Optional[List["RequirementType"]] = None
     # operators: Optional[List["RequirementOperator"]] = None
     # The following model import causes circular import
-    #requirement_sets: Optional[List["RequirementSet"]] = None
+    # requirement_sets: Optional[List["RequirementSet"]] = None
     examinations: List["Examination"] = Field(default_factory=list)
     examination_indications: List["ExaminationIndication"] = Field(default_factory=list)
-    examination_indication_classification_choices: List["ExaminationIndicationClassificationChoice"] = Field(default_factory=list)
+    examination_indication_classification_choices: List[
+        "ExaminationIndicationClassificationChoice"
+    ] = Field(default_factory=list)
     patient_examinations: List["PatientExamination"] = Field(default_factory=list)
-    
-    patient_examination_indication: List["PatientExaminationIndication"] = Field(default_factory=list)
+
+    patient_examination_indication: List["PatientExaminationIndication"] = Field(
+        default_factory=list
+    )
     lab_values: List["LabValue"] = Field(default_factory=list)
     patient_lab_values: List["PatientLabValue"] = Field(default_factory=list)
     patient_lab_samples: List["PatientLabSample"] = Field(default_factory=list)
     patient_diseases: List["PatientDisease"] = Field(default_factory=list)
     diseases: List["Disease"] = Field(default_factory=list)
-    disease_classification_choices: List["DiseaseClassificationChoice"] = Field(default_factory=list)
+    disease_classification_choices: List["DiseaseClassificationChoice"] = Field(
+        default_factory=list
+    )
     events: List["Event"] = Field(default_factory=list)
     patient_events: List["PatientEvent"] = Field(default_factory=list)
     patient_findings: List["PatientFinding"] = Field(default_factory=list)
     findings: List["Finding"] = Field(default_factory=list)
-    finding_classification_choices: List["FindingClassificationChoice"] = Field(default_factory=list)
-    finding_classifications: List["FindingClassification"] = Field(default_factory=list) # Added for direct classification checks if needed
+    finding_classification_choices: List["FindingClassificationChoice"] = Field(
+        default_factory=list
+    )
+    finding_classifications: List["FindingClassification"] = Field(
+        default_factory=list
+    )  # Added for direct classification checks if needed
     finding_interventions: List["FindingIntervention"] = Field(default_factory=list)
     patient_lab_sample_types: List["PatientLabSampleType"] = Field(default_factory=list)
-    patient_medications: List["PatientMedication"] = Field(default_factory=list) # Added
-    patient_medication_schedules: List["PatientMedicationSchedule"] = Field(default_factory=list) # Added
+    patient_medications: List["PatientMedication"] = Field(
+        default_factory=list
+    )  # Added
+    patient_medication_schedules: List["PatientMedicationSchedule"] = Field(
+        default_factory=list
+    )  # Added
     # Added direct medication-related fields
     medications: List["Medication"] = Field(default_factory=list)
     medication_indications: List["MedicationIndication"] = Field(default_factory=list)
@@ -87,38 +110,42 @@ class RequirementLinks(BaseModel):
         """
         if self.patient_lab_values:
             for plv in self.patient_lab_values:
-                if hasattr(plv, 'sample') and plv.sample and \
-                   hasattr(plv.sample, 'patient') and plv.sample.patient:
+                if (
+                    hasattr(plv, "sample")
+                    and plv.sample
+                    and hasattr(plv.sample, "patient")
+                    and plv.sample.patient
+                ):
                     return plv.sample.patient
         if self.patient_lab_samples:
             for pls in self.patient_lab_samples:
-                if hasattr(pls, 'patient') and pls.patient:
+                if hasattr(pls, "patient") and pls.patient:
                     return pls.patient
         if self.patient_examinations:
             for pe in self.patient_examinations:
-                if hasattr(pe, 'patient') and pe.patient:
+                if hasattr(pe, "patient") and pe.patient:
                     return pe.patient
         if self.patient_diseases:
             for pd in self.patient_diseases:
-                if hasattr(pd, 'patient') and pd.patient:
+                if hasattr(pd, "patient") and pd.patient:
                     return pd.patient
         if self.patient_events:
             for pev in self.patient_events:
-                if hasattr(pev, 'patient') and pev.patient:
+                if hasattr(pev, "patient") and pev.patient:
                     return pev.patient
         if self.patient_findings:
             for pf in self.patient_findings:
-                if hasattr(pf, 'patient') and pf.patient:
+                if hasattr(pf, "patient") and pf.patient:
                     return pf.patient
         # Check PatientMedication
         if self.patient_medications:
             for pm in self.patient_medications:
-                if hasattr(pm, 'patient') and pm.patient:
+                if hasattr(pm, "patient") and pm.patient:
                     return pm.patient
         # Check PatientMedicationSchedule
         if self.patient_medication_schedules:
             for pms in self.patient_medication_schedules:
-                if hasattr(pms, 'patient') and pms.patient:
+                if hasattr(pms, "patient") and pms.patient:
                     return pms.patient
         return None
 
@@ -126,32 +153,37 @@ class RequirementLinks(BaseModel):
     def data_model_dict(self):
         """
         Provides access to the data model dictionary used for requirement type parsing.
-        
+
         Returns:
             The `data_model_dict` imported from the requirement type parser module.
         """
-        from endoreg_db.models.requirement.requirement_evaluation.requirement_type_parser import data_model_dict
+        from endoreg_db.models.requirement.requirement_evaluation.requirement_type_parser import (
+            data_model_dict,
+        )
+
         return data_model_dict
 
     @property
     def data_model_dict_reverse(self):
         """
         Provides a reverse mapping dictionary for data model types used in requirement evaluation.
-        
+
         Returns:
             The `data_model_dict_reverse` dictionary imported from the requirement type parser module.
         """
-        from endoreg_db.models.requirement.requirement_evaluation.requirement_type_parser import data_model_dict_reverse
+        from endoreg_db.models.requirement.requirement_evaluation.requirement_type_parser import (
+            data_model_dict_reverse,
+        )
 
         return data_model_dict_reverse
 
-    def match_any(self, other:"RequirementLinks") -> bool:
+    def match_any(self, other: "RequirementLinks") -> bool:
         """
         Determines if any linked model in this instance is also present in another RequirementLinks instance.
-        
+
         Compares each list attribute of both instances and returns True if any element in any list overlaps.
         """
-        
+
         other_dict = other.model_dump()
         self_dict = self.model_dump()
         for key in self_dict:
@@ -159,12 +191,12 @@ class RequirementLinks(BaseModel):
             if key in other_dict and self_dict[key] and other_dict[key]:
                 if any(item in other_dict[key] for item in self_dict[key]):
                     return True
-        return False # Ensure False is returned if no match is found
-    
+        return False  # Ensure False is returned if no match is found
+
     def active(self) -> dict[str, list]:
         """
         Returns a dictionary of all non-empty linked model lists.
-        
+
         Only attributes with non-empty lists are included in the returned dictionary.
         """
         active_links_dict = {}
@@ -180,14 +212,26 @@ class RequirementLinks(BaseModel):
         """
         data = self.model_dump()
         fields = [
-            'examinations', 'examination_indications', 'patient_examinations',
-            'lab_values', 'patient_lab_values', 'patient_diseases', 'diseases',
-            'disease_classification_choices', 'events', 'patient_events', 'findings',
-            'patient_findings', 'finding_classification_choices', 'finding_interventions',
-            'patient_medications', 'patient_medication_schedules', 'medications',
-            'medication_indications', 'medication_intake_times', 'medication_schedules'
+            "examinations",
+            "examination_indications",
+            "patient_examinations",
+            "lab_values",
+            "patient_lab_values",
+            "patient_diseases",
+            "diseases",
+            "disease_classification_choices",
+            "events",
+            "patient_events",
+            "findings",
+            "patient_findings",
+            "finding_classification_choices",
+            "finding_interventions",
+            "patient_medications",
+            "patient_medication_schedules",
+            "medications",
+            "medication_indications",
+            "medication_intake_times",
+            "medication_schedules",
         ]
         parts = [f"{f}={len(data.get(f, []))}" for f in fields]
         return f"RequirementLinks({', '.join(parts)})"
-
-

endoreg_db/utils/ocr.py

@@ -1,18 +1,18 @@
 import pytesseract
-from PIL import Image, ImageOps, ImageFilter
+from PIL import Image, ImageOps
+import cv2
 import os
 from collections import Counter
 from tempfile import TemporaryDirectory
 import re
 from datetime import datetime
 from typing import Dict, List
-import numpy as np
 from endoreg_db.utils.cropping import crop_and_insert
 
 
-
 N_FRAMES_MEAN_OCR = 2
 
+
 # Helper function to process date strings
 def process_date_text(date_text):
     """
@@ -26,7 +26,7 @@ def process_date_text(date_text):
     """
     try:
         # Remove any non-digit characters
-        date_text_clean = re.sub(r'\D', '', date_text)
+        date_text_clean = re.sub(r"\D", "", date_text)
         # Reformat to 'ddmmyyyy' if necessary
         if len(date_text_clean) == 8:
             return datetime.strptime(date_text_clean, "%d%m%Y").date()
@@ -37,14 +37,15 @@ def process_date_text(date_text):
         # set date to 1/1/1900
         return datetime.strptime("01011900", "%d%m%Y").date()
 
+
 # Helper function to process patient names
 def process_name_text(name_text):
     """
     Remove all numbers, punctuation, and whitespace from a string of text and return the result.
     """
-    name = re.sub(r'[0-9!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\s]+', '', name_text).strip()
+    name = re.sub(r'[0-9!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\s]+', "", name_text).strip()
     # capitalize first letter of each word
-    name = ' '.join([word.capitalize() for word in name.split()])
+    name = " ".join([word.capitalize() for word in name.split()])
     return name
 
 
@@ -53,7 +54,8 @@ def process_general_text(endoscope_text):
     """
     This function takes in a string of text from an endoscope and returns a cleaned version of the text.
     """
-    return ' '.join(endoscope_text.split())
+    return " ".join(endoscope_text.split())
+
 
 def roi_values_valid(roi):
     """
@@ -61,6 +63,7 @@ def roi_values_valid(roi):
     """
     return all([value >= 0 for value in roi.values()])
 
+
 # Function to extract text from ROIs
 def extract_text_from_rois(image_path, processor):
     """
@@ -75,11 +78,11 @@ def extract_text_from_rois(image_path, processor):
     """
     # Read the image using Pillow
     image = Image.open(image_path)
-    image_dimensions = image.size # (width, height)
+    image_dimensions = image.size  # (width, height)
 
     ####### Adjust Image #######
     # Convert to grayscale
-    gray = image.convert('L')
+    gray = image.convert("L")
 
     # Invert colors for white text on black background
     inverted = ImageOps.invert(gray)
@@ -89,36 +92,36 @@ def extract_text_from_rois(image_path, processor):
 
     # Define your ROIs and their corresponding post-processing functions in tuples
     rois_with_postprocessing = [
-        ('examination_date', processor.get_roi_examination_date, process_date_text),
+        ("examination_date", processor.get_roi_examination_date, process_date_text),
         ("patient_first_name", processor.get_roi_patient_first_name, process_name_text),
-        ('patient_last_name', processor.get_roi_patient_last_name, process_name_text),
-        ('patient_dob', processor.get_roi_patient_dob, process_date_text),
-        ('endoscope_type', processor.get_roi_endoscope_type, process_general_text),
-        ('endoscope_sn', processor.get_roi_endoscopy_sn, process_general_text),
+        ("patient_last_name", processor.get_roi_patient_last_name, process_name_text),
+        ("patient_dob", processor.get_roi_patient_dob, process_date_text),
+        ("endoscope_type", processor.get_roi_endoscope_type, process_general_text),
+        ("endoscope_sn", processor.get_roi_endoscopy_sn, process_general_text),
     ]
 
     # Extract and post-process text for each ROI
     for roi_name, roi_function, post_process in rois_with_postprocessing:
         # Get the ROI dictionary
         roi = roi_function()
-        
+
         # Check if the ROI has values
-        
+
         if roi_values_valid(roi):
-            x, y, w, h = roi['x'], roi['y'], roi['width'], roi['height']
-            
+            x, y, w, h = roi["x"], roi["y"], roi["width"], roi["height"]
+
             # Get white image with original shape and just the roi remaining
-            roi_image = crop_and_insert(inverted, x,y,h,w)
+            roi_image = crop_and_insert(inverted, x, y, h, w)
 
             # OCR configuration: Recognize white text on black background without corrections
-            config = '--psm 10 -c tessedit_char_whitelist=0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-üöäÜÖÄß'
+            config = "--psm 10 -c tessedit_char_whitelist=0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-üöäÜÖÄß"
 
             # Use pytesseract to do OCR on the preprocessed ROI
             text = pytesseract.image_to_string(roi_image, config=config).strip()
 
             # Post-process extracted text
             processed_text = post_process(text)
-            
+
             extracted_texts[roi_name] = processed_text
 
         else:
@@ -126,6 +129,7 @@ def extract_text_from_rois(image_path, processor):
 
     return extracted_texts
 
+
 def get_most_frequent_values(rois_texts: Dict[str, List[str]]) -> Dict[str, str]:
     """
     Given a dictionary of ROIs and their corresponding texts, returns a dictionary of the most frequent text for each ROI.
@@ -142,6 +146,7 @@ def get_most_frequent_values(rois_texts: Dict[str, List[str]]) -> Dict[str, str]
         most_frequent[key], _ = counter.most_common(1)[0] if counter else (None, None)
     return most_frequent
 
+
 def process_video(video_path, processor):
     """
     Processes a video file by extracting text from regions of interest (ROIs) in each frame.
@@ -169,10 +174,10 @@ def process_video(video_path, processor):
                 frame_path = os.path.join(temp_dir, f"frame_{frame_number}.jpg")
                 cv2.imwrite(frame_path, frame)  # Save the frame as a JPEG file
                 # cv2.imwrite(f"_tmp/frame_{frame_number}.jpg", frame)
-                
+
                 # Extract text from ROIs
                 extracted_texts = extract_text_from_rois(frame_path, processor)
-                
+
                 # Store the extracted text from each ROI
                 for key, text in extracted_texts.items():
                     rois_texts[key].append(text)
@@ -180,11 +185,11 @@ def process_video(video_path, processor):
 
             frame_number += 1
 
-            if frames_for_mean_extraction >= N_FRAMES_MEAN_OCR: break
+            if frames_for_mean_extraction >= N_FRAMES_MEAN_OCR:
+                break
 
         # Release the video capture object
         video.release()
 
         # Get the most frequent values for each ROI
         return get_most_frequent_values(rois_texts)
-

endoreg_db/utils/operation_log.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from django.http import HttpRequest
+
+from endoreg_db.models.operation_log import OperationLog
+
+logger = logging.getLogger(__name__)
+
+
+def record_operation(
+    request: HttpRequest,
+    *,
+    action: str,
+    resource_type: str = "",
+    resource_id: Optional[int] = None,
+    status_before: Optional[str] = None,
+    status_after: Optional[str] = None,
+    meta: Optional[dict[str, Any]] = None,
+) -> None:
+    """
+    Create an OperationLog entry from a view.
+    """
+    user = getattr(request, "user", None)
+
+    try:
+        log = OperationLog(
+            actor_user=user if getattr(user, "is_authenticated", False) else None,
+            actor_username=getattr(user, "username", "") if user else "",
+            actor_email=getattr(user, "email", "") if user else "",
+            actor_keycloak_id="",  # fill later if you add it to your user model
+            action=action,
+            http_method=getattr(request, "method", ""),
+            path=getattr(request, "path", ""),
+            resource_type=resource_type,
+            resource_id=resource_id,
+            status_before=status_before or "",
+            status_after=status_after or "",
+            meta=meta or None,
+        )
+        log.save()
+    except Exception:
+        # Never kill the main request flow because of logging
+        logger.exception(
+            "Failed to record operation %s for %s(%s)",
+            action,
+            resource_type,
+            resource_id,
+        )
+
+
+# TODO: will make the name more generic later base don the requirement,after merge
+def get_resource_type_from_instance(obj):
+    name = obj.__class__.__name__
+    '''if name == "VideoFile":
+        return "video"
+    if name == "RawPdfFile":
+        return "pdf"'''
+    return name.lower()

endoreg_db/utils/parse_and_generate_yaml.py

@@ -7,25 +7,24 @@ module_root = file_path.parent.parent
 data_dir = module_root / "data"
 
 
-def collect_center_names(
-):
+def collect_center_names():
     input_file_path = data_dir / "center/data.yaml"
     fist_name_dir = data_dir / "names_first"
     last_name_dir = data_dir / "names_last"
     # Load the input YAML file
-    with open(input_file_path, 'r', encoding='utf-8') as file:
+    with open(input_file_path, "r", encoding="utf-8") as file:
         data = yaml.safe_load(file)
-    
+
     # Containers for first and last names
     first_names_set = set()
     last_names_set = set()
-    
+
     # Extract first and last names from the YAML data
     for entry in data:
-        fields = entry.get('fields', {})
-        first_names_set.update(fields.get('first_names', []))
-        last_names_set.update(fields.get('last_names', []))
-    
+        fields = entry.get("fields", {})
+        first_names_set.update(fields.get("first_names", []))
+        last_names_set.update(fields.get("last_names", []))
+
     # Create a list of dictionaries for first and last names
     first_names_data = [
         {"model": "endoreg_db.first_name", "fields": {"name": name}}
@@ -35,12 +34,12 @@ def collect_center_names(
         {"model": "endoreg_db.last_name", "fields": {"name": name}}
         for name in sorted(last_names_set)
     ]
-    
+
     # Write the data to separate YAML files
-    with open(fist_name_dir/"first_names.yaml", "w", encoding='utf-8') as first_file:
+    with open(fist_name_dir / "first_names.yaml", "w", encoding="utf-8") as first_file:
         yaml.dump(first_names_data, first_file, allow_unicode=True, sort_keys=False)
-    
-    with open(last_name_dir/"last_names.yaml", "w", encoding='utf-8') as last_file:
+
+    with open(last_name_dir / "last_names.yaml", "w", encoding="utf-8") as last_file:
         yaml.dump(last_names_data, last_file, allow_unicode=True, sort_keys=False)
 
     # print("Generated first_names.yaml and last_names.yaml successfully.")

endoreg_db/utils/paths.py

@@ -40,8 +40,8 @@ if not STORAGE_DIR.exists():
 IMPORT_DIR_NAME = "import"
 EXPORT_DIR_NAME = "export"
 
-IMPORT_DIR = IO_DIR / IMPORT_DIR_NAME      # data/import
-EXPORT_DIR = IO_DIR / EXPORT_DIR_NAME      # data/export
+IMPORT_DIR = IO_DIR / IMPORT_DIR_NAME  # data/import
+EXPORT_DIR = IO_DIR / EXPORT_DIR_NAME  # data/export
 
 
 IMPORT_VIDEO_DIR_NAME = "video_import"
@@ -64,7 +64,7 @@ DOCUMENT_DIR = STORAGE_DIR / "documents"
 
 # After initial import, files will remain here.
 
-TRANSCODING_DIR = STORAGE_DIR /"temp"
+TRANSCODING_DIR = STORAGE_DIR / "temp"
 
 SENSITIVE_VIDEO_DIR_NAME = "sensitive_videos"
 SENSITIVE_REPORT_DIR_NAME = "sensitive_reports"
@@ -116,7 +116,7 @@ data_paths: Dict[str, Path] = {
     "weights_export": EXPORT_DIR / WEIGHTS_DIR_NAME,
     "transcoding": TRANSCODING_DIR,
     "frame": FRAME_DIR,
-    "documents": DOCUMENT_DIR
+    "documents": DOCUMENT_DIR,
 }
 
 logger.info(f"Storage directory: {STORAGE_DIR.resolve()}")
@@ -126,7 +126,7 @@ for key, path in data_paths.items():
     path.mkdir(parents=True, exist_ok=True)
 
     logger.info(f"{key.capitalize()} directory: {path.resolve()}")
-    
+
 
 def to_storage_relative(path: Union[str, Path]) -> str:
     """
@@ -156,4 +156,4 @@ def to_storage_relative(path: Union[str, Path]) -> str:
         return str(path)
 
     # Use POSIX-style separators for Django FileField
-    return rel.as_posix()
+    return rel.as_posix()