medicafe 0.240517.0__py3-none-any.whl → 0.240716.2__py3-none-any.whl

MediLink/MediLink_Deductible.py

@@ -0,0 +1,203 @@
+"""
+# Create a summary JSON
+summary = {
+    "Payer ID": ins_payerID,
+    "Provider": provider_last_name,
+    "Member ID": ins_memberID,
+    "Date of Birth": dob,
+    "Patient Name": patient_name,
+    "Patient Info": {
+        "DOB": dob,
+        "Address": "{} {}".format(patient_info.get("addressLine1", ""), patient_info.get("addressLine2", "")).strip(),
+        "City": patient_info.get("city", ""),
+        "State": patient_info.get("state", ""),
+        "ZIP": patient_info.get("zip", ""),
+        "Relationship": patient_info.get("relationship", "")
+    },
+    "Insurance Info": {
+        "Payer Name": insurance_info.get("payerName", ""),
+        "Payer ID": ins_payerID,
+        "Member ID": ins_memberID,
+        "Group Number": insurance_info.get("groupNumber", ""),
+        "Insurance Type": ins_insuranceType,
+        "Type Code": ins_insuranceTypeCode,
+        "Address": "{} {}".format(insurance_info.get("addressLine1", ""), insurance_info.get("addressLine2", "")).strip(),
+        "City": insurance_info.get("city", ""),
+        "State": insurance_info.get("state", ""),
+        "ZIP": insurance_info.get("zip", "")
+    },
+    "Policy Info": {
+        "Eligibility Dates": eligibilityDates,
+        "Policy Member ID": policy_info.get("memberId", ""),
+        "Policy Status": policy_status
+    },
+    "Deductible Info": {
+        "Remaining Amount": remaining_amount
+    }
+}
+
+# Print debug JSON
+# Uncomment below if you need to debug later
+# print("\nDebug JSON Summary:")
+# print(json.dumps(summary, indent=2))
+"""
+import MediLink_API_v3
+import os
+import sys
+from datetime import datetime
+import requests
+import json
+
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try:
+    from MediBot import MediBot_Preprocessor_lib
+except ImportError:
+    import MediBot_Preprocessor_lib
+
+# Load configuration
+config, _ = MediLink_ConfigLoader.load_configuration()
+
+# Initialize the API client
+client = MediLink_API_v3.APIClient()
+
+# Get provider_last_name and npi from configuration
+provider_last_name = config['MediLink_Config'].get('default_billing_provider_last_name')
+npi = config['MediLink_Config'].get('default_billing_provider_npi')
+
+# Define the list of payer_id's to iterate over
+payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']
+
+# Get the latest CSV
+CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
+csv_data = MediBot_Preprocessor_lib.load_csv_data(CSV_FILE_PATH)
+
+# Only keep rows that contain a valid number from the payer_ids list
+valid_rows = [row for row in csv_data if str(row['Ins1 Payer ID']) in payer_ids]
+
+# Function to check if the date format is correct
+def validate_and_format_date(date_str):
+    for fmt in ('%Y-%m-%d', '%m/%d/%Y', '%d-%b-%Y', '%d-%m-%Y'):
+        try:
+            formatted_date = datetime.strptime(date_str, fmt).strftime('%Y-%m-%d')
+            return formatted_date
+        except ValueError:
+            continue
+    return None
+
+# List of patients with DOB and MemberID from CSV data
+patients = [
+    (validate_and_format_date(row['Patient DOB']), row['Primary Policy Number']) 
+    for row in valid_rows if validate_and_format_date(row['Patient DOB']) is not None
+]
+
+# Function to get eligibility information
+def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi):
+    try:
+        # Log the parameters being sent to the function
+        MediLink_ConfigLoader.log("Calling get_eligibility_v3 with parameters:", level="INFO")
+        MediLink_ConfigLoader.log("payer_id: {}".format(payer_id), level="INFO")
+        MediLink_ConfigLoader.log("provider_last_name: {}".format(provider_last_name), level="INFO")
+        MediLink_ConfigLoader.log("date_of_birth: {}".format(date_of_birth), level="INFO")
+        MediLink_ConfigLoader.log("member_id: {}".format(member_id), level="INFO")
+        MediLink_ConfigLoader.log("npi: {}".format(npi), level="INFO")
+
+        # Call the get_eligibility_v3 function
+        eligibility = MediLink_API_v3.get_eligibility_v3(
+            client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+        )
+        
+        # Log the response
+        MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="INFO")
+        
+        return eligibility
+    except requests.exceptions.HTTPError as e:
+        # Log the HTTP error response
+        MediLink_ConfigLoader.log("HTTPError: {}".format(e), level="ERROR")
+        MediLink_ConfigLoader.log("Response content: {}".format(e.response.content), level="ERROR")
+    except Exception as e:
+        # Log any other exceptions
+        MediLink_ConfigLoader.log("Error: {}".format(e), level="ERROR")
+    return None
+
+# Function to extract required fields and display in a tabular format
+def display_eligibility_info(data, dob, member_id):
+    if data is None:
+        return
+
+    for policy in data["memberPolicies"]:
+        # Skip non-medical policies
+        if policy["policyInfo"]["coverageType"] != "Medical":
+            continue
+
+        patient_info = policy["patientInfo"][0]
+        lastName = patient_info.get("lastName", "")
+        firstName = patient_info.get("firstName", "")
+        middleName = patient_info.get("middleName", "")
+
+        # Check if the remaining amount is per individual first, then fallback to family
+        if 'individual' in policy["deductibleInfo"]:
+            remaining_amount = policy["deductibleInfo"]["individual"]["inNetwork"].get("remainingAmount", "")
+        else:
+            remaining_amount = policy["deductibleInfo"]["family"]["inNetwork"].get("remainingAmount", "")
+
+        insurance_info = policy["insuranceInfo"]
+        ins_insuranceType = insurance_info.get("insuranceType", "")
+        ins_insuranceTypeCode = insurance_info.get("insuranceTypeCode", "")
+        ins_memberID = insurance_info.get("memberId", "")
+        ins_payerID = insurance_info.get("payerId", "")
+
+        policy_info = policy["policyInfo"]
+        eligibilityDates = policy_info.get("eligibilityDates", "")
+        policy_status = policy_info.get("policyStatus", "")
+
+        patient_name = "{} {} {}".format(firstName, middleName, lastName).strip()[:20]
+
+        # Display patient information in a table row format
+        eligibility_end_date = eligibilityDates.get("endDate", "")
+        table_row = "{:<20} | {:<10} | {:<5} | {:<30}".format(
+            patient_name, dob, ins_payerID, ins_insuranceType)
+        print(table_row)
+        table_row_details = "{:<20} | {:<10} | {:<5} | {:<15} | {:<8} | {:<15} | {:<20}".format(
+            "", "", "", ins_insuranceTypeCode, eligibility_end_date[-10:], policy_status, remaining_amount)
+        print(table_row_details)
+
+# Print the table header once before entering the loop
+table_header = "{:<20} | {:<10} | {:<5} | {:<30}".format(
+    "Patient Name", "DOB", "Payer ID", "Insurance Type")
+print(table_header)
+print("-" * len(table_header))
+sub_header = "{:<20} | {:<10} | {:<5} | {:<15} | {:<8} | {:<15} | {:<20}".format(
+    "", "", "", "Type Code", "End Date", "Policy Status", "Remaining Amount")
+print(sub_header)
+print("-" * len(sub_header))
+
+# Set to keep track of processed patients
+processed_patients = set()
+
+# Loop through each payer_id and patient to call the API, then display the eligibility information
+errors = []
+for payer_id in payer_ids:
+    for dob, member_id in patients:
+        # Skip if this patient has already been processed
+        if (dob, member_id) in processed_patients:
+            continue
+        try:
+            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi)
+            if eligibility_data is not None:
+                display_eligibility_info(eligibility_data, dob, member_id)  # Display as we get the result
+                processed_patients.add((dob, member_id))  # Mark this patient as processed
+        except Exception as e:
+            errors.append((dob, member_id, str(e)))
+
+# Display errors if any
+if errors:
+    print("\nErrors encountered during API calls:")
+    for error in errors:
+        print("DOB: {}, Member ID: {}, Error: {}".format(error[0], error[1], error[2]))

MediLink/MediLink_Down.py

@@ -1,128 +1,154 @@
+# MediLink_Down.py
 import os
 import argparse
 import shutil
-from datetime import datetime
 import glob
-import MediLink_ERA_decoder
+import csv
+from MediLink_Decoder import process_file
+from MediLink_ConfigLoader import load_configuration, log
 from MediLink_DataMgmt import operate_winscp
-import MediLink_ConfigLoader
 
-"""
-We need to make another function that figures out claim rejections and tries to solve them.
-
-1. Config File Path Adjustment: Ensure the configuration file's path is adaptable for various environments, or clearly document the process for setting this path.
-2. Logging Enhancements: Improve the logging mechanism to offer comprehensive insights through both file and console outputs, aiding in troubleshooting and operational monitoring.
-3. CSV Output Refinement: Update the CSV output structure to include essential ERA data such as Payer Address, ensuring completeness and accuracy of information.
-4. CSV Consolidation Logic: Develop logic for intelligently consolidating CSV outputs from batch-processed ERA files, ensuring coherent and comprehensive data aggregation.
-5. Secure Endpoint Authentication: Establish a secure method for inputting and storing endpoint authentication details, enhancing script security.
-6. Automated Endpoint Processing: Integrate automated looping through configured endpoints for ERA file retrieval, maximizing efficiency and reducing manual oversight.
-7. Configuration Key Accuracy: Audit the script to correct any inaccuracies in configuration key references, ensuring seamless configuration data retrieval.
-"""
-
-# Because I can't figure out how to get it to work directly in the WinSCP command.
-# And on the Windows XP machine apparently the default path is C:\\ ...
-# This needs to get fixed. Ugh.
-def move_downloaded_files(local_storage_path):
-    # Define the target directory for storing downloaded files
+def move_downloaded_files(local_storage_path, config):
     local_response_directory = os.path.join(local_storage_path, "responses")
     
     if not os.path.exists(local_response_directory):
         os.makedirs(local_response_directory)
     
-    # Identify all downloaded .era files in the current directory
-    # downloaded_files = [f for f in os.listdir('.') if f.endswith('.era')]
-    downloaded_files = [f for f in os.listdir('C:\\Users\\danie\\OneDrive\\Documents') if f.endswith('.era')]
+    download_dir = config['MediLink_Config']['local_storage_path']
+    file_extensions = ['.era', '.277', '.277ibr', '.277ebr', '.dpt', '.ebt', '.ibt']  # Extendable list of file extensions
     
-    # Move each file to the local_response_directory
-    for file in downloaded_files:
-        source_path = os.path.join('C:\\Users\\danie\\OneDrive\\Documents', file)
-        # source_path = os.path.join('.', file)    for the XP machine? -- This whole thing needs repaired. 
-        destination_path = os.path.join(local_response_directory, file)
-        shutil.move(source_path, destination_path)
-        MediLink_ConfigLoader.log("Moved '{}' to '{}'".format(file, local_response_directory))
-
-def find_era_files(era_file_path):
-    """
-    Find all files matching the era_file_path pattern.
-    This function normalizes the path and supports wildcard patterns.
-    """
-    # Normalize the path to handle slashes correctly
-    normalized_path = os.path.normpath(era_file_path)
+    for ext in file_extensions:
+        downloaded_files = [f for f in os.listdir(download_dir) if f.endswith(ext)]
+        for file in downloaded_files:
+            source_path = os.path.join(download_dir, file)
+            destination_path = os.path.join(local_response_directory, file)
+            shutil.move(source_path, destination_path)
+            log("Moved '{}' to '{}'".format(file, local_response_directory))
 
-    # Handling different wildcard scenarios
-    if "*" in normalized_path:
-        # Use glob to find all files matching the pattern
+def find_files(file_path_pattern):
+    normalized_path = os.path.normpath(file_path_pattern)
+    if os.path.isdir(normalized_path):
+        return [os.path.join(normalized_path, f) for f in os.listdir(normalized_path) if os.path.isfile(os.path.join(normalized_path, f))]
+    elif "*" in normalized_path:
         matching_files = glob.glob(normalized_path)
-        # Normalize paths in the resulting list
         return [os.path.normpath(file) for file in matching_files]
     else:
-        # Single file specified, return it in a list if it exists
         return [normalized_path] if os.path.exists(normalized_path) else []
 
-def main(desired_endpoint='AVAILITY'):
-    parser = argparse.ArgumentParser(description="Process ERA files and convert them to CSV format.")
-    parser.add_argument('--config_path', type=str, help='Path to the configuration JSON file', default="json\\config.json") # Default handling of json path
-    parser.add_argument('--desired_endpoint', type=str, help='The desired endpoint key from the configuration.', default=desired_endpoint)
-    parser.add_argument('--era_file_path', type=str, help='Optional: Specify a path to an ERA file for direct translation.', default=None)
+def translate_files(files, output_directory):
+    translated_files = []
+    consolidated_records = []
+    file_counts = {'.era': 0, '.277': 0, '.277ibr': 0, '.277ebr': 0, '.dpt': 0, '.ebt': 0, '.ibt': 0}
+
+    for file in files:
+        ext = os.path.splitext(file)[1]
+        if ext in file_counts:
+            file_counts[ext] += 1
+
+        try:
+            records = process_file(file, output_directory, return_records=True)
+            consolidated_records.extend(records)
+            csv_file_path = os.path.join(output_directory, os.path.basename(file) + '_decoded.csv')
+            log("Translated file to CSV: {}".format(csv_file_path), level="INFO")
+            translated_files.append(csv_file_path)
+        except ValueError as ve:
+            log("Unsupported file type: {}".format(file), level="WARNING")
+        except Exception as e:
+            log("Error processing file {}: {}".format(file, e), level="ERROR")
+    
+    print("Detected and processed file counts by type:")
+    for ext, count in file_counts.items():
+        print("{}: {} files detected".format(ext, count))
+
+    return consolidated_records, translated_files
+
+def display_translated_files(translated_files):
+    print("\nTranslated Files Summary:")
+    for file in translated_files:
+        print(" - {}".format(file))
+
+def main():
+    parser = argparse.ArgumentParser(description="Process files and convert them to CSV format.")
+    parser.add_argument('--config_path', type=str, help='Path to the configuration JSON file', default="json/config.json")
+    parser.add_argument('--file_path_pattern', type=str, help='Path pattern or directory for files to process.', default=None)
     args = parser.parse_args()
     
-    # Setup Logger, Load configuration and output directory
-    config, _ = MediLink_ConfigLoader.load_configuration(args.config_path)
+    config, _ = load_configuration(args.config_path)
     local_storage_path = config['MediLink_Config']['local_storage_path']
     output_directory = os.path.join(local_storage_path, "translated_csvs")
-     
-    # Direct ERA file translation if a file path is provided
-    if args.era_file_path:
-        era_files = find_era_files(args.era_file_path)
-        if era_files:
-            era_files_str = ', '.join(era_files)
-            MediLink_ConfigLoader.log("Translating ERA files: {}".format(era_files_str))
-            MediLink_ERA_decoder.translate_era_to_csv(era_files, output_directory)
-            # Instead of returning a single CSV file path, consolidate here
-            consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
-            MediLink_ConfigLoader.log("Translation and consolidation completed.")
-            return consolidate_csv_path
+
+    # If a file path pattern is provided, process those files directly
+    if args.file_path_pattern:
+        files = find_files(args.file_path_pattern)
+        if files:
+            files_str = ', '.join(files)
+            log("Translating files: {}".format(files_str), level="INFO")
+            consolidated_records, translated_files = translate_files(files, output_directory)
+            log("Translation completed.", level="INFO")
+            if consolidated_records:
+                display_consolidated_records(consolidated_records)
+            prompt_csv_export(consolidated_records, output_directory)
+            return
         else:
-            MediLink_ConfigLoader.log("No ERA files found matching: {}".format(args.era_file_path))
+            log("No files found matching: {}".format(args.file_path_pattern), level="WARNING")
             return
-    
-    # TODO (Low Remit) This probably needs to be built into a loop that cycles through all 3 endpoints. 
-    # I think the uploader has something like this implemented already since it sends to all the endpoints.
-    # The loop should use the tdqa or whatever the progress bar is called.
-    # print("Please wait...\n")
-    
-    # Validate endpoint key
-    endpoint_key = args.desired_endpoint
+
+    # Handle downloading files via WinSCP
+    endpoint_key = 'AVAILITY'
     if endpoint_key not in config['MediLink_Config']['endpoints']:
-        MediLink_ConfigLoader.log("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key))
+        log("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key), level="WARNING")
         endpoint_key = 'AVAILITY'
     
-    # Retrieve endpoint configuration and local storage path
-    endpoint_config = config['MediLink_Config']['endpoints'][endpoint_key]
-    local_storage_path = config['MediLink_Config']['local_storage_path']
-        
-    # Download ERA files from the configured endpoint
-    downloaded_files = operate_winscp("download", None, endpoint_config, local_storage_path, config)
+    endpoint_configs = [config['MediLink_Config']['endpoints'][key] for key in config['MediLink_Config']['endpoints']]
+    downloaded_files = []
 
-    # Translate downloaded ERA files to CSV format
-    translated_csv_paths = []
-    for file in downloaded_files:
-        # TODO (Low Remit) This needs to add functionality for differentiating between ERA, 277, IBT or 
-        # whatever else might be included in the download folders.
-        MediLink_ERA_decoder.translate_era_to_csv([file], output_directory)
-        csv_file_path = os.path.join(output_directory, os.path.basename(file) + '.csv')
-        translated_csv_paths.append(csv_file_path)
-        MediLink_ConfigLoader.log("Translated ERA to CSV: {}".format(csv_file_path))
+    for endpoint_config in endpoint_configs:
+        downloaded_files += operate_winscp("download", None, endpoint_config, local_storage_path, config)
     
-    # Consolidate new CSVs
-    consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
+    move_downloaded_files(local_storage_path, config)
     
-    # Return the list of translated CSV file paths
-    return consolidate_csv_path
+    consolidated_records, translated_files = translate_files(downloaded_files, output_directory)
+    if consolidated_records:
+        display_consolidated_records(consolidated_records)
+    prompt_csv_export(consolidated_records, output_directory)
+
+def display_consolidated_records(records):
+    # Define the new fieldnames and their respective widths
+    new_fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+    col_widths = {field: len(field) for field in new_fieldnames}
+    
+    # Update column widths based on records
+    for record in records:
+        for field in new_fieldnames:
+            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
+    
+    # Create table header
+    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in new_fieldnames)
+    print(header)
+    print("-" * len(header))
+    
+    # Create table rows
+    for record in records:
+        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in new_fieldnames)
+        print(row)
+
+def prompt_csv_export(records, output_directory):
+    if records:
+        user_input = input("Do you want to export the consolidated records to a CSV file? (y/n): ")
+        if user_input.lower() == 'y':
+            output_file_path = os.path.join(output_directory, "Consolidated_Records.csv")
+            write_records_to_csv(records, output_file_path)
+            log("Consolidated CSV file created at: {}".format(output_file_path), level="INFO")
+        else:
+            log("CSV export skipped by user.", level="INFO")
+
+def write_records_to_csv(records, output_file_path):
+    fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+    with open(output_file_path, 'w', newline='') as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for record in records:
+            writer.writerow(record)
 
 if __name__ == "__main__":
-    consolidate_csv_path = main()
-    if consolidate_csv_path:
-        print("CSV File Created: {}".format(consolidate_csv_path))
-    else:
-        print("No CSV file was created.")
+    main()