endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/utils/links/requirement_link.py

@@ -0,0 +1,237 @@
+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,
+    PatientFinding,
+    Finding,
+    FindingIntervention,
+    FindingClassification,
+    FindingClassificationChoice,
+    LabValue,
+    PatientLabValue,
+    PatientLabSample,
+    PatientLabSampleType,
+    PatientMedication,  # Added
+    PatientMedicationSchedule,  # Added
+    Medication,  # Added
+    MedicationIndication,  # Added
+    MedicationIntakeTime,  # Added
+    MedicationSchedule,  # Added
+)
+
+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.
+
+    Attributes:
+        # requirement_types (List[RequirementType]): A List of requirement types.
+        # operators (List[RequirementOperator]): A List of operators.
+        # requirement_sets (List[RequirementSet]): A List of requirement sets.
+        examinations (List[Examination]): A List of examinations.
+        examination_indications (List[ExaminationIndication]): A List of examination indications.
+        lab_values (List[LabValue]): A List of lab values.
+        diseases (List[Disease]): A List of diseases.
+        disease_classification_choices (List[DiseaseClassificationChoice]): A List of disease classification choices.
+        events (List[Event]): A List of events.
+        findings (List[Finding]): A List of findings.
+        finding_morphology_classification_choices (List[FindingMorphologyClassificationChoice]): A List of finding morphology classification choices.
+        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
+    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)
+    patient_examinations: List["PatientExamination"] = 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
+    )
+    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_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
+    # Added direct medication-related fields
+    medications: List["Medication"] = Field(default_factory=list)
+    medication_indications: List["MedicationIndication"] = Field(default_factory=list)
+    medication_intake_times: List["MedicationIntakeTime"] = Field(default_factory=list)
+    medication_schedules: List["MedicationSchedule"] = Field(default_factory=list)
+
+    def get_first_patient(self) -> Optional["Patient"]:
+        """
+        Retrieves the first Patient instance found through the linked patient-specific models.
+        Iterates through various patient-related lists and returns the .patient attribute
+        from the first relevant object found.
+        """
+        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
+                ):
+                    return plv.sample.patient
+        if self.patient_lab_samples:
+            for pls in self.patient_lab_samples:
+                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:
+                    return pe.patient
+        if self.patient_diseases:
+            for pd in self.patient_diseases:
+                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:
+                    return pev.patient
+        if self.patient_findings:
+            for pf in self.patient_findings:
+                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:
+                    return pm.patient
+        # Check PatientMedicationSchedule
+        if self.patient_medication_schedules:
+            for pms in self.patient_medication_schedules:
+                if hasattr(pms, "patient") and pms.patient:
+                    return pms.patient
+        return None
+
+    @property
+    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,
+        )
+
+        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,
+        )
+
+        return data_model_dict_reverse
+
+    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:
+            # print(f"Checking key: {key}") # This is a debug print, can be removed
+            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
+
+    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 = {}
+        # Use model_dump() to iterate field data reliably (pydantic v2)
+        for field_name, field_value in self.model_dump().items():
+            if isinstance(field_value, list) and field_value:
+                active_links_dict[field_name] = field_value
+        return active_links_dict
+
+    def __repr__(self):
+        """
+        Returns a concise string summarizing the counts of each linked model list in the instance.
+        """
+        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",
+        ]
+        parts = [f"{f}={len(data.get(f, []))}" for f in fields]
+        return f"RequirementLinks({', '.join(parts)})"

endoreg_db/utils/names.py

@@ -0,0 +1,82 @@
+# Use faker library to generate fake names by gender
+# Use german names by default
+
+from faker import Faker
+import gender_guesser.detector as gender_detector
+
+
+def create_mock_examiner_name() -> tuple[str, str]:
+    """
+    Generate a mock examiner's name using the Faker library.
+    This function creates a tuple with a first name and a last name for a mock examiner. It utilizes the "de_DE" locale for generating German names.
+    Returns:
+        tuple[str, str]: A tuple containing the first name and the last name.
+    """
+
+    fake = Faker("de_DE")
+    first_name = fake.first_name()
+    last_name = fake.last_name()
+    return first_name, last_name
+
+
+def create_mock_patient_name(gender: str) -> tuple[str, str]:
+    """
+    Generate a mock patient's name based on the provided gender using the Faker library.
+    This function creates a tuple with a first name and a last name for a mock patient. It utilizes the "de_DE" locale for generating German names. When the input gender string is checked:
+    - If it contains "male", a male name is generated.
+    - If it contains "female", a female name is generated.
+    - Otherwise, a generic name is generated without considering gender.
+    Parameters:
+        gender (str): A string indicating the gender to be used for generating the name.
+    Returns:
+        tuple[str, str]: A tuple containing the first name and the last name.
+    """
+
+    fake = Faker("de_DE")
+
+    if "male" in gender.lower():
+        gender = "male"
+    elif "female" in gender.lower():
+        gender = "female"
+
+    if gender == "male":
+        first_name = fake.first_name_male()
+        last_name = fake.last_name_male()
+
+    elif gender == "female":
+        first_name = fake.first_name_female()
+        last_name = fake.last_name_female()
+
+    else:
+        first_name = fake.first_name()
+        last_name = fake.last_name()
+
+    return first_name, last_name
+
+
+def guess_name_gender(name: str) -> str:
+    """Return a normalized gender slug (male|female|unknown) for the given name.
+
+    Uses :mod:`gender_guesser` to infer gender without touching the database. All
+    detector outputs are mapped onto our canonical slugs so callers can perform
+    their own model lookups or fall back safely.
+    """
+
+    detector = gender_detector.Detector(case_sensitive=False)
+    try:
+        detected = detector.get_gender(name or "")
+    except Exception:  # pragma: no cover - defensive, detector is pure-Python
+        detected = None
+
+    if not detected:
+        return "unknown"
+
+    normalized = detected.lower()
+    if normalized in {"male", "mostly_male"}:
+        return "male"
+    if normalized in {"female", "mostly_female"}:
+        return "female"
+
+    # gender-guesser returns "andy" for androgynous names and "unknown" for
+    # unrecognised inputs – both should map to our "unknown" slug.
+    return "unknown"

endoreg_db/utils/ocr.py

@@ -0,0 +1,195 @@
+import pytesseract
+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
+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):
+    """
+    Processes a string of text that represents a date and returns a datetime.date object.
+
+    Args:
+        date_text (str): A string of text that represents a date.
+
+    Returns:
+        datetime.date: A datetime.date object representing the parsed date, or None if the text cannot be parsed.
+    """
+    try:
+        # Remove any non-digit characters
+        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()
+        elif len(date_text_clean) == 14:
+            return datetime.strptime(date_text_clean, "%d%m%Y%H%M%S").date()
+    except ValueError:
+        # Return None if the text cannot be parsed into a date
+        # 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()
+    # capitalize first letter of each word
+    name = " ".join([word.capitalize() for word in name.split()])
+    return name
+
+
+# Helper function to process endoscope type text
+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())
+
+
+def roi_values_valid(roi):
+    """
+    Check if all values in an ROI dictionary are valid (>=0).
+    """
+    return all([value >= 0 for value in roi.values()])
+
+
+# Function to extract text from ROIs
+def extract_text_from_rois(image_path, processor):
+    """
+    Extracts text from regions of interest (ROIs) in an image using OCR.
+
+    Args:
+        image_path (str): The path to the image file.
+        processor (EndoscopyProcessor): An instance of the EndoscopyProcessor class.
+
+    Returns:
+        dict: A dictionary containing the extracted text for each ROI.
+    """
+    # Read the image using Pillow
+    image = Image.open(image_path)
+    image_dimensions = image.size  # (width, height)
+
+    ####### Adjust Image #######
+    # Convert to grayscale
+    gray = image.convert("L")
+
+    # Invert colors for white text on black background
+    inverted = ImageOps.invert(gray)
+
+    # Initialize the dictionary to hold the extracted text
+    extracted_texts = {}
+
+    # Define your ROIs and their corresponding post-processing functions in tuples
+    rois_with_postprocessing = [
+        ("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),
+    ]
+
+    # 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"]
+
+            # Get white image with original shape and just the roi remaining
+            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-üöäÜÖÄß"
+
+            # 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:
+            pass
+
+    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.
+
+    Args:
+        rois_texts: A dictionary where the keys are the names of the ROIs and the values are lists of texts.
+
+    Returns:
+        A dictionary where the keys are the names of the ROIs and the values are the most frequent text for each ROI.
+    """
+    most_frequent = {}
+    for key in rois_texts.keys():
+        counter = Counter([text for text in rois_texts[key] if text])
+        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.
+
+    Args:
+        video_path (str): The path to the video file to process.
+        processor (OCRProcessor): An instance of the OCRProcessor class that defines the ROIs to extract text from.
+
+    Returns:
+        dict: A dictionary containing the most frequent text values extracted from each ROI.
+    """
+    # Create a temporary directory to store frames
+    with TemporaryDirectory() as temp_dir:
+        # Capture the video
+        video = cv2.VideoCapture(video_path)
+        success, frame_number = True, 0
+        rois_texts = {roi_name: [] for roi_name in processor.get_rois().keys()}
+        frames_for_mean_extraction = 0
+
+        while success:
+            success, frame = video.read()
+
+            # Check if this is the 200th frame
+            if frame_number % 1000 == 0 and success:
+                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)
+                frames_for_mean_extraction += 1
+
+            frame_number += 1
+
+            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,87 @@
+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__)
+
+
+# -----------------------------
+# Operation actions
+# -----------------------------
+
+ACTION_ANONYMIZATION_START = "anonymization.start"
+ACTION_ANONYMIZATION_VALIDATED = "anonymization.validated"
+
+ACTION_SEGMENT_ANNOTATED = "segment.annotated"
+ACTION_SEGMENT_CREATED = "segment.created"
+
+# -----------------------------
+# Operation statuses
+# -----------------------------
+
+STATUS_VALIDATED = "validated"
+STATUS_UNVALIDATED = "unvalidated"
+
+STATUS_NOT_STARTED = "not_started"
+STATUS_PROCESSING = "processing"
+STATUS_ANONYMIZED = "anonymized"
+
+
+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 based on 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

@@ -0,0 +1,45 @@
+import yaml
+from pathlib import Path
+
+# get this files path
+file_path = Path(__file__)
+module_root = file_path.parent.parent
+data_dir = module_root / "data"
+
+
+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:
+        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", []))
+
+    # Create a list of dictionaries for first and last names
+    first_names_data = [
+        {"model": "endoreg_db.first_name", "fields": {"name": name}}
+        for name in sorted(first_names_set)
+    ]
+    last_names_data = [
+        {"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:
+        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:
+        yaml.dump(last_names_data, last_file, allow_unicode=True, sort_keys=False)
+
+    # print("Generated first_names.yaml and last_names.yaml successfully.")