medicafe 0.240809.0__py3-none-any.whl → 0.240925.9__py3-none-any.whl

MediBot/update_json.py

@@ -1,7 +1,25 @@
+# update_json.py
 import json
 import sys
 from collections import OrderedDict
 
+def get_current_csv_path(json_file):
+    try:
+        with open(json_file, 'r', encoding='utf-8') as file:
+            try:
+                data = json.load(file, object_pairs_hook=OrderedDict)
+                return data.get('CSV_FILE_PATH', None)
+            except ValueError as decode_err:
+                print("Error decoding JSON file '{}': {}".format(json_file, decode_err))
+                sys.exit(1)
+    except IOError as io_err:
+        print("Error accessing file '{}': {}".format(json_file, io_err))
+        sys.exit(1)
+    except Exception as e:
+        print("An unexpected error occurred: {}".format(e))
+        sys.exit(1)
+    return None
+
 def update_csv_path(json_file, new_path):
     try:
         with open(json_file, 'r', encoding='utf-8') as file:
@@ -38,6 +56,13 @@ if __name__ == "__main__":
         json_path = sys.argv[1]
         new_csv_path = sys.argv[2]
         update_csv_path(json_path, new_csv_path)
+    elif len(sys.argv) == 2:
+        json_path = sys.argv[1]
+        current_csv_path = get_current_csv_path(json_path)
+        if current_csv_path:
+            print(current_csv_path)
+        else:
+            print("No CSV path found in config.")
     else:
-        print("Usage: update_json.py <path_to_json_file> <new_csv_path>")
+        print("Usage: update_json.py <path_to_json_file> [<new_csv_path>]")
         sys.exit(1)

MediBot/update_medicafe.py

@@ -1,8 +1,57 @@
-import subprocess
-import sys
-from tqdm import tqdm
-import requests
-import time
+#update_medicafe.py
+import subprocess, sys, requests, time
+
+def get_installed_version(package):
+    try:
+        process = subprocess.Popen(
+            [sys.executable, '-m', 'pip', 'show', package],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        stdout, stderr = process.communicate()
+        if process.returncode == 0:
+            for line in stdout.decode().splitlines():
+                if line.startswith("Version:"):
+                    return line.split(":", 1)[1].strip()
+        return None
+    except Exception as e:
+        print("Error retrieving installed version: {}".format(e))
+        return None
+
+def get_latest_version(package, retries=3, delay=1):
+    """
+    Fetch the latest version of the specified package from PyPI with retries.
+    """
+    for attempt in range(1, retries + 1):
+        try:
+            response = requests.get("https://pypi.org/pypi/{}/json".format(package), timeout=10)
+            response.raise_for_status()  # Raise an error for bad responses
+            data = response.json()
+            latest_version = data['info']['version']
+            
+            # Print the version with attempt information
+            if attempt == 1:
+                print("Latest available version: {}".format(latest_version))
+            else:
+                print("Latest available version: {} ({} attempt)".format(latest_version, attempt))
+            
+            # Check if the latest version is different from the current version
+            current_version = get_installed_version(package)
+            if current_version and compare_versions(latest_version, current_version) == 0:
+                # If the versions are the same, perform a second request
+                time.sleep(delay)
+                response = requests.get("https://pypi.org/pypi/{}/json".format(package), timeout=10)
+                response.raise_for_status()
+                data = response.json()
+                latest_version = data['info']['version']
+            
+            return latest_version  # Return the version after the check
+        except requests.RequestException as e:
+            print("Attempt {}: Error fetching latest version: {}".format(attempt, e))
+            if attempt < retries:
+                print("Retrying in {} seconds...".format(delay))
+                time.sleep(delay)
+    return None
 
 def check_internet_connection():
     try:
@@ -11,47 +60,88 @@ def check_internet_connection():
     except requests.ConnectionError:
         return False
 
-def upgrade_medicafe(package):
-    try:
-        # Check internet connection
-        if not check_internet_connection():
-            print("Error: No internet connection detected. Please check your internet connection and try again.")
-            sys.exit(1)
+def compare_versions(version1, version2):
+    v1_parts = list(map(int, version1.split(".")))
+    v2_parts = list(map(int, version2.split(".")))
+    return (v1_parts > v2_parts) - (v1_parts < v2_parts)
+
+def upgrade_package(package, retries=3, delay=2):  # Updated retries to 3
+    """
+    Attempts to upgrade the package multiple times with delays in between.
+    """
+    if not check_internet_connection():
+        print("Error: No internet connection detected. Please check your internet connection and try again.")
+        sys.exit(1)
+    
+    for attempt in range(1, retries + 1):
+        print("Attempt {} to upgrade {}...".format(attempt, package))
+        process = subprocess.Popen(
+            [
+                sys.executable, '-m', 'pip', 'install', '--upgrade',
+                package, '--no-cache-dir', '--disable-pip-version-check', '-q'
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
         
-        total_progress = 200  # Total progress for two runs
+        stdout, stderr = process.communicate()
         
-        with tqdm(total=total_progress, desc="Upgrading %s" % package, unit="%") as progress_bar:
-            stdout_accumulator = b""
-            stderr_accumulator = b""
-            
-            for _ in range(2):  # Run pip install twice
-                process = subprocess.Popen([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-cache-dir', '--disable-pip-version-check', '--no-deps'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = process.communicate()
-                stdout_accumulator += stdout
-                stderr_accumulator += stderr
-                
-                if process.returncode != 0:
-                    # If the return code is non-zero, print error details
-                    print("Error: Upgrade failed. Details:")
-                    print("stdout:", stdout)
-                    print("stderr:", stderr)
-                    sys.exit(1)
-                
-                progress_bar.update(total_progress // 2)  # Update progress bar
-                
-                # Add a 3-second sleep between runs
-                time.sleep(3)
-                
-            progress_bar.update(total_progress // 2)  # Update progress bar
-            print("stdout:", stdout_accumulator.decode("utf-8"))
-            print("stderr:", stderr_accumulator.decode("utf-8"))
-            time.sleep(1)
-    except Exception as e:
-        # Log any other exceptions
-        print("Error:", e)
-        time.sleep(3)
+        if process.returncode == 0:
+            print(stdout.decode().strip())
+            new_version = get_installed_version(package)  # Get new version after upgrade
+            if compare_versions(new_version, get_latest_version(package)) >= 0:  # Compare versions
+                if attempt == 1:
+                    print("Upgrade succeeded!")
+                else:
+                    print("Attempt {}: Upgrade succeeded!".format(attempt))
+                time.sleep(delay)
+                return True
+            else:
+                print("Upgrade failed. Current version remains: {}".format(new_version))
+                if attempt < retries:
+                    print("Retrying in {} seconds...".format(delay))
+                    time.sleep(delay)
+        else:
+            print(stderr.decode().strip())
+            print("Attempt {}: Upgrade failed.".format(attempt))
+            if attempt < retries:
+                print("Retrying in {} seconds...".format(delay))
+                time.sleep(delay)
+    
+    print("Error: All upgrade attempts failed.")
+    return False
+
+def main():
+    package = "medicafe"
+    
+    current_version = get_installed_version(package)
+    if not current_version:
+        print("{} is not installed.".format(package))
         sys.exit(1)
+    
+    latest_version = get_latest_version(package)
+    if not latest_version:
+        print("Could not retrieve the latest version information.")
+        sys.exit(1)
+    
+    print("Current version of {}: {}".format(package, current_version))
+    print("Latest version of {}: {}".format(package, latest_version))
+    
+    if compare_versions(latest_version, current_version) > 0:
+        print("A newer version is available. Proceeding with upgrade.")
+        if upgrade_package(package):
+            # Verify upgrade
+            time.sleep(3)
+            new_version = get_installed_version(package)
+            if compare_versions(new_version, latest_version) >= 0:
+                print("Upgrade successful. New version: {}".format(new_version))
+            else:
+                print("Upgrade failed. Current version remains: {}".format(new_version))
+                sys.exit(1)
+        else:
+            sys.exit(1)
+    else:
+        print("You already have the latest version installed.")
 
 if __name__ == "__main__":
-    medicafe_package = "medicafe"
-    upgrade_medicafe(medicafe_package)
+    main()

MediLink/MediLink.py

@@ -1,22 +1,21 @@
-import os
+# MediLink.py
+import os, sys
 import MediLink_Down
 import MediLink_Up
 import MediLink_ConfigLoader
 import MediLink_DataMgmt
 
 # For UI Functions
-import os
 import MediLink_UI  # Import UI module for handling all user interfaces
 from tqdm import tqdm
 
 # Add parent directory of the project to the Python path
-import sys
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-sys.path.append(project_dir)
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
 
 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
 
 # Retrieve insurance options with codes and descriptions
 config, _ = MediLink_ConfigLoader.load_configuration()
@@ -135,46 +134,86 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     # Return only the enriched detailed patient data, eliminating the need for a separate summary list
     return detailed_patient_data
 
-def check_for_new_remittances(config):
+def check_for_new_remittances(config=None):
+    """
+    Function to check for new remittance files across all configured endpoints.
+    Loads the configuration, validates it, and processes each endpoint to download and handle files.
+    Accumulates results from all endpoints and processes them together at the end.
+    """
+    # Start the process and log the initiation
+    MediLink_ConfigLoader.log("Starting check_for_new_remittances function")
     print("\nChecking for new files across all endpoints...")
-    endpoints = config['MediLink_Config']['endpoints']
-    processed_endpoints = []
-    
-    if isinstance(endpoints, dict): # BUG This check can probably be removed later.
-        for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
-            if 'remote_directory_down' in endpoint_info:  # Check if the 'remote_directory_down' key exists
-                #print("Processing endpoint: ", endpoint_info['name']) 
-                # BUG (Debug and verbosity removal) this is really for debug only. Positive statements can be muted.
-                try:
-                    ERA_path = MediLink_Down.main(desired_endpoint=endpoint_key)
-                    processed_endpoints.append((endpoint_info['name'], ERA_path))
-                    MediLink_ConfigLoader.log("Results for {} saved to: {}".format(endpoint_info['name'], ERA_path), level="DEBUG")
-                    # TODO (Low SFTP - Download side) This needs to check to see if this actually worked maybe winscplog before saying it completed successfully 
-                    # Check if there is commonality with the upload side so we can use the same validation function.
-                except Exception as e:
-                    print("An error occurred while checking remittances for {}: {}".format(endpoint_info['name'], e))
-            else:
-                MediLink_ConfigLoader.log("Skipping endpoint '{}' as it does not have 'remote_directory_down' configured.".format(endpoint_info['name']), level="WARNING")
+    MediLink_ConfigLoader.log("Checking for new files across all endpoints...")
+
+    # Step 1: Load and validate the configuration
+    if config is None:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+
+    if not config or 'MediLink_Config' not in config or 'endpoints' not in config['MediLink_Config']:
+        MediLink_ConfigLoader.log("Error: Config is missing necessary sections. Aborting...", level="ERROR")
+        return
+
+    endpoints = config['MediLink_Config'].get('endpoints')
+    if not isinstance(endpoints, dict):
+        MediLink_ConfigLoader.log("Error: 'endpoints' is not a dictionary. Aborting...", level="ERROR")
+        return
+
+    # Lists to accumulate all consolidated records and translated files across all endpoints
+    all_consolidated_records = []
+    all_translated_files = []
+
+    # Step 2: Process each endpoint and accumulate results
+    for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
+        # Validate endpoint structure
+        if not endpoint_info or not isinstance(endpoint_info, dict):
+            MediLink_ConfigLoader.log("Error: Invalid endpoint structure for {}. Skipping...".format(endpoint_key), level="ERROR")
+            continue
+
+        if 'remote_directory_down' in endpoint_info:
+            # Process the endpoint and handle the files
+            MediLink_ConfigLoader.log("Processing endpoint: {}".format(endpoint_key))
+            consolidated_records, translated_files = process_endpoint(endpoint_key, endpoint_info, config)
+            
+            # Accumulate the results for later processing
+            if consolidated_records:
+                all_consolidated_records.extend(consolidated_records)
+            if translated_files:
+                all_translated_files.extend(translated_files)
+        else:
+            MediLink_ConfigLoader.log("Skipping endpoint '{}'. 'remote_directory_down' not configured.".format(endpoint_info.get('name', 'Unknown')), level="WARNING")
+
+    # Step 3: After processing all endpoints, handle the accumulated results
+    if all_consolidated_records:
+        MediLink_Down.display_consolidated_records(all_consolidated_records)  # Ensure this is called only once
+        MediLink_Down.prompt_csv_export(all_consolidated_records, config['MediLink_Config']['local_storage_path'])
     else:
-        print("Error: Endpoint config is not a 'dictionary' as expected.")
-    # Check if all ERA paths are the same
-    unique_era_paths = set(path for _, path in processed_endpoints)
-    if len(unique_era_paths) == 1:
-        common_era_path = unique_era_paths.pop()  # Get the common ERA path
-        endpoints_list = ", ".join(endpoint for endpoint, _ in processed_endpoints)
-        print("\nProcessed Endpoints: {}".format(endpoints_list))
-        print("File located at: {}\n".format(common_era_path))
-        # TODO (MediPost) These prints will eventually be logs when MediPost is made.
+        MediLink_ConfigLoader.log("No records to display after processing all endpoints.", level="WARNING")
+        print("No records to display after processing all endpoints.")
+
+def process_endpoint(endpoint_key, endpoint_info, config):
+    """
+    Helper function to process a single endpoint.
+    Downloads files from the endpoint, processes them, and returns the consolidated records and translated files.
+    """
+    try:
+        # Process the files for the given endpoint
+        local_storage_path = config['MediLink_Config']['local_storage_path']
+        MediLink_ConfigLoader.log("[Process Endpoint] Local storage path set to {}".format(local_storage_path))
+        downloaded_files = MediLink_Down.operate_winscp("download", None, endpoint_info, local_storage_path, config)
         
-    else:
-        if processed_endpoints:
-            print("\nProcessed Endpoints:")
-            for endpoint, path in processed_endpoints:
-                print("Endpoint: {}, ERA Path: {}".format(endpoint, path))
+        if downloaded_files:
+            MediLink_ConfigLoader.log("[Process Endpoint] WinSCP Downloaded the following files: \n{}".format(downloaded_files))
+            return MediLink_Down.handle_files(local_storage_path, downloaded_files)
         else:
-            print("No endpoints were processed.")
+            MediLink_ConfigLoader.log("[Process Endpoint]No files were downloaded for endpoint: {}.".format(endpoint_key), level="WARNING")
+            return [], []
+
+    except Exception as e:
+        # Handle any exceptions that occur during the processing
+        MediLink_ConfigLoader.log("Error processing endpoint {}: {}".format(endpoint_key, e), level="ERROR")
+        return [], []
 
-def user_decision_on_suggestions(detailed_patient_data, config):
+def user_decision_on_suggestions(detailed_patient_data, config, insurance_edited):
     """
     Presents the user with all patient summaries and suggested endpoints,
     then asks for confirmation to proceed with all or specify adjustments manually.
@@ -183,11 +222,11 @@ def user_decision_on_suggestions(detailed_patient_data, config):
     although the user decision is persisting. Possibly consider making the current/suggested/confirmed endpoint 
     part of a class that the user can interact with via these menus? Probably better handling that way.
     """
-    # Display summaries of patient details and endpoints.
-    MediLink_UI.display_patient_summaries(detailed_patient_data)
+    if insurance_edited:
+        # Display summaries only if insurance types were edited
+        MediLink_UI.display_patient_summaries(detailed_patient_data)
 
-    # Ask the user if they want to proceed with all suggested endpoints.
-    proceed = MediLink_UI.ask_for_proceeding_with_endpoints()
+    proceed = input("Do you want to proceed with all suggested endpoints? (Y/N): ").strip().lower() == 'y'
 
     # If the user agrees to proceed with all suggested endpoints, confirm them.
     if proceed:
@@ -244,7 +283,9 @@ def main_menu():
     config, crosswalk = MediLink_ConfigLoader.load_configuration() 
     
     # Check to make sure payer_id key is available in crosswalk, otherwise, go through that crosswalk initialization flow
-    MediBot_Crosswalk_Library.check_and_initialize_crosswalk(config)
+    if 'payer_id' not in crosswalk:
+        print("Crosswalk 'payer_id' not found. Please run MediBot_Preprocessor.py with the --update-crosswalk argument.")
+        exit() # BUG Halting the script execution here for now, should be handled in the preprocessor script.
     
     # Check if the application is in test mode
     if config.get("MediLink_Config", {}).get("TestMode", False):
@@ -287,7 +328,7 @@ def main_menu():
             detailed_patient_data = collect_detailed_patient_data(selected_files, config, crosswalk)
             
             # Process the claims submission.
-            handle_submission(detailed_patient_data, config)
+            handle_submission(detailed_patient_data, config, crosswalk)
         elif choice == '3' or (choice == '2' and not all_files):
             # Exit the program if the user chooses to exit or if no files are present.
             MediLink_UI.display_exit_message()
@@ -296,16 +337,17 @@ def main_menu():
             # Display an error message if the user's choice does not match any valid option.
             MediLink_UI.display_invalid_choice()
 
-def handle_submission(detailed_patient_data, config):
+def handle_submission(detailed_patient_data, config, crosswalk):
     """
     Handles the submission process for claims based on detailed patient data.
     This function orchestrates the flow from user decision on endpoint suggestions to the actual submission of claims.
     """
-    # TODO If we get here via a user decline we end up not displaying the patient summary data, but this doesn't happen in the first round. Can be de-tangled later.
-    
+    insurance_edited = False  # Flag to track if insurance types were edited
+
     # Ask the user if they want to edit insurance types
     edit_insurance = input("Do you want to edit insurance types? (y/n): ").strip().lower()
     if edit_insurance in ['y', 'yes', '']:
+        insurance_edited = True  # User chose to edit insurance types
         while True:
             # Bulk edit insurance types
             MediLink_DataMgmt.bulk_edit_insurance_types(detailed_patient_data, insurance_options)
@@ -317,7 +359,7 @@ def handle_submission(detailed_patient_data, config):
                 print("Returning to bulk edit insurance types.")
     
     # Initiate user interaction to confirm or adjust suggested endpoints.
-    adjusted_data = user_decision_on_suggestions(detailed_patient_data, config)
+    adjusted_data = user_decision_on_suggestions(detailed_patient_data, config, insurance_edited)
     
     # Confirm all remaining suggested endpoints.
     confirmed_data = MediLink_DataMgmt.confirm_all_suggested_endpoints(adjusted_data)
@@ -328,7 +370,7 @@ def handle_submission(detailed_patient_data, config):
         if MediLink_Up.confirm_transmission(organized_data):
             if MediLink_Up.check_internet_connection():
                 # Submit claims if internet connectivity is confirmed.
-                _ = MediLink_Up.submit_claims(organized_data, config)
+                _ = MediLink_Up.submit_claims(organized_data, config, crosswalk)
                 # TODO submit_claims will have a receipt return in the future.
             else:
                 # Notify the user of an internet connection error.

MediLink/MediLink_837p_encoder.py

@@ -1,13 +1,12 @@
-import re
+# MediLink_837p_encoder.py
+import re, argparse, os
 from datetime import datetime
-import argparse
-import os
 import MediLink_ConfigLoader
 from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
 import MediLink_837p_encoder_library
 #from tqdm import tqdm
 
-def format_single_claim(patient_data, config, endpoint, transaction_set_control_number):
+def format_single_claim(patient_data, config, endpoint, transaction_set_control_number, crosswalk, client):
     """
     Formats a single claim into 837P segments based on the provided patient data and endpoint.
     
@@ -21,7 +20,7 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     - String representation of the formatted 837P claim.
     """
     # Pre-resolve and enrich with Payer Name and ID for special case handling like Florida Blue.
-    patient_data = MediLink_837p_encoder_library.payer_id_to_payer_name(patient_data, config, endpoint)
+    patient_data = MediLink_837p_encoder_library.payer_id_to_payer_name(patient_data, config, endpoint, crosswalk, client)
     
     segments = []
         
@@ -63,7 +62,7 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     segments.extend(MediLink_837p_encoder_library.create_nm1_rendering_provider_segment(config))
     
     # Claim information 2300, 2310C Service Facility and 2400 loop segments
-    segments.extend(MediLink_837p_encoder_library.create_clm_and_related_segments(patient_data, config))
+    segments.extend(MediLink_837p_encoder_library.create_clm_and_related_segments(patient_data, config, crosswalk))
 
     # Placeholder for the SE segment to be updated with actual segment count later
     segments.append("SE**{transaction_set_control_number:04d}~")
@@ -124,7 +123,7 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
         MediLink_ConfigLoader.log("Error: Failed to write output file. {}".format(e), config, level="ERROR")
         return None
 
-def process_file(file_path, config, endpoint_key, transaction_set_control_number):
+def process_single_file(file_path, config, endpoint_key, transaction_set_control_number, crosswalk): # BUG Duplicate function name??
     """
     Process the claim data from a file into the 837P format.
 
@@ -145,7 +144,7 @@ def process_file(file_path, config, endpoint_key, transaction_set_control_number
             return None, transaction_set_control_number  # Halt processing if the user chooses
 
     # Process each valid claim
-    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number)
+    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number, crosswalk)
 
     formatted_claims_str = '\n'.join(formatted_claims)  # Join formatted claims into a single string
     return formatted_claims_str, transaction_set_control_number
@@ -179,7 +178,7 @@ def read_and_validate_claims(file_path, config):
 
     return valid_claims, validation_errors
 
-def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number):
+def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number, crosswalk):
     """
     Formats a list of parsed claim data into 837P segments.
 
@@ -196,7 +195,7 @@ def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_c
     transaction_set_control_number = starting_transaction_set_control_number
 
     for parsed_data in parsed_data_list:
-        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number)
+        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number, crosswalk)
         formatted_claims.append(formatted_claim)
         transaction_set_control_number += 1  # Increment for each successfully processed claim
 
@@ -274,7 +273,7 @@ def validate_claim_data(parsed_data, config, required_fields=[]):
 
     return True, []
 
-def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
+def process_and_write_file(file_path, config, endpoint, crosswalk, starting_tscn=1):
     """        
     Process a single file, create complete 837P document with headers and trailers, and write to output file.
 
@@ -286,7 +285,7 @@ def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
     """
     print("Processing: {}".format(file_path))
     MediLink_ConfigLoader.log("Processing: {}".format(file_path))
-    formatted_data, transaction_set_control_number = process_file(file_path, config, endpoint, starting_tscn)
+    formatted_data, transaction_set_control_number = process_single_file(file_path, config, endpoint, starting_tscn, crosswalk)
     isa_header, gs_header, ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
     
     # Combine everything into a single document
@@ -303,6 +302,7 @@ def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
     print("File processed. Output saved to: {}".format(output_file_path))
 
 def main():
+    # BUG (MAJOR) THIS NEEDS THE API CLIENT TO BE PASSED INTO THE FUNCTION FOR SINGLE FILE PROCESSING.
     """
     Converts fixed-width files to 837P format for health claim submissions.
 
@@ -329,7 +329,7 @@ def main():
     parser.add_argument(
         "-e", "--endpoint", 
         required=True,
-        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA", "UHCAPI"],
+        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA", "UHCAPI", "CLAIMSHUTTLE"], # This should read from the config?
         help="Specify the endpoint for which the conversion is intended."
     )
     parser.add_argument(
@@ -346,13 +346,13 @@ def main():
 
     print("Starting the conversion process for {}. Processing {} at '{}'.".format(args.endpoint, 'directory' if args.is_directory else 'file', args.path))
 
-    config, _ = MediLink_ConfigLoader.load_configuration()
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
     config = config.get('MediLink_Config', config)
     
-    process_files(args.path, config, args.endpoint, args.is_directory)
+    process_dat_files(args.path, config, args.endpoint, args.is_directory, crosswalk)
     print("Conversion complete.")
 
-def process_files(path, config, endpoint, is_directory):
+def process_dat_files(path, config, endpoint, is_directory, crosswalk):
     """
     Processes either a single file or all files within a directory.
 
@@ -370,10 +370,10 @@ def process_files(path, config, endpoint, is_directory):
         for file_name in os.listdir(path):
             if file_name.endswith(".DAT"):
                 file_path = os.path.join(path, file_name)
-                process_and_write_file(file_path, config, endpoint)
+                process_and_write_file(file_path, config, endpoint, crosswalk)
     else:
         MediLink_ConfigLoader.log("Processing the single file: {}".format(path))
-        process_and_write_file(path, config, endpoint)
+        process_and_write_file(path, config, endpoint, crosswalk)
 
 if __name__ == "__main__":
     main()
@@ -381,7 +381,7 @@ if __name__ == "__main__":
 # The functions below are the ones that are used as non-main library by outside scripts.
 #######################################################################################
 
-def convert_files_for_submission(detailed_patient_data, config):
+def convert_files_for_submission(detailed_patient_data, config, crosswalk, client): 
     """
     Processes detailed patient data for submission based on their confirmed endpoints,
     generating separate 837P files for each endpoint according to the configured submission type.
@@ -424,18 +424,18 @@ def convert_files_for_submission(detailed_patient_data, config):
                 chart_number = patient_data.get('CHART', 'UNKNOWN')#[:5] truncation might cause collisions.
                 suffix = "_{}".format(chart_number)
                 # Process and convert each patient's data to a separate file
-                converted_path = process_claim(config, endpoint, [patient_data], suffix)
+                converted_path = process_claim(config, endpoint, [patient_data], crosswalk, client, suffix)
                 if converted_path:
                     converted_files_paths.append(converted_path)
         else:
             # Process all patient data together for batch submissions
-            converted_path = process_claim(config, endpoint, patient_data_list)
+            converted_path = process_claim(config, endpoint, patient_data_list, crosswalk, client)
             if converted_path:
                 converted_files_paths.append(converted_path)
 
     return converted_files_paths
 
-def process_claim(config, endpoint, patient_data_list, suffix=""):
+def process_claim(config, endpoint, patient_data_list, crosswalk, client, suffix=""): 
     """
     Processes patient data for a specified endpoint, converting it into the 837P format.
     Can handle both batch and single-patient submissions.
@@ -465,7 +465,7 @@ def process_claim(config, endpoint, patient_data_list, suffix=""):
         is_valid, validation_errors = validate_claim_data(patient_data, config)
         if is_valid:
             # Format the claim into 837P segments
-            formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number)
+            formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number, crosswalk, client)
             document_segments.append(formatted_claim)
             transaction_set_control_number += 1
         else: