Easy_Audiometry_PDF_Scraper_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "90786add-7433-411c-82b5-b1161b05a17b",
   "metadata": {},
   "source": [
    "# Programma voor de extractie van audiometrische data uit PDF EasyViewer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80bc3f0c-ed0c-48a9-96fc-1e0a46b77499",
   "metadata": {
    "tags": []
   },
   "source": [
    "Eigenaar: Guido Cattani"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf2bc7d2-3559-4eaa-8e0b-d3aa7f306d1b",
   "metadata": {},
   "source": [
    "Datum van deze versie: 20 December 2023 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8f602101-43a1-416a-a46d-b62119e7e2b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from colorama import Fore, Style, init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "607a42e8-e029-4253-a018-b82281c88fb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\tWelkom bij EasyPDF AudioScraper versie 2 (20 december 2023).\n",
      "Dit programma kan een Easy Data pdf-file met toon- en spraakaudiogram analyseren en een beschrijving maken.\n",
      "De beschrijving wordt opgeslagen in een textfile in uw (Onedrive) downloadlocatie.\n",
      "Het programma is niet altijd nauwkeurig. Controleer daarom altijd goed de beschrijving.\n",
      "\t© 2023 Guido Cattani\n",
      "\n"
     ]
    }
   ],
   "source": [
    "init()\n",
    "a ='\\n\\tWelkom bij EasyPDF AudioScraper versie 2 (20 december 2023).' \n",
    "b ='\\nDit programma kan een Easy Data pdf-file met toon- en spraakaudiogram analyseren en een beschrijving maken.'\n",
    "c ='\\nDe beschrijving wordt opgeslagen in een textfile in uw (Onedrive) downloadlocatie.'\n",
    "d = '\\nHet programma is niet altijd nauwkeurig. Controleer daarom altijd goed de beschrijving.'\n",
    "e = '\\n© 2023 Guido Cattani'\n",
    "print(Fore.WHITE + Style.BRIGHT + a + b + c + d + e + '\\n' + Style.RESET_ALL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "282361db-17b6-4c53-af02-9d624da75b98",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "import re\n",
    "import os\n",
    "from os.path import expanduser, join\n",
    "import fitz  # PyMuPDF\n",
    "from PIL import Image\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8adb80d1-279f-44b2-b396-579995833f9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constants of this program (for maintenance)\n",
    "\n",
    "# Define constants for rectangle coordinates, depends heavily from pdf layout\n",
    "\n",
    "# Coordinates Header\n",
    "HEADER_LEFT = 0\n",
    "HEADER_TOP = 0\n",
    "HEADER_RIGHT = 600\n",
    "HEADER_BOTTOM = 140\n",
    "\n",
    "# Coordinates Audiogram Left ear\n",
    "LEFT_EAR_LEFT = 321\n",
    "LEFT_EAR_TOP = 140\n",
    "LEFT_EAR_RIGHT = 600\n",
    "LEFT_EAR_BOTTOM = 449\n",
    "\n",
    "# Coordinates Audiogram Right ear\n",
    "RIGHT_EAR_LEFT = 0\n",
    "RIGHT_EAR_TOP = 140\n",
    "RIGHT_EAR_RIGHT = 320\n",
    "RIGHT_EAR_BOTTOM = 449\n",
    "\n",
    "# Coordinates Bottom Text\n",
    "BOTTOM_LEFT = 0\n",
    "BOTTOM_TOP = 660\n",
    "BOTTOM_RIGHT = 600\n",
    "BOTTOM_BOTTOM = 800\n",
    "\n",
    "# Coordinates Speech Audiogram\n",
    "SPEECH_LEFT = 40\n",
    "SPEECH_TOP = 460\n",
    "SPEECH_RIGHT = 590\n",
    "SPEECH_BOTTOM = 650\n",
    "\n",
    "# Coordinates Speech Audiogram Right Ear (RE)\n",
    "SPEECH_RE_LEFT = 40\n",
    "SPEECH_RE_TOP = 460\n",
    "SPEECH_RE_RIGHT = 330\n",
    "SPEECH_RE_BOTTOM = 650\n",
    "\n",
    "# Coordinates Speech Audiogram Left Ear (LE)\n",
    "SPEECH_LE_LEFT = 314\n",
    "SPEECH_LE_TOP = 460\n",
    "SPEECH_LE_RIGHT = 590\n",
    "SPEECH_LE_BOTTOM = 650\n",
    "\n",
    "# Coordinates to determin speech-audiogram origin and scale\n",
    "SCORE_100 = 19\n",
    "SCORE_50 = 68\n",
    "SCORE_0 = 118\n",
    "LEVEL_0_RE = 44\n",
    "LEVEL_120_RE = 262\n",
    "LEVEL_0_LE = 26\n",
    "LEVEL_120_LE = 243\n",
    "\n",
    "\n",
    "# Tuple containing the speech audiogram origin coordinates (x, y)\n",
    "SPEECH_RE_ORIGIN = (LEVEL_0_RE, SCORE_0) # Origin of right ear (RE) speech-audiogram\n",
    "SPEECH_LE_ORIGIN = (LEVEL_0_LE, SCORE_0) # Origin of right ear (LE) speech-audiogram\n",
    "\n",
    "\n",
    "# Define RGB range for colors to detect in speech-audiogram\n",
    "# Define RGB range for red color\n",
    "RED_COLOR_RANGE = [(217, 256), (100, 160), (100, 160)]\n",
    "\n",
    "# Define RGB range for blue color\n",
    "BLUE_COLOR_RANGE = [(100, 160), (100, 160), (190, 256)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aad168e7-a0eb-4a89-aa03-4f03a52555d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define constants for hearing loss extent thresholds\n",
    "VERY_SEVERE_EXTENT = 80\n",
    "SEVERE_TO_VERY_SEVERE_EXTENT = 75\n",
    "SEVERE_EXTENT = 60\n",
    "MODERATE_TO_SEVERE_EXTENT = 55\n",
    "MODERATE_EXTENT = 40\n",
    "LIGHT_TO_MODERATE_EXTENT = 35\n",
    "LIGHT_EXTENT = 20\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1737b915-5ace-4a9d-8be7-4506c2f3fe56",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def open_pdf_safely(pdf_path):\n",
    "    \"\"\"\n",
    "    Safely opens a PDF document using PyMuPDF.\n",
    "\n",
    "    Args:\n",
    "        pdf_path (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        fitz.Document or None: A PyMuPDF document object if the file is found, else None.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        pdf_document = fitz.open(pdf_path)\n",
    "        return pdf_document\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Bestand niet gevonden: {pdf_path}\")\n",
    "        return None\n",
    "    except fitz.PyMuPDFError as e:\n",
    "        print(f\"Een fout is opgetreden tijdens het openen van het PDF-bestand: {e}\")\n",
    "        return None\n",
    "    except Exception as e:\n",
    "        print(f\"Een onbekende fout is opgetreden tijdens het openen van het PDF-bestand: {e}\")\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4a1f473c-86b8-435f-9bce-dc8fe1fa93e5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def extract_text_from_rect(pdf_path, rect):\n",
    "    \"\"\"\n",
    "    Extracts text from a specified rectangle in a PDF document using PyMuPDF.\n",
    "\n",
    "    Args:\n",
    "        pdf_path (str): Path to the PDF file.\n",
    "        rect (fitz.Rect): Rectangle defining the area to extract text from.\n",
    "\n",
    "    Returns:\n",
    "        str: Extracted text from the specified rectangle.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        pdf_document = fitz.open(pdf_path)\n",
    "        page = pdf_document[0]  # Assuming 1 page PDF\n",
    "        text = page.get_text(\"text\", clip=rect)\n",
    "        pdf_document.close()\n",
    "        return text\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Bestand niet gevonden: {pdf_path}\")\n",
    "        return \"\"\n",
    "    except fitz.PyMuPDFError as e:\n",
    "        print(f\"Een fout is opgetreden bij het extraheren van tekst uit het PDF-bestand: {e}\")\n",
    "        return \"\"\n",
    "    except Exception as e:\n",
    "        print(f\"Een onbekende fout is opgetreden bij het extraheren van tekst uit het PDF-bestand: {e}\")\n",
    "        return \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1782002b-0519-4900-b76f-7a71aafff068",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def extract_header_text(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts header text (with patientID) from a PDF document using PyMuPDF.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Extracted header text.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        header_rect = fitz.Rect(HEADER_LEFT, HEADER_TOP, HEADER_RIGHT, HEADER_BOTTOM)\n",
    "        header_text = extract_text_from_rect(pdf_infile, header_rect)\n",
    "        return header_text\n",
    "    except fitz.PyMuPDFError as e:\n",
    "        print(f\"An error occurred while extracting text from the header: {e}\")\n",
    "        return \"\"\n",
    "    except Exception as e:\n",
    "        print(f\"An unknown error occurred while extracting text from the header: {e}\")\n",
    "        return \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "762af20d-7b0a-47cc-976e-df66b772b3d5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def extract_right_audiogram_text(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts text from the right ear audiogram section of a PDF audiogram document using PyMuPDF.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Extracted text from the right ear audiogram section.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        right_ear_audiogram_rect = fitz.Rect(RIGHT_EAR_LEFT, RIGHT_EAR_TOP, RIGHT_EAR_RIGHT, RIGHT_EAR_BOTTOM)\n",
    "        right_ear_audiogram_text = extract_text_from_rect(pdf_infile, right_ear_audiogram_rect)\n",
    "        return right_ear_audiogram_text\n",
    "    except fitz.PyMuPDFError as e:\n",
    "        print(f\"An error occurred while extracting text from the right ear audiogram section: {e}\")\n",
    "        return \"\"\n",
    "    except Exception as e:\n",
    "        print(f\"An unknown error occurred while extracting text from the right ear audiogram section: {e}\")\n",
    "        return \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4dda1145-5b2b-4c85-b637-22c708a77927",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def extract_bottom_text(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts bottom text from a PDF document using PyMuPDF.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Extracted bottom text.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        bottom_rect = fitz.Rect(BOTTOM_LEFT, BOTTOM_TOP, BOTTOM_RIGHT, BOTTOM_BOTTOM)\n",
    "        bottom_text = extract_text_from_rect(pdf_infile, bottom_rect)\n",
    "        return bottom_text\n",
    "    except fitz.PyMuPDFError as e:\n",
    "        print(f\"An error occurred while extracting text from the bottom of the PDF: {e}\")\n",
    "        return \"\"\n",
    "    except Exception as e:\n",
    "        print(f\"An unknown error occurred while extracting text from the bottom of the PDF: {e}\")\n",
    "        return \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fcdf75b0-5844-41b3-a653-ae71d5184d45",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def extract_left_audiogram_text(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts text from the left ear audiogram section of a PDF audiogram document using PyMuPDF.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Extracted text from the left ear audiogram section.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        left_ear_audiogram_rect = fitz.Rect(LEFT_EAR_LEFT, LEFT_EAR_TOP, LEFT_EAR_RIGHT, LEFT_EAR_BOTTOM)\n",
    "        left_ear_audiogram_text = extract_text_from_rect(pdf_infile, left_ear_audiogram_rect)\n",
    "        return left_ear_audiogram_text\n",
    "    except fitz.PyMuPDFError as e:\n",
    "        print(f\"An error occurred while extracting text from the left ear audiogram section: {e}\")\n",
    "        return \"\"\n",
    "    except Exception as e:\n",
    "        print(f\"An unknown error occurred while extracting text from the left ear audiogram section: {e}\")\n",
    "        return \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "397ffcef-72fb-41af-b371-d070f4b55c14",
   "metadata": {},
   "outputs": [],
   "source": [
    "def provide_hearing_loss_data(audiogram_text):\n",
    "    \"\"\"\n",
    "    Extracts hearing loss data from audiogram text looking for the strings 'Be:', 'FI:' and 'FIH:'.\n",
    "\n",
    "    Args:\n",
    "        audiogram_text (str): Text containing audiogram data.\n",
    "\n",
    "    Returns:\n",
    "        tuple: Tuple containing hearing loss data as integers (BG_05_1, LG_05_1, LG_1_4, ABG).\n",
    "    \"\"\"\n",
    "    try:\n",
    "        lines = audiogram_text.split('\\n')\n",
    "\n",
    "        # Define the patterns to search for\n",
    "        patterns = ['Be:', 'FI:', 'FIH:']\n",
    "\n",
    "        # Initialize the variables with None\n",
    "        BG_05_1 = None  # Average Bone Conduction Thresholds [dBHL] at 0.5, 1, 2 kHz\n",
    "        LG_05_1 = None  # Average Air Conduction Thresholds [dBHL] at 0.5, 1, 2 kHz\n",
    "        LG_1_4 = None   # Average Air Conduction Thresholds [dBHL] at 1, 2, 4 kHz\n",
    "        ABG = None      # Average Air-Bone Gap [dBHL] at 1, 2, 4 kHz (LG_05_1 - BG_05_1)\n",
    "\n",
    "        # Traverse lines to find hearing loss data\n",
    "        for line in lines:\n",
    "            for pattern in patterns:\n",
    "                if pattern in line:\n",
    "                    try:\n",
    "                        value_str = line.split(pattern)[1].strip()\n",
    "                        if value_str == \"-\":\n",
    "                            value = None\n",
    "                        else:\n",
    "                            value = int(value_str)  # Convert the extracted string to an integer\n",
    "                    except (IndexError, ValueError):\n",
    "                        value = None  # Set to None when extraction fails\n",
    "\n",
    "                    if pattern == 'Be:':\n",
    "                        BG_05_1 = value\n",
    "                    elif pattern == 'FI:':\n",
    "                        LG_05_1 = value\n",
    "                    elif pattern == 'FIH:':\n",
    "                        LG_1_4 = value\n",
    "                    break  # Break the loop after finding the first occurrence\n",
    "\n",
    "        if BG_05_1 is not None and LG_05_1 is not None and BG_05_1:\n",
    "            ABG = LG_05_1 - BG_05_1\n",
    "\n",
    "        return BG_05_1, LG_05_1, LG_1_4, ABG\n",
    "\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred while extracting hearing loss data: {e}\")\n",
    "        return None, None, None, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0ad9a5de-5c9a-4416-a980-8d7f3563514a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def type_hearing_loss(hearing_loss_data):\n",
    "    \"\"\"\n",
    "    Determines the type of hearing loss based on provided data, providing a description.\n",
    "\n",
    "    Args:\n",
    "        hearing_loss_data (tuple): Tuple containing hearing loss data (BG_05_1, LG_05_1, LG_1_4, ABG).\n",
    "\n",
    "    Returns:\n",
    "        str: Description of hearing loss type.\n",
    "    \"\"\"\n",
    "    BG_05_1, LG_05_1, LG_1_4, ABG = hearing_loss_data\n",
    "    after_extent_hl = ' dB (gemiddeld bij 1, 2 en 4 kHz)'\n",
    "    \n",
    "    if LG_1_4 == None: type_hearing_loss = 'gemengd/perceptief gehoorverlies, met een niet te bepalen gemiddelde omvang (bij 1, 2 en 4 kHz)'\n",
    "    elif LG_1_4 < 20 and LG_05_1 < 20: type_hearing_loss = '(nagenoeg) normale gehoordrempels, ' + str(LG_1_4) + after_extent_hl\n",
    "    elif LG_1_4 < 20 and 20 <= LG_05_1 < 25: type_hearing_loss = 'nagenoeg normale gehoordrempels, ' + str(LG_1_4) + after_extent_hl\n",
    "    elif LG_1_4 >= 20 and ABG == None: type_hearing_loss = '(vermoedelijk) perceptief / conductief / gemengd gehoorverlies, ' + str(LG_1_4) + after_extent_hl\n",
    "    elif LG_1_4 >= 20 and ABG < 15: type_hearing_loss = 'perceptief gehoorverlies, ' + str(LG_1_4) + after_extent_hl\n",
    "    elif LG_1_4 >= 20 and ABG > 15 and BG_05_1 <= 15: type_hearing_loss = 'conductief gehoorverlies, ' + str(LG_1_4) + after_extent_hl\n",
    "    elif LG_1_4 >= 20 and ABG > 15 and 15 < BG_05_1 <= 20: type_hearing_loss = '(overwegend) conductief gehoorverlies, ' + str(LG_1_4) + after_extent_hl\n",
    "    elif LG_1_4 >= 20 and ABG > 15 and BG_05_1 > 20: type_hearing_loss = 'gemengd gehoorverlies, ' + str(LG_1_4) + after_extent_hl\n",
    "    \n",
    "    return type_hearing_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d08e275a-c253-4486-af64-73df8d7e94bc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def short_hearing_loss(hearing_loss_data):\n",
    "    \"\"\"\n",
    "    Generates a short description of the hearing loss based on provided data.\n",
    "\n",
    "    Args:\n",
    "        hearing_loss_data (tuple): Tuple containing hearing loss data (BG_05_1, LG_05_1, LG_1_4, ABG).\n",
    "\n",
    "    Returns:\n",
    "        str: Short description of hearing loss extent and type.\n",
    "    \"\"\"\n",
    "    BG_05_1, LG_05_1, LG_1_4, ABG = hearing_loss_data\n",
    "    \n",
    "    if LG_1_4 == None: type_hearing_loss = ' gemengd/perceptief gehoorverlies / (functioneel) doof oor'\n",
    "    elif LG_1_4 < 20 and LG_05_1 < 20: type_hearing_loss = '(nagenoeg) normale gehoordrempels'\n",
    "    elif LG_1_4 >= 20 and ABG == None: type_hearing_loss = ' (vermoedelijk) perceptief / conductief / gemengd gehoorverlies'\n",
    "    elif LG_1_4 >= 20 and ABG < 15: type_hearing_loss = ' perceptief gehoorverlies'\n",
    "    elif LG_1_4 >= 20 and ABG > 15 and BG_05_1 <= 15: type_hearing_loss = ' conductief gehoorverlies'\n",
    "    elif LG_1_4 >= 20 and ABG > 15 and 15 < BG_05_1 <= 20: type_hearing_loss = ' (overwegend) conductief gehoorverlies'\n",
    "    elif LG_1_4 >= 20 and ABG > 15 and BG_05_1 > 20: type_hearing_loss = ' gemengd gehoorverlies'\n",
    " \n",
    "\n",
    "    if LG_1_4 == None: \n",
    "        extent_hl = 'een zeer ernstig'\n",
    "    elif LG_1_4 < LIGHT_EXTENT: \n",
    "        extent_hl = ''\n",
    "    elif LIGHT_EXTENT <= LG_1_4 < LIGHT_TO_MODERATE_EXTENT: \n",
    "        extent_hl = 'een licht'\n",
    "    elif LIGHT_TO_MODERATE_EXTENT <= LG_1_4 < MODERATE_EXTENT: \n",
    "        extent_hl = 'een licht tot matig'\n",
    "    elif MODERATE_EXTENT <= LG_1_4 < MODERATE_TO_SEVERE_EXTENT: \n",
    "        extent_hl = 'een matig'\n",
    "    elif MODERATE_TO_SEVERE_EXTENT <= LG_1_4 < SEVERE_EXTENT: \n",
    "        extent_hl = 'een matig tot ernstig'\n",
    "    elif SEVERE_EXTENT <= LG_1_4 < SEVERE_TO_VERY_SEVERE_EXTENT: \n",
    "        extent_hl = 'een ernstig'\n",
    "    elif SEVERE_TO_VERY_SEVERE_EXTENT <= LG_1_4 < VERY_SEVERE_EXTENT: \n",
    "        extent_hl = 'een ernstig tot zeer ernstig'\n",
    "    elif LG_1_4 >= VERY_SEVERE_EXTENT: \n",
    "        extent_hl = 'een zeer ernstig'\n",
    "  \n",
    "    \n",
    "    return (extent_hl + type_hearing_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "97143fad-f306-40cb-bd40-4a89ef443a55",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def patient_data(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts patient data (pt-ID and birthday) from the header of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Formatted patient data containing pt-ID and birthday.\n",
    "    \"\"\"\n",
    "    ...\n",
    "    header = extract_header_text(pdf_infile)\n",
    "    l = header.split('\\n')\n",
    "        # Define the patterns to search for\n",
    "    patterns = ['PatientId:', 'Geb-dat:']\n",
    "\n",
    "    # Initialize the variables with None\n",
    "    pt_id = None\n",
    "    birthday = None\n",
    "\n",
    "    # Traverse list l to find hearing loss data\n",
    "    for element in l:\n",
    "        for pattern in patterns:\n",
    "            if pattern in element:\n",
    "                try:\n",
    "                    value = element.split(pattern)[1]  # Take the string\n",
    "                except IndexError:\n",
    "                    value = None  # Set to None when extraction fails\n",
    "\n",
    "                if pattern == 'PatientId:':\n",
    "                    pt_id = value\n",
    "                elif pattern == 'Geb-dat:':\n",
    "                    birthday = value\n",
    "                break  # Break the loop after finding the first occurrence\n",
    "    \n",
    "    result = 'PtId_' + pt_id + '_GebDat_' + birthday\n",
    "    result = result.replace(' ', '')\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e04725b-f035-4a6d-adf2-8aa39cd94086",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def test_date(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts the test date from the bottom text of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str or None: Extracted test date in 'dd-mm-yyyy' format or None if not found.\n",
    "    \"\"\"\n",
    "    text = extract_bottom_text(pdf_infile)\n",
    "    # Define a regular expression pattern to match dates in the format 'dd-mm-yyyy'\n",
    "    date_pattern = r'\\d{2}-\\d{2}-\\d{4}'\n",
    "    \n",
    "    # Find all matches of the pattern in the text\n",
    "    dates = re.findall(date_pattern, text)\n",
    "    \n",
    "    # Return the first match if found, otherwise return None\n",
    "    if dates:\n",
    "        return dates[0]\n",
    "    else:\n",
    "        return None   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6fa971a6-55db-4a68-8490-60328970a8e5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def print_date(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts the print date from the bottom text of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str or None: Extracted test date in 'dd-mm-yyyy' format or None if not found.\n",
    "    \"\"\"\n",
    "    text = extract_bottom_text(pdf_infile)\n",
    "    # Define a regular expression pattern to match dates in the format 'dd-mm-yyyy'\n",
    "    date_pattern = r'\\d{2}-\\d{2}-\\d{4}'\n",
    "    \n",
    "    # Find all matches of the pattern in the text\n",
    "    dates = re.findall(date_pattern, text)\n",
    "    \n",
    "    # Return the first match if found, otherwise return None\n",
    "    if dates:\n",
    "        return dates[1]\n",
    "    else:\n",
    "        return None   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "67bb40a5-2a17-481b-bf2c-c16cf1fd39be",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def check_for_insert(pdf_infile):\n",
    "    \"\"\"\n",
    "    Checks for the presence of string 'insert' in the bottom text of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Returns 'met insert phones ' if 'insert' is found, else an empty string.\n",
    "    \"\"\"\n",
    "    text = extract_bottom_text(pdf_infile)\n",
    "    text = text.lower()\n",
    "\n",
    "    res = None\n",
    "\n",
    "    if 'insert' in text: res = 'met insert phones'\n",
    "    else: res = ''  \n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ab183345-d647-4673-8164-258b9bf0d4be",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_for_hoofdtel(pdf_infile):\n",
    "    \"\"\"\n",
    "    Checks for the presence of string 'hoofdtel' or 'koptel' in the bottom text of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Returns 'met hoofdtelefoon' if 'koptel' is found, else an empty string.\n",
    "    \"\"\"\n",
    "    text = extract_bottom_text(pdf_infile)\n",
    "    text = text.lower()\n",
    "\n",
    "    res = None\n",
    "\n",
    "    if 'hoofdtel' in text or 'koptel' in text: res = 'met hoofdtelefoon'\n",
    "    else: res = ''  \n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "397a8fbb-8fe5-4ec9-ab7f-341dc9605a5d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def check_for_bloktest(pdf_infile):\n",
    "    \"\"\"\n",
    "    Checks for the presence of string 'blok' or 'bt' in the bottom text of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Returns 'blokkentest ' if 'blok' (or 'bt') is found, else an empty string.\n",
    "    \"\"\"\n",
    "    text = extract_bottom_text(pdf_infile)\n",
    "    text = text.lower()\n",
    "\n",
    "    res = None\n",
    "\n",
    "    if 'blok' in text: res = 'blokkentest'\n",
    "    elif 'bt' in text: res = 'blokkentest'\n",
    "    else: res = ''  \n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c77b14d1-dc6b-48e0-b38d-8cec228a5856",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_checks(pdf_infile):\n",
    "    ch = check_for_hoofdtel(pdf_infile)\n",
    "    ci = check_for_insert(pdf_infile)\n",
    "    cb = check_for_bloktest(pdf_infile)\n",
    "    t = cb, ci, ch\n",
    "    l = [s for s in t if s != '']\n",
    "    res = ' '.join(l)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1faa7654-255d-41cb-a90d-189a63b2a2f3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def check_for_speech_material(pdf_infile):\n",
    "    \"\"\"\n",
    "    Checks for the presence of string 'blok' or 'bt' in the bottom text of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Returns 'blokkentest ' if 'blok' (or 'bt') is found, else an empty string.\n",
    "    \"\"\"\n",
    "    text = extract_bottom_text(pdf_infile)\n",
    "    text = text.lower()\n",
    "\n",
    "    res = None\n",
    "\n",
    "    if 'sap' in text: res = 'SAP '\n",
    "    elif 'pit' in text: res = 'PIT'\n",
    "    elif 'kl' in text or 'kind' in text: res = 'NVA-kinderlijsten'\n",
    "    else: res = 'NVA'  \n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "76c28e6b-6160-41a3-b103-ac75cd0dede2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def patient_sex(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts patient sex information from the header of a PDF audiogram document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Returns 'Mevrouw ' if patient is female, 'De heer ' if patient is male.\n",
    "    \"\"\"\n",
    "    header = extract_header_text(pdf_infile)\n",
    "    l = header.split('\\n')\n",
    "        # Define the patterns to search for\n",
    "    patterns = ['Vrouw', 'Man']\n",
    "\n",
    "    # Initialize the variable with None\n",
    "    sex = None\n",
    "\n",
    "    # Traverse list l to find hearing loss data\n",
    "    for element in l:\n",
    "        for pattern in patterns:\n",
    "            if pattern in element:\n",
    "                try:\n",
    "                    value = pattern  # Take the string\n",
    "                except IndexError:\n",
    "                    value = None  # Set to None when extraction fails\n",
    "\n",
    "                if value == 'Vrouw':\n",
    "                    sex = 'Mevrouw '\n",
    "                elif value == 'Man':\n",
    "                    sex = 'De heer '\n",
    "                break  # Break the loop after finding the first occurrence\n",
    "    \n",
    "    return sex\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "25161f2c-ac03-4a5e-b15a-52d2fd5d539e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_age_from_header(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts the age (in years) from the header text.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file containing the header text.\n",
    "\n",
    "    Returns:\n",
    "        int or None: Extracted age in years or None if not found.\n",
    "    \"\"\"\n",
    "    header_text = extract_header_text(pdf_infile)\n",
    "    \n",
    "    # Define the pattern to search for\n",
    "    age_pattern = r'Leeftijd: (\\d+)'\n",
    "\n",
    "    # Search for the age pattern in the header text\n",
    "    match = re.search(age_pattern, header_text)\n",
    "\n",
    "    if match:\n",
    "        # Extract the matched age\n",
    "        age_in_years = int(match.group(1))\n",
    "        return age_in_years\n",
    "\n",
    "    return None  # Return None if the age pattern is not found\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "48854bf0-7e37-44ae-a4b3-78dcb13da343",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_surname_from_pdf(pdf_infile):\n",
    "    \"\"\"\n",
    "    Extracts the surname from the header text of a PDF document.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Extracted surname.\n",
    "    \"\"\"\n",
    "    # Extract header text from the PDF\n",
    "    header_text = extract_header_text(pdf_infile)\n",
    "\n",
    "    # Split the header text into lines\n",
    "    lines = header_text.split('\\n')\n",
    "    line = lines[2] # Search for the line containing the surname and family name\n",
    "    parts = line.split(',') # Split the line into parts using the comma as a separator\n",
    "        \n",
    "    # Assuming the surname is the second part (index 1) after the comma\n",
    "    if len(parts) > 1:\n",
    "        surname = parts[1].strip()\n",
    "        return surname + ' '\n",
    "\n",
    "    # If the surname is not found, return an empty string\n",
    "    return \"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "651016d6-a2dd-4f0c-ac2b-13a69d0001f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def crop_pdf(open_pdf_document, crop_rect):\n",
    "    \"\"\"\n",
    "    Crop a PDF file and return the cropped pdf_document.\n",
    "\n",
    "    Args:\n",
    "        pdf_document (fitz.Document): PyMuPDF document object.\n",
    "        crop_rect (tuple): Coordinates (left, top, right, bottom) to crop the PDF.\n",
    "\n",
    "    Returns:\n",
    "        fitz.Document or None: Cropped PyMuPDF document object if successful, else None.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        \n",
    "        # Crop the PDF using the specified rectangle\n",
    "        open_pdf_document[0].set_cropbox(fitz.Rect(crop_rect))\n",
    "\n",
    "        # print(\"PDF successfully cropped\")\n",
    "        return open_pdf_document\n",
    "    \n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred while cropping the PDF: {e}\")\n",
    "        return None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b7366a77-46b2-463e-8278-e5f35683a716",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_colored_points(image, color_range):\n",
    "    \"\"\"\n",
    "    Filter colored points in an image based on the specified RGB range.\n",
    "\n",
    "    Args:\n",
    "        image (PIL.Image.Image): The input image.\n",
    "        color_range (list of tuples): RGB ranges for filtering colored points.\n",
    "\n",
    "    Returns:\n",
    "        list of tuples: Coordinates of the selected colored points.\n",
    "    \"\"\"\n",
    "    # Convert the image to a NumPy array\n",
    "    img_array = np.array(image)\n",
    "\n",
    "    # Extract the RGB channels\n",
    "    r_channel = img_array[:, :, 0]\n",
    "    g_channel = img_array[:, :, 1]\n",
    "    b_channel = img_array[:, :, 2]\n",
    "\n",
    "    # Create masks for each channel based on the specified ranges\n",
    "    color_mask = (\n",
    "        (r_channel >= color_range[0][0]) & (r_channel <= color_range[0][1]) &\n",
    "        (g_channel >= color_range[1][0]) & (g_channel <= color_range[1][1]) &\n",
    "        (b_channel >= color_range[2][0]) & (b_channel <= color_range[2][1])\n",
    "    )\n",
    "\n",
    "    # Get the coordinates of the selected points\n",
    "    colored_points_coords = np.argwhere(color_mask)\n",
    "\n",
    "    return colored_points_coords\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e6adff83-0321-4f4a-89db-e9370225d693",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_red_points(image):\n",
    "    \"\"\"\n",
    "    Filter red points in an image based on a predefined RGB range.\n",
    "\n",
    "    Args:\n",
    "        image (PIL.Image.Image): The input image.\n",
    "\n",
    "    Returns:\n",
    "        list of tuples: Coordinates of the selected red points.\n",
    "    \"\"\"\n",
    "    result = filter_colored_points(image, RED_COLOR_RANGE)\n",
    "    return result \n",
    "\n",
    "def red_points_coords(pdf_path, crop_rect = (SPEECH_RE_LEFT, SPEECH_RE_TOP, SPEECH_RE_RIGHT, SPEECH_RE_BOTTOM)):\n",
    "    \n",
    "    # Crop the PDF to get the speech audiogram for the right ear\n",
    "    speech_audio_right = crop_pdf(pdf_path, crop_rect)\n",
    "\n",
    "    if speech_audio_right is not None:\n",
    "        try:\n",
    "            # Render the page as an image\n",
    "            pix = speech_audio_right[0].get_pixmap()\n",
    "            img = Image.frombytes(\"RGB\", [pix.width, pix.height], pix.samples)\n",
    "\n",
    "            # Get the coordinates of red points\n",
    "            red_points_coords = filter_red_points(img)\n",
    "\n",
    "            # Count the number of red points\n",
    "            # red_points_count = len(red_points_coords)\n",
    "\n",
    "            # print(f\"Number of Red Points: {red_points_count}\")\n",
    "\n",
    "        except Exception as e:\n",
    "            print(f\"Error processing PDF: {e}\")\n",
    "\n",
    "    return red_points_coords\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7801708e-8551-4766-bc9c-0a3c1ca9f9b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_blue_points(image):\n",
    "    \"\"\"\n",
    "    Filter blue points in an image based on a pblueefined RGB range.\n",
    "\n",
    "    Args:\n",
    "        image (PIL.Image.Image): The input image.\n",
    "\n",
    "    Returns:\n",
    "        list of tuples: Coordinates of the selected blue points.\n",
    "    \"\"\"\n",
    "    result = filter_colored_points(image, BLUE_COLOR_RANGE)\n",
    "    return result \n",
    "\n",
    "def blue_points_coords(pdf_path, crop_rect = (SPEECH_LE_LEFT, SPEECH_LE_TOP, SPEECH_LE_RIGHT, SPEECH_LE_BOTTOM)):\n",
    "    \n",
    "    # Crop the PDF to get the speech audiogram for the right ear\n",
    "    speech_audio_right = crop_pdf(pdf_path, crop_rect)\n",
    "\n",
    "    if speech_audio_right is not None:\n",
    "        try:\n",
    "            # Render the page as an image\n",
    "            pix = speech_audio_right[0].get_pixmap()\n",
    "            img = Image.frombytes(\"RGB\", [pix.width, pix.height], pix.samples)\n",
    "\n",
    "            # Get the coordinates of blue points\n",
    "            blue_points_coords = filter_blue_points(img)\n",
    "\n",
    "            # Count the number of blue points\n",
    "            # blue_points_count = len(blue_points_coords)\n",
    "\n",
    "            # print(f\"Number of blue Points: {blue_points_count}\")\n",
    "\n",
    "        except Exception as e:\n",
    "            print(f\"Error processing PDF: {e}\")\n",
    "\n",
    "    return blue_points_coords\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fb4a9e3b-74a3-47db-9e5c-54c80920768b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform_coordinates_right_speechaudio(coords_array, origin_point = SPEECH_RE_ORIGIN):\n",
    "    \"\"\"\n",
    "    Transform coordinates from the right speech audiogram to a standardized format.\n",
    "\n",
    "    Parameters:\n",
    "    - coords_array (numpy.ndarray): Input array with shape (n, 2) representing (x, y) coordinates.\n",
    "    - origin_point (tuple): Origin point for coordinate transformation.\n",
    "\n",
    "    Returns:\n",
    "    numpy.ndarray: Transformed coordinates in a standardized format.\n",
    "\n",
    "    This function adjusts the x and y coordinates based on the provided origin_point.\n",
    "    It scales the x coordinate to represent dB levels and the y coordinate to represent speech scores.\n",
    "    The transformed coordinates are returned as a numpy array with shape (n, 2).\n",
    "\n",
    "    Example:\n",
    "    >>> origin = (44, 118)\n",
    "    >>> coordinates = np.array([[50, 90], [60, 80], [70, 70]])\n",
    "    >>> transform_coordinates_right_speechaudio(coordinates, origin)\n",
    "    array([[ 47.83,   0.  ],\n",
    "           [ 57.5 ,   0.22],\n",
    "           [ 67.17,   0.44]])\n",
    "    \"\"\"\n",
    "    # Adjust x coordinates for origin, swapping them too\n",
    "    dB_levels = 3 + (coords_array[:, 1] - origin_point[0]) * 120 / (LEVEL_120_RE - LEVEL_0_RE)\n",
    "\n",
    "    # Adjust y coordinates for origin, swapping them too\n",
    "    score = (origin_point[1] - coords_array[:, 0]) / (SCORE_0 - SCORE_100)\n",
    "\n",
    "    result = np.column_stack((dB_levels, score))  # Create a numpy array [x, y]\n",
    "    return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2535db8d-9722-4d2a-b3e5-453ebb31cee8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform_coordinates_left_speechaudio(coords_array, origin_point = SPEECH_LE_ORIGIN):\n",
    "    \"\"\"\n",
    "    Transform coordinates from the left speech audiogram to a standardized format.\n",
    "\n",
    "    Parameters:\n",
    "    - coords_array (numpy.ndarray): Input array with shape (n, 2) representing (x, y) coordinates.\n",
    "    - origin_point (tuple): Origin point for coordinate transformation.\n",
    "\n",
    "    Returns:\n",
    "    numpy.ndarray: Transformed coordinates in a standardized format.\n",
    "\n",
    "    This function adjusts the x and y coordinates based on the provided origin_point.\n",
    "    It scales the x coordinate to represent dB levels and the y coordinate to represent speech scores.\n",
    "    The transformed coordinates are returned as a numpy array with shape (n, 2).\n",
    "\n",
    "    Example:\n",
    "    >>> origin = (26, 118)\n",
    "    >>> coordinates = np.array([[50, 90], [60, 80], [70, 70]])\n",
    "    >>> transform_coordinates_right_speechaudio(coordinates, origin)\n",
    "    array([[ 47.83,   0.  ],\n",
    "           [ 57.5 ,   0.22],\n",
    "           [ 67.17,   0.44]])\n",
    "    \"\"\"\n",
    "    # Adjust x coordinates for origin, swapping them too\n",
    "    dB_levels = 3 + (coords_array[:, 1] - origin_point[0]) * 120 / (LEVEL_120_LE - LEVEL_0_LE)\n",
    "\n",
    "    # Adjust y coordinates for origin, swapping them too\n",
    "    score = (origin_point[1] - coords_array[:, 0]) / (SCORE_0 - SCORE_100)\n",
    "\n",
    "    result = np.column_stack((dB_levels, score))  # Create a numpy array [x, y]\n",
    "    return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e18ac1cc-cd05-4f06-b0c1-bfb4a6a35933",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_max_score_and_level(arr_adj_coords):\n",
    "    \"\"\"\n",
    "    Analyze a 2D numpy array with speech levels and speech scores.\n",
    "    \n",
    "    Returns the maximum speech score and its corresponding level.\n",
    "\n",
    "    Parameters:\n",
    "    - arr_adj_coords (numpy.ndarray): 2D array with shape (n, 2) representing (speech level, speech score).\n",
    "\n",
    "    Returns:\n",
    "    tuple: A tuple containing the speech level and the corresponding maximal speech score in %.\n",
    "\n",
    "    If the array is empty, returns (None, None).\n",
    "    \"\"\"\n",
    "    if arr_adj_coords.size == 0:\n",
    "        return (None, None)  # Handle the case with an empty array\n",
    "\n",
    "    # Find the index of the element containing the max speech score\n",
    "    id_max = arr_adj_coords[:, 1].argmax()\n",
    "    \n",
    "    # Extract the array element with max speech score\n",
    "    arr_max = arr_adj_coords[id_max]\n",
    "\n",
    "    # Round and adjust the max score\n",
    "    score_max = arr_max[1].round(2)\n",
    "    score_max = int(1 + ((score_max * 100 / 3).round(0)) * 3) if score_max > 0.49 else int(((score_max * 100 / 3).round(0)) * 3)\n",
    "    score_max = 100 if score_max > 100 else score_max\n",
    "    score_max = 0 if score_max < 0 else score_max\n",
    "    \n",
    "    # Round and adjust the max level\n",
    "    level_max = int(((arr_max[0] / 5).round(0)) * 5)\n",
    "    level_max = 120 if level_max > 120 else level_max\n",
    "    level_max = 0 if level_max < 0 else level_max\n",
    "    \n",
    "    return level_max, score_max\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d80a6420-f7ba-4205-82ba-15c30ebcf133",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_srt_level(arr_adj_coords):\n",
    "    \"\"\"\n",
    "    Find the Speech Reception Threshold (SRT) level corresponding to a speech score of 0.5.\n",
    "\n",
    "    Parameters:\n",
    "    - arr_adj_coords (numpy.ndarray): Input array with shape (n, 2) representing (x, y) coordinates.\n",
    "\n",
    "    Returns:\n",
    "    float or None: SRT level if it can be determined, else None.\n",
    "\n",
    "    This function performs linear interpolation to estimate the SRT level based on the input coordinates.\n",
    "    If the maximal speech score is less than 0.5 or the minimal speech score is greater than 0.5,\n",
    "    the function returns None.\n",
    "    \"\"\"\n",
    "    if arr_adj_coords.size == 0:\n",
    "        return None  # Handle the case with an empty array\n",
    "\n",
    "    # Sort the array by speech score\n",
    "    sorted_coords = arr_adj_coords[arr_adj_coords[:, 1].argsort()]\n",
    "\n",
    "    # Extract the dB levels and speech scores\n",
    "    dB_levels = sorted_coords[:, 0]\n",
    "    scores = sorted_coords[:, 1]\n",
    "\n",
    "    # Check if the target score (0.5) is within the range\n",
    "    if scores[0] > 0.5 or scores[-1] < 0.5:\n",
    "        return None\n",
    "\n",
    "    # Find the index where the transition occurs\n",
    "    transition_index = np.searchsorted(scores, 0.5, side=\"right\")\n",
    "\n",
    "    # Perform linear interpolation\n",
    "    srt_level_abs = np.interp(0.5, scores[transition_index - 1:transition_index + 1], dB_levels[transition_index - 1:transition_index + 1])\n",
    "    srt_level = int(srt_level_abs - 25)\n",
    "    \n",
    "    return srt_level\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7aff42c9-1240-44fe-ba87-c6458926bb4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def describe_speech_audiogram(level_max_score, max_score, srt, side):\n",
    "    \"\"\"\n",
    "    Generate a descriptive text for a speech audiogram based on three features:\n",
    "    \n",
    "    Parameters:\n",
    "    - level_max_score (float or None): Speech level corresponding to the maximal speech score.\n",
    "    - max_score (float): Maximal speech score in the speech audiogram.\n",
    "    - srt (float or None): Speech Reception Threshold level corresponding to a speech score of 0.5.\n",
    "\n",
    "    Returns:\n",
    "    str: A descriptive text based on the provided features.\n",
    "    If level_max_score is None, returns 'niet getest of spraakverstaan nihil'.\n",
    "    If max_score is less than 50, adds ', drempelverschuiving niet te bepalen' to the text.\n",
    "    If srt is None, adds ', drempelverschuiving niet bepaald' to the text.\n",
    "    Otherwise, adds ', drempelverschuiving {srt} dB' to the text.\n",
    "\n",
    "    Example:\n",
    "    >>> describe_speech_audiogram(60, 75, 25)\n",
    "    'maximale score 75% bij 60 dB, drempelverschuiving 25 dB'\n",
    "    \"\"\"\n",
    "    if level_max_score is None:\n",
    "        return side + ' ' +  'niet getest of spraakverstaan nihil'\n",
    "\n",
    "    text_srt = ', drempelverschuiving niet bepaald' if srt is None else f', drempelverschuiving {srt} dB'\n",
    "    text_score = f'maximale score {max_score}% bij {level_max_score} dB'\n",
    "    \n",
    "    if max_score < 50:\n",
    "        return side + ' ' + text_score + ', drempelverschuiving niet te bepalen'\n",
    "    \n",
    "    return side + ' ' +  text_score + text_srt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fc5dd6e4-4351-4830-a241-d146b2557416",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def toonaudiometry_results(pdf_infile, hearing_loss_data_right_ear, hearing_loss_data_left_ear, speech_audio_result):\n",
    "    \"\"\"\n",
    "    Generates a formatted report of the audiometry results.\n",
    "\n",
    "    Args:\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "        str: Formatted report of the audiometry results.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # data of test and patient\n",
    "        pt = '\\n' + patient_data(pdf_infile)\n",
    "        day = '\\nOnderzoeksdatum: ' + test_date(pdf_infile) + ', Afdrukdatum: ' + print_date(pdf_infile) + '\\n'\n",
    "        date = '\\nDatum: ' + test_date(pdf_infile)\n",
    "        \n",
    "        # text with comments in the bottom section\n",
    "        text = \"\\n\\nOpmerkingen\\n\" + extract_bottom_text(pdf_infile)\n",
    "        \n",
    "        # check for age of subject\n",
    "        age_at_test = extract_age_from_header(pdf_infile)\n",
    "        if age_at_test > 18: nm = patient_sex(pdf_infile)\n",
    "        else: nm = extract_surname_from_pdf(pdf_infile)\n",
    "        \n",
    "        # compose lines of text for \"long description\"\n",
    "        a = \"\\nToonaudiometrie \" + '(' + sum_of_checks(pdf_infile)+ ')'\n",
    "        b = \"\\nBetrouwbaarheid goed/redelijk/matig/slecht\"\n",
    "        c = \"\\nRechts \" + type_hearing_loss(hearing_loss_data_right_ear)\n",
    "        d = \"\\nLinks \" + type_hearing_loss(hearing_loss_data_left_ear) + \"\\n\\n\"\n",
    "        g = f\"Spraakaudiometrie ({check_for_speech_material(pdf_infile)}{' ' if check_for_hoofdtel(pdf_infile) != '' or check_for_insert(pdf_infile) != '' else ''}{check_for_hoofdtel(pdf_infile)}{check_for_insert(pdf_infile)})\\n\"\n",
    "        h = speech_audio_result + \"\\n\\n\"\n",
    "        \n",
    "        # compose lines of text for \"short description\"\n",
    "        z = '\\n' + patient_sex(pdf_infile) + 'heeft rechts ' + short_hearing_loss(hearing_loss_data_right_ear) \\\n",
    "        + ' en links ' + short_hearing_loss(hearing_loss_data_left_ear) + '.'\n",
    "        if short_hearing_loss(hearing_loss_data_right_ear) == short_hearing_loss(hearing_loss_data_left_ear):\n",
    "            z = '\\n' + nm + 'heeft beiderzijds ' + short_hearing_loss(hearing_loss_data_right_ear) + '.\\n'\n",
    "        else: \n",
    "            z = '\\n' + nm + 'heeft rechts ' + short_hearing_loss(hearing_loss_data_right_ear) \\\n",
    "            + ' en links ' + short_hearing_loss(hearing_loss_data_left_ear) + '.\\n'\n",
    "            \n",
    "        # compose the all text\n",
    "        result = pt + day + date + a + b + c + d + g + h + date + z + text\n",
    "        print(result)\n",
    "        return result\n",
    "\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred while generating audiometry results: {e}\")\n",
    "        return \"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0ce651a4-b59a-464b-80f1-0aa8e977eef9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_pdf_file_path_from_user():\n",
    "    \"\"\"\n",
    "    Prompts the user to enter the path to the PDF file containing the audiogram.\n",
    "\n",
    "    Returns:\n",
    "        str: The user-provided path to the PDF file.\n",
    "    \"\"\"\n",
    "    while True:\n",
    "        pdf_path = input(Fore.LIGHTRED_EX + Style.BRIGHT +\"\\nVoer de locatie van het PDF-bestand met het audiogram in:\\n\"\\\n",
    "                         + Style.RESET_ALL)\n",
    "\n",
    "        # Check if the path exists\n",
    "        if not os.path.exists(pdf_path):\n",
    "            print(\"Ongeldige locatie. Het opgegeven pad bestaat niet. Probeer opnieuw.\")\n",
    "            continue\n",
    "\n",
    "        # Check if the path is a file\n",
    "        if not os.path.isfile(pdf_path):\n",
    "            print(\"Ongeldige locatie. Het opgegeven pad leidt niet naar een bestand. Probeer opnieuw.\")\n",
    "            continue\n",
    "\n",
    "        # Check if the file has a PDF extension\n",
    "        if not pdf_path.lower().endswith('.pdf'):\n",
    "            print(\"Ongeldig bestandsformaat. Het bestand moet een PDF-bestand zijn. Probeer opnieuw.\")\n",
    "            continue\n",
    "\n",
    "        return pdf_path\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f40fa9ad-5f83-4314-8a48-7b63e0722569",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_user_downloads_folder():\n",
    "    \"\"\"\n",
    "    Get the appropriate Downloads folder based on the user's setup.\n",
    "    \n",
    "    Returns:\n",
    "        str: Path to the user's Downloads folder.\n",
    "    \"\"\"\n",
    "    # Get the path to the user's standard Downloads folder\n",
    "    standard_downloads = join(expanduser(\"~\"), \"Downloads\")\n",
    "    \n",
    "    # Check if the standard Downloads folder exists\n",
    "    if os.path.exists(standard_downloads):\n",
    "        return standard_downloads\n",
    "    \n",
    "    # If standard Downloads folder doesn't exist, try the OneDrive Downloads folder\n",
    "    onedrive_downloads = join(expanduser(\"~\"), \"OneDrive - adelante-zorggroep.nl\", \"Downloads\")\n",
    "    \n",
    "    # Check if the OneDrive Downloads folder exists\n",
    "    if os.path.exists(onedrive_downloads):\n",
    "        return onedrive_downloads\n",
    "    \n",
    "    # If neither exists, return None or raise an exception based on your preference\n",
    "    raise FileNotFoundError(\"Neither standard Downloads nor OneDrive Downloads folder found.\")\n",
    "\n",
    "def save_results_to_downloads(results, pdf_infile):\n",
    "    \"\"\"\n",
    "    Saves the formatted results to a text file in the user's preferred Downloads folder.\n",
    "\n",
    "    Args:\n",
    "        results (str): Formatted results.\n",
    "        pdf_infile (str): Path to the PDF file.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # Get the user's preferred Downloads folder\n",
    "        downloads_folder = get_user_downloads_folder()\n",
    "        \n",
    "        # Define the file name\n",
    "        f_name = patient_data(pdf_infile) + '_' + 'TestDat_' + test_date(pdf_infile) + '.txt'\n",
    "        \n",
    "        # Create the full path to the file in the user's preferred Downloads folder\n",
    "        file_path = join(downloads_folder, f_name)\n",
    "\n",
    "        # Save the formatted results to the output file\n",
    "        with open(file_path, 'w') as file:\n",
    "            file.write(results)\n",
    "\n",
    "        print(\"\\nResultaten opgeslagen in: \\n\", file_path)\n",
    "\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred while saving results to file: {e}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "71bbb2e2-00ae-48e8-a67b-de9d9a11aab3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Main program\n",
    "def main(): \n",
    "\n",
    "    while True:\n",
    "        # Ask the user to provide the location of the PDF file with an audiogram to analyze\n",
    "        pdf_infile = get_pdf_file_path_from_user()\n",
    "\n",
    "        # Open PDF safely\n",
    "        pdf_document = open_pdf_safely(pdf_infile)\n",
    "\n",
    "        if pdf_document is not None:\n",
    "            try:\n",
    "                # Extract text from right_ear and left_ear audiograms\n",
    "                right_ear_audiogram_text = extract_right_audiogram_text(pdf_document)\n",
    "                left_ear_audiogram_text = extract_left_audiogram_text(pdf_document)\n",
    "\n",
    "                # Extract and Process Hearing Loss data\n",
    "                hearing_loss_data_right_ear = provide_hearing_loss_data(right_ear_audiogram_text)\n",
    "                hearing_loss_data_left_ear = provide_hearing_loss_data(left_ear_audiogram_text)\n",
    "\n",
    "                # Extract and Process Right ear Speech-audiogram\n",
    "                red_points_re = red_points_coords(pdf_document, crop_rect=(SPEECH_RE_LEFT, SPEECH_RE_TOP, SPEECH_RE_RIGHT, SPEECH_RE_BOTTOM))\n",
    "                adj_red_points_re = transform_coordinates_right_speechaudio(red_points_re)\n",
    "                level_max_score_re, max_score_re = find_max_score_and_level(adj_red_points_re)\n",
    "                srt_re = find_srt_level(adj_red_points_re)\n",
    "                text_re = describe_speech_audiogram(level_max_score_re, max_score_re, srt_re, side='Rechts' )\n",
    "\n",
    "                # Extract and Process Left ear Speech-audiogram\n",
    "                blue_points_le = blue_points_coords(pdf_document, crop_rect=(SPEECH_LE_LEFT, SPEECH_LE_TOP, SPEECH_LE_RIGHT, SPEECH_LE_BOTTOM))\n",
    "                adj_blue_points_le = transform_coordinates_left_speechaudio(blue_points_le)\n",
    "                level_max_score_le, max_score_le = find_max_score_and_level(adj_blue_points_le)\n",
    "                srt_le = find_srt_level(adj_blue_points_le)\n",
    "                text_le = describe_speech_audiogram(level_max_score_le, max_score_le, srt_le, side='Links')\n",
    "\n",
    "                # Speech-audiometry Result\n",
    "                speech_audiometry_text = f'{text_re}\\n{text_le}'\n",
    "\n",
    "                # Get the formatted result\n",
    "                formatted_result = toonaudiometry_results(pdf_document, hearing_loss_data_right_ear, hearing_loss_data_left_ear, speech_audiometry_text)\n",
    "\n",
    "                # Save the formatted result to a text file in the same directory as the PDF file\n",
    "                save_results_to_downloads(formatted_result, pdf_infile)\n",
    "                \n",
    "                \n",
    "            except Exception as e:\n",
    "                print(f\"An error occurred: {e}\")\n",
    "\n",
    "        # Check if the user wants to exit\n",
    "        exit_input = input(Fore.LIGHTRED_EX + Style.BRIGHT +\"\\nDruk op Enter voor de analyse van een andere file, of typ 'exit' en druk op Enter om te verlaten:\\n\"\\\n",
    "                           + Style.RESET_ALL)\n",
    "        if exit_input.lower() == 'exit':\n",
    "            print(\"Het programma wordt afgesloten. Tot ziens!\")\n",
    "            break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b7152eaa-eddf-44e9-b7ad-2b345e3ffb46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "\u001b[91m\u001b[1m\n",
      "Voer de locatie van het PDF-bestand met het audiogram in:\n",
      "\u001b[0m /home/guido/Python_Programs/project_audiogram/EasyPDF_AudioScraper/bad74547-e6be-41c0-8f8d-bdac23416730.pdf\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PtId_03511674_GebDat_31-01-1960\n",
      "Onderzoeksdatum: 19-12-2023, Afdrukdatum: 19-12-2023\n",
      "\n",
      "Datum: 19-12-2023\n",
      "Toonaudiometrie ()\n",
      "Betrouwbaarheid goed/redelijk/matig/slecht\n",
      "Rechts gemengd gehoorverlies, 80 dB (gemiddeld bij 1, 2 en 4 kHz)\n",
      "Links gemengd gehoorverlies, 85 dB (gemiddeld bij 1, 2 en 4 kHz)\n",
      "\n",
      "Spraakaudiometrie (NVA)\n",
      "Rechts maximale score 73% bij 115 dB, drempelverschuiving 79 dB\n",
      "Links maximale score 79% bij 110 dB, drempelverschuiving 73 dB\n",
      "\n",
      "\n",
      "Datum: 19-12-2023\n",
      "Mevrouw heeft beiderzijds een zeer ernstig gemengd gehoorverlies.\n",
      "\n",
      "\n",
      "Opmerkingen\n",
      "Onderzoek:\n",
      "19-12-2023\n",
      "Afdruk datum:\n",
      "19-12-2023\n",
      "Pagina:\n",
      "1 van 1\n",
      "Onderzoeker:\n",
      "L Engbersen\n",
      "\n",
      "\n",
      "Resultaten opgeslagen in: \n",
      " /home/guido/Downloads/PtId_03511674_GebDat_31-01-1960_TestDat_19-12-2023.txt\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "\u001b[91m\u001b[1m\n",
      "\tDruk op Enter voor de analyse van een andere file, of typ 'exit' en druk op Enter om te verlaten:\n",
      "\u001b[0m \n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "Interrupted by user",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[39], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m#   /home/guido/Python_Programs/project_audiogram/EasyPDF_AudioScraper/bad74547-e6be-41c0-8f8d-bdac23416730.pdf\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# Call the main function to execute the program\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m----> 4\u001b[0m     main()\n",
      "Cell \u001b[0;32mIn[38], line 6\u001b[0m, in \u001b[0;36mmain\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmain\u001b[39m(): \n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m      5\u001b[0m         \u001b[38;5;66;03m# Ask the user to provide the location of the PDF file with an audiogram to analyze\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m         pdf_infile \u001b[38;5;241m=\u001b[39m get_pdf_file_path_from_user()\n\u001b[1;32m      8\u001b[0m         \u001b[38;5;66;03m# Open PDF safely\u001b[39;00m\n\u001b[1;32m      9\u001b[0m         pdf_document \u001b[38;5;241m=\u001b[39m open_pdf_safely(pdf_infile)\n",
      "Cell \u001b[0;32mIn[36], line 9\u001b[0m, in \u001b[0;36mget_pdf_file_path_from_user\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;124;03mPrompts the user to enter the path to the PDF file containing the audiogram.\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \n\u001b[1;32m      5\u001b[0m \u001b[38;5;124;03mReturns:\u001b[39;00m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;124;03m    str: The user-provided path to the PDF file.\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m----> 9\u001b[0m     pdf_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m(Fore\u001b[38;5;241m.\u001b[39mLIGHTRED_EX \u001b[38;5;241m+\u001b[39m Style\u001b[38;5;241m.\u001b[39mBRIGHT \u001b[38;5;241m+\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mVoer de locatie van het PDF-bestand met het audiogram in:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\\\n\u001b[1;32m     10\u001b[0m                      \u001b[38;5;241m+\u001b[39m Style\u001b[38;5;241m.\u001b[39mRESET_ALL)\n\u001b[1;32m     12\u001b[0m     \u001b[38;5;66;03m# Check if the path exists\u001b[39;00m\n\u001b[1;32m     13\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(pdf_path):\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/ipykernel/kernelbase.py:1202\u001b[0m, in \u001b[0;36mKernel.raw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m   1200\u001b[0m     msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mraw_input was called, but this frontend does not support input requests.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1201\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m StdinNotImplementedError(msg)\n\u001b[0;32m-> 1202\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_input_request(\n\u001b[1;32m   1203\u001b[0m     \u001b[38;5;28mstr\u001b[39m(prompt),\n\u001b[1;32m   1204\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_parent_ident[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mshell\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m   1205\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_parent(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mshell\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m   1206\u001b[0m     password\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m   1207\u001b[0m )\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/ipykernel/kernelbase.py:1245\u001b[0m, in \u001b[0;36mKernel._input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m   1242\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m:\n\u001b[1;32m   1243\u001b[0m     \u001b[38;5;66;03m# re-raise KeyboardInterrupt, to truncate traceback\u001b[39;00m\n\u001b[1;32m   1244\u001b[0m     msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInterrupted by user\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1245\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1246\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m   1247\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog\u001b[38;5;241m.\u001b[39mwarning(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid Message:\u001b[39m\u001b[38;5;124m\"\u001b[39m, exc_info\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
     ]
    }
   ],
   "source": [
    "#   /home/guido/Python_Programs/project_audiogram/EasyPDF_AudioScraper/bad74547-e6be-41c0-8f8d-bdac23416730.pdf\n",
    "# Call the main function to execute the program\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}