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

MediLink/MediLink_Down.py

@@ -1,137 +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', '.txt']  # 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, '.txt': 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 args.file_path_pattern:
-        process_files_by_pattern(args.file_path_pattern, output_directory)
-    else:
-        download_and_process_files(config, local_storage_path, output_directory)
-
-def process_files_by_pattern(file_path_pattern, output_directory):
-    files = find_files(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)
-    else:
-        log("No files found matching: {}".format(file_path_pattern), level="WARNING")
-
-def download_and_process_files(config, local_storage_path, output_directory):
-    downloaded_files = download_files_from_endpoints(config, local_storage_path)
-    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 download_files_from_endpoints(config, local_storage_path):
-    endpoint_configs = config['MediLink_Config']['endpoints'].values()
-    downloaded_files = []
-    for endpoint_config in endpoint_configs:
-        downloaded_files += operate_winscp("download", None, endpoint_config, local_storage_path, config)
-    return downloaded_files
-
-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':
@@ -141,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()
@@ -218,7 +209,7 @@ class RequestHandler(BaseHTTPRequestHandler):
                 self.send_header('Content-type', 'text/html')
                 self.end_headers()
                 self.wfile.write("Authentication successful. You can close this window now.".encode())
-                initiate_link_retrieval()  # Proceed with link retrieval
+                initiate_link_retrieval(config)  # Pass config here
             else:
                 log("Authentication failed with response: {}".format(token_response))  # Add this line
                 self.send_response(400)
@@ -353,13 +344,13 @@ def open_browser_with_executable(url, browser_path=None):
     except Exception as e:
         log("Failed to open browser: {}".format(e))
 
-def initiate_link_retrieval():
+def initiate_link_retrieval(config):
     log("Initiating browser via implicit GET.")
-    url_get = "https://script.google.com/macros/s/AKfycbzlq8d32mDlLdtFxgL_zvLJernlGPB64ftyxyH8F1nNlr3P-VBH6Yd0NGa1pbBc5AozvQ/exec?action=get_link"
+    url_get = "https://script.google.com/macros/s/{}/exec?action=get_link".format(config['MediLink_Config']['webapp_deployment_id'])  # Use config here
     open_browser_with_executable(url_get)
     
     log("Preparing POST call.")
-    url = "https://script.google.com/macros/s/AKfycbzlq8d32mDlLdtFxgL_zvLJernlGPB64ftyxyH8F1nNlr3P-VBH6Yd0NGa1pbBc5AozvQ/exec"
+    url = "https://script.google.com/macros/s/{}/exec".format(config['MediLink_Config']['webapp_deployment_id'])  # Use config here
     downloaded_emails = list(load_downloaded_emails())
     payload = {
         "downloadedEmails": downloaded_emails
@@ -446,7 +437,7 @@ def auth_and_retrieval():
         shutdown_event.wait()  # Wait for the shutdown event to be set after authentication
     else:
         log("Access token found. Proceeding.")
-        initiate_link_retrieval()
+        initiate_link_retrieval(config)  # Pass config here
         shutdown_event.wait()  # Wait for the shutdown event to be set
 
 if __name__ == "__main__":

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,9 +1,10 @@
+# MediLink_UI.py
 from datetime import datetime
-import os
-import sys
+import os, 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)
 
 try:
     import MediLink_ConfigLoader
@@ -106,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")
@@ -137,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.
-    
-    :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)
+    # 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
     
-    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

MediLink/MediLink_Up.py

@@ -1,7 +1,6 @@
+# MediLink_Up.py
 from datetime import datetime
-import os
-import re
-import subprocess
+import os, re, subprocess, traceback
 from tqdm import tqdm
 import MediLink_837p_encoder
 from MediLink_ConfigLoader import log, load_configuration
@@ -34,7 +33,7 @@ def check_internet_connection():
         print("An error occurred checking for internet connectivity:", e)
         return False
 
-def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
+def submit_claims(detailed_patient_data_grouped_by_endpoint, config, crosswalk):
     """
     Submits claims for each endpoint, either via WinSCP or API, based on configuration settings.
 
@@ -63,8 +62,9 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
         # Attempt submission to each endpoint
         if True: #confirm_transmission({endpoint: patients_data}): # Confirm transmission to each endpoint with detailed overview
             if check_internet_connection():
+                client = MediLink_API_v3.APIClient()
                 # Process files per endpoint
-                converted_files = MediLink_837p_encoder.convert_files_for_submission(patients_data, config)
+                converted_files = MediLink_837p_encoder.convert_files_for_submission(patients_data, config, crosswalk, client)
                 if converted_files:
                     if method == 'winscp':
                         # Transmit files via WinSCP
@@ -86,7 +86,6 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
                         # Transmit files via API
                         try:
                             api_responses = []
-                            client = MediLink_API_v3.APIClient()
                             for file_path in converted_files:
                                 with open(file_path, 'r') as file:
                                     x12_request_data = file.read().replace('\n', '').replace('\r', '').strip()
@@ -242,10 +241,15 @@ def prepare_receipt_data(submission_results):
                 # Unpack the tuple to get status and message
                 status, message = file_result
             except ValueError as e:
-                log("ValueError: {} for file_result: {}".format(e, file_result), level="ERROR")
+                file_result_length = len(file_result) if hasattr(file_result, '__len__') else 'Unknown'
+                error_msg = 'Too many values to unpack.' if 'too many values to unpack' in str(e) else \
+                            'Not enough values to unpack.' if 'not enough values to unpack' in str(e) else \
+                            'Value unpacking error.'
+                log("ValueError: {} for file_result: {} (Length: {})".format(error_msg, file_result, file_result_length), level="ERROR")
                 continue
             except Exception as e:
-                log("Unexpected error: {}".format(e), level="ERROR")
+                tb = traceback.format_exc()
+                log("Unexpected error: {}. Traceback: {}".format(e, tb), level="ERROR")
                 continue
 
             log("Status: {}, Message: {}".format(status, message), level="DEBUG")

{medicafe-0.240809.0.dist-info → medicafe-0.241015.0.dist-info}/METADATA

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