medicafe 0.250723.0__tar.gz → 0.250723.2__tar.gz

{medicafe-0.250723.0 → medicafe-0.250723.2}/MediBot/MediBot.py

@@ -66,13 +66,16 @@ def run_ahk_script(script_content):
             
             if process.returncode != 0:
                 print("AHK script failed with exit status: {}".format(process.returncode))  # Log the exit status of the failed script
+                MediLink_ConfigLoader.log("AHK script failed with exit status: {}".format(process.returncode), level="ERROR")
                 if stderr:
                     print("AHK Error: {}".format(stderr.decode('utf-8', errors='ignore')))
+                    MediLink_ConfigLoader.log("AHK Error: {}".format(stderr.decode('utf-8', errors='ignore')), level="ERROR")
             return  # Success - no file cleanup needed
             
         except Exception as e:
             # If stdin method fails, fall back to traditional file method
             print("AHK stdin execution failed, falling back to file method: {}".format(e))
+            MediLink_ConfigLoader.log("AHK stdin execution failed, falling back to file method: {}".format(e), level="ERROR")
             # Continue to fallback implementation below
     
     # Traditional file-based method (fallback or when optimization disabled)
@@ -87,9 +90,12 @@ def run_ahk_script(script_content):
         subprocess.check_call([AHK_EXECUTABLE, temp_script_name])  # Execute the AHK script using the AutoHotkey executable
     except subprocess.CalledProcessError as e:
         print("AHK script failed with exit status: {}".format(e.returncode))  # Log the exit status of the failed script
+        MediLink_ConfigLoader.log("AHK script failed with exit status: {}".format(e.returncode), level="ERROR")
         print("Output from AHK script: {}".format(e.output))  # Log the output from the failed script
+        MediLink_ConfigLoader.log("Output from AHK script: {}".format(e.output), level="ERROR")
     except Exception as e:
         print("An unexpected error occurred while running the AHK script: {}".format(e))  # Log any unexpected errors
+        MediLink_ConfigLoader.log("An unexpected error occurred while running the AHK script: {}".format(e), level="ERROR")
         traceback.print_exc()  # Print the full traceback for debugging purposes
     finally:
         # Delete the temporary script file
@@ -98,6 +104,7 @@ def run_ahk_script(script_content):
                 os.unlink(temp_script_name)  # Attempt to delete the temporary script file
             except OSError as e:
                 print("Error deleting temporary script file: {}".format(e))  # Log any errors encountered while deleting the file
+                MediLink_ConfigLoader.log("Error deleting temporary script file: {}".format(e), level="ERROR")
                 # Future Improvement: Implement a cleanup mechanism to handle orphaned temporary files
 
 # Global variable to store the last processed entry

{medicafe-0.250723.0 → medicafe-0.250723.2}/MediBot/MediBot_Crosswalk_Library.py

@@ -279,19 +279,22 @@ def check_crosswalk_health(crosswalk):
         crosswalk (dict): The crosswalk dictionary to check.
     
     Returns:
-        tuple: (is_healthy, missing_names_count, missing_medisoft_ids_count)
+        tuple: (is_healthy, missing_names_count, missing_medisoft_ids_count, missing_names_list, missing_medisoft_ids_list)
     """
     if 'payer_id' not in crosswalk or not crosswalk['payer_id']:
-        return False, 0, 0
+        return False, 0, 0, [], []
 
     missing_names = 0
     missing_medisoft_ids = 0
+    missing_names_list = []
+    missing_medisoft_ids_list = []
     
     for payer_id, details in crosswalk['payer_id'].items():
         # Check if name is missing or "Unknown"
         name = details.get('name', '')
         if not name or name == 'Unknown':
             missing_names += 1
+            missing_names_list.append(payer_id)
 
         # Check if at least one medisoft ID exists in either field
         medisoft_id = details.get('medisoft_id', [])
@@ -306,10 +309,11 @@ def check_crosswalk_health(crosswalk):
         # If both are empty, count as missing; if either has at least one, it's healthy
         if not medisoft_id and not medisoft_medicare_id:
             missing_medisoft_ids += 1
+            missing_medisoft_ids_list.append(payer_id)
 
     # Consider healthy if no missing names and no missing medisoft IDs
     is_healthy = (missing_names == 0 and missing_medisoft_ids == 0)
-    return is_healthy, missing_names, missing_medisoft_ids
+    return is_healthy, missing_names, missing_medisoft_ids, missing_names_list, missing_medisoft_ids_list
 
 def prompt_user_for_api_calls(crosswalk, config):
     """
@@ -324,7 +328,7 @@ def prompt_user_for_api_calls(crosswalk, config):
         bool: True if should proceed with API calls, False if should skip
     """
     
-    is_healthy, missing_names, missing_medisoft_ids = check_crosswalk_health(crosswalk)
+    is_healthy, missing_names, missing_medisoft_ids, missing_names_list, missing_medisoft_ids_list = check_crosswalk_health(crosswalk)
     total_payers = len(crosswalk.get('payer_id', {}))
     
     if is_healthy:
@@ -362,13 +366,27 @@ def prompt_user_for_api_calls(crosswalk, config):
     else:
         print("\nCrosswalk needs attention:")
         print("  - {} payers found".format(total_payers))
+        
+        # Show detailed information about missing names
         if missing_names > 0:
-            print("  - {} payers missing names".format(missing_names))
+            print("  - {} payers missing names: {}".format(missing_names, ", ".join(missing_names_list)))
+        
+        # Show detailed information about missing medisoft IDs
         if missing_medisoft_ids > 0:
-            print("  - {} payers missing medisoft IDs".format(missing_medisoft_ids))
-        print("Proceeding with API validation calls...")
-        MediLink_ConfigLoader.log("Crosswalk unhealthy - proceeding with API calls", config, level="INFO")
-        return True
+            print("  - {} payers missing medisoft IDs: {}".format(missing_medisoft_ids, ", ".join(missing_medisoft_ids_list)))
+            # API validation CANNOT resolve missing medisoft IDs
+            print("    TODO: Need user interface to manually input medisoft IDs for these payers")
+        
+        # Only proceed with API calls if there are missing names (API can help with those)
+        if missing_names > 0:
+            print("Proceeding with API validation calls to resolve missing names...")
+            MediLink_ConfigLoader.log("Crosswalk has missing names - proceeding with API calls", config, level="INFO")
+            return True
+        else:
+            print("No missing names to resolve via API. Skipping API validation calls.")
+            print("TODO: Manual intervention needed for missing medisoft IDs")
+            MediLink_ConfigLoader.log("Crosswalk has missing medisoft IDs but no missing names - skipping API calls", config, level="INFO")
+            return False
 
 def crosswalk_update(client, config, crosswalk, skip_known_payers=True): # Upstream of this is only MediBot_Preprocessor.py and MediBot.py
     """

{medicafe-0.250723.0 → medicafe-0.250723.2}/MediBot/MediBot_Preprocessor_lib.py

@@ -434,28 +434,50 @@ def update_procedure_codes(csv_data, crosswalk):
         for diagnosis_code in diagnosis_codes
     }
 
-    # Initialize counter for updated rows
+    # Initialize counters for tracking
     updated_count = 0
+    missing_medisoft_codes = set()
+    missing_procedure_mappings = set()
 
     # 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
+                    # Track missing procedure mapping
+                    missing_procedure_mappings.add(diagnosis_code)
+                    row['Procedure Code'] = "Unknown"  # Will be handled by 837p encoder
+                    MediLink_ConfigLoader.log("Missing procedure mapping for diagnosis code '{}' (Medisoft code: '{}') in row {}".format(
+                        diagnosis_code, medisoft_code, row_num), level="WARNING")
             else:
-                row['Procedure Code'] = "Unknown"  # Or handle as appropriate
+                # Track missing Medisoft code mapping
+                if medisoft_code:  # Only track if there's actually a code
+                    missing_medisoft_codes.add(medisoft_code)
+                row['Procedure Code'] = "Unknown"  # Will be handled by 837p encoder
+                MediLink_ConfigLoader.log("Missing Medisoft code mapping for '{}' in row {}".format(
+                    medisoft_code, row_num), level="WARNING")
         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
+    # Log summary statistics
     MediLink_ConfigLoader.log("Total {} 'Procedure Code' rows updated.".format(updated_count), level="INFO")
+    
+    if missing_medisoft_codes:
+        MediLink_ConfigLoader.log("Missing Medisoft code mappings: {}".format(sorted(missing_medisoft_codes)), level="WARNING")
+        print("WARNING: {} Medisoft codes need to be added to diagnosis_to_medisoft mapping: {}".format(
+            len(missing_medisoft_codes), sorted(missing_medisoft_codes)))
+    
+    if missing_procedure_mappings:
+        MediLink_ConfigLoader.log("Missing procedure mappings for diagnosis codes: {}".format(sorted(missing_procedure_mappings)), level="WARNING")
+        print("WARNING: {} diagnosis codes need to be added to procedure_to_diagnosis mapping: {}".format(
+            len(missing_procedure_mappings), sorted(missing_procedure_mappings)))
 
     return True
 
@@ -573,8 +595,11 @@ def update_diagnosis_codes(csv_data):
                     # Convert diagnosis code to Medisoft shorthand format.
                     medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
                     if medisoft_shorthand is None and diagnosis_code:
+                        # Use fallback logic for missing mapping
                         defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
                         medisoft_shorthand = defaulted_code
+                        MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
+                            diagnosis_code, medisoft_shorthand), level="WARNING")
                     MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
                     
                     row['Default Diagnosis #1'] = medisoft_shorthand

{medicafe-0.250723.0 → medicafe-0.250723.2}/MediLink/MediLink_837p_encoder_library.py

@@ -733,41 +733,37 @@ def create_clm_and_related_segments(parsed_data, config, crosswalk):
     See MediLink_837p_cob_library.create_enhanced_clm_segment() for enhanced implementation.
     """
     
+    # FINAL LINE OF DEFENSE: Validate all claim data before creating segments
+    validated_data = validate_claim_data_for_837p(parsed_data, config, crosswalk)
+    
     segments = []
     
     # Format the claim number
-    chart_number = parsed_data.get('CHART', '')
-    date_of_service = parsed_data.get('DATE', '')
+    chart_number = validated_data.get('CHART', '')
+    date_of_service = validated_data.get('DATE', '')
     formatted_claim_number = format_claim_number(chart_number, date_of_service)
         
     # CLM - Claim Information
     # TODO (COB ENHANCEMENT): Enhanced claim frequency handling
     # For COB claims, CLM05-3 should be "1" (original) unless replacement logic applies
     claim_frequency = "1"  # Default to original
-    # if parsed_data.get('claim_type') == 'secondary':
+    # if validated_data.get('claim_type') == 'secondary':
     #     claim_frequency = "1"  # Original for secondary claims
     
     segments.append("CLM*{}*{}***{}:B:{}*Y*A*Y*Y~".format(
         formatted_claim_number,
-        parsed_data['AMOUNT'],
-        parsed_data['TOS'],
+        validated_data['AMOUNT'],
+        validated_data['TOS'],
         claim_frequency))
     
     # HI - Health Care Diagnosis Code
     # Hardcoding "ABK" for ICD-10 codes as they are the only ones used now.
-    medisoft_code = ''.join(filter(str.isalnum, parsed_data['DIAG']))
+    medisoft_code = ''.join(filter(str.isalnum, validated_data['DIAG']))
     diagnosis_code = next((key for key, value in crosswalk.get('diagnosis_to_medisoft', {}).items() if value == medisoft_code), None)
     
+    # This should never be None now due to validation, but keeping as safety check
     if diagnosis_code is None:
-        error_message = "Diagnosis code is empty for chart number: {}. Please verify. Medisoft code is {}".format(chart_number, medisoft_code)
-        MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
-        print(error_message)
-        diagnosis_code = input("Enter the complete diagnosis code: ")
-        # Update the crosswalk dictionary with the new pairing of diagnosis_code and medisoft_code.
-        crosswalk['diagnosis_to_medisoft'][diagnosis_code] = medisoft_code
-        MediLink_ConfigLoader.log("Updated crosswalk with new diagnosis code: {}, for Medisoft code {}".format(diagnosis_code, medisoft_code), config, level="INFO")
-        # TODO This needs to actually save the .json though which right now I'd like to route through the dedicated function for updating the crosswalk. 
-        # TODO This should have been a validation exercise upstream and not a last minute check like this.
+        raise ValueError("Diagnosis code mapping failed for patient {} with medisoft code {}".format(chart_number, medisoft_code))
 
     cleaned_diagnosis_code = ''.join(char for char in diagnosis_code if char.isalnum())
     segments.append("HI*ABK:{}~".format(cleaned_diagnosis_code))
@@ -795,13 +791,13 @@ def create_clm_and_related_segments(parsed_data, config, crosswalk):
     
     # SV1 - Professional Service
     segments.append("SV1*HC:{}:{}*{}*MJ*{}***1~".format(
-        parsed_data['CODEA'],
-        parsed_data['POS'],
-        parsed_data['AMOUNT'],
-        parsed_data['MINTUES']))
+        validated_data['CODEA'],
+        validated_data['POS'],
+        validated_data['AMOUNT'],
+        validated_data['MINTUES']))
     
     # DTP - Date
-    segments.append("DTP*472*D8*{}~".format(convert_date_format(parsed_data['DATE'])))
+    segments.append("DTP*472*D8*{}~".format(convert_date_format(validated_data['DATE'])))
     
     # Is there REF - Line Item Control Number missing here? Private insurance doesn't need it, but Medicare does?
     # segments.append("REF*6R*1~") # REF01, Reference Identification Qualifier; REF02, Line Item Control Number.
@@ -946,5 +942,131 @@ def create_interchange_trailer(config, num_transactions, isa13, num_functional_g
     
     return ge_segment, iea_segment
 
+def validate_claim_data_for_837p(parsed_data, config, crosswalk):
+    """
+    Final line of defense validation for 837P claim data.
+    
+    This function validates that all required fields have valid values before creating
+    the 837P claim. If invalid values are found, it provides detailed user guidance
+    and allows manual input to correct the data.
+    
+    Parameters:
+    - parsed_data: Dictionary containing claim data
+    - config: Configuration settings
+    - crosswalk: Crosswalk data for mappings
+    
+    Returns:
+    - Dictionary with validated claim data, or raises ValueError if validation fails
+    """
+    validated_data = parsed_data.copy()
+    chart_number = parsed_data.get('CHART', 'UNKNOWN')
+    
+    # Validate diagnosis code
+    medisoft_code = ''.join(filter(str.isalnum, parsed_data.get('DIAG', '')))
+    diagnosis_code = next((key for key, value in crosswalk.get('diagnosis_to_medisoft', {}).items() if value == medisoft_code), None)
+    
+    if not diagnosis_code:
+        # Log the error condition with detailed context
+        error_message = "Diagnosis code is empty for chart number: {}. Please verify. Medisoft code is {}".format(chart_number, medisoft_code)
+        MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+        
+        print("\n{}".format("="*80))
+        print("CRITICAL: Missing diagnosis code mapping for patient {}".format(chart_number))
+        print("{}".format("="*80))
+        print("Medisoft code: '{}'".format(medisoft_code))
+        print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
+        print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
+        print("\nThis diagnosis code needs to be added to the crosswalk.json file.")
+        print("\nCurrent diagnosis_to_medisoft mapping format:")
+        
+        # Show example entries from the crosswalk
+        diagnosis_examples = list(crosswalk.get('diagnosis_to_medisoft', {}).items())[:3]
+        for full_code, medisoft_short in diagnosis_examples:
+            print("  '{}': '{}'".format(full_code, medisoft_short))
+        
+        print("\nPlease enter the complete ICD-10 diagnosis code (e.g., H25.10):")
+        diagnosis_code = input("> ").strip()
+        
+        if not diagnosis_code:
+            raise ValueError("Cannot proceed without diagnosis code for patient {}".format(chart_number))
+        
+        # Update the crosswalk dictionary with the new pairing of diagnosis_code and medisoft_code
+        crosswalk['diagnosis_to_medisoft'][diagnosis_code] = medisoft_code
+        MediLink_ConfigLoader.log("Updated crosswalk with new diagnosis code: {}, for Medisoft code {}".format(diagnosis_code, medisoft_code), config, level="INFO")
+        print("\n✓ Added '{}' -> '{}' to crosswalk".format(diagnosis_code, medisoft_code))
+        print("  IMPORTANT: You must manually save this to crosswalk.json to persist the change!")
+        # TODO This needs to actually save the .json though which right now I'd like to route through the dedicated function for updating the crosswalk. 
+        # TODO This should have been a validation exercise upstream and not a last minute check like this.
+    
+    # Validate procedure code
+    procedure_code = parsed_data.get('CODEA', '').strip()
+    if not procedure_code or procedure_code.lower() in ['unknown', 'none', '']:
+        # Log the error condition with detailed context
+        error_message = "Procedure code is empty for chart number: {}. Please verify. Diagnosis code is {}".format(chart_number, diagnosis_code)
+        MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+        
+        print("\n{}".format("="*80))
+        print("CRITICAL: Missing procedure code for patient {}".format(chart_number))
+        print("{}".format("="*80))
+        print("Diagnosis: {}".format(diagnosis_code))
+        print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
+        print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
+        print("\nThis procedure code needs to be added to the crosswalk.json file.")
+        print("\nCurrent procedure_to_diagnosis mapping format:")
+        
+        # Show example entries from the crosswalk
+        procedure_examples = list(crosswalk.get('procedure_to_diagnosis', {}).items())[:3]
+        for proc_code, diagnosis_list in procedure_examples:
+            print("  '{}': {}".format(proc_code, diagnosis_list))
+        
+        print("\nPlease enter the CPT procedure code (e.g., 66984):")
+        procedure_code = input("> ").strip()
+        
+        if not procedure_code:
+            raise ValueError("Cannot proceed without procedure code for patient {}".format(chart_number))
+        
+        # Update the crosswalk dictionary with the new pairing of procedure_code and diagnosis_code
+        if procedure_code not in crosswalk.get('procedure_to_diagnosis', {}):
+            crosswalk.setdefault('procedure_to_diagnosis', {})[procedure_code] = []
+        crosswalk['procedure_to_diagnosis'][procedure_code].append(diagnosis_code)
+        MediLink_ConfigLoader.log("Updated crosswalk with new procedure code: {}, for diagnosis code {}".format(procedure_code, diagnosis_code), config, level="INFO")
+        print("\n✓ Added '{}' -> ['{}'] to crosswalk".format(procedure_code, diagnosis_code))
+        print("  IMPORTANT: You must manually save this to crosswalk.json to persist the change!")
+        # TODO This needs to actually save the .json though which right now I'd like to route through the dedicated function for updating the crosswalk. 
+        # TODO This should have been a validation exercise upstream and not a last minute check like this.
+    
+    # Update the validated data
+    validated_data['DIAG'] = medisoft_code
+    validated_data['CODEA'] = procedure_code
+    
+    # Validate other critical fields
+    critical_fields = {
+        'AMOUNT': 'claim amount',
+        'TOS': 'type of service',
+        'POS': 'place of service',
+        'MINTUES': 'service minutes'
+    }
+    
+    for field, description in critical_fields.items():
+        value = validated_data.get(field, '').strip()
+        if not value or value.lower() in ['unknown', 'none', '']:
+            print("\n{}".format("="*80))
+            print("CRITICAL: Missing {} for patient {}".format(description, chart_number))
+            print("{}".format("="*80))
+            print("Field: {}".format(field))
+            print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
+            print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
+            print("\nPlease enter the {}:".format(description))
+            new_value = input("> ").strip()
+            
+            if not new_value:
+                raise ValueError("Cannot proceed without {} for patient {}".format(description, chart_number))
+            
+            validated_data[field] = new_value
+            print("\n✓ Updated {} to '{}'".format(field, new_value))
+    
+    print("\n✓ All claim data validated for patient {}".format(chart_number))
+    return validated_data
+
 
 

{medicafe-0.250723.0 → medicafe-0.250723.2}/PKG-INFO

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

{medicafe-0.250723.0 → medicafe-0.250723.2}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250723.0 → medicafe-0.250723.2}/setup.py

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