medicafe 0.240419.2__py3-none-any.whl → 0.240613.0__py3-none-any.whl

MediBot/MediBot_dataformat_library.py

@@ -1,8 +1,23 @@
 import re
 from datetime import datetime
 import re  #for addresses
-from MediBot_Preprocessor import open_csv_for_editing, config, initialize
-from MediBot_UI import manage_script_pause
+
+# Add parent directory of the project to the Python path
+import os
+import sys
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try: 
+    from MediLink import MediLink_ConfigLoader
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
+except ImportError:
+    from MediLink_ConfigLoader import load_configuration
+    config, crosswalk = load_configuration()
+
+from MediBot_Preprocessor_lib import open_csv_for_editing, initialize
+from MediBot_UI import manage_script_pause, app_control
+
 
 # Bring in all the constants
 initialize(config)
@@ -11,11 +26,13 @@ initialize(config)
 def format_name(value):  
     if ',' in value:
         return value
-    hyphenated_name_pattern = r'(?P<First>[\w-]+)\s+(?P<Middle>[\w-]+)?\s+(?P<Last>[\w-]+)'
+    hyphenated_name_pattern = r'(?P<First>[\w-]+)\s+(?P<Middle>[\w-]?)\s+(?P<Last>[\w-]+)'
     match = re.match(hyphenated_name_pattern, value)
     if match:
         first_name = match.group('First')
         middle_name = match.group('Middle') or ''
+        if len(middle_name) > 1:
+            middle_name = middle_name[0]  # take only the first character
         last_name = match.group('Last')
         return '{}, {} {}'.format(last_name, first_name, middle_name).strip()
     parts = value.split()
@@ -43,70 +60,97 @@ def format_policy(value):
 def format_gender(value):
     return value[0].upper()
 
+def enforce_significant_length(output):
+    # Replace spaces with a placeholder that counts as one significant digit
+    temp_output = output.replace('{Space}', ' ')
+    
+    # Check if the number of significant digits exceeds 30
+    if len(temp_output) > 30:
+        
+        # First line of defense: Replace ' APT ' with ' #' if the original length is longer than 30 characters.
+        temp_output = temp_output.replace(' APT ', ' #')
+        
+        # Remove spaces in a controlled manner from right to left if still too long
+        while len(temp_output) > 30:
+            # Find the last space
+            last_space_index = temp_output.rfind(' ')
+            if last_space_index == -1:
+                break
+            # Remove the last space
+            temp_output = temp_output[:last_space_index] + temp_output[last_space_index+7:]
+
+        # If still greater than 30, truncate to 30 characters
+        if len(temp_output) > 30:
+            temp_output = temp_output[:30]
+
+    # Replace placeholder back with actual space for final return
+    return temp_output.replace(' ', '{Space}')
+
 def format_street(value, csv_data, reverse_mapping, parsed_address_components):
-    global script_paused
-    script_paused = False
+    # Temporarily disable script pause status
+    app_control.set_pause_status(False)
     
-    # Remove periods from the input (seems to be an XP-only issue?)
+    # Remove period characters.
     value = value.replace('.', '')
     
-    # Only proceed with parsing if a comma is present in the value
+    # Proceed only if there's a comma, indicating a likely full address
     if ',' in value:
         try:
-            # Access the common cities from the loaded configuration
+            MediLink_ConfigLoader.log("Attempting to resolve address via regex...")
+            # Retrieve common city names from configuration and prepare a regex pattern
             common_cities = config.get('cities', [])
-
-            # Convert cities to a case-insensitive regex pattern
             city_pattern = '|'.join(re.escape(city) for city in common_cities)
             city_regex_pattern = r'(?P<City>{})'.format(city_pattern)
             city_regex = re.compile(city_regex_pattern, re.IGNORECASE)
 
-            # Check if the address contains one of the common cities
+            # Search for a common city in the address
             city_match = city_regex.search(value)
                     
             if city_match:
-                city = city_match.group('City').upper()  # Normalize city name to uppercase
+                # Extract city name and partition the value around it
+                city = city_match.group('City').upper()
                 street, _, remainder = value.partition(city)
-
-                # Extract state and zip code from the remainder
+                
+                # Regex pattern to find state and zip code in the remainder
                 address_pattern = r',\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(?:-\d{4})?)?'
-
                 match = re.search(address_pattern, remainder)
-                    
+
                 if match:
-                    # Update global parsed address components
+                    # Update parsed address components
                     parsed_address_components['City'] = city
                     parsed_address_components['State'] = match.group('State')
                     parsed_address_components['Zip Code'] = match.group('Zip')
-                    
-                    return street.strip()  # Return formatted street address
+                    # Return formatted street address, enforcing significant length
+                    return enforce_significant_length(street.strip())
             else:
-                # Fallback to old regex
-                # value = street + ', ' + city + remainder
+                # Fallback regex for parsing addresses without a common city
                 address_pattern = r'(?P<Street>[\w\s]+),?\s+(?P<City>[\w\s]+),\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(-\d{4})?)'
                 match = re.match(address_pattern, value)
 
                 if match:
-                    # Update global parsed address components
+                    # Update parsed address components
                     parsed_address_components['City'] = match.group('City')
                     parsed_address_components['State'] = match.group('State')
                     parsed_address_components['Zip Code'] = match.group('Zip')
-
-                    return match.group('Street').strip()  # Return formatted street address
+                    # Return formatted street address, enforcing significant length
+                    return enforce_significant_length(match.group('Street').strip())
                     
         except Exception as e:
+            # Handle exceptions by logging and offering to correct data manually
             print("Address format error: Unable to parse address '{}'. Error: {}".format(value, e))
-            print("Please update the CSV file for this record.")
-            script_paused = True
-            open_csv_for_editing(CSV_FILE_PATH)  # Offer to open the CSV for manual correction
-            manage_script_pause(csv_data, e, reverse_mapping) 
-            return value.replace(' ', '{Space}')  # Fallback to return original value with spaces escaped
+            app_control.set_pause_status(True)
+            open_csv_for_editing(CSV_FILE_PATH)
+            manage_script_pause(csv_data, e, reverse_mapping)
+            # Return original value with spaces formatted, enforcing significant length
+            return enforce_significant_length(value.replace(' ', '{Space}'))
     else:
-        # If no comma is present, return the value as is, assuming it's just a street name
-        return value.replace(' ', '{Space}')
-    
-    # This return acts as a fallback in case the initial comma check passes but no address components are matched
-    return value.replace(' ', '{Space}')  
+        # If no comma is present, treat the input as a simple street name
+        formatted_value = value.replace(' ', '{Space}')
+        enforced_format = enforce_significant_length(formatted_value)
+        return enforced_format
+
+    # Fallback return in case no address components are matched even though a comma was present
+    return enforce_significant_length(value.replace(' ', '{Space}')) 
 
 def format_zip(value):
     # Ensure the value is a string, in case it's provided as an integer
@@ -138,7 +182,7 @@ def format_data(medisoft_field, value, csv_data, reverse_mapping, parsed_address
     elif medisoft_field == 'Secondary Group Number':
         formatted_value = format_policy(value)
     else:
-        formatted_value = value
+        formatted_value = str(value) # Ensure value is always a string
 
     formatted_value = formatted_value.replace(',', '{,}').replace(' ', '{Space}')
     ahk_command = 'SendInput, {}{{Enter}}'.format(formatted_value)

MediBot/MediBot_docx_decoder.py

@@ -0,0 +1,295 @@
+from docx import Document
+import re
+from lxml import etree
+import zipfile
+from datetime import datetime
+import os
+import sys
+from collections import OrderedDict
+
+# Add parent directory of the project to the Python path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try:
+    import MediLink_ConfigLoader
+except ImportError:
+    from MediLink import MediLink_ConfigLoader
+
+def parse_docx(filepath):
+    try:
+        doc = Document(filepath)  # Open the .docx file
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error opening document: {}".format(e))  # Log error
+        return {}
+
+    patient_data = OrderedDict()  # Initialize OrderedDict to store data
+    MediLink_ConfigLoader.log("Extracting Date of Service from {}".format(filepath), level="DEBUG")
+    
+    date_of_service = extract_date_of_service(filepath)  # Extract date of service
+    MediLink_ConfigLoader.log("Date of Service recorded as: {}".format(date_of_service), level="DEBUG")
+
+    for table in doc.tables:  # Iterate over tables in the document
+        for row in table.rows:
+            cells = [cell.text.strip() for cell in row.cells]
+            if len(cells) > 4 and cells[3].startswith('#'):
+                try:
+                    patient_id = parse_patient_id(cells[3])
+                    diagnosis_code = parse_diagnosis_code(cells[4])
+                    left_or_right_eye = parse_left_or_right_eye(cells[4])
+                    femto_yes_or_no = parse_femto_yes_or_no(cells[4])
+
+                    if patient_id not in patient_data:
+                        patient_data[patient_id] = {}
+
+                    if date_of_service in patient_data[patient_id]:
+                        MediLink_ConfigLoader.log("Duplicate entry for patient ID {} on date {}. Skipping.".format(patient_id, date_of_service))
+                    else:
+                        patient_data[patient_id][date_of_service] = [diagnosis_code, left_or_right_eye, femto_yes_or_no]
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Error processing row: {}. Error: {}".format(cells, e))
+    
+    # Validation steps
+    validate_unknown_entries(patient_data)
+    validate_diagnostic_code(patient_data)
+    
+    return patient_data
+
+def validate_unknown_entries(patient_data):
+    for patient_id, dates in list(patient_data.items()):
+        for date, details in list(dates.items()):
+            if 'Unknown' in details:
+                warning_message = "Warning: 'Unknown' entry found. Patient ID: {}, Date: {}, Details: {}".format(patient_id, date, details)
+                MediLink_ConfigLoader.log(warning_message, level="WARNING")
+                print(warning_message)
+                del patient_data[patient_id][date]
+        if not patient_data[patient_id]:  # If no dates left for the patient, remove the patient
+            del patient_data[patient_id]
+
+def validate_diagnostic_code(patient_data):
+    for patient_id, dates in patient_data.items():
+        for date, details in dates.items():
+            diagnostic_code, eye, _ = details
+            if diagnostic_code[-1].isdigit():
+                if eye == 'Left' and not diagnostic_code.endswith('2'):
+                    log_and_warn(patient_id, date, diagnostic_code, eye)
+                elif eye == 'Right' and not diagnostic_code.endswith('1'):
+                    log_and_warn(patient_id, date, diagnostic_code, eye)
+
+def log_and_warn(patient_id, date, diagnostic_code, eye):
+    warning_message = (
+        "Warning: Mismatch found for Patient ID: {}, Date: {}, "
+        "Diagnostic Code: {}, Eye: {}".format(patient_id, date, diagnostic_code, eye)
+    )
+    MediLink_ConfigLoader.log(warning_message, level="WARNING")
+    print(warning_message)
+
+# Extract and parse the date of service from the .docx file
+def extract_date_of_service(docx_path):
+    extract_to = "extracted_docx"
+    try:
+        if not os.path.exists(extract_to):
+            os.makedirs(extract_to)
+        with zipfile.ZipFile(docx_path, 'r') as docx:
+            docx.extractall(extract_to)
+            MediLink_ConfigLoader.log("Extracted DOCX to: {}".format(extract_to), level="DEBUG")
+
+        file_path = find_text_in_xml(extract_to, "Surgery Schedule")
+        if file_path:
+            return extract_date_from_file(file_path)
+        else:
+            MediLink_ConfigLoader.log("Target text 'Surgery Schedule' not found in any XML files.", level="WARNING")
+            return None
+    finally:
+        # Clean up the extracted files
+        remove_directory(extract_to)
+        MediLink_ConfigLoader.log("Cleaned up extracted files in: {}".format(extract_to), level="DEBUG")
+
+def remove_directory(path):
+    if os.path.exists(path):
+        for root, dirs, files in os.walk(path, topdown=False):
+            for name in files:
+                os.remove(os.path.join(root, name))
+            for name in dirs:
+                os.rmdir(os.path.join(root, name))
+        os.rmdir(path)
+
+# Find the target text in the extracted XML files
+def find_text_in_xml(directory, target_text):
+    for root_dir, dirs, files in os.walk(directory):
+        for file in files:
+            if file.endswith('.xml'):
+                file_path = os.path.join(root_dir, file)
+                try:
+                    tree = etree.parse(file_path)
+                    root = tree.getroot()
+                    namespaces = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'} # hardcoded for XP handling BUG
+                    for elem in root.xpath('//w:t', namespaces=namespaces):
+                        if elem.text and target_text in elem.text:
+                            MediLink_ConfigLoader.log("Found target text in file: {}".format(file_path), level="DEBUG")
+                            return file_path
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Error parsing XML file {}: {}".format(file_path, e))
+                    print("Error parsing XML file {}: {}".format(file_path, e))
+    return None
+
+# Normalize month and day abbreviations
+def normalize_text(text):
+    month_map = {
+        'JAN': 'JANUARY', 'FEB': 'FEBRUARY', 'MAR': 'MARCH', 'APR': 'APRIL', 
+        'MAY': 'MAY', 'JUN': 'JUNE', 'JUL': 'JULY', 'AUG': 'AUGUST', 
+        'SEP': 'SEPTEMBER', 'OCT': 'OCTOBER', 'NOV': 'NOVEMBER', 'DEC': 'DECEMBER'
+    }
+    day_map = {
+        'MON': 'MONDAY', 'TUE': 'TUESDAY', 'WED': 'WEDNESDAY', 'THU': 'THURSDAY', 
+        'FRI': 'FRIDAY', 'SAT': 'SATURDAY', 'SUN': 'SUNDAY'
+    }
+    
+    for abbr, full in month_map.items():
+        text = re.sub(r'\b' + abbr + r'\b', full, text, flags=re.IGNORECASE)
+    for abbr, full in day_map.items():
+        text = re.sub(r'\b' + abbr + r'\b', full, text, flags=re.IGNORECASE)
+    
+    return text
+
+def reassemble_year(text):
+    # First, handle the most common case where a 4-digit year is split as (3,1), (1,3), or (2,2)
+    text = re.sub(r'(\d{3}) (\d{1})', r'\1\2', text)
+    text = re.sub(r'(\d{1}) (\d{3})', r'\1\2', text)
+    text = re.sub(r'(\d{2}) (\d{2})', r'\1\2', text)
+    
+    # Handle the less common cases where the year might be split as (1,1,2) or (2,1,1) or (1,2,1)
+    parts = re.findall(r'\b(\d{1,2})\b', text)
+    if len(parts) >= 4:
+        for i in range(len(parts) - 3):
+            candidate = ''.join(parts[i:i + 4])
+            if len(candidate) == 4 and candidate.isdigit():
+                combined_year = candidate
+                text = re.sub(r'\b' + r'\b \b'.join(parts[i:i + 4]) + r'\b', combined_year, text)
+                break
+    
+    return text
+
+# Extract and parse the date from the file
+def extract_date_from_file(file_path):
+    try:
+        tree = etree.parse(file_path)
+        root = tree.getroot()
+        collected_text = []
+        
+        namespaces = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'} # hardcoded for XP handling BUG
+        for elem in root.xpath('//w:t', namespaces=namespaces):
+            if elem.text:
+                collected_text.append(elem.text.strip())
+        
+        for elem in root.iter():
+            if elem.tag.endswith('t') and elem.text:
+                collected_text.append(elem.text.strip())
+
+        combined_text = ' '.join(collected_text)
+        combined_text = reassemble_year(combined_text) # Fix OCR splitting years
+        # combined_text = re.sub(r'(\d{3}) (\d{1})', r'\1\2', combined_text) # initial year regex.
+        combined_text = normalize_text(combined_text)  # Normalize abbreviations
+        combined_text = re.sub(r',', '', combined_text)  # Remove commas if they exist
+
+        # Log the combined text
+        MediLink_ConfigLoader.log("Combined text: {}".format(combined_text), level="DEBUG")
+        # print("DEBUG: Combined text: {}".format(combined_text))
+        
+        day_week_pattern = r"(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)"
+        month_day_pattern = r"(JANUARY|FEBRUARY|MARCH|APRIL|MAY|JUNE|JULY|AUGUST|SEPTEMBER|OCTOBER|NOVEMBER|DECEMBER) \d{1,2}"
+        year_pattern = r"\d{4}"
+
+        day_of_week = re.search(day_week_pattern, combined_text, re.IGNORECASE)
+        month_day = re.search(month_day_pattern, combined_text, re.IGNORECASE)
+        year_match = re.search(year_pattern, combined_text, re.IGNORECASE)
+        
+        # Log the results of the regex searches
+        MediLink_ConfigLoader.log("Day of week found: {}".format(day_of_week.group() if day_of_week else 'None'), level="DEBUG")
+        MediLink_ConfigLoader.log("Month and day found: {}".format(month_day.group() if month_day else 'None'), level="DEBUG")
+        MediLink_ConfigLoader.log("Year found: {}".format(year_match.group() if year_match else 'None'), level="DEBUG")
+
+        if day_of_week and month_day and year_match:
+            date_str = "{} {} {}".format(day_of_week.group(), month_day.group(), year_match.group())
+            try:
+                date_obj = datetime.strptime(date_str, '%A %B %d %Y')
+                return date_obj.strftime('%m-%d-%Y')
+            except ValueError as e:
+                MediLink_ConfigLoader.log("Error converting date: {}. Error: {}".format(date_str, e), level="ERROR")
+        else:
+            MediLink_ConfigLoader.log("Date components not found or incomplete in the text. Combined text: {}, Day of week: {}, Month and day: {}, Year: {}"
+                .format(combined_text, 
+                        day_of_week.group() if day_of_week else 'None', 
+                        month_day.group() if month_day else 'None', 
+                        year_match.group() if year_match else 'None'),
+                level="WARNING")
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error extracting date from file: {}. Error: {}".format(file_path, e))
+        print("Error extracting date from file: {}. Error: {}".format(file_path, e))
+    
+    return None
+
+def parse_patient_id(text):
+    try:
+        return text.split()[0].lstrip('#')  # Extract patient ID number (removing the '#')
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing patient ID: {}. Error: {}".format(text, e))
+        return None
+
+def parse_diagnosis_code(text):
+    try:
+        if '(' in text and ')' in text:  # Extract the diagnosis code before the '/'
+            full_code = text[text.index('(')+1:text.index(')')]
+            return full_code.split('/')[0]
+        return text.split('/')[0]
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing diagnosis code: {}. Error: {}".format(text, e))
+        return "Unknown"
+
+def parse_left_or_right_eye(text):
+    try:
+        if 'LEFT EYE' in text.upper():
+            return 'Left'
+        elif 'RIGHT EYE' in text.upper():
+            return 'Right'
+        else:
+            return 'Unknown'
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing left or right eye: {}. Error: {}".format(text, e))
+        return 'Unknown'
+
+def parse_femto_yes_or_no(text):
+    try:
+        if 'FEMTO' in text.upper():
+            return True
+        else:
+            return False
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing femto yes or no: {}. Error: {}".format(text, e))
+        return False
+
+
+def rotate_docx_files(directory):
+    # List all files in the directory
+    files = os.listdir(directory)
+
+    # Filter files that contain "DR" and "SS" in the filename
+    filtered_files = [file for file in files if "DR" in file and "SS" in file]
+
+    # Iterate through filtered files
+    for filename in filtered_files:
+        filepath = os.path.join(directory, filename)
+        # Parse each document and print the resulting dictionary
+        patient_data_dict = parse_docx(filepath)
+        print("Data from file '{}':".format(filename))
+        import pprint
+        pprint.pprint(patient_data_dict)
+        print()
+
+def main():
+    # Call the function with the directory containing your .docx files
+    directory = "C:\\Users\\danie\\Downloads\\"
+    rotate_docx_files(directory)
+
+if __name__ == "__main__":
+    main()

MediBot/update_medicafe.py

@@ -1,17 +1,55 @@
 import subprocess
 import sys
 from tqdm import tqdm
+import requests
+import time
+
+def check_internet_connection():
+    try:
+        requests.get("http://www.google.com", timeout=5)
+        return True
+    except requests.ConnectionError:
+        return False
 
 def upgrade_medicafe(package):
     try:
-        # Use tqdm to create a progress bar
-        with tqdm(total=100, desc="Upgrading %s" % package, unit="%") as progress_bar:
-            subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-deps', '--disable-pip-version-check'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            # Update progress bar to 100% upon completion
-            progress_bar.update(100 - progress_bar.n)
-        print("Update successful.")
-    except subprocess.CalledProcessError:
-        print("Update failed. Please check your internet connection and try again later.")
+        # Check internet connection
+        if not check_internet_connection():
+            print("Error: No internet connection detected. Please check your internet connection and try again.")
+            sys.exit(1)
+        
+        total_progress = 200  # Total progress for two runs
+        
+        with tqdm(total=total_progress, desc="Upgrading %s" % package, unit="%") as progress_bar:
+            stdout_accumulator = b""
+            stderr_accumulator = b""
+            
+            for _ in range(2):  # Run pip install twice
+                process = subprocess.Popen([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-cache-dir', '--disable-pip-version-check', '--no-deps'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                stdout, stderr = process.communicate()
+                stdout_accumulator += stdout
+                stderr_accumulator += stderr
+                
+                if process.returncode != 0:
+                    # If the return code is non-zero, print error details
+                    print("Error: Upgrade failed. Details:")
+                    print("stdout:", stdout)
+                    print("stderr:", stderr)
+                    sys.exit(1)
+                
+                progress_bar.update(total_progress // 2)  # Update progress bar
+                
+                # Add a 3-second sleep between runs
+                time.sleep(3)
+                
+            progress_bar.update(total_progress // 2)  # Update progress bar
+            print("stdout:", stdout_accumulator.decode("utf-8"))
+            print("stderr:", stderr_accumulator.decode("utf-8"))
+            time.sleep(1)
+    except Exception as e:
+        # Log any other exceptions
+        print("Error:", e)
+        time.sleep(3)
         sys.exit(1)
 
 if __name__ == "__main__":