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

MediBot/MediBot.bat

@@ -133,6 +133,7 @@ if "!internet_available!"=="0" (
     goto main_menu
 )
 echo Downloading emails...
+:: move this path.
 py "../MediLink/MediLink_Gmail.py" "%firefox_path%"
 if errorlevel 1 (
     echo Failed to download emails.
@@ -161,6 +162,7 @@ if "!internet_available!"=="0" (
 )
 call :process_csvs
 cls
+:: move this path.
 py "C:\Python34\Lib\site-packages\MediLink\MediLink.py"
 if errorlevel 1 echo MediLink failed to execute.
 pause
@@ -173,7 +175,13 @@ for /f "tokens=1-5 delims=/: " %%a in ('echo %time%') do (
     set "minute=%%b"
     set "second=%%c"
 )
-set "timestamp=%DATE:~-4%%DATE:~3,2%%DATE:~0,2%_%hour%%minute%"
+for /f "tokens=2-4 delims=/ " %%a in ('echo %date%') do (
+    set "day=%%a"
+    set "month=%%b"
+    set "year=%%c"
+)
+set "timestamp=!year!!month!!day!_!hour!!minute!"
+
 set "latest_csv="
 for /f "delims=" %%a in ('dir /b /a-d /o-d "%source_folder%\*.csv" 2^>nul') do (
     set "latest_csv=%%a"

MediBot/MediBot.py

@@ -22,41 +22,6 @@ except ImportError:
     from MediBot import MediBot_Crosswalk_Library
     crosswalk_update = MediBot_Crosswalk_Library.crosswalk_update
 
-"""
-# Development Task List for MediBot
-
-Error Handling Improvements
-- [ ] Its really difficult to get out of the main menu if you go open MediBot by accident
-- [ ] Develop a centralized error handling and logging mechanism for improved troubleshooting.
-- [ ] Implement validation checks during patient data entry to prevent submission of incomplete or incorrect records.
-
-Insurance Mode Adjustments
-- [ ] Integrate a comprehensive list of insurance company codes for automatic selection.
-- [ ] Automate insurance-specific data entry adjustments, such as character replacements specific to Medicare.
-
-Diagnosis Entry
-- [ ] Automate data extraction from Surgery Schedule to import to CSV a column indicating diagnosis code per px.
-
-Script Efficiency and Reliability
-- [ ] Ensure robust handling of Medisoft's field navigation quirks, particularly for fields that are skipped or require special access.
-
-Documentation and Support
-- [ ] Create detailed documentation for setup, configuration, and usage of the script.
-- [ ] Establish a support channel for users to report issues or request features.
-
-Future Directions
-- [ ] Consider developing a graphical user interface (GUI) for non-technical users for easier script management and execution.
-
-Medisoft Field Navigation: 
-    Investigate and optimize navigation for fields that Medisoft skips or requires backward navigation to access.
-
-Insurance Mode Features: 
-    Evaluate the feasibility and implement the use of the F6 search for insurance address verification, enhancing user verification processes. 
-
-Error Handling and Logging: 
-    Implement a check for AHK script execution status, providing feedback or troubleshooting steps if the script encounters issues.
-"""
-
 def identify_field(header, field_mapping):
     for medisoft_field, patterns in field_mapping.items():
         for pattern in patterns:
@@ -223,7 +188,7 @@ class ExecutionState:
             MediLink_ConfigLoader.log("Constants initialized...")
             
         except Exception as e:
-            print("Failed to load or update configuration: {}".format(e))
+            print("MediBot: Failed to load or update configuration: {}".format(e))
             raise # Re-throwing the exception or using a more sophisticated error handling mechanism might be needed
             # Handle the exception somehow (e.g., retry, halt, log)??
         
@@ -261,6 +226,7 @@ if __name__ == "__main__":
         MediLink_ConfigLoader.log("Pre-processing CSV Data...", level="INFO")
         MediBot_Preprocessor.preprocess_csv_data(csv_data, e_state.crosswalk)  
         headers = csv_data[0].keys() # Make sure all the headers are in place
+        # Patient charges should be added prior to the intake_scan.
         
         print("Performing Intake Scan...")
         MediLink_ConfigLoader.log("Performing Intake Scan...", level="INFO")
@@ -294,9 +260,12 @@ if __name__ == "__main__":
             
             if existing_patients:
                 print("\nNOTE: The following patient(s) already EXIST in the system and \n      will be excluded from processing:")
+                # TODO ... not excluded anymore, because charges may need to be added. 
+                # So at this point in the processing, we should have already processed the surgery schedules and enriched the data with Charges.
                 for patient_id, patient_name in existing_patients:
                     print("(ID: {0}) {1}".format(patient_id, patient_name))
                 # Update csv_data to exclude existing patients
+                # TODO This now has to be updated to handle patients that exist but need new charges added. 
                 csv_data = [row for row in csv_data if row[reverse_mapping['Patient ID #2']] in patients_to_process]
             else:
                 print("\nSelected patient(s) are NEW patients and will be processed.")
@@ -306,6 +275,10 @@ if __name__ == "__main__":
             else:
                 proceed = input("\nDo you want to proceed with the {} remaining patient(s)? (yes/no): ".format(len(patients_to_process))).lower().strip() in ['yes', 'y']
 
+            # TODO Here is where we need to add the step where we move to MediBot_Charges. 
+            # The return is an enriched dataset to be picked up by medibot which means we need to return: 
+            # csv_data, field_mapping, reverse_mapping, and fixed_values.
+
             if proceed:
             
             #    Would be nice to have some kind of self-test here.

MediBot/MediBot_Charges.py

@@ -1,28 +0,0 @@
-"""
-MediBot_Charges.py
-
-This module provides a helper function for MediBot.py, specifically designed to handle the charge entry process in Medisoft for patients undergoing cataract surgeries. Each patient typically undergoes procedures on both eyes, treated as separate procedures but often requiring price bundling to address patient preferences for consistent billing across both eyes.
-
-Key Features:
-- Handles up to 200 patients in a single batch, with typical usage around 20 patients.
-- Implements price bundling logic to ensure that if a patient has multiple procedures (one for each eye), the charges are balanced such that the total cost is evenly spread across both procedures. This approach aligns with patient expectations of receiving consistent charges for each eye.
-- Integrates pricing schedules from a configuration file for private insurance, which vary based on the duration of the procedure:
-    - $450 for 1-15 minutes
-    - $480 for 16-22 minutes
-    - $510 for 23-27 minutes
-    - $540 for 28-37 minutes
-    - $580 for 37-59 minutes (59 minutes being the maximum allowed duration)
-- Special handling for Medicare patients, details of which are pending clarification.
-
-Limitations:
-- The bundling logic for commercial insurance billing is subject to the fulfillment of deductibles and other conditions, which do not necessarily synchronize with the timing of procedures for both eyes. The exact mechanics of this bundling under various conditions remain partially unspecified.
-
-Usage:
-- This module is intended to be used as part of the MediBot system, interfaced through MediBot.py, to automate the data entry and billing process in Medisoft for ophthalmology clinics, specifically those performing cataract surgeries.
-
-Note:
-- The exact implementation details for Medicare patients and the full logic for price bundling under all insurance conditions are yet to be finalized and documented.
-
-Date:
-- 4/16/24
-"""

MediBot/MediBot_Crosswalk_Library.py

@@ -167,6 +167,7 @@ def crosswalk_update(config, crosswalk):
   
     # Load incremental mapping data from Z.dat (Patient ID to Insurance Name)
     # TODO This may be a redundant approach?
+    # This is a singular path. This is fine though because any time we process a Z.DAT we'd have the crosswalk incremented.
     patient_id_to_insurance_name = MediBot_Preprocessor_lib.parse_z_dat(config['MediLink_Config']['Z_DAT_PATH'], config['MediLink_Config'])
     MediLink_ConfigLoader.log("Parsed Z data...")
 

MediBot/MediBot_Preprocessor.py

@@ -20,61 +20,6 @@ try:
 except ImportError:
     from MediBot import MediBot_Preprocessor_lib
 
-"""
-Preprocessing Enhancements
-- [X] Preprocess Insurance Policy Numbers and Group Numbers to replace '-' with ''.
-- [X] De-duplicate entries in the CSV and only entering the px once even if they show up twice in the file.
-- [ ] Implement dynamic field combination in CSV pre-processing for flexibility with various CSV formats.
-- [ ] Enhance SSN cleaning logic to handle more variations of sensitive data masking.
-- [ ] Optimize script startup and CSV loading to reduce initial latency.
-
-Data Integrity and Validation
-- [ ] Conduct a thorough CSV integrity check before processing to flag potential issues upfront.
-- [ ] Implement a mechanism to confirm the accuracy of entered data, potentially through a verification step or summary report.
-- [ ] Explore the possibility of integrating direct database queries for existing patient checks to streamline the process.
-- [ ] Automate the replacement of spaces with underscores ('_') in last names for Medicare entries.
-- [ ] Enhance CSV integrity checks to identify and report potential issues with data format, especially concerning insurance policy numbers and special character handling.
-
-Known Issues and Bugs
-- [ ] Address the handling of '.' and other special characters that may disrupt parsing, especially under Windows XP.
-- [ ] Investigate the issue with Excel modifying long policy numbers in the CSV and provide guidance or a workaround.
-
-Future Work
-- [X] Check for PatientID number in La Forma Z to link back to Carol's table for mapping Medisoft insurance name to payerID and payer name and address.
-- [X] Check for PatientID to Medisoft custom insurance name mapping in MAPAT.
-- [X] Middle Names should all be single letters. Make sure it gets truncated before submitting.
-- [ ] Consolidate data from multiple sources (Provider_Notes.csv, Surgery_Schedule.csv, and Carols_CSV.csv) into a single table with Patient ID as the key, ensuring all data elements are aligned and duplicate entries are minimized.
-- [ ] Implement logic to verify and match Patient IDs across different files to ensure data integrity before consolidation. (Catching errors between source data)
-- [ ] Optimize the preprocessing of surgery dates and diagnosis codes for use in patient billing and scheduling systems.
-- [ ] Read Surgery Schedule doc and parse out a Patient ID : Diagnosis Code table.
-- [ ] The Minutes & Cancellation data with logic to consolidate into one table in memory.
-- [ ] Dynamically list the endpoint for a new Payer ID via API or user interaction to update the crosswalk.json efficiently.
-- [ ] Pull listed addresses of insurance from the CSV. (Not really necessary)
-- [ ] Retroactively learn Medisoft insurance name and payerID from the provided data sources.
-
-Development Roadmap for crosswalk_update():
-- [X] Automation required for updating the crosswalk.json when new Medisoft insurance is discovered.
-- [X] New Medisoft insurances are identified based on the payer ID number.
-- [X] Check the existence of the payer ID in crosswalk.json under existing endpoints.
-- [X] Facilitate grouping of IDs for insurances like CIGNA with multiple addresses but few payer IDs.
-- [X] Retroactive learning based on selected insurances in Medisoft 
-- [ ] Prompt user via endpoint APIs to add new payer ID to an endpoint if it does not exist.
-- [ ] Retain payer IDs without Insurance ID for future assignments.
-- [ ] Check for free payer IDs and determine the appropriate endpoint for assignment.
-- [ ] Present unrecognized payer IDs with Carol's Insurance Name to users for assignment to Insurance ID. (Try API Call)
-- [ ] Integrate API checks to verify payer ID availability and related information.
-- [ ] Implement "Fax/Mail or Other" endpoint for unavailable payer IDs.
-- [ ] Present user with a list of top insurances for selection based on fuzzy search scores.
-- [ ] Establish payer ID to insurance ID relationship based on user selection.
-- [ ] Implicitly establish payer ID to endpoint mapping based on user selection.
-- [ ] Implement validation mechanisms to prevent incorrect mappings and ensure data integrity.
-- [ ] Considerations for extracting insurance addresses (if necessary)
-- [ ] Handle better the case where a payer_id doesn't exist (When Carol's CSV doesn't bring the Payer ID).
-        Maybe ask the user what the payer ID is for that patient? I dont know.
-- [ ] TODO (MED) Crosswalk (both initializing and updating) needs to pull AFTER the Preprocessor for Carol's CSV because
-        all that data lives in-memory and then gets corrections or replacements before being used so we need 
-        the post-correction data to be used to build and update the crosswalk.
-"""
 # Load configuration
 # Should this also take args? Path for ./MediLink needed to be added for this to resolve
 config, crosswalk = MediLink_ConfigLoader.load_configuration()
@@ -82,10 +27,11 @@ config, crosswalk = MediLink_ConfigLoader.load_configuration()
 # CSV Preprocessor built for Carol
 def preprocess_csv_data(csv_data, crosswalk):
     try:
-        # Add the "Ins1 Insurance ID" column to the CSV data.
-        # This initializes the column with empty values for each row.
-        MediLink_ConfigLoader.log("CSV Pre-processor: Adding 'Ins1 Insurance ID' column to the CSV data...", level="INFO")
-        MediBot_Preprocessor_lib.add_insurance_id_column(csv_data)
+        # Add the "Ins1 Insurance ID" and "Default Diagnosis #1" columns to the CSV data.
+        # This initializes the columns with empty values for each row.
+        columns_to_add = ['Ins1 Insurance ID', 'Default Diagnosis #1', 'Procedure Code', 'Minutes', 'Amount']
+        MediLink_ConfigLoader.log("CSV Pre-processor: Initializing empty columns to the CSV data...", level="INFO")
+        MediBot_Preprocessor_lib.add_columns(csv_data, columns_to_add)
         
         # Filter out rows without a Patient ID and rows where the Primary Insurance
         # is 'AETNA', 'AETNA MEDICARE', or 'HUMANA MED HMO'.
@@ -93,13 +39,20 @@ def preprocess_csv_data(csv_data, crosswalk):
         MediBot_Preprocessor_lib.filter_rows(csv_data)
         
         # Convert 'Surgery Date' from string format to datetime objects for sorting purposes.
-        # Sort the patients by 'Surgery Date' and then by 'Patient Last' name alphabetically.
-        # Deduplicate patient records based on Patient ID, keeping the entry with the earliest surgery date.
+        MediBot_Preprocessor_lib.convert_surgery_date(csv_data)
+        
         # Update the CSV data to include only unique patient records.
         # Re-sort the CSV data after deduplication to ensure the correct order.
+        # Sort the patients by 'Surgery Date' and then by 'Patient Last' name alphabetically.
+        # Deduplicate patient records based on Patient ID, keeping the entry with the earliest surgery date.
         MediLink_ConfigLoader.log("CSV Pre-processor: Sorting and de-duplicating patient records...", level="INFO")
-        MediBot_Preprocessor_lib.convert_surgery_date(csv_data)
-        MediBot_Preprocessor_lib.sort_and_deduplicate(csv_data)
+        MediBot_Preprocessor_lib.sort_and_deduplicate(csv_data) 
+        # TODO This eventually needs to be handled differently because now we're wanting to handle both surgery dates.
+        # Instead of deleting, maybe we need to make a secondary dataset or some kind of flag or isolate here where 
+        # MediBot knows to skip it when entering the patient data but is ready to put Charges for the second surgery date.
+        # MediLink_Scheduler will have a dictionary persist somewhere that would tell us which patients were billed 
+        # and which haven't been yet. So, if the patient 'exists' in the system, the next quetion is about claims/billing status.
+        # Eventually, we really want to get out of Medisoft... 
         
         # Convert 'Surgery Date' back to string format if needed for further processing.
         # Combine 'Patient First', 'Patient Middle', and 'Patient Last' into a single 'Patient Name' field.
@@ -117,6 +70,16 @@ def preprocess_csv_data(csv_data, crosswalk):
         # If the Payer ID is not found in the crosswalk, create a placeholder entry in the crosswalk and mark the row for review.
         MediLink_ConfigLoader.log("CSV Pre-processor: Populating 'Ins1 Insurance ID' based on Crosswalk...", level="INFO")
         MediBot_Preprocessor_lib.update_insurance_ids(csv_data, crosswalk)
+        
+        # Enrich the "Default Diagnosis #1" column based on the parsed docx for each row.
+        # This needs to handle the different patient dates correctly so we get the right diagnosis code assigned to the right patient on the right date of service.
+        # Currently, we've deleted all the second date entries for patients. As long as they exist in the system, they're just deleted.
+        MediLink_ConfigLoader.log("CSV Pre-processor: Populating 'Default Diagnosis #1' based on Surgery Schedule and Crosswalk...", level="INFO")
+        MediBot_Preprocessor_lib.update_diagnosis_codes(csv_data)
+        
+        # Enrich the procedure code column based on the diagnosis code for each patient. 
+        MediLink_ConfigLoader.log("CSV Pre-processor: Populating 'Procedure Code' based on Crosswalk...", level="INFO")
+        MediBot_Preprocessor_lib.update_procedure_codes(csv_data)
     
     except Exception as e:
         message = "An error occurred while pre-processing CSV data. Please repair the CSV directly and try again: {}".format(e)

MediBot/MediBot_Preprocessor_lib.py

@@ -17,37 +17,13 @@ except ImportError:
     
 try:
     from MediBot_UI import app_control
+    from MediBot_docx_decoder import parse_docx
 except ImportError:
     from MediBot import MediBot_UI
     app_control = MediBot_UI.app_control
+    from MediBot import MediBot_docx_decoder
+    parse_docx = MediBot_docx_decoder.parse_docx
 
-"""
-Draft Docstring to move over from Preprocessor.
-
-Data Integrity and Validation
- Implement a mechanism to confirm the accuracy of entered data, potentially through a verification step or summary report.
- Enhance CSV integrity checks to identify and report potential issues with data format, especially concerning insurance policy numbers and special character handling.
-
-Development Roadmap for crosswalk_update()
- Automation required for updating the crosswalk.json when new Medisoft insurance is discovered.
-For open_csv_for_editing
-
-Known Issues and Bugs
- Address the handling of '.' and other special characters that may disrupt parsing, especially under Windows XP.
-
-For load_csv_data
-
-Preprocessing Enhancements
- Optimize script startup and CSV loading to reduce initial latency.
-
-Data Integrity and Validation
- Conduct a thorough CSV integrity check before processing to flag potential issues upfront.
-
-Future Work
- Consolidate data from multiple sources (Provider_Notes.csv, Surgery_Schedule.csv, and Carols_CSV.csv) into a single table with Patient ID as the key, ensuring all data elements are aligned and duplicate entries are minimized.
- Implement logic to verify and match Patient IDs across different files to ensure data integrity before consolidation. (Catching errors between source data)
- Optimize the preprocessing of surgery dates and diagnosis codes for use in patient billing and scheduling systems.
-"""
 class InitializationError(Exception):
     def __init__(self, message):
         self.message = message
@@ -105,13 +81,32 @@ def load_csv_data(csv_file_path):
         sys.exit(1)  # Halt the script in case of other IO errors
 
 # CSV Pre-processor Helper functions
-def add_insurance_id_column(csv_data):
+def add_columns(csv_data, column_headers):
+    """
+    Adds one or multiple columns to the CSV data.
+    
+    Parameters:
+    csv_data (list of dict): The CSV data where each row is represented as a dictionary.
+    column_headers (list of str or str): A list of column headers to be added to each row, or a single column header.
+    
+    Returns:
+    None: The function modifies the csv_data in place.
+    """
+    if isinstance(column_headers, str):
+        column_headers = [column_headers]
+    elif not isinstance(column_headers, list):
+        raise ValueError("column_headers should be a list or a string")
+
     for row in csv_data:
-        row['Ins1 Insurance ID'] = ''  # Initialize the column with empty values
+        for header in column_headers:
+            row[header] = ''  # Initialize the column with empty values
 
+# Extracting the list to a variable for future refactoring:
 def filter_rows(csv_data):
+    # TODO This should go to the crosswalk.
+    excluded_insurance = ['AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO']
     csv_data[:] = [row for row in csv_data if row.get('Patient ID', '').strip()]
-    csv_data[:] = [row for row in csv_data if row.get('Primary Insurance', '').strip() not in ['AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO']]
+    csv_data[:] = [row for row in csv_data if row.get('Primary Insurance', '').strip() not in excluded_insurance]
 
 def convert_surgery_date(csv_data):
     for row in csv_data:
@@ -121,6 +116,7 @@ def convert_surgery_date(csv_data):
             row['Surgery Date'] = datetime.min  # Assign a minimum datetime value for sorting purposes
 
 def sort_and_deduplicate(csv_data):
+    # TODO we need to figure out a new logic here for doing second-eye charges. I don't know what the flow should be yet.
     csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
     unique_patients = {}
     for row in csv_data:
@@ -128,6 +124,8 @@ def sort_and_deduplicate(csv_data):
         if patient_id not in unique_patients or row['Surgery Date'] < unique_patients[patient_id]['Surgery Date']:
             unique_patients[patient_id] = row
     csv_data[:] = list(unique_patients.values())
+    # TODO Sorting, now that we're going to have the Surgery Schedules available, should be ordered as the patients show up on the schedule.
+    # If we don't have that surgery schedule yet for some reason, we should default to the current ordering strategy.
     csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
 
 def combine_fields(csv_data):
@@ -177,6 +175,149 @@ def update_insurance_ids(csv_data, crosswalk):
                     'endpoint': 'OPTUMEDI' # Default probably should be a flag for the crosswalk update function to deal with. BUG HARDCODE THERE ARE 3 of these defaults
                 } 
 
+def update_procedure_codes(csv_data):
+    # Define the Medisoft shorthand to diagnostic codes dictionary
+    # TODO The reverse of this will be in the crosswalk. We'll need to reverse it here for lookup.
+    medisoft_to_diagnosis = {
+        "25811": "H25.811",
+        "25812": "H25.812",
+        "2512": "H25.12",
+        "2511": "H25.11",
+        "529XA": "T85.29XA",
+        "4301": "H43.01",
+        "4302": "H43.02",
+        "011X2": "H40.11X2",
+        "051X3": "H40.51X3",
+        "5398A": "T85.398A"
+    }
+
+    # Define the procedure codes to diagnostic codes dictionary
+    procedure_to_diagnosis = {
+        "00142": ["H25.811", "H25.812", "H25.12", "H25.11", "T85.29XA"],
+        "00145": ["H43.01", "H43.02"],
+        "00140": ["H40.11X2", "H40.51X3"]
+    }
+
+    # Reverse the dictionary for easier lookup from diagnostic code to procedure code
+    diagnosis_to_procedure = {}
+    for procedure_code, diagnosis_codes in procedure_to_diagnosis.items():
+        for diagnosis_code in diagnosis_codes:
+            diagnosis_to_procedure[diagnosis_code] = procedure_code
+
+    # Initialize counter for updated rows
+    updated_count = 0
+
+    # Update the "Procedure Code" column in the CSV data
+    for row_num, row in enumerate(csv_data, start=1):
+        try:
+            medisoft_code = row.get('Default Diagnosis #1', '').strip()
+            diagnosis_code = medisoft_to_diagnosis.get(medisoft_code)
+            if diagnosis_code:
+                procedure_code = diagnosis_to_procedure.get(diagnosis_code)
+                if procedure_code:
+                    row['Procedure Code'] = procedure_code
+                    updated_count += 1
+                else:
+                    row['Procedure Code'] = "Unknown"  # Or handle as appropriate
+            else:
+                row['Procedure Code'] = "Unknown"  # Or handle as appropriate
+        except Exception as e:
+            MediLink_ConfigLoader.log("In update_procedure_codes, Error processing row {}: {}".format(row_num, e), level="ERROR")
+
+    # Log total count of updated rows
+    MediLink_ConfigLoader.log("Total {} 'Procedure Code' rows updated.".format(updated_count), level="INFO")
+
+    return True
+
+def update_diagnosis_codes(csv_data):
+    try:
+        # Load configuration and crosswalk
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        
+        # Extract the local storage path from the configuration
+        local_storage_path = config['MediLink_Config']['local_storage_path']
+        
+        # Initialize a dictionary to hold diagnosis codes from all DOCX files
+        all_patient_data = {}
+
+        # Iterate through all files in the specified directory
+        for filename in os.listdir(local_storage_path):
+            if filename.endswith(".docx"):
+                filepath = os.path.join(local_storage_path, filename)
+                MediLink_ConfigLoader.log("Processing DOCX file: {}".format(filepath), level="INFO")
+                try:
+                    patient_data = parse_docx(filepath)
+                    for patient_id, service_dates in patient_data.items():
+                        if patient_id not in all_patient_data:
+                            all_patient_data[patient_id] = {}
+                        for date_of_service, diagnosis_data in service_dates.items():
+                            all_patient_data[patient_id][date_of_service] = diagnosis_data
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Error parsing DOCX file {}: {}".format(filepath, e), level="ERROR")
+        
+        # Debug logging for all_patient_data
+        MediLink_ConfigLoader.log("All patient data collected from DOCX files: {}".format(all_patient_data), level="INFO")
+
+        # Define the diagnosis to Medisoft shorthand dictionary
+        diagnosis_to_medisoft = {
+            "H25.811": "25811",
+            "H25.812": "25812",
+            "H25.12": "2512",
+            "H25.11": "2511",
+            "T85.29XA": "529XA",
+            "H43.01": "4301",
+            "H43.02": "4302",
+            "H40.11X2": "011X2",
+            "H40.51X3": "051X3",
+            "T85.398A": "5398A"
+        }
+        
+        # Convert surgery dates in CSV data
+        convert_surgery_date(csv_data)
+        
+        # Initialize counter for updated rows
+        updated_count = 0
+
+        # Update the "Default Diagnosis #1" column in the CSV data
+        for row_num, row in enumerate(csv_data, start=1):
+            MediLink_ConfigLoader.log("Processing row number {}.".format(row_num), level="INFO")
+            patient_id = row.get('Patient ID', '').strip()
+            surgery_date = row.get('Surgery Date', '')
+
+            # Convert surgery_date to string format for lookup
+            if surgery_date != datetime.min:
+                surgery_date_str = surgery_date.strftime("%m-%d-%Y")
+            else:
+                surgery_date_str = ''
+
+            MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="INFO")
+
+            if patient_id in all_patient_data:
+                if surgery_date_str in all_patient_data[patient_id]:
+                    diagnosis_code, left_or_right_eye, femto_yes_or_no = all_patient_data[patient_id][surgery_date_str]
+                    MediLink_ConfigLoader.log("Found diagnosis data for Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="INFO")
+                    
+                    # Convert diagnosis code to Medisoft shorthand format.
+                    defaulted_code = diagnosis_code[1:].replace('.', '')[-5:] if diagnosis_code else ''
+                    medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, defaulted_code)
+                    MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="INFO")
+                    
+                    row['Default Diagnosis #1'] = medisoft_shorthand
+                    updated_count += 1
+                    MediLink_ConfigLoader.log("Updated row number {} with new diagnosis code.".format(row_num), level="INFO")
+                else:
+                    MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} in row {}.".format(patient_id, row_num), level="INFO")
+            else:
+                MediLink_ConfigLoader.log("Patient ID: {} not found in DOCX data for row {}.".format(patient_id, row_num), level="INFO")
+
+        # Log total count of updated rows
+        MediLink_ConfigLoader.log("Total {} 'Default Diagnosis #1' rows updated.".format(updated_count), level="INFO")
+
+    except Exception as e:
+        message = "An error occurred while updating diagnosis codes. Please check the DOCX files and configuration: {}".format(e)
+        MediLink_ConfigLoader.log(message, level="ERROR")
+        print(message)
+
 def load_data_sources(config, crosswalk):
     """Loads historical mappings from MAPAT and Carol's CSVs."""
     patient_id_to_insurance_id = load_insurance_data_from_mapat(config, crosswalk)
@@ -269,36 +410,34 @@ def load_insurance_data_from_mapat(config, crosswalk):
 def parse_z_dat(z_dat_path, config):
     """
     Parses the Z.dat file to map Patient IDs to Insurance Names using the provided fixed-width file format.
-    
+
     Args:
         z_dat_path (str): Path to the Z.dat file.
         config (dict): Configuration object containing slicing information and other parameters.
-    
+
     Returns:
         dict: A dictionary mapping Patient IDs to Insurance Names.
     """
     patient_id_to_insurance_name = {}
-    
+
     try:
-        # Reading blocks of fixed-width data (3 lines per record: personal, insurance, service)
-        for personal_info, insurance_info, service_info in MediLink_DataMgmt.read_fixed_width_data(z_dat_path):
+        # Reading blocks of fixed-width data (up to 5 lines per record)
+        for personal_info, insurance_info, service_info, service_info_2, service_info_3 in MediLink_DataMgmt.read_fixed_width_data(z_dat_path):
             # Parsing the data using slice definitions from the config
-            parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', config))
-        
+            parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
+
             # Extract Patient ID and Insurance Name from parsed data
             patient_id = parsed_data.get('PATID')
             insurance_name = parsed_data.get('INAME')
-            
+
             if patient_id and insurance_name:
                 patient_id_to_insurance_name[patient_id] = insurance_name
                 MediLink_ConfigLoader.log("Mapped Patient ID {} to Insurance Name {}".format(patient_id, insurance_name), config, level="INFO")
-    
+
     except FileNotFoundError:
-        MediLink_ConfigLoader.log("File not found: {}".format(z_dat_path), config, level="ERROR")
-        raise
+        MediLink_ConfigLoader.log("File not found: {}".format(z_dat_path), config, level="INFO")
     except Exception as e:
-        MediLink_ConfigLoader.log("Failed to parse Z.dat: {}".format(str(e)), config, level="ERROR")
-        raise
+        MediLink_ConfigLoader.log("Failed to parse Z.dat: {}".format(str(e)), config, level="INFO")
 
     return patient_id_to_insurance_name
 

MediBot/MediBot_UI.py

@@ -17,12 +17,7 @@ except ImportError:
     from MediLink_ConfigLoader import load_configuration
     config, crosswalk = load_configuration()
 
-"""
-User Interaction Refinements
-- [ ] Refine the menu options for clearer user guidance during script pauses and errors.
-- [ ] Add functionality for user to easily repeat or skip specific entries without script restart.
-    Develop more intuitive skip and retry mechanisms that are responsive to user input during data entry sessions.
-"""
+
 # Function to check if a specific key is pressed
 VK_END = int(config.get('VK_END', ""), 16) # Try F12 (7B). Virtual key code for 'End' (23)
 VK_PAUSE = int(config.get('VK_PAUSE', ""), 16) # Try F11 (7A). Virtual-key code for 'Home' (24)
@@ -122,7 +117,7 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
             patient_name = row.get(patient_name_header, "Unknown")
             surgery_date = row.get('Surgery Date', "Unknown Date")  # Access 'Surgery Date' as string directly from the row
             
-            print("{0:03d}: {3:.5s} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, surgery_date))
+            print("{0:03d}: {3:%m-%d} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, surgery_date))
 
             displayed_indices.append(index)
             displayed_patient_ids.append(patient_id)

MediBot/MediBot_dataformat_library.py

@@ -19,15 +19,6 @@ from MediBot_Preprocessor_lib import open_csv_for_editing, initialize
 from MediBot_UI import manage_script_pause, app_control
 
 
-"""
-- [X] (TEST) Address Formatting 30-character Limit:
-    (LOW) Address the issue where the format_street function in Medibot may produce addresses exceeding
-    the 30-character limit. Current stop-gap is removing period characters and the abbreviation "APT" 
-    surrounded by spaces from all records as a temporary solution. 
-    If the address still exceeds 30 characters, the function will attempt to remove spaces from right to left
-    until it reaches 30 significant digits or runs out of spaces, then truncate to 30 characters if necessary.
-"""
-
 # Bring in all the constants
 initialize(config)