endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/utils/links/requirement_link.py

@@ -0,0 +1,193 @@
+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,76 @@
+# 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:
+    """
+    Guesses the gender for a given name by using a gender detector and retrieving the corresponding Gender model instance.
+    Parameters:
+        name (str): The name for which the gender is to be determined.
+    Returns:
+        Gender: The Gender object corresponding to the detected gender name.
+    Raises:
+        Gender.DoesNotExist: If no Gender object matching the detected gender is found.
+        Exception: For any other exceptions that occur during gender detection or database lookup.
+    """
+
+    from endoreg_db.models import Gender
+
+    detector = gender_detector.Detector(case_sensitive=False)
+    gender_name = detector.get_gender(name)
+    gender = Gender.objects.get(name=gender_name)
+    if not gender:
+        gender = Gender.objects.get(name="unknown")
+    return gender

endoreg_db/utils/ocr.py

@@ -0,0 +1,190 @@
+import pytesseract
+from PIL import Image, ImageOps, ImageFilter
+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):
+    """
+    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/parse_and_generate_yaml.py

@@ -0,0 +1,46 @@
+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.")

endoreg_db/utils/paths.py

@@ -0,0 +1,95 @@
+"""
+Centralizes path management for the application.
+
+This module sets up all necessary directories for storage and import operations.
+It provides a unified dictionary 'data_paths' for accessing all path objects.
+"""
+
+from logging import getLogger
+
+from sphinx.search import no
+logger = getLogger(__name__)
+
+from pathlib import Path
+from typing import Dict
+import os
+# Alternative approach using env_path helper, deprecated since monorepo setup. Alright for single install, env is always preferred.
+#from endoreg_db.config.env import env_path
+
+STORAGE_DIR = Path(os.getenv("STORAGE_DIR", "storage"))
+
+storage_dir_env = os.getenv("STORAGE_DIR")
+if storage_dir_env is None:
+    raise RuntimeError("STORAGE_DIR environment variable is not set.")
+storage_dir_str = Path(storage_dir_env)
+STORAGE_DIR = storage_dir_str
+if not STORAGE_DIR.exists():
+    STORAGE_DIR.mkdir(parents=True, exist_ok=True)
+
+PREFIX_RAW = "raw_"
+IMPORT_DIR_NAME = "import"
+EXPORT_DIR_NAME = "export"
+
+VIDEO_DIR_NAME = "videos"
+ANONYM_VIDEO_DIR_NAME = "anonym_videos" # Added for processed videos
+FRAME_DIR_NAME = "frames"
+PDF_DIR_NAME = "pdfs" # Changed from reports
+WEIGHTS_DIR_NAME = "model_weights"
+EXAMINATION_DIR_NAME = "examinations"
+
+RAW_VIDEO_DIR_NAME = f"{PREFIX_RAW}videos"
+RAW_FRAME_DIR_NAME = f"{PREFIX_RAW}frames"
+RAW_PDF_DIR_NAME = f"{PREFIX_RAW}pdfs" # Changed from reports
+
+# Define data subdirectories under STORAGE_DIR
+VIDEO_DIR = STORAGE_DIR / VIDEO_DIR_NAME
+ANONYM_VIDEO_DIR = STORAGE_DIR / ANONYM_VIDEO_DIR_NAME # Added
+FRAME_DIR = STORAGE_DIR / FRAME_DIR_NAME
+PDF_DIR = STORAGE_DIR / PDF_DIR_NAME # Changed
+WEIGHTS_DIR = STORAGE_DIR / WEIGHTS_DIR_NAME
+RAW_VIDEO_DIR = STORAGE_DIR / RAW_VIDEO_DIR_NAME
+RAW_FRAME_DIR = STORAGE_DIR / RAW_FRAME_DIR_NAME
+RAW_PDF_DIR = STORAGE_DIR / RAW_PDF_DIR_NAME # Changed
+
+IMPORT_DIR = STORAGE_DIR / IMPORT_DIR_NAME
+VIDEO_IMPORT_DIR = IMPORT_DIR / VIDEO_DIR_NAME
+FRAME_IMPORT_DIR = IMPORT_DIR / FRAME_DIR_NAME
+PDF_IMPORT_DIR = IMPORT_DIR / PDF_DIR_NAME # Changed
+WEIGHTS_IMPORT_DIR = IMPORT_DIR / WEIGHTS_DIR_NAME
+
+EXPORT_DIR = STORAGE_DIR / EXPORT_DIR_NAME
+
+data_paths:Dict[str,Path] = {
+    "storage": STORAGE_DIR,
+    "video": VIDEO_DIR,
+    "anonym_video": ANONYM_VIDEO_DIR, # Added
+    "frame": FRAME_DIR,
+    "pdf": PDF_DIR, # Changed
+    "import": IMPORT_DIR,
+    "video_import": VIDEO_IMPORT_DIR,
+    "frame_import": FRAME_IMPORT_DIR,
+    "pdf_import": PDF_IMPORT_DIR, # Changed
+    "raw_video": RAW_VIDEO_DIR,
+    "raw_frame": RAW_FRAME_DIR,
+    "raw_pdf": RAW_PDF_DIR, # Changed
+    "weights": WEIGHTS_DIR,
+    "weights_import": WEIGHTS_IMPORT_DIR,
+    "export": EXPORT_DIR,
+    "video_export": EXPORT_DIR / VIDEO_DIR_NAME,
+    "anonym_video_export": EXPORT_DIR / ANONYM_VIDEO_DIR_NAME, # Added
+    "frame_export": EXPORT_DIR / FRAME_DIR_NAME,
+    "pdf_export": EXPORT_DIR / PDF_DIR_NAME, # Changed
+    "weights_export": EXPORT_DIR / WEIGHTS_DIR_NAME,
+    "examination_export": EXPORT_DIR / EXAMINATION_DIR_NAME,
+    "raw_video_export": EXPORT_DIR / RAW_VIDEO_DIR_NAME,
+    "raw_frame_export": EXPORT_DIR / RAW_FRAME_DIR_NAME,
+    "raw_pdf_export": EXPORT_DIR / RAW_PDF_DIR_NAME, # Changed
+}
+
+logger.info(f"Storage directory: {STORAGE_DIR.resolve()}")
+logger.info(f"Export directory: {EXPORT_DIR.resolve()}")
+
+# for key, path in data_paths.items():
+#     path.mkdir(parents=True, exist_ok=True)
+
+#     logger.info(f"{key.capitalize()} directory: {path.resolve()}")