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

MediLink/MediLink_Down.py

@@ -1,138 +1,97 @@
 # MediLink_Down.py
-import os
-import argparse
-import shutil
-import glob
-import csv
-from MediLink_Decoder import process_file
-from MediLink_ConfigLoader import load_configuration, log
+import os, shutil
+from MediLink_Decoder import process_decoded_file, display_consolidated_records, write_records_to_csv
+from MediLink_ConfigLoader import log, load_configuration
 from MediLink_DataMgmt import operate_winscp
 
-def move_downloaded_files(local_storage_path, config):
+def handle_files(local_storage_path, downloaded_files):
+    """
+    Moves downloaded files to the appropriate directory and translates them to CSV format.
+    """
+    log("Starting to handle downloaded files.")
+    
+    # Set the local response directory
     local_response_directory = os.path.join(local_storage_path, "responses")
+    os.makedirs(local_response_directory, exist_ok=True)
     
-    if not os.path.exists(local_response_directory):
-        os.makedirs(local_response_directory)
+    # Supported file extensions
+    file_extensions = ['.era', '.277', '.277ibr', '.277ebr', '.dpt', '.ebt', '.ibt', '.txt']
     
-    download_dir = config['MediLink_Config']['local_storage_path']
-    file_extensions = ['.era', '.277', '.277ibr', '.277ebr', '.dpt', '.ebt', '.ibt']  # Extendable list of file extensions
+    files_moved = []
     
-    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)
+    for file in downloaded_files:
+        if any(file.lower().endswith(ext) for ext in file_extensions):  # Case-insensitive match
+            source_path = os.path.join(local_storage_path, file)
             destination_path = os.path.join(local_response_directory, file)
-            shutil.move(source_path, destination_path)
-            log("Moved '{}' to '{}'".format(file, local_response_directory))
-
-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)
-        return [os.path.normpath(file) for file in matching_files]
-    else:
-        return [normalized_path] if os.path.exists(normalized_path) else []
+            
+            try:
+                shutil.move(source_path, destination_path)
+                log("Moved '{}' to '{}'".format(file, local_response_directory))
+                files_moved.append(destination_path)
+            except Exception as e:
+                log("Error moving file '{}' to '{}': {}".format(file, destination_path, e), level="ERROR")
+    
+    if not files_moved:
+        log("No files were moved. Ensure that files with supported extensions exist in the download directory.", level="WARNING")
+    
+    # Translate the files
+    consolidated_records, translated_files = translate_files(files_moved, local_response_directory)
+    
+    return consolidated_records, translated_files
 
 def translate_files(files, output_directory):
+    """
+    Translates given files into CSV format and returns the list of translated files and consolidated records.
+    """
+    log("Translating files: {}".format(files), level="DEBUG")
+
+    if not files:
+        log("No files provided for translation. Exiting translate_files.", level="WARNING")
+        return [], []
+
     translated_files = []
     consolidated_records = []
-    file_counts = {'.era': 0, '.277': 0, '.277ibr': 0, '.277ebr': 0, '.dpt': 0, '.ebt': 0, '.ibt': 0}
+    
+    # Supported file extensions with selector
+    file_type_selector = {
+        '.era': False,
+        '.277': False,
+        '.277ibr': False,
+        '.277ebr': False,
+        '.dpt': False,
+        '.ebt': True,  # Only EBT files are processed
+        '.ibt': False,
+        '.txt': False
+    }
+
+    file_counts = {ext: 0 for ext in file_type_selector.keys()}
 
     for file in files:
         ext = os.path.splitext(file)[1]
-        if ext in file_counts:
+        if file_type_selector.get(ext, False):  # Check if the file type is selected
             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:")
+            try:
+                records = process_decoded_file(os.path.join(output_directory, file), output_directory, return_records=True)
+                consolidated_records.extend(records)
+                csv_file_path = os.path.join(output_directory, os.path.basename(file) + '_decoded.csv')
+                translated_files.append(csv_file_path)
+                log("Translated file to CSV: {}".format(csv_file_path), level="INFO")
+            except ValueError:
+                log("Unsupported file type: {}".format(file), level="WARNING")
+            except Exception as e:
+                log("Error processing file {}: {}".format(file, e), level="ERROR")
+
+    log("Detected and processed file counts by type:")
     for ext, count in file_counts.items():
-        print("{}: {} files detected".format(ext, count))
+        log("{}: {} files detected".format(ext, count), level="INFO")
 
     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()
-    
-    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")
-
-    # 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:
-            log("No files found matching: {}".format(args.file_path_pattern), level="WARNING")
-            return
-
-    # Handle downloading files via WinSCP
-    endpoint_key = 'AVAILITY'
-    if endpoint_key not in config['MediLink_Config']['endpoints']:
-        log("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key), level="WARNING")
-        endpoint_key = 'AVAILITY'
-    
-    endpoint_configs = [config['MediLink_Config']['endpoints'][key] for key in config['MediLink_Config']['endpoints']]
-    downloaded_files = []
-
-    for endpoint_config in endpoint_configs:
-        downloaded_files += operate_winscp("download", None, endpoint_config, local_storage_path, config)
-    
-    move_downloaded_files(local_storage_path, config)
-    
-    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):
+    """
+    Prompts the user to export consolidated records to a CSV file.
+    """
     if records:
         user_input = input("Do you want to export the consolidated records to a CSV file? (y/n): ")
         if user_input.lower() == 'y':
@@ -142,13 +101,48 @@ def prompt_csv_export(records, output_directory):
         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)
+def main(desired_endpoint=None):
+    """
+    Main function for running MediLink_Down as a standalone script. 
+    Simplified to handle only CLI operations and delegate the actual processing to the high-level function.
+    """
+    log("Running MediLink_Down.main with desired_endpoint={}".format(desired_endpoint))
+
+    if not desired_endpoint:
+        log("No specific endpoint provided. Aborting operation.", level="ERROR")
+        return None, None
+    
+    try:
+        config, _ = load_configuration()
+        endpoint_config = config['MediLink_Config']['endpoints'].get(desired_endpoint)
+        if not endpoint_config or 'remote_directory_down' not in endpoint_config:
+            log("Configuration for endpoint '{}' is incomplete or missing 'remote_directory_down'.".format(desired_endpoint), level="ERROR")
+            return None, None
+
+        local_storage_path = config['MediLink_Config']['local_storage_path']
+        log("Local storage path set to {}".format(local_storage_path))
+        
+        downloaded_files = operate_winscp("download", None, endpoint_config, local_storage_path, config)
+        
+        if downloaded_files:
+            log("From main(), WinSCP Downloaded the following files: \n{}".format(downloaded_files))
+            consolidated_records, translated_files = handle_files(local_storage_path, downloaded_files)
+            
+            # Convert UnifiedRecord instances to dictionaries before displaying
+            dict_consolidated_records = [record.to_dict() for record in consolidated_records]
+            display_consolidated_records(dict_consolidated_records)
+
+            # Prompt for CSV export
+            prompt_csv_export(consolidated_records, local_storage_path)
+            
+            return consolidated_records, translated_files
+        else:
+            log("No files were downloaded for endpoint: {}. Exiting...".format(desired_endpoint), level="WARNING")
+            return None, None
+
+    except Exception as e:
+        log("An error occurred in MediLink_Down.main: {}".format(e), level="ERROR")
+        return None, None
 
 if __name__ == "__main__":
-    main()
+    main()

MediLink/MediLink_Gmail.py

@@ -1,17 +1,8 @@
-import sys
-import os
-import subprocess
-import time
-import webbrowser
+# MediLink_Gmail.py
+import sys, os, subprocess, time, webbrowser, requests, json, ssl, signal
 from MediLink_ConfigLoader import log, load_configuration
-
-import requests
-import json
 from http.server import BaseHTTPRequestHandler, HTTPServer
-import ssl
-import signal
 from threading import Thread, Event
-
 import platform
 
 config, _ = load_configuration()

MediLink/MediLink_Parser.py

@@ -1,6 +1,8 @@
 # MediLink_Parser.py
 
-def parse_era_content(content):
+import re
+
+def parse_era_content(content, debug=False):
     extracted_data = []
     normalized_content = content.replace('~\n', '~')
     lines = normalized_content.split('~')
@@ -74,13 +76,14 @@ def parse_era_content(content):
         })
         extracted_data.append(record)
 
-    print("Parsed ERA Content:")
-    for data in extracted_data:
-        print(data)
+    if debug:
+        print("Parsed ERA Content:")
+        for data in extracted_data:
+            print(data)
 
     return extracted_data
 
-def parse_277_content(content):
+def parse_277_content(content, debug=False):
     segments = content.split('~')
     records = []
     current_record = {}
@@ -115,19 +118,20 @@ def parse_277_content(content):
     if current_record:
         records.append(current_record)
 
-    print("Parsed 277 Content:")
-    for record in records:
-        print(record)
+    if debug:
+        print("Parsed 277 Content:")
+        for record in records:
+            print(record)
 
     return records
 
-def parse_277IBR_content(content):
-    return parse_277_content(content)
+def parse_277IBR_content(content, debug=False):
+    return parse_277_content(content, debug)
 
-def parse_277EBR_content(content):
-    return parse_277_content(content)
+def parse_277EBR_content(content, debug=False):
+    return parse_277_content(content, debug)
 
-def parse_dpt_content(content):
+def parse_dpt_content(content, debug=False):
     extracted_data = []
     lines = content.splitlines()
     record = {}
@@ -143,34 +147,56 @@ def parse_dpt_content(content):
     if record:
         extracted_data.append(record)
 
-    print("Parsed DPT Content:")
-    for data in extracted_data:
-        print(data)
+    if debug:
+        print("Parsed DPT Content:")
+        for data in extracted_data:
+            print(data)
 
     return extracted_data
 
-def parse_ebt_content(content):
-    extracted_data = []
-    lines = content.splitlines()
-    record = {}
+def parse_ebt_content(content, debug=False):
+    extracted_data = []  # List to hold all extracted records
+    lines = content.splitlines()  # Split the content into individual lines
+    record = {}  # Dictionary to hold the current record being processed
+
+    # Regular expression pattern to match key-value pairs in the format "Key: Value"
+    key_value_pattern = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+?:|$)')
+
     for line in lines:
+        # Check for the start of a new record based on the presence of 'Patient Name'
         if 'Patient Name:' in line and record:
-            extracted_data.append(record)
-            record = {}
-        parts = line.split(':')
-        if len(parts) == 2:
-            key, value = parts[0].strip(), parts[1].strip()
-            record[key] = value
+            ebt_post_processor(record)  # Process the current record before adding it to the list
+            extracted_data.append(record)  # Add the completed record to the list
+            record = {}  # Reset the record for the next entry
+
+        # Find all key-value pairs in the current line
+        matches = key_value_pattern.findall(line)
+        for key, value in matches:
+            key = key.strip()  # Remove leading/trailing whitespace from the key
+            value = value.strip()  # Remove leading/trailing whitespace from the value
+            record[key] = value  # Add the key-value pair to the current record
+
+    # Process and add the last record if it exists
     if record:
-        extracted_data.append(record)
+        ebt_post_processor(record)  # Final processing of the last record
+        extracted_data.append(record)  # Add the last record to the list
 
-    print("Parsed EBT Content:")
-    for data in extracted_data:
-        print(data)
+    # Debug output to show parsed data if debugging is enabled
+    if debug:
+        print("Parsed EBT Content:")
+        for data in extracted_data:
+            print(data)
 
-    return extracted_data
+    return extracted_data  # Return the list of extracted records
+
+def ebt_post_processor(record):
+    # Process the 'Message Initiator' field to separate it from 'Message Type'
+    if 'Message Initiator' in record and 'Message Type:' in record['Message Initiator']:
+        parts = record['Message Initiator'].split('Message Type:')  # Split the string into parts
+        record['Message Initiator'] = parts[0].strip()  # Clean up the 'Message Initiator'
+        record['Message Type'] = parts[1].strip()  # Clean up the 'Message Type'
 
-def parse_ibt_content(content):
+def parse_ibt_content(content, debug=False):
     extracted_data = []
     lines = content.splitlines()
     record = {}
@@ -186,8 +212,9 @@ def parse_ibt_content(content):
     if record:
         extracted_data.append(record)
 
-    print("Parsed IBT Content:")
-    for data in extracted_data:
-        print(data)
+    if debug:
+        print("Parsed IBT Content:")
+        for data in extracted_data:
+            print(data)
 
-    return extracted_data
+    return extracted_data

MediLink/MediLink_UI.py

@@ -1,6 +1,15 @@
+# MediLink_UI.py
 from datetime import datetime
-import os
-import MediLink_ConfigLoader
+import os, sys
+
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
+
+try:
+    import MediLink_ConfigLoader
+except ImportError:
+    from MediLink import MediLink_ConfigLoader
 
 def display_welcome():
     print("\n" + "-" * 60)
@@ -98,13 +107,6 @@ def display_patient_summaries(detailed_patient_data):
             print("Summary at index {} is missing key: {}".format(index, e))
     print() # add blank line for improved readability.
 
-def ask_for_proceeding_with_endpoints():
-    """
-    Asks the user if they want to proceed with all suggested endpoints.
-    """
-    proceed = input("Do you want to proceed with all suggested endpoints? (Y/N): ").strip().lower()
-    return proceed == 'y'
-
 def display_file_summary(index, summary):
     # Ensure surgery_date is converted to a datetime object
     surgery_date = datetime.strptime(summary['surgery_date'], "%m-%d-%y")
@@ -129,26 +131,37 @@ def display_file_summary(index, summary):
         insurance_type[:2],
         summary['suggested_endpoint'][:20])
     )
-    
+
 def user_select_files(file_list):
-    """
-    Prompt the user to select files from a list of detected files.
+    # Sort files by creation time in descending order
+    file_list = sorted(file_list, key=os.path.getctime, reverse=True)[:10]  # Limit to max 10 files
     
-    :param file_list: List of detected files.
-    :return: List of files selected by the user.
-    """
-    # Sort the files by creation time in descending order
-    file_list = sorted(file_list, key=os.path.getctime, reverse=True)
-    
-    print("Select claim files to submit from the following list:")
+    print("\nSelect the Z-form files to submit from the following list:\n")
+
+    formatted_files = []
     for i, file in enumerate(file_list):
-        print("{}: {}".format(i+1, os.path.basename(file)))
+        basename = os.path.basename(file)
+        parts = basename.split('_')
+        
+        # Try to parse the timestamp from the filename
+        if len(parts) > 2:
+            try:
+                timestamp_str = parts[1] + parts[2].split('.')[0]
+                timestamp = datetime.strptime(timestamp_str, '%Y%m%d%H%M%S')
+                formatted_date = timestamp.strftime('%m/%d %I:%M %p')  # Changed to 12HR format with AM/PM
+            except ValueError:
+                formatted_date = basename  # Fallback to original filename if parsing fails
+        else:
+            formatted_date = basename  # Fallback to original filename if no timestamp
+        
+        formatted_files.append((formatted_date, file))
+        print("{}: {}".format(i + 1, formatted_date))
     
     selected_indices = input("\nEnter the numbers of the files to process, separated by commas\n(or press Enter to select all): ")
     if not selected_indices:
-        return file_list
+        return [file for _, file in formatted_files]
     
     selected_indices = [int(i.strip()) - 1 for i in selected_indices.split(',')]
-    selected_files = [file_list[i] for i in selected_indices]
+    selected_files = [formatted_files[i][1] for i in selected_indices]
     
-    return selected_files
+    return selected_files