medicafe 0.250720.0__py3-none-any.whl → 0.250722.0__py3-none-any.whl

MediBot/MediBot.bat

@@ -281,9 +281,11 @@ for %%f in ("%target_folder%\!latest_csv!") do set "latest_csv_name=%%~nxf"
 
 :: Compare the paths and prompt user if necessary
 if not "!current_csv_name!"=="!latest_csv_name!" (
+    echo.
     echo ALERT: Config file CSV path differs from the latest CSV. This can happen if a new CSV is downloaded.
     echo Current CSV: !current_csv_name!
     echo Latest CSV: !latest_csv_name!
+    echo.
     set /p update_choice="Do you want to update to the latest CSV? (Y/N): "
     if /i "!update_choice!"=="Y" (
         echo Updating config file with latest CSV...

MediBot/MediBot_Preprocessor.py

@@ -25,7 +25,8 @@ except ImportError as e:
 
 # Load configuration
 # Should this also take args? Path for ./MediLink needed to be added for this to resolve
-config, crosswalk = MediLink_ConfigLoader.load_configuration()
+# Use cached configuration to avoid repeated I/O operations
+config, crosswalk = MediBot_Preprocessor_lib.get_cached_configuration()
 
 # CSV Preprocessor built for Carol
 def preprocess_csv_data(csv_data, crosswalk):
@@ -57,9 +58,7 @@ def preprocess_csv_data(csv_data, crosswalk):
         # 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.
-        # Combine 'Patient Address1' and 'Patient Address2' into a single 'Patient Street' field.
+        # Batch field operations: Convert dates, combine names/addresses, and apply replacements
         MediLink_ConfigLoader.log("CSV Pre-processor: Constructing Patient Name and Address for Medisoft...", level="INFO")
         MediBot_Preprocessor_lib.combine_fields(csv_data)
         
@@ -97,7 +96,8 @@ def preprocess_csv_data(csv_data, crosswalk):
 
 def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
     existing_patients = []
-    patients_to_process = list(selected_patient_ids)  # Clone the selected patient IDs list
+    # Convert to set for O(1) lookup performance
+    selected_patient_ids_set = set(selected_patient_ids)
 
     try:
         with open(MAPAT_MED_PATH, 'r') as file:
@@ -107,17 +107,17 @@ def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
                     patient_id = line[194:202].strip()  # Extract Patient ID (Columns 195-202)
                     patient_name = line[9:39].strip()  # Extract Patient Name (Columns 10-39)
                     
-                    if patient_id in selected_patient_ids:
+                    if patient_id in selected_patient_ids_set:
                         existing_patients.append((patient_id, patient_name))
-                        # Remove all occurrences of this patient_id from patients_to_process as a filter rather than .remove because 
-                        # then it only makes one pass and removes the first instance.
+                        # Remove from set for O(1) operation
+                        selected_patient_ids_set.discard(patient_id)
     except FileNotFoundError:
         # Handle the case where MAPAT_MED_PATH is not found
         print("MAPAT.med was not found at location indicated in config file.")
         print("Skipping existing patient check and continuing...")
         
-    # Filter out all instances of existing patient IDs
-    patients_to_process = [id for id in patients_to_process if id not in [patient[0] for patient in existing_patients]]
+    # Convert remaining set back to list for return
+    patients_to_process = list(selected_patient_ids_set)
     
     return existing_patients, patients_to_process
 
@@ -129,14 +129,25 @@ def intake_scan(csv_headers, field_mapping):
     MediLink_ConfigLoader.log("Intake Scan - Field Mapping: {}".format(field_mapping), level="DEBUG")
     MediLink_ConfigLoader.log("Intake Scan - CSV Headers: {}".format(csv_headers), level="DEBUG")
     
+    # Pre-compile regex patterns for better performance
+    compiled_patterns = {}
+    for medisoft_field, patterns in field_mapping.items():
+        compiled_patterns[medisoft_field] = [re.compile(pattern, re.IGNORECASE) for pattern in patterns]
+    
+    # Pre-compile the alphanumeric regex for policy number validation
+    alphanumeric_pattern = re.compile("^[a-zA-Z0-9]*$")
+    
     # Iterate over the Medisoft fields defined in field_mapping
     for medisoft_field in field_mapping.keys():
-        for pattern in field_mapping[medisoft_field]:
-            matched_headers = [header for header in csv_headers if re.search(pattern, header, re.IGNORECASE)]
-            if matched_headers:
-                # Assuming the first matched header is the desired one
-                identified_fields[matched_headers[0]] = medisoft_field
-                # MediLink_ConfigLoader.log("Found Header: {}".format(identified_fields[matched_headers[0]]))
+        matched = False
+        for pattern in compiled_patterns[medisoft_field]:
+            # Use early termination - find first match and break
+            for header in csv_headers:
+                if pattern.search(header):
+                    identified_fields[header] = medisoft_field
+                    matched = True
+                    break
+            if matched:
                 break
         else:
             # Check if the missing field is a required field before appending the warning
@@ -160,7 +171,7 @@ def intake_scan(csv_headers, field_mapping):
         if 'Insurance Policy Number' in field:
             policy_number = identified_fields.get(header)
             MediLink_ConfigLoader.log("Checking Insurance Policy Number '{}' for alphanumeric characters.".format(policy_number), level="DEBUG")
-            if not bool(re.match("^[a-zA-Z0-9]*$", policy_number)):
+            if not alphanumeric_pattern.match(policy_number):
                 missing_fields_warnings.append("WARNING: Insurance Policy Number '{}' contains invalid characters.".format(policy_number))
                 MediLink_ConfigLoader.log("Insurance Policy Number '{}' contains invalid characters.".format(policy_number), level="WARNING")
         # Additional checks can be added as needed for other fields
@@ -187,15 +198,19 @@ def main():
 
     args = parser.parse_args()
 
-    config, crosswalk = MediLink_ConfigLoader.load_configuration()
-    
-    client = APIClient()
-    
     # If no arguments provided, print usage instructions
     if not any(vars(args).values()):
         parser.print_help()
         return
 
+    # Load configuration only when needed
+    if args.update_crosswalk or args.init_crosswalk or args.load_csv or args.preprocess_csv or args.open_csv:
+        config, crosswalk = MediBot_Preprocessor_lib.get_cached_configuration()
+    
+    # Initialize API client only when needed
+    if args.update_crosswalk or args.init_crosswalk:
+        client = APIClient()
+    
     if args.update_crosswalk:
         print("Updating the crosswalk...")
         MediBot_Crosswalk_Library.crosswalk_update(client, config, crosswalk)

MediBot/MediBot_Preprocessor_lib.py

@@ -7,6 +7,10 @@ import chardet  # Ensure chardet is imported
 # Add the parent directory of the project to the Python path
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
+# Configuration cache to avoid repeated loading
+_config_cache = None
+_crosswalk_cache = None
+
 # Attempt to import necessary modules, falling back if they are not found
 try:
     import MediLink_ConfigLoader
@@ -44,6 +48,17 @@ def initialize(config):
         except AttributeError:
             raise InitializationError("Error: '{}' not found in config.".format(key))
 
+def get_cached_configuration():
+    """
+    Returns cached configuration and crosswalk data to avoid repeated I/O operations.
+    """
+    global _config_cache, _crosswalk_cache
+    
+    if _config_cache is None or _crosswalk_cache is None:
+        _config_cache, _crosswalk_cache = MediLink_ConfigLoader.load_configuration()
+    
+    return _config_cache, _crosswalk_cache
+
 def open_csv_for_editing(csv_file_path):
     try:
         # Open the CSV file with its associated application
@@ -105,13 +120,18 @@ def load_csv_data(csv_file_path):
             # Clean the headers
             cleaned_headers = clean_header(reader.fieldnames)
 
-            # Create a mapping of cleaned headers to original headers
+            # Create a mapping of cleaned headers to original headers (pre-compute once)
             header_mapping = {cleaned_headers[i]: reader.fieldnames[i] for i in range(len(cleaned_headers))}
 
-            # Process the remaining rows
+            # Process the remaining rows - optimize by pre-allocating the list
             csv_data = []
+            # Pre-allocate list size if we can estimate it (optional optimization)
+            # csv_data = [None] * estimated_size  # if we had row count
+            
             for row in reader:
-                cleaned_row = {cleaned_headers[i]: row[header_mapping[cleaned_headers[i]]] for i in range(len(cleaned_headers))}
+                # Use dict() constructor with generator expression for better performance
+                cleaned_row = dict((cleaned_headers[i], row[header_mapping[cleaned_headers[i]]]) 
+                                 for i in range(len(cleaned_headers)))
                 csv_data.append(cleaned_row)
 
             return csv_data  # Return a list of dictionaries
@@ -205,12 +225,20 @@ def combine_fields(csv_data):
 
 def apply_replacements(csv_data, crosswalk):
     replacements = crosswalk.get('csv_replacements', {})
+    # Pre-define the keys to check for better performance
+    keys_to_check = ['Patient SSN', 'Primary Insurance', 'Ins1 Payer ID']
+    
     for row in csv_data:
+        # Use early termination - check each replacement only if needed
         for old_value, new_value in replacements.items():
-            for key in ['Patient SSN', 'Primary Insurance', 'Ins1 Payer ID']:
+            replacement_made = False
+            for key in keys_to_check:
                 if row.get(key) == old_value:
                     row[key] = new_value
-                    break  # Exit the loop once a replacement is made
+                    replacement_made = True
+                    break  # Exit the key loop once a replacement is made
+            if replacement_made:
+                break  # Exit the replacement loop once any replacement is made
 
 import difflib
 from collections import defaultdict
@@ -230,12 +258,15 @@ def find_best_medisoft_id(insurance_name, medisoft_ids, medisoft_to_mains_names)
     best_match_ratio = 0
     best_medisoft_id = None
 
+    # Pre-process insurance name once
+    processed_insurance = ''.join(c for c in insurance_name if not c.isdigit()).upper()
+
     for medisoft_id in medisoft_ids:
         mains_names = medisoft_to_mains_names.get(medisoft_id, [])
         for mains_name in mains_names:
             # Preprocess names by extracting non-numeric characters and converting to uppercase
-            processed_mains = ''.join(filter(lambda x: not x.isdigit(), mains_name)).upper()
-            processed_insurance = ''.join(filter(lambda x: not x.isdigit(), insurance_name)).upper()
+            # Use more efficient string processing
+            processed_mains = ''.join(c for c in mains_name if not c.isdigit()).upper()
 
             # Log the processed names before computing the match ratio
             MediLink_ConfigLoader.log("Processing Medisoft ID '{}': Comparing processed insurance '{}' with processed mains '{}'.".format(medisoft_id, processed_insurance, processed_mains), level="DEBUG")
@@ -414,8 +445,8 @@ def update_procedure_codes(csv_data, crosswalk):
 
 def update_diagnosis_codes(csv_data):
     try:
-        # Load configuration and crosswalk
-        config, crosswalk = MediLink_ConfigLoader.load_configuration()
+        # Use cached configuration instead of loading repeatedly
+        config, crosswalk = get_cached_configuration()
         
         # Extract the local storage path from the configuration
         local_storage_path = config['MediLink_Config']['local_storage_path']
@@ -449,17 +480,23 @@ 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
-        docx_files = [
-            os.path.join(local_storage_path, filename)
-            for filename in os.listdir(local_storage_path)
-            if filename.endswith(".docx")
-        ]
-
-        # Filter files based on modification time
-        valid_files = [
-            filepath for filepath in docx_files
-            if threshold_start <= datetime.fromtimestamp(os.path.getmtime(filepath)) <= threshold_end
-        ]
+        # Optimize by combining file gathering and filtering in one pass
+        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
+        except OSError:
+            MediLink_ConfigLoader.log("Error accessing directory: {}".format(local_storage_path), level="ERROR")
+            return
 
         # Process valid DOCX files
         for filepath in valid_files:
@@ -583,8 +620,8 @@ def load_insurance_data_from_mains(config):
     Returns:
         dict: A dictionary mapping insurance names to insurance IDs.
     """
-    # Reset config pull to make sure its not using the MediLink config key subset
-    config, crosswalk = MediLink_ConfigLoader.load_configuration()
+    # Use cached configuration to avoid repeated loading
+    config, crosswalk = get_cached_configuration()
     
     # Retrieve MAINS path and slicing information from the configuration   
     # TODO (Low) For secondary insurance, this needs to be pulling from the correct MAINS (there are 2)

MediLink/MediLink_837p_cob_library.py

@@ -56,41 +56,16 @@ project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 if project_dir not in sys.path:
     sys.path.append(project_dir)
 
-# Safe import strategy to avoid circular dependencies
-def safe_import_encoder_functions():
-    """
-    Safely imports required functions from the encoder library.
-    Uses dynamic imports to avoid circular dependencies while maintaining functionality.
-    
-    Returns:
-    - Dictionary containing imported functions or None if import fails
-    """
+# Safe import for utility functions - works in multiple contexts
+try:
+    from .MediLink_837p_utilities import convert_date_format
+except (ImportError, SystemError):
     try:
-        # Dynamic import to avoid circular dependency
-        from MediLink_837p_encoder_library import convert_date_format
-        return {
-            'convert_date_format': convert_date_format
-        }
+        from MediLink_837p_utilities import convert_date_format
     except ImportError as e:
-        # Fallback implementation for convert_date_format
-        MediLink_ConfigLoader.log("Warning: Could not import encoder functions: {}".format(e), level="WARNING")
-        return None
-
-# Initialize encoder functions with fallback
-_encoder_functions = safe_import_encoder_functions()
-
-def get_convert_date_format():
-    """
-    Safely gets the convert_date_format function with fallback implementation.
-    
-    Returns:
-    - convert_date_format function or fallback implementation
-    """
-    if _encoder_functions and 'convert_date_format' in _encoder_functions:
-        return _encoder_functions['convert_date_format']
-    else:
-        # Fallback implementation
-        def fallback_convert_date_format(date_str):
+        # Fallback implementation for convert_date_format if utilities module is not available
+        MediLink_ConfigLoader.log("Warning: Could not import utilities functions: {}".format(e), level="WARNING")
+        def convert_date_format(date_str):
             """Fallback date format conversion function"""
             try:
                 # Parse the input date string into a datetime object
@@ -101,7 +76,6 @@ def get_convert_date_format():
             except (ValueError, TypeError):
                 # Return original string if conversion fails
                 return date_str
-        return fallback_convert_date_format
 
 def create_2320_other_subscriber_segments(patient_data, config, crosswalk):
     """
@@ -253,9 +227,8 @@ def create_2430_service_line_cob_segments(patient_data, config, crosswalk):
         
         # DTP*573 segment for adjudication date
         if service.get('adjudication_date'):
-            convert_date = get_convert_date_format()
             dtp_segment = "DTP*573*D8*{}~".format(
-                convert_date(service.get('adjudication_date'))
+                convert_date_format(service.get('adjudication_date'))
             )
             segments.append(dtp_segment)
     
@@ -310,9 +283,8 @@ def create_2330C_other_subscriber_name_segments(patient_data, config, crosswalk)
         
         # Optional DMG segment for date of birth/gender
         if patient_data.get('subscriber_dob'):
-            convert_date = get_convert_date_format()
             dmg_segment = "DMG*D8*{}*{}~".format(
-                convert_date(patient_data.get('subscriber_dob')),
+                convert_date_format(patient_data.get('subscriber_dob')),
                 patient_data.get('subscriber_gender', '')
             )
             segments.append(dmg_segment)
@@ -636,7 +608,8 @@ def get_enhanced_insurance_options(config):
         'MA': 'Medicare Advantage',
         'MC': 'Medicare Part C'
     }
-    enhanced_options = {**base_options, **medicare_options}
+    enhanced_options = base_options.copy()
+    enhanced_options.update(medicare_options)
     return enhanced_options
 
 # Main COB processing function

MediLink/MediLink_837p_encoder.py

@@ -1,9 +1,33 @@
 # MediLink_837p_encoder.py
 import re, argparse, os
 from datetime import datetime
-import MediLink_ConfigLoader
-from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
-import MediLink_837p_encoder_library
+
+# Safe import for ConfigLoader - works in multiple contexts
+try:
+    from . import MediLink_ConfigLoader
+except (ImportError, SystemError):
+    try:
+        import MediLink_ConfigLoader
+    except ImportError:
+        from MediLink import MediLink_ConfigLoader
+
+# Safe import for DataMgmt functions - works in multiple contexts
+try:
+    from .MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
+except (ImportError, SystemError):
+    try:
+        from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
+    except ImportError:
+        from MediLink.MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
+
+# Safe import for encoder library - works in multiple contexts
+try:
+    from . import MediLink_837p_encoder_library
+except (ImportError, SystemError):
+    try:
+        import MediLink_837p_encoder_library
+    except ImportError:
+        from MediLink import MediLink_837p_encoder_library
 # TODO (COB ENHANCEMENT): Import COB library when implementing Medicare and secondary claim support
 # import MediLink_837p_cob_library
 #from tqdm import tqdm

MediLink/MediLink_837p_encoder_library.py

@@ -10,27 +10,56 @@ if project_dir not in sys.path:
 from MediBot import MediBot_Preprocessor_lib
 load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
 from MediBot import MediBot_Crosswalk_Library
-from MediLink_API_v3 import fetch_payer_name_from_api
-
-# Converts date format from one format to another.
-def convert_date_format(date_str):
-    # Parse the input date string into a datetime object using the input format    
-    # Determine the input date format based on the length of the input string
-    input_format = "%m-%d-%Y" if len(date_str) == 10 else "%m-%d-%y"
-    date_obj = datetime.strptime(date_str, input_format)
-    # Format the datetime object into the desired output format and return
-    return date_obj.strftime("%Y%m%d")
-
-# Formats date and time according to the specified format.
-def format_datetime(dt=None, format_type='date'):
-    if dt is None:
-        dt = datetime.now()
-    if format_type == 'date':
-        return dt.strftime('%Y%m%d')
-    elif format_type == 'isa':
-        return dt.strftime('%y%m%d')
-    elif format_type == 'time':
-        return dt.strftime('%H%M')
+
+# Safe import for API functions - works in multiple contexts
+try:
+    from .MediLink_API_v3 import fetch_payer_name_from_api
+except (ImportError, SystemError):
+    try:
+        from MediLink_API_v3 import fetch_payer_name_from_api
+    except ImportError:
+        import MediLink_API_v3
+        fetch_payer_name_from_api = MediLink_API_v3.fetch_payer_name_from_api
+
+# Safe import for utility functions - works in multiple contexts
+try:
+    from .MediLink_837p_utilities import (
+        convert_date_format,
+        format_datetime,
+        get_user_confirmation,
+        prompt_user_for_payer_id,
+        format_claim_number,
+        generate_segment_counts,
+        handle_validation_errors,
+        get_output_directory,
+        winscp_validate_output_directory
+    )
+except (ImportError, SystemError):
+    try:
+        from MediLink_837p_utilities import (
+            convert_date_format,
+            format_datetime,
+            get_user_confirmation,
+            prompt_user_for_payer_id,
+            format_claim_number,
+            generate_segment_counts,
+            handle_validation_errors,
+            get_output_directory,
+            winscp_validate_output_directory
+        )
+    except ImportError:
+        import MediLink_837p_utilities
+        convert_date_format = MediLink_837p_utilities.convert_date_format
+        format_datetime = MediLink_837p_utilities.format_datetime
+        get_user_confirmation = MediLink_837p_utilities.get_user_confirmation
+        prompt_user_for_payer_id = MediLink_837p_utilities.prompt_user_for_payer_id
+        format_claim_number = MediLink_837p_utilities.format_claim_number
+        generate_segment_counts = MediLink_837p_utilities.generate_segment_counts
+        handle_validation_errors = MediLink_837p_utilities.handle_validation_errors
+        get_output_directory = MediLink_837p_utilities.get_output_directory
+        winscp_validate_output_directory = MediLink_837p_utilities.winscp_validate_output_directory
+
+
 
 # Constructs the ST segment for transaction set.
 def create_st_segment(transaction_set_control_number):
@@ -152,7 +181,11 @@ def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     # Submitter contact details
     contact_name = config.get('submitter_name', 'NONE')
     contact_telephone_number = config.get('submitter_tel', 'NONE')
-    entity_type_qualifier = '2' # if contact_name else '1'  BUG - 1 if submitter_first_name is not empty. Reference: billing_entity_type_qualifier = '1' if billing_provider_firstname else '2' 
+    
+    # Get submitter first name to determine entity type qualifier
+    submitter_first_name = config.get('submitter_first_name', '')
+    # Determine entity_type_qualifier: '1' for individual (with first name), '2' for organization
+    entity_type_qualifier = '1' if submitter_first_name else '2' # Make sure that this is correct. Original default was 2.
     
     # Construct NM1 segment for the submitter
     nm1_segment = "NM1*41*{}*{}*****{}*{}~".format(entity_type_qualifier, submitter_name, submitter_id_qualifier, submitter_id) # BUG - need to check submitter_name because this is written as fixed ****** which implies a single entry and not a first and last name. This is weird.
@@ -237,15 +270,7 @@ def create_2010BB_payer_information_segment(parsed_data):
     # Build NM1 segment using provided payer name and payer ID
     return build_nm1_segment(payer_name, payer_id)
 
-def get_user_confirmation(prompt_message):
-    while True:
-        response = input(prompt_message).strip().lower()
-        if response in ['yes', 'y']:
-            return True
-        elif response in ['no', 'n']:
-            return False
-        else:
-            print("Please respond with 'yes' or 'no'.")
+
 
 def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parsed_data, crosswalk, client):
     # Check if the payer_id is in the crosswalk with a name already attached to it.
@@ -405,18 +430,7 @@ def handle_missing_payer_id(insurance_name, config, crosswalk, client):
         MediLink_ConfigLoader.log("User did not confirm the standard insurance name. Manual intervention is required.", config, level="CRITICAL")
         return None
 
-def prompt_user_for_payer_id(insurance_name):
-    """
-    Prompts the user to input the payer ID manually and ensures that a valid alphanumeric ID is provided.
-    """
-    while True:
-        print("Manual intervention required: No payer ID found for insurance name '{}'.".format(insurance_name))
-        payer_id = input("Please enter the payer ID manually: ").strip()
-        
-        if payer_id.isalnum():
-            return payer_id
-        else:
-            print("Error: Payer ID must be alphanumeric. Please try again.")
+
 
 def build_nm1_segment(payer_name, payer_id):
     # Step 1: Build NM1 segment using payer name and ID
@@ -696,15 +710,7 @@ def create_nm1_rendering_provider_segment(config, is_rendering_provider_differen
     else:
         return []
 
-def format_claim_number(chart_number, date_of_service):
-    # Remove any non-alphanumeric characters from chart number and date
-    chart_number_alphanumeric = ''.join(filter(str.isalnum, chart_number))
-    date_of_service_alphanumeric = ''.join(filter(str.isalnum, date_of_service))
-    
-    # Combine the alphanumeric components without spaces
-    formatted_claim_number = chart_number_alphanumeric + date_of_service_alphanumeric
-    
-    return formatted_claim_number
+
 
 # Constructs the CLM and related segments based on parsed data and configuration.
 def create_clm_and_related_segments(parsed_data, config, crosswalk): 
@@ -940,70 +946,5 @@ def create_interchange_trailer(config, num_transactions, isa13, num_functional_g
     
     return ge_segment, iea_segment
 
-# Generates segment counts for the formatted 837P transaction and updates SE segment.
-def generate_segment_counts(compiled_segments, transaction_set_control_number):
-    # Count the number of segments, not including the placeholder SE segment
-    segment_count = compiled_segments.count('~')   # + 1 Including SE segment itself, but seems to be giving errors.
-    
-    # Ensure transaction set control number is correctly formatted as a string
-    formatted_control_number = str(transaction_set_control_number).zfill(4)  # Pad to ensure minimum 4 characters
-
-    # Construct the SE segment with the actual segment count and the formatted transaction set control_number
-    se_segment = "SE*{0}*{1}~".format(segment_count, formatted_control_number)
 
-    # Assuming the placeholder SE segment was the last segment added before compiling
-    # This time, we directly replace the placeholder with the correct SE segment
-    formatted_837p = compiled_segments.rsplit('SE**', 1)[0] + se_segment
-    
-    return formatted_837p
 
-def handle_validation_errors(transaction_set_control_number, validation_errors, config):
-    for error in validation_errors:
-        MediLink_ConfigLoader.log("Validation error for transaction set {}: {}".format(transaction_set_control_number, error), config, level="WARNING")
-    
-    print("Validation errors encountered for transaction set {}. Errors: {}".format(transaction_set_control_number, validation_errors))
-    user_input = input("Skip this patient and continue without incrementing transaction set number? (yes/no): ")
-    if user_input.lower() == 'yes':
-        print("Skipping patient...")
-        MediLink_ConfigLoader.log("Skipped processing of transaction set {} due to user decision.".format(transaction_set_control_number), config, level="INFO")
-        return True  # Skip the current patient
-    else:
-        print("Processing halted due to validation errors.")
-        MediLink_ConfigLoader.log("HALT: Processing halted at transaction set {} due to unresolved validation errors.".format(transaction_set_control_number), config, level="ERROR")
-        sys.exit()  # Optionally halt further processing
-        
-def winscp_validate_output_directory(output_directory):
-    """
-    Validates the output directory path to ensure it has no spaces.
-    If spaces are found, prompts the user to input a new path.
-    If the directory doesn't exist, creates it.
-    """
-    while ' ' in output_directory:
-        print("\nWARNING: The output directory path contains spaces, which can cause issues with upload operations.")
-        print("    Current proposed path: {}".format(output_directory))
-        new_path = input("Please enter a new path for the output directory: ")
-        output_directory = new_path.strip()  # Remove leading/trailing spaces
-    
-    # Check if the directory exists, if not, create it
-    if not os.path.exists(output_directory):
-        os.makedirs(output_directory)
-        print("INFO: Created output directory: {}".format(output_directory))
-    
-    return output_directory
-
-def get_output_directory(config):
-    # Retrieve desired default output file path from config 
-    output_directory = config.get('outputFilePath', '').strip()
-    # BUG (Low SFTP) Add WinSCP validation because of the mishandling of spaces in paths. (This shouldn't need to exist.)
-    if not output_directory:
-        print("Output file path is not specified in the configuration.")
-        output_directory = input("Please enter a valid output directory path: ").strip()
-    
-    # Validate the directory path (checks for spaces and existence)
-    output_directory = winscp_validate_output_directory(output_directory)
-    
-    if not os.path.isdir(output_directory):
-        print("Output directory does not exist or is not accessible. Please check the configuration.")
-        return None
-    
-    return output_directory

MediLink/MediLink_837p_utilities.py

@@ -0,0 +1,264 @@
+# MediLink_837p_utilities.py
+"""
+837P Encoder Utility Functions
+
+This module contains utility functions extracted from MediLink_837p_encoder_library.py
+to reduce the size and complexity of the main encoder library while avoiding circular imports.
+
+Functions included:
+- Date/time formatting utilities
+- User interaction utilities  
+- File/path handling utilities
+- Processing utilities
+- Validation utilities
+
+Import Strategy:
+This module only imports base Python modules and MediLink_ConfigLoader to avoid 
+circular dependencies. Other modules import from this utilities module.
+"""
+
+from datetime import datetime
+import sys
+import os
+import re
+
+# Import MediLink_ConfigLoader for logging functionality
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+# =============================================================================
+# DATE/TIME UTILITIES
+# =============================================================================
+
+def convert_date_format(date_str):
+    """
+    Converts date format from one format to another.
+    
+    Parameters:
+    - date_str: Date string in MM-DD-YYYY or MM-DD-YY format
+    
+    Returns:
+    - Date string in YYYYMMDD format
+    """
+    # Parse the input date string into a datetime object using the input format    
+    # Determine the input date format based on the length of the input string
+    input_format = "%m-%d-%Y" if len(date_str) == 10 else "%m-%d-%y"
+    date_obj = datetime.strptime(date_str, input_format)
+    # Format the datetime object into the desired output format and return
+    return date_obj.strftime("%Y%m%d")
+
+def format_datetime(dt=None, format_type='date'):
+    """
+    Formats date and time according to the specified format.
+    
+    Parameters:
+    - dt: datetime object (defaults to current datetime if None)
+    - format_type: 'date', 'isa', or 'time'
+    
+    Returns:
+    - Formatted date/time string
+    """
+    if dt is None:
+        dt = datetime.now()
+    if format_type == 'date':
+        return dt.strftime('%Y%m%d')
+    elif format_type == 'isa':
+        return dt.strftime('%y%m%d')
+    elif format_type == 'time':
+        return dt.strftime('%H%M')
+
+# =============================================================================
+# USER INTERACTION UTILITIES
+# =============================================================================
+
+def get_user_confirmation(prompt_message):
+    """
+    Prompts user for yes/no confirmation with validation.
+    
+    Parameters:
+    - prompt_message: Message to display to user
+    
+    Returns:
+    - Boolean: True for yes, False for no
+    """
+    while True:
+        response = input(prompt_message).strip().lower()
+        if response in ['yes', 'y']:
+            return True
+        elif response in ['no', 'n']:
+            return False
+        else:
+            print("Please respond with 'yes' or 'no'.")
+
+def prompt_user_for_payer_id(insurance_name):
+    """
+    Prompts the user to input the payer ID manually and ensures that a valid alphanumeric ID is provided.
+    
+    Parameters:
+    - insurance_name: Name of the insurance for context
+    
+    Returns:
+    - Valid alphanumeric payer ID
+    """
+    while True:
+        print("Manual intervention required: No payer ID found for insurance name '{}'.".format(insurance_name))
+        payer_id = input("Please enter the payer ID manually: ").strip()
+        
+        if payer_id.isalnum():
+            return payer_id
+        else:
+            print("Error: Payer ID must be alphanumeric. Please try again.")
+
+# =============================================================================
+# FILE/PATH UTILITIES
+# =============================================================================
+
+def format_claim_number(chart_number, date_of_service):
+    """
+    Formats claim number by combining chart number and date of service.
+    
+    Parameters:
+    - chart_number: Patient chart number
+    - date_of_service: Date of service
+    
+    Returns:
+    - Formatted claim number (alphanumeric only)
+    """
+    # Remove any non-alphanumeric characters from chart number and date
+    chart_number_alphanumeric = ''.join(filter(str.isalnum, chart_number))
+    date_of_service_alphanumeric = ''.join(filter(str.isalnum, date_of_service))
+    
+    # Combine the alphanumeric components without spaces
+    formatted_claim_number = chart_number_alphanumeric + date_of_service_alphanumeric
+    
+    return formatted_claim_number
+
+def winscp_validate_output_directory(output_directory):
+    """
+    Validates the output directory path to ensure it has no spaces.
+    If spaces are found, prompts the user to input a new path.
+    If the directory doesn't exist, creates it.
+    
+    Parameters:
+    - output_directory: Directory path to validate
+    
+    Returns:
+    - Validated directory path
+    """
+    while ' ' in output_directory:
+        print("\nWARNING: The output directory path contains spaces, which can cause issues with upload operations.")
+        print("    Current proposed path: {}".format(output_directory))
+        new_path = input("Please enter a new path for the output directory: ")
+        output_directory = new_path.strip()  # Remove leading/trailing spaces
+    
+    # Check if the directory exists, if not, create it
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+        print("INFO: Created output directory: {}".format(output_directory))
+    
+    return output_directory
+
+def get_output_directory(config):
+    """
+    Retrieves and validates output directory from configuration.
+    
+    Parameters:
+    - config: Configuration dictionary
+    
+    Returns:
+    - Valid output directory path or None if invalid
+    """
+    # Retrieve desired default output file path from config 
+    output_directory = config.get('outputFilePath', '').strip()
+    # BUG (Low SFTP) Add WinSCP validation because of the mishandling of spaces in paths. (This shouldn't need to exist.)
+    if not output_directory:
+        print("Output file path is not specified in the configuration.")
+        output_directory = input("Please enter a valid output directory path: ").strip()
+    
+    # Validate the directory path (checks for spaces and existence)
+    output_directory = winscp_validate_output_directory(output_directory)
+    
+    if not os.path.isdir(output_directory):
+        print("Output directory does not exist or is not accessible. Please check the configuration.")
+        return None
+    
+    return output_directory
+
+# =============================================================================
+# PROCESSING UTILITIES
+# =============================================================================
+
+def generate_segment_counts(compiled_segments, transaction_set_control_number):
+    """
+    Generates segment counts for the formatted 837P transaction and updates SE segment.
+    
+    Parameters:
+    - compiled_segments: String containing compiled 837P segments
+    - transaction_set_control_number: Transaction set control number
+    
+    Returns:
+    - Formatted 837P string with correct SE segment
+    """
+    # Count the number of segments, not including the placeholder SE segment
+    segment_count = compiled_segments.count('~')   # + 1 Including SE segment itself, but seems to be giving errors.
+    
+    # Ensure transaction set control number is correctly formatted as a string
+    formatted_control_number = str(transaction_set_control_number).zfill(4)  # Pad to ensure minimum 4 characters
+
+    # Construct the SE segment with the actual segment count and the formatted transaction set control_number
+    se_segment = "SE*{0}*{1}~".format(segment_count, formatted_control_number)
+
+    # Assuming the placeholder SE segment was the last segment added before compiling
+    # This time, we directly replace the placeholder with the correct SE segment
+    formatted_837p = compiled_segments.rsplit('SE**', 1)[0] + se_segment
+    
+    return formatted_837p
+
+# =============================================================================
+# VALIDATION UTILITIES
+# =============================================================================
+
+def handle_validation_errors(transaction_set_control_number, validation_errors, config):
+    """
+    Handles validation errors with user interaction for decision making.
+    
+    Parameters:
+    - transaction_set_control_number: Current transaction set control number
+    - validation_errors: List of validation errors
+    - config: Configuration for logging
+    
+    Returns:
+    - Boolean: True to skip patient, False to halt processing
+    """
+    for error in validation_errors:
+        MediLink_ConfigLoader.log("Validation error for transaction set {}: {}".format(transaction_set_control_number, error), config, level="WARNING")
+    
+    print("Validation errors encountered for transaction set {}. Errors: {}".format(transaction_set_control_number, validation_errors))
+    user_input = input("Skip this patient and continue without incrementing transaction set number? (yes/no): ")
+    if user_input.lower() == 'yes':
+        print("Skipping patient...")
+        MediLink_ConfigLoader.log("Skipped processing of transaction set {} due to user decision.".format(transaction_set_control_number), config, level="INFO")
+        return True  # Skip the current patient
+    else:
+        print("Processing halted due to validation errors.")
+        MediLink_ConfigLoader.log("HALT: Processing halted at transaction set {} due to unresolved validation errors.".format(transaction_set_control_number), config, level="ERROR")
+        sys.exit()  # Optionally halt further processing
+
+# =============================================================================
+# UTILITY FUNCTION REGISTRY
+# =============================================================================
+
+# Export all utility functions for easy importing
+__all__ = [
+    'convert_date_format',
+    'format_datetime', 
+    'get_user_confirmation',
+    'prompt_user_for_payer_id',
+    'format_claim_number',
+    'winscp_validate_output_directory', 
+    'get_output_directory',
+    'generate_segment_counts',
+    'handle_validation_errors'
+] 

MediLink/MediLink_DataMgmt.py

@@ -88,11 +88,16 @@ def read_fixed_width_data(file_path):
 # TODO (Refactor) Consider consolidating with the other read_fixed_with_data 
 def read_general_fixed_width_data(file_path, slices):
     # handle any fixed-width data based on provided slice definitions
-    with open(file_path, 'r', encoding='utf-8') as file:
-        next(file)  # Skip the header
-        for line_number, line in enumerate(file, start=1):
-            insurance_name = {key: line[start:end].strip() for key, (start, end) in slices.items()}
-            yield insurance_name, line_number
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            next(file)  # Skip the header
+            for line_number, line in enumerate(file, start=1):
+                insurance_name = {key: line[start:end].strip() for key, (start, end) in slices.items()}
+                yield insurance_name, line_number
+    except FileNotFoundError:
+        print("File not found: {}".format(file_path))
+        MediLink_ConfigLoader.log("File not found: {}".format(file_path), level="ERROR")
+        return
 
 def consolidate_csvs(source_directory, file_prefix="Consolidated", interactive=False):
     """

MediLink/MediLink_Deductible.py

@@ -229,14 +229,32 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             )
             print("\nValidation report generated: {}".format(validation_file_path))
             
-            # Log any Super Connector API errors
-            if super_connector_eligibility and "rawGraphQLResponse" in super_connector_eligibility:
-                raw_response = super_connector_eligibility.get('rawGraphQLResponse', {})
-                errors = raw_response.get('errors', [])
-                if errors:
-                    print("Super Connector API returned {} error(s):".format(len(errors)))
-                    for i, error in enumerate(errors):
-                        print("  Error {}: {} - {}".format(i+1, error.get('code', 'UNKNOWN'), error.get('description', 'No description')))
+                    # Log any Super Connector API errors
+        if super_connector_eligibility and "rawGraphQLResponse" in super_connector_eligibility:
+            raw_response = super_connector_eligibility.get('rawGraphQLResponse', {})
+            errors = raw_response.get('errors', [])
+            if errors:
+                print("Super Connector API returned {} error(s):".format(len(errors)))
+                for i, error in enumerate(errors):
+                    error_code = error.get('code', 'UNKNOWN')
+                    error_desc = error.get('description', 'No description')
+                    print("  Error {}: {} - {}".format(i+1, error_code, error_desc))
+                    
+                    # Check for data in error extensions (some APIs return data here)
+                    extensions = error.get('extensions', {})
+                    if extensions and 'details' in extensions:
+                        details = extensions.get('details', [])
+                        if details:
+                            print("    Found {} detail records in error extensions".format(len(details)))
+                            # Log first detail record for debugging
+                            if details:
+                                first_detail = details[0]
+                                print("    First detail: {}".format(first_detail))
+            
+            # Check status code
+            status_code = super_connector_eligibility.get('statuscode')
+            if status_code and status_code != '200':
+                print("Super Connector API status code: {} (non-200 indicates errors)".format(status_code))
             
             # Open validation report in Notepad
             os.system('notepad.exe "{}"'.format(validation_file_path))
@@ -291,6 +309,22 @@ def extract_super_connector_patient_info(eligibility_data):
                     'firstName': member_info.get("firstName", ""),
                     'middleName': member_info.get("middleName", "")
                 }
+        
+        # Check for data in error extensions (some APIs return data here despite errors)
+        errors = raw_response.get('errors', [])
+        for error in errors:
+            extensions = error.get('extensions', {})
+            if extensions and 'details' in extensions:
+                details = extensions.get('details', [])
+                if details:
+                    # Use the first detail record that has patient info
+                    for detail in details:
+                        if detail.get('lastName') or detail.get('firstName'):
+                            return {
+                                'lastName': detail.get("lastName", ""),
+                                'firstName': detail.get("firstName", ""),
+                                'middleName': detail.get("middleName", "")
+                            }
     
     # Fallback to top-level fields
     return {
@@ -446,6 +480,28 @@ def extract_super_connector_insurance_info(eligibility_data):
                     'memberId': insurance_info.get("memberId", ""),
                     'payerId': insurance_info.get("payerId", "")
                 }
+        
+        # Check for data in error extensions (some APIs return data here despite errors)
+        errors = raw_response.get('errors', [])
+        for error in errors:
+            extensions = error.get('extensions', {})
+            if extensions and 'details' in extensions:
+                details = extensions.get('details', [])
+                if details:
+                    # Use the first detail record that has insurance info
+                    for detail in details:
+                        if detail.get('memberId') or detail.get('payerId'):
+                            # Try to determine insurance type from available data
+                            insurance_type = detail.get('planType', '')
+                            if not insurance_type:
+                                insurance_type = detail.get('productType', '')
+                            
+                            return {
+                                'insuranceType': insurance_type,
+                                'insuranceTypeCode': detail.get("productServiceCode", ""),
+                                'memberId': detail.get("memberId", ""),
+                                'payerId': detail.get("payerId", "")
+                            }
     
     # Fallback to top-level fields
     insurance_type = eligibility_data.get("planTypeDescription", "")

MediLink/MediLink_Deductible_Validator.py

@@ -266,13 +266,57 @@ def check_data_quality_issues(super_connector_data):
         errors = raw_response.get('errors', [])
         if errors:
             for error in errors:
-                issues.append({
-                    "type": "API Error",
-                    "field": "rawGraphQLResponse.errors",
-                    "value": error.get('code', 'UNKNOWN'),
-                    "issue": "Super Connector API returned error: {}".format(error.get('description', 'No description')),
-                    "recommendation": "Review API implementation and error handling"
-                })
+                error_code = error.get('code', 'UNKNOWN')
+                error_desc = error.get('description', 'No description')
+                
+                # Check if this is an informational error with data
+                if error_code == 'INFORMATIONAL':
+                    extensions = error.get('extensions', {})
+                    if extensions and 'details' in extensions:
+                        details = extensions.get('details', [])
+                        if details:
+                            issues.append({
+                                "type": "Informational Error with Data",
+                                "field": "rawGraphQLResponse.errors",
+                                "value": error_code,
+                                "issue": "API returned informational error but provided data in extensions: {}".format(error_desc),
+                                "recommendation": "Data available in error extensions - system will attempt to extract"
+                            })
+                        else:
+                            issues.append({
+                                "type": "API Error",
+                                "field": "rawGraphQLResponse.errors",
+                                "value": error_code,
+                                "issue": "Super Connector API returned error: {}".format(error_desc),
+                                "recommendation": "Review API implementation and error handling"
+                            })
+                    else:
+                        issues.append({
+                            "type": "API Error",
+                            "field": "rawGraphQLResponse.errors",
+                            "value": error_code,
+                            "issue": "Super Connector API returned error: {}".format(error_desc),
+                            "recommendation": "Review API implementation and error handling"
+                        })
+                else:
+                    issues.append({
+                        "type": "API Error",
+                        "field": "rawGraphQLResponse.errors",
+                        "value": error_code,
+                        "issue": "Super Connector API returned error: {}".format(error_desc),
+                        "recommendation": "Review API implementation and error handling"
+                    })
+        
+        # Check status code
+        status_code = super_connector_data.get('statuscode')
+        if status_code and status_code != '200':
+            issues.append({
+                "type": "Non-200 Status Code",
+                "field": "statuscode",
+                "value": status_code,
+                "issue": "API returned status code {} instead of 200".format(status_code),
+                "recommendation": "Check API health and error handling"
+            })
     
     # Check for multiple eligibility records (this is actually good, but worth noting)
     if "rawGraphQLResponse" in super_connector_data:

{medicafe-0.250720.0.dist-info → medicafe-0.250722.0.dist-info}/METADATA

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

{medicafe-0.250720.0.dist-info → medicafe-0.250722.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-MediBot/MediBot.bat,sha256=9df6kV6qnmnqP59G6OdT5osqnyfIGeQYbVJgfsfiPxM,13260
+MediBot/MediBot.bat,sha256=anz5i-Td1k3HhRUvkCqHsw9lBLVmO6q9bt5kLTfr1Iw,13282
 MediBot/MediBot.py,sha256=KNR3Pj46W9dQaE3OH3fFAHoa6P-hS8pjJ9xB5STEqOU,19513
 MediBot/MediBot_Charges.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Crosswalk_Library.py,sha256=eYFcP6KjnzOfZbAYhs6Umv4sKguRJAQkKgYQQynJ50M,49025
 MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediBot/MediBot_Preprocessor.py,sha256=uPGj0OwlHi0CByvNy9gKnfwfK7Y6lzQ7sLchwJw3l7g,13010
-MediBot/MediBot_Preprocessor_lib.py,sha256=XdDkBTmjsSlOfnuc3iBYKudQRhGo3DEL_zboYGqovnQ,37697
+MediBot/MediBot_Preprocessor.py,sha256=Lc9uQnE5SAa0dQTOREdPV1QUB2cywXTHJ1h2w-fyeeQ,13331
+MediBot/MediBot_Preprocessor_lib.py,sha256=UszeR1YKi7jKrEQ4Fdn5ORmhoCrOqCStn05AG9M-SXg,39400
 MediBot/MediBot_UI.py,sha256=tdTXLQ_nUVbtpkxUGSuKbEgYv6CFk6EsmEMAVMLL4_A,11165
 MediBot/MediBot_dataformat_library.py,sha256=JXTV-HWahqeYF_lbNn1UYxqUtZ6ZBeFXHOyRGlDq4xM,8406
 MediBot/MediBot_docx_decoder.py,sha256=z-_oVrSocu4-CenDGDHOkDeqPcKqZqm6Ao9mABgqxJU,23561
@@ -15,9 +15,10 @@ MediBot/update_json.py,sha256=9FJZb-32EujpKuSoCjyCbdTdthOIuhcMoN4Wchuzn8A,2508
 MediBot/update_medicafe.py,sha256=rx1zUvCI99JRdr8c1csMGI2uJBl3pqusvX-xr3KhmR4,11881
 MediLink/MediLink.py,sha256=O3VSLm2s5viCRBL1is7Loj_nSaLMMcFZ-weXAmVp_20,21588
 MediLink/MediLink_277_decoder.py,sha256=Z3hQK2j-YzdXjov6aDlDRc7M_auFBnl3se4OF5q6_04,4358
-MediLink/MediLink_837p_cob_library.py,sha256=rpeEmTdmpIGZRP42INTaVBaswQH9O9jTdFe6NCvOdyc,30865
-MediLink/MediLink_837p_encoder.py,sha256=OiYU2cyr9rFBGv7XOwYuZjCKWbUNb9vN2TcX6vvUZWM,27242
-MediLink/MediLink_837p_encoder_library.py,sha256=GE-gqszSRFWwtSCVJQ3OZCooIZKhCA1qNojQgG7ii8c,52675
+MediLink/MediLink_837p_cob_library.py,sha256=pWWd03yXTamNJKDbPCdOCkfglW4OLXQtIN3eiMSdfAA,29934
+MediLink/MediLink_837p_encoder.py,sha256=ODdDl_hBDYCf3f683qB3I51FGCKxrMeKL3gfT0wNAFM,28073
+MediLink/MediLink_837p_encoder_library.py,sha256=y4cTt8G2yQbMm8oEmccJJTb0yOTeUj8CrcfI1IpOLxY,48688
+MediLink/MediLink_837p_utilities.py,sha256=Bi91S1aJbsEOpWXp_IOUgCQ76IPiOJNkOfXXtcirzmI,10416
 MediLink/MediLink_API_Generator.py,sha256=vBZ8moR9tvv7mb200HlZnJrk1y-bQi8E16I2r41vgVM,10345
 MediLink/MediLink_API_v2.py,sha256=mcIgLnXPS_NaUBrkKJ8mxCUaQ0AuQUeU1vG6DoplbVY,7733
 MediLink/MediLink_API_v3.py,sha256=D17yXicLRvHfEsx5c-VUNZlke5oSnclQu6cKJACzeHA,40745
@@ -25,10 +26,10 @@ MediLink/MediLink_APIs.py,sha256=jm3f9T034MJKH8A_CIootULoeuk7H8s7PazpFZRCbKI,622
 MediLink/MediLink_Azure.py,sha256=Ow70jctiHFIylskBExN7WUoRgrKOvBR6jNTnQMk6lJA,210
 MediLink/MediLink_ClaimStatus.py,sha256=DkUL5AhmuaHsdKiQG1btciJIuexl0OLXBEH40j1KFTg,9927
 MediLink/MediLink_ConfigLoader.py,sha256=u9ecB0SIN7zuJAo8KcoQys95BtyAo-8S2n4mRd0S3XU,4356
-MediLink/MediLink_DataMgmt.py,sha256=jrTAPSNVzs1wwYl1g0_8Mda3k2B27CbaSw8Pu2qmThw,33058
+MediLink/MediLink_DataMgmt.py,sha256=MjCF1L-4RkQnz_vBULPB-DVsEtv0X1WHT1o9YjCGQ7s,33280
 MediLink/MediLink_Decoder.py,sha256=Suw9CmUHgoe0ZW8sJP_pIO8URBrhO5FmxFF8RcUj9lI,13318
-MediLink/MediLink_Deductible.py,sha256=I7cqnubXakPZPGXU9ZA6uJnayFzZt8wjAdfbBg4Mt0I,33559
-MediLink/MediLink_Deductible_Validator.py,sha256=7uVAh4YZ8YvpKRolMbassh4kwX3nL-a0rX_comdfGyI,20427
+MediLink/MediLink_Deductible.py,sha256=nD9dwStQY34FYmnuqg361UgFX8vLpZk88Im0LZJ45IQ,36732
+MediLink/MediLink_Deductible_Validator.py,sha256=2g-lZd-Y5fJ1mfP87vM6oABg0t5Om-7EkEkilVvDWYY,22888
 MediLink/MediLink_Down.py,sha256=hrDODhs-zRfOKCdiRGENN5Czu-AvdtwJj4Q7grcRXME,6518
 MediLink/MediLink_ERA_decoder.py,sha256=MiOtDcXnmevPfHAahIlTLlUc14VcQWAor9Xa7clA2Ts,8710
 MediLink/MediLink_Gmail.py,sha256=OYsASNgP4YSTaSnj9XZxPPiy0cw41JC-suLIgRyNrlQ,31439
@@ -48,8 +49,8 @@ MediLink/test.py,sha256=kSvvJRL_3fWuNS3_x4hToOnUljGLoeEw6SUTHQWQRJk,3108
 MediLink/test_cob_library.py,sha256=wUMv0-Y6fNsKcAs8Z9LwfmEBRO7oBzBAfWmmzwoNd1g,13841
 MediLink/test_validation.py,sha256=FJrfdUFK--xRScIzrHCg1JeGdm0uJEoRnq6CgkP2lwM,4154
 MediLink/webapp.html,sha256=JPKT559aFVBi1r42Hz7C77Jj0teZZRumPhBev8eSOLk,19806
-medicafe-0.250720.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250720.0.dist-info/METADATA,sha256=NFhsecNELOCIQ6c6Mtx4MsuLCQCXv5P2bjBA3leBCF0,5501
-medicafe-0.250720.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250720.0.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
-medicafe-0.250720.0.dist-info/RECORD,,
+medicafe-0.250722.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250722.0.dist-info/METADATA,sha256=FnSb5W8xyvEFPh047lU6jEWr650em4_eFgOMsD-L97E,5501
+medicafe-0.250722.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250722.0.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
+medicafe-0.250722.0.dist-info/RECORD,,