medicafe 0.250720.0__tar.gz → 0.250722.0__tar.gz

{medicafe-0.250720.0 → medicafe-0.250722.0}/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...

{medicafe-0.250720.0 → medicafe-0.250722.0}/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)

{medicafe-0.250720.0 → medicafe-0.250722.0}/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)

{medicafe-0.250720.0 → medicafe-0.250722.0}/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

{medicafe-0.250720.0 → medicafe-0.250722.0}/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

{medicafe-0.250720.0 → medicafe-0.250722.0}/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