medicafe 0.250723.1__tar.gz → 0.250723.3__tar.gz

{medicafe-0.250723.1 → medicafe-0.250723.3}/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.1 → medicafe-0.250723.3}/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[SUCCESS] 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[SUCCESS] 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[SUCCESS] Updated {} to '{}'".format(field, new_value))
+    
+    print("\n[SUCCESS] All claim data validated for patient {}".format(chart_number))
+    return validated_data
+
 
 

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

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

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

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

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

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