medicafe 0.240517.0__tar.gz → 0.240613.0__tar.gz

{medicafe-0.240517.0 → medicafe-0.240613.0}/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"

{medicafe-0.240517.0 → medicafe-0.240613.0}/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.

{medicafe-0.240517.0 → medicafe-0.240613.0}/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...")
 

{medicafe-0.240517.0 → medicafe-0.240613.0}/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)

{medicafe-0.240517.0 → medicafe-0.240613.0}/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
 

{medicafe-0.240517.0 → medicafe-0.240613.0}/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)

{medicafe-0.240517.0 → medicafe-0.240613.0}/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)