medicafe 0.250723.3__tar.gz → 0.250723.5__tar.gz

{medicafe-0.250723.3 → medicafe-0.250723.5}/MediBot/MediBot.py

@@ -393,9 +393,11 @@ if __name__ == "__main__":
 
             # Check if there are patients left to process
             if len(patients_to_process) == 0:
-                proceed = input("\nAll patients have been processed. Continue anyway?: ").lower().strip() in ['yes', 'y']
+                print("\nAll patients have been processed. Continue anyway?: ", end='', flush=True)
+                proceed = input().lower().strip() in ['yes', 'y']
             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']
+                print("\nDo you want to proceed with the {} remaining patient(s)? (yes/no): ".format(len(patients_to_process)), end='', flush=True)
+                proceed = input().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: 
@@ -406,7 +408,8 @@ if __name__ == "__main__":
                 print("  Press 'F8'  to create a New Patient.")
                 print("  Press 'F12' to begin data entry.")
                 print("  Press 'F11' at any time to Pause.")
-                input("\n*** Press [Enter] when ready to begin! ***\n")
+                print("\n*** Press [Enter] when ready to begin! ***")
+                input()
                 MediLink_ConfigLoader.log("Opening Medisoft...")
                 open_medisoft(app_control.get_medisoft_shortcut())
                 app_control.set_pause_status(True)

{medicafe-0.250723.3 → medicafe-0.250723.5}/MediBot/MediBot_Preprocessor_lib.py

@@ -517,30 +517,48 @@ def update_diagnosis_codes(csv_data):
 
         MediLink_ConfigLoader.log("BAD IDEA: Processing DOCX files modified between {} and {}.".format(threshold_start, threshold_end), level="INFO")
 
-        # Gather all relevant DOCX files in the specified directory
-        # Optimize by combining file gathering and filtering in one pass
+        # PERFORMANCE OPTIMIZATION: Use os.scandir() for more efficient file system operations
+        # This reduces the number of file system calls and improves performance with large directories
         valid_files = []
         try:
-            for filename in os.listdir(local_storage_path):
-                if filename.endswith(".docx"):
-                    filepath = os.path.join(local_storage_path, filename)
-                    # Check modification time only once per file
-                    try:
-                        mtime = os.path.getmtime(filepath)
-                        if threshold_start <= datetime.fromtimestamp(mtime) <= threshold_end:
-                            valid_files.append(filepath)
-                    except (OSError, ValueError):
-                        # Skip files with invalid modification times
-                        continue
+            # Use os.scandir() for better performance (XP/3.4.4 compatible)
+            with os.scandir(local_storage_path) as entries:
+                for entry in entries:
+                    if entry.name.endswith('.docx'):
+                        # Get file modification time in single operation
+                        try:
+                            stat_info = entry.stat()
+                            mtime = stat_info.st_mtime
+                            if threshold_start <= datetime.fromtimestamp(mtime) <= threshold_end:
+                                valid_files.append(entry.path)
+                        except (OSError, ValueError):
+                            # Skip files with invalid modification times
+                            continue
         except OSError:
             MediLink_ConfigLoader.log("Error accessing directory: {}".format(local_storage_path), level="ERROR")
             return
 
+        # PERFORMANCE OPTIMIZATION: Pre-process patient IDs for efficient lookup
+        # Create a set of patient IDs from CSV data for faster lookups
+        patient_ids_in_csv = {row.get('Patient ID', '').strip() for row in csv_data}
+
+        # PERFORMANCE OPTIMIZATION: Pre-convert surgery dates to string format
+        # Convert all surgery dates to string format once to avoid repeated conversions in loops
+        surgery_date_strings = {}
+        for row in csv_data:
+            patient_id = row.get('Patient ID', '').strip()
+            surgery_date = row.get('Surgery Date')
+            if surgery_date != datetime.min:
+                surgery_date_strings[patient_id] = surgery_date.strftime("%m-%d-%Y")
+            else:
+                surgery_date_strings[patient_id] = ''
+
         # Process valid DOCX files
         for filepath in valid_files:
             MediLink_ConfigLoader.log("Processing DOCX file: {}".format(filepath), level="INFO")
             try:
                 patient_data = parse_docx(filepath, surgery_dates)  # Pass surgery_dates to parse_docx
+                # PERFORMANCE OPTIMIZATION: Use defaultdict for more efficient dictionary operations
                 for patient_id, service_dates in patient_data.items():
                     if patient_id not in all_patient_data:
                         all_patient_data[patient_id] = {}
@@ -556,9 +574,6 @@ def update_diagnosis_codes(csv_data):
         # Debug logging for all_patient_data
         MediLink_ConfigLoader.log("All patient data collected from DOCX files: {}".format(all_patient_data), level="DEBUG")
         
-        # Extract patient IDs from csv_data for efficient matching
-        patient_ids_in_csv = {row.get('Patient ID', '').strip() for row in csv_data}
-
         # Check if any patient data was collected
         if not all_patient_data or not patient_ids_in_csv.intersection(all_patient_data.keys()):
             MediLink_ConfigLoader.log("No patient data collected or no matching Patient IDs found. Skipping further processing.", level="INFO")
@@ -570,20 +585,17 @@ def update_diagnosis_codes(csv_data):
         # Initialize counter for updated rows
         updated_count = 0
 
+        # PERFORMANCE OPTIMIZATION: Single pass through CSV data with pre-processed lookups
         # Update the "Default Diagnosis #1" column in the CSV data
         for row_num, row in enumerate(csv_data, start=1):
             patient_id = row.get('Patient ID', '').strip()
+            # Use pre-processed patient ID lookup for efficiency
             if patient_id not in patient_ids_in_csv:
                 continue  # Skip rows that do not match any patient ID
 
             MediLink_ConfigLoader.log("Processing row number {}.".format(row_num), level="DEBUG")
-            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 = ''
+            # Use pre-converted surgery date string for efficient lookup
+            surgery_date_str = surgery_date_strings.get(patient_id, '')
 
             MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
 

{medicafe-0.250723.3 → medicafe-0.250723.5}/MediBot/MediBot_UI.py

@@ -147,7 +147,8 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
         selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, exclude_medicare=True)
 
     print("-" * 60)
-    proceed = input("\nDo you want to proceed with the selected patients? (yes/no): ").lower().strip() in ['yes', 'y']
+    print("\nDo you want to proceed with the selected patients? (yes/no): ", end='', flush=True)
+    proceed = input().lower().strip() in ['yes', 'y']
 
     if not proceed:
         display_menu_header("Patient Selection for Today's Data Entry")
@@ -156,7 +157,8 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
         
         while True:
             while True:
-                selection = input("\nEnter the number(s) of the patients you wish to proceed with \n(e.g., 1,3,5): ").strip()
+                print("\nEnter the number(s) of the patients you wish to proceed with \n(e.g., 1,3,5): ", end='', flush=True)
+                selection = input().strip()
                 if not selection:
                     print("Invalid entry. Please provide at least one number.")
                     continue
@@ -194,6 +196,8 @@ def display_menu_header(title):
     print("\n" + "-" * 60)
     print(title)
     print("-" * 60)
+    # Force flush for Windows XP compatibility
+    sys.stdout.flush()
 
 def handle_user_interaction(interaction_mode, error_message):
     # Import here to avoid circular imports
@@ -228,7 +232,8 @@ def handle_user_interaction(interaction_mode, error_message):
         print("3: Go back two patients and redo")
         print("4: Exit script")
         print("-" * 60)
-        choice = input("Enter your choice (1/2/3/4): ").strip()
+        print("Enter your choice (1/2/3/4): ", end='', flush=True)
+        choice = input().strip()
         
         if choice == '1':
             print("Selected: 'Retry last entry'. Please press 'F12' to continue.")
@@ -254,10 +259,15 @@ def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
 
     if interaction_mode == 'triage':
         display_menu_header("            =(^.^)= Welcome to MediBot! =(^.^)=")
+        
+        # Force flush for Windows XP compatibility
+        sys.stdout.flush()
 
         while True:
             try:
-                response = input("\nAm I processing Medicare patients? (yes/no): ").lower().strip()
+                # Use a more explicit prompt format for Windows XP
+                print("\nAm I processing Medicare patients? (yes/no): ", end='', flush=True)
+                response = input().lower().strip()
                 if response:
                     if response in ['yes', 'y']:
                         app_control.load_paths_from_config(medicare=True)

{medicafe-0.250723.3 → medicafe-0.250723.5}/MediBot/MediBot_docx_decoder.py

@@ -1,7 +1,7 @@
 #MediBot_docx_decoder.py
 from datetime import datetime
 from collections import OrderedDict
-import os, re, sys, zipfile
+import os, re, sys, zipfile, pprint
 from docx import Document
 from lxml import etree
 
@@ -14,6 +14,56 @@ try:
 except ImportError:
     from MediLink import MediLink_ConfigLoader
 
+# Pre-compile regex patterns for better performance (XP/3.4.4 compatible)
+_DIAGNOSIS_CODE_PATTERN = re.compile(r'H\d{2}\.\d+')
+_DAY_WEEK_PATTERN = re.compile(r"(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)")
+_MONTH_DAY_PATTERN = re.compile(r"(JANUARY|FEBRUARY|MARCH|APRIL|MAY|JUNE|JULY|AUGUST|SEPTEMBER|OCTOBER|NOVEMBER|DECEMBER) \d{1,2}")
+_YEAR_PATTERN = re.compile(r"\d{4}")
+_YEAR_SPLIT_PATTERNS = [
+    re.compile(r'(\d{3}) (\d{1})'),
+    re.compile(r'(\d{1}) (\d{3})'),
+    re.compile(r'(\d{2}) (\d{2})')
+]
+_DIGIT_PARTS_PATTERN = re.compile(r'\b(\d{1,2})\b')
+_COMMA_PATTERN = re.compile(r',')
+
+# Pre-compile abbreviation patterns for normalize_text optimization
+_MONTH_ABBR_PATTERNS = {
+    'JAN': re.compile(r'\bJAN\b', re.IGNORECASE),
+    'FEB': re.compile(r'\bFEB\b', re.IGNORECASE),
+    'MAR': re.compile(r'\bMAR\b', re.IGNORECASE),
+    'APR': re.compile(r'\bAPR\b', re.IGNORECASE),
+    'MAY': re.compile(r'\bMAY\b', re.IGNORECASE),
+    'JUN': re.compile(r'\bJUN\b', re.IGNORECASE),
+    'JUL': re.compile(r'\bJUL\b', re.IGNORECASE),
+    'AUG': re.compile(r'\bAUG\b', re.IGNORECASE),
+    'SEP': re.compile(r'\bSEP\b', re.IGNORECASE),
+    'OCT': re.compile(r'\bOCT\b', re.IGNORECASE),
+    'NOV': re.compile(r'\bNOV\b', re.IGNORECASE),
+    'DEC': re.compile(r'\bDEC\b', re.IGNORECASE)
+}
+
+_DAY_ABBR_PATTERNS = {
+    'MON': re.compile(r'\bMON\b', re.IGNORECASE),
+    'TUE': re.compile(r'\bTUE\b', re.IGNORECASE),
+    'WED': re.compile(r'\bWED\b', re.IGNORECASE),
+    'THU': re.compile(r'\bTHU\b', re.IGNORECASE),
+    'FRI': re.compile(r'\bFRI\b', re.IGNORECASE),
+    'SAT': re.compile(r'\bSAT\b', re.IGNORECASE),
+    'SUN': re.compile(r'\bSUN\b', re.IGNORECASE)
+}
+
+# Month and day mapping dictionaries
+_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'
+}
+
 
 def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
     try:
@@ -186,10 +236,15 @@ def find_text_in_xml(extract_dir, target_text):
                     root = tree.getroot()
                     namespaces = root.nsmap
                     MediLink_ConfigLoader.log("Processing file: {}".format(file_path), level="DEBUG")
+                    # More efficient: collect all text first, then search
+                    all_text = []
                     for elem in root.xpath('//w:t', namespaces=namespaces):
-                        if elem.text and target_pattern.search(elem.text):
-                            MediLink_ConfigLoader.log("Found target text '{}' in file: {}".format(target_text, file_path), level="DEBUG")
-                            return file_path
+                        if elem.text:
+                            all_text.append(elem.text)
+                    combined_text = ' '.join(all_text)
+                    if target_pattern.search(combined_text):
+                        MediLink_ConfigLoader.log("Found target text '{}' in file: {}".format(target_text, file_path), level="DEBUG")
+                        return file_path
                 except etree.XMLSyntaxError as e:
                     MediLink_ConfigLoader.log("XMLSyntaxError parsing file {}: {}".format(file_path, e), level="ERROR")
                 except Exception as e:
@@ -211,18 +266,14 @@ def extract_date_from_file(file_path):
         combined_text = ' '.join(collected_text)
         combined_text = reassemble_year(combined_text)  # Fix OCR splitting years
         combined_text = normalize_text(combined_text)  # Normalize abbreviations
-        combined_text = re.sub(r',', '', combined_text)  # Remove commas if they exist
+        combined_text = _COMMA_PATTERN.sub('', combined_text)  # Remove commas if they exist
 
         # Log the combined text
         MediLink_ConfigLoader.log("Combined text from file '{}': {}".format(file_path, combined_text[:200]), level="DEBUG")
         
-        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)
+        day_of_week = _DAY_WEEK_PATTERN.search(combined_text, re.IGNORECASE)
+        month_day = _MONTH_DAY_PATTERN.search(combined_text, re.IGNORECASE)
+        year_match = _YEAR_PATTERN.search(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")
@@ -276,18 +327,14 @@ def extract_date_from_content(xml_content):
         combined_text = ' '.join(collected_text)
         combined_text = reassemble_year(combined_text)  # Fix OCR splitting years
         combined_text = normalize_text(combined_text)    # Normalize abbreviations
-        combined_text = re.sub(r',', '', combined_text)   # Remove commas if they exist
+        combined_text = _COMMA_PATTERN.sub('', combined_text)   # Remove commas if they exist
 
         # Log the combined text
         MediLink_ConfigLoader.log("Combined text: {}".format(combined_text[:200]), level="DEBUG")  # Log first 200 characters
 
-        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)
+        day_of_week = _DAY_WEEK_PATTERN.search(combined_text, re.IGNORECASE)
+        month_day = _MONTH_DAY_PATTERN.search(combined_text, re.IGNORECASE)
+        year_match = _YEAR_PATTERN.search(combined_text, re.IGNORECASE)
 
         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")
@@ -342,40 +389,34 @@ def remove_directory(path):
 
 
 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)
+    # Optimized single-pass processing to avoid O(n²) complexity
+    # Process all abbreviations in one pass instead of multiple regex calls
+    for abbr, pattern in _MONTH_ABBR_PATTERNS.items():
+        text = pattern.sub(_MONTH_MAP[abbr], text)
+    for abbr, pattern in _DAY_ABBR_PATTERNS.items():
+        text = pattern.sub(_DAY_MAP[abbr], text)
     
     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)
+    # Optimized year reassembly with early exit conditions
+    # First, handle the most common cases with pre-compiled patterns
+    for pattern in _YEAR_SPLIT_PATTERNS:
+        text = pattern.sub(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)
+    parts = _DIGIT_PARTS_PATTERN.findall(text)
     if len(parts) >= 4:
+        # Early exit: only process if we have enough parts
         for i in range(len(parts) - 3):
             candidate = ''.join(parts[i:i + 4])
             if len(candidate) == 4 and candidate.isdigit():
-                combined_year = candidate
-                pattern = r'\b' + r'\s+'.join(parts[i:i + 4]) + r'\b'
-                text = re.sub(pattern, combined_year, text)
-                break
+                # More efficient pattern construction
+                pattern_parts = [r'\b' + part + r'\b' for part in parts[i:i + 4]]
+                pattern = r'\s+'.join(pattern_parts)
+                text = re.sub(pattern, candidate, text)
+                break  # Early exit after first successful combination
     
     return text
 
@@ -390,9 +431,8 @@ def parse_patient_id(text):
 
 def parse_diagnosis_code(text):
     try:
-        # Regular expression to find all ICD-10 codes starting with 'H' and containing a period
-        pattern = re.compile(r'H\d{2}\.\d+')
-        matches = pattern.findall(text)
+        # Use pre-compiled pattern for better performance
+        matches = _DIAGNOSIS_CODE_PATTERN.findall(text)
         
         if matches:
             return matches[0]  # Return the first match
@@ -432,27 +472,72 @@ def parse_femto_yes_or_no(text):
         return False
 
 
-def rotate_docx_files(directory):
-    # List all files in the directory
-    files = os.listdir(directory)
+def rotate_docx_files(directory, surgery_dates=None):
+    """
+    Process all DOCX files in the specified directory that contain "DR" and "SS" in their filename.
+    
+    Parameters:
+    - directory (str): Path to the directory containing DOCX files
+    - surgery_dates (set, optional): Set of surgery dates to filter by. If None, processes all files.
+    
+    Returns:
+    - dict: Combined patient data from all processed files
+    """
+    # PERFORMANCE OPTIMIZATION: Use os.scandir() for more efficient file system operations
+    # This reduces the number of file system calls and improves performance with large directories
+    valid_files = []
+    try:
+        # Use os.scandir() for better performance (XP/3.4.4 compatible)
+        with os.scandir(directory) as entries:
+            for entry in entries:
+                # Filter files that contain "DR" and "SS" in the filename
+                if (entry.name.endswith('.docx') and 
+                    "DR" in entry.name and 
+                    "SS" in entry.name):
+                    valid_files.append(entry.path)
+    except OSError as e:
+        print("Error accessing directory '{}': {}".format(directory, e))
+        return {}
 
-    # 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]
+    if not valid_files:
+        print("No valid DOCX files found in directory: {}".format(directory))
+        return {}
+
+    # Initialize combined patient data dictionary
+    combined_patient_data = {}
+    
+    # Process each valid DOCX file
+    for filepath in valid_files:
+        filename = os.path.basename(filepath)  # Extract filename for display
+        print("Processing file: {}".format(filename))
+        
+        try:
+            # Parse the document with surgery_dates parameter
+            patient_data_dict = parse_docx(filepath, surgery_dates or set())
+            
+            # Combine patient data from this file with overall results
+            for patient_id, service_dates in patient_data_dict.items():
+                if patient_id not in combined_patient_data:
+                    combined_patient_data[patient_id] = {}
+                combined_patient_data[patient_id].update(service_dates)
+            
+            # Print results for this file
+            print("Data from file '{}':".format(filename))
+            pprint.pprint(patient_data_dict)
+            print()
+            
+        except Exception as e:
+            print("Error processing file '{}': {}".format(filename, e))
+            MediLink_ConfigLoader.log("Error processing DOCX file '{}': {}".format(filepath, e), level="ERROR")
+            continue  # Continue with next file instead of crashing
 
-    # 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()
+    return combined_patient_data
 
 
 def main():
     # Call the function with the directory containing your .docx files
     directory = "C:\\Users\\danie\\Downloads\\"
+    # Note: surgery_dates parameter is now optional
     rotate_docx_files(directory)
 
 

{medicafe-0.250723.3 → medicafe-0.250723.5}/MediLink/MediLink_API_v3.py

@@ -640,6 +640,13 @@ def submit_uhc_claim(client, x12_request_data):
     it returns a simulated response. If Test Mode is not enabled, it submits the claim and then retrieves 
     the claim acknowledgement details using the transaction ID from the initial response.
 
+    NOTE: This function uses endpoints that may not be available in the new swagger version:
+    - /Claims/api/claim-submission/v1 (claim submission)
+    - /Claims/api/claim-details/v1 (claim acknowledgement)
+    
+    If these endpoints are deprecated in the new swagger, this function will need to be updated
+    to use the new available endpoints.
+
     :param client: An instance of APIClient
     :param x12_request_data: The x12 837p data as a string
     :return: The final response containing the claim acknowledgement details or a dummy response if in Test Mode

{medicafe-0.250723.3 → medicafe-0.250723.5}/MediLink/MediLink_Parser.py

@@ -1,10 +1,16 @@
 # MediLink_Parser.py
 
 import re
+from collections import defaultdict
+
+# Pre-compile regex patterns for better performance
+_EBT_KEY_VALUE_PATTERN = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+:|$)')
+_ERA_SEGMENT_PATTERN = re.compile(r'\*')
+_277_SEGMENT_PATTERN = re.compile(r'\*')
 
 def parse_era_content(content, debug=False):
     extracted_data = []
-    normalized_content = content.replace('~\n', '~')
+    normalized_content = content.replace('~\n', '~')  # Normalize line endings
     lines = normalized_content.split('~')
 
     record = {}
@@ -13,25 +19,27 @@ def parse_era_content(content, debug=False):
     is_payer_section = False
 
     for line in lines:
-        segments = line.split('*')
+        segments = _ERA_SEGMENT_PATTERN.split(line)
 
         if segments[0] == 'TRN' and len(segments) > 2:
-            check_eft = segments[2]
+            check_eft = segments[2]  # Extract check/EFT number
 
         if segments[0] == 'N1':
             if segments[1] == 'PR':
-                is_payer_section = True
+                is_payer_section = True  # Enter payer section
             elif segments[1] == 'PE':
-                is_payer_section = False
+                is_payer_section = False  # Exit payer section
 
         if is_payer_section and segments[0] == 'N3' and len(segments) > 1:
-            payer_address = segments[1]
+            payer_address = segments[1]  # Extract payer address
 
         if segments[0] == 'CLP' and len(segments) >= 5:
             if record:
+                # Calculate adjustment amount if not explicitly provided
                 if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
                     adjustment_amount = write_off + patient_responsibility
 
+                # Update record with calculated amounts
                 record.update({
                     'Payer Address': payer_address,
                     'Allowed Amount': allowed_amount,
@@ -41,8 +49,10 @@ def parse_era_content(content, debug=False):
                 })
                 extracted_data.append(record)
 
+                # Reset counters for next record
                 allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
 
+            # Start new record
             record = {
                 'Check EFT': check_eft,
                 'Chart Number': segments[1],
@@ -52,19 +62,28 @@ def parse_era_content(content, debug=False):
             }
 
         elif segments[0] == 'CAS':
-            if segments[1] == 'CO':
-                write_off += float(segments[3])
-            elif segments[1] == 'PR':
-                patient_responsibility += float(segments[3])
-            elif segments[1] == 'OA':
-                adjustment_amount += float(segments[3])
+            try:
+                if segments[1] == 'CO':
+                    write_off += float(segments[3])  # Contractual obligation
+                elif segments[1] == 'PR':
+                    patient_responsibility += float(segments[3])  # Patient responsibility
+                elif segments[1] == 'OA':
+                    adjustment_amount += float(segments[3])  # Other adjustments
+            except (ValueError, IndexError):
+                # Skip malformed CAS segments
+                continue
 
         elif segments[0] == 'AMT' and segments[1] == 'B6':
-            allowed_amount += float(segments[2])
+            try:
+                allowed_amount += float(segments[2])  # Allowed amount
+            except (ValueError, IndexError):
+                # Skip malformed AMT segments
+                continue
 
         elif segments[0] == 'DTM' and (segments[1] == '232' or segments[1] == '472'):
-            record['Date of Service'] = segments[2]
+            record['Date of Service'] = segments[2]  # Service date
 
+    # Process final record
     if record:
         if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
             adjustment_amount = write_off + patient_responsibility
@@ -87,36 +106,36 @@ def parse_277_content(content, debug=False):
     segments = content.split('~')
     records = []
     current_record = {}
+    
     for segment in segments:
-        parts = segment.split('*')
+        parts = _277_SEGMENT_PATTERN.split(segment)
         if parts[0] == 'HL':
             if current_record:
-                records.append(current_record)
-                current_record = {}
+                records.append(current_record)  # Save completed record
+                current_record = {}  # Start new record
         elif parts[0] == 'NM1':
-            if parts[1] == 'QC':
-                current_record['Patient'] = parts[3] + ' ' + parts[4]
-            elif parts[1] == '41':
-                current_record['Clearing House'] = parts[3]
-            elif parts[1] == 'PR':
-                current_record['Payer'] = parts[3]
-        elif parts[0] == 'TRN':
-            current_record['Claim #'] = parts[2]
-        elif parts[0] == 'STC':
-            current_record['Status'] = parts[1]
+            if parts[1] == 'QC' and len(parts) > 4:
+                current_record['Patient'] = ' '.join([parts[3], parts[4]])  # Patient name
+            elif parts[1] == '41' and len(parts) > 3:
+                current_record['Clearing House'] = parts[3]  # Clearing house
+            elif parts[1] == 'PR' and len(parts) > 3:
+                current_record['Payer'] = parts[3]  # Payer name
+        elif parts[0] == 'TRN' and len(parts) > 2:
+            current_record['Claim #'] = parts[2]  # Claim number
+        elif parts[0] == 'STC' and len(parts) > 1:
+            current_record['Status'] = parts[1]  # Claim status
             if len(parts) > 4:
-                current_record['Paid'] = parts[4]
-        elif parts[0] == 'DTP':
+                current_record['Paid'] = parts[4]  # Paid amount
+        elif parts[0] == 'DTP' and len(parts) > 3:
             if parts[1] == '472':
-                current_record['Serv.'] = parts[3]
+                current_record['Serv.'] = parts[3]  # Service date
             elif parts[1] == '050':
-                current_record['Proc.'] = parts[3]
-        elif parts[0] == 'AMT':
-            if parts[1] == 'YU':
-                current_record['Charged'] = parts[2]
+                current_record['Proc.'] = parts[3]  # Process date
+        elif parts[0] == 'AMT' and parts[1] == 'YU' and len(parts) > 2:
+            current_record['Charged'] = parts[2]  # Charged amount
 
     if current_record:
-        records.append(current_record)
+        records.append(current_record)  # Add final record
 
     if debug:
         print("Parsed 277 Content:")
@@ -135,17 +154,22 @@ def parse_dpt_content(content, debug=False):
     extracted_data = []
     lines = content.splitlines()
     record = {}
+    
     for line in lines:
         if 'Patient Account Number:' in line:
             if record:
-                extracted_data.append(record)
-            record = {}
-        parts = line.split(':')
-        if len(parts) == 2:
-            key, value = parts[0].strip(), parts[1].strip()
-            record[key] = value
+                extracted_data.append(record)  # Save completed record
+            record = {}  # Start new record
+        
+        # More efficient split - only split on first occurrence
+        colon_pos = line.find(':')
+        if colon_pos != -1:
+            key = line[:colon_pos].strip()
+            value = line[colon_pos + 1:].strip()
+            record[key] = value  # Add key-value pair to current record
+    
     if record:
-        extracted_data.append(record)
+        extracted_data.append(record)  # Add final record
 
     if debug:
         print("Parsed DPT Content:")
@@ -158,10 +182,7 @@ def parse_ebt_content(content, debug=False):
     extracted_data = []  # List to hold all extracted records
     lines = content.splitlines()  # Split the content into individual lines
     record = {}  # Dictionary to hold the current record being processed
-
-    # Regular expression pattern to match key-value pairs in the format "Key: Value"
-    key_value_pattern = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+?:|$)')
-
+    
     for line in lines:
         # Check for the start of a new record based on the presence of 'Patient Name'
         if 'Patient Name:' in line and record:
@@ -170,7 +191,7 @@ def parse_ebt_content(content, debug=False):
             record = {}  # Reset the record for the next entry
 
         # Find all key-value pairs in the current line
-        matches = key_value_pattern.findall(line)
+        matches = _EBT_KEY_VALUE_PATTERN.findall(line)
         for key, value in matches:
             key = key.strip()  # Remove leading/trailing whitespace from the key
             value = value.strip()  # Remove leading/trailing whitespace from the value
@@ -200,17 +221,22 @@ def parse_ibt_content(content, debug=False):
     extracted_data = []
     lines = content.splitlines()
     record = {}
+    
     for line in lines:
         if 'Submitter Batch ID:' in line:
             if record:
-                extracted_data.append(record)
-            record = {}
-        parts = line.split(':')
-        if len(parts) == 2:
-            key, value = parts[0].strip(), parts[1].strip()
-            record[key] = value
+                extracted_data.append(record)  # Save completed record
+            record = {}  # Start new record
+        
+        # More efficient split - only split on first occurrence
+        colon_pos = line.find(':')
+        if colon_pos != -1:
+            key = line[:colon_pos].strip()
+            value = line[colon_pos + 1:].strip()
+            record[key] = value  # Add key-value pair to current record
+    
     if record:
-        extracted_data.append(record)
+        extracted_data.append(record)  # Add final record
 
     if debug:
         print("Parsed IBT Content:")

{medicafe-0.250723.3 → medicafe-0.250723.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250723.3
+Version: 0.250723.5
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250723.3 → medicafe-0.250723.5}/medicafe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250723.3
+Version: 0.250723.5
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250723.3 → medicafe-0.250723.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='medicafe',
-    version="0.250723.3",
+    version="0.250723.5",
     description='MediCafe',
     long_description="""
     # Project Overview: MediCafe