medicafe 0.250813.2__py3-none-any.whl → 0.250814.3__py3-none-any.whl

MediLink/MediLink_APIs.py

@@ -1,138 +0,0 @@
-# Unused archive backup. This has been superceded by API_v2
-
-import time, requests
-try:
-    from MediLink import MediLink_ConfigLoader
-except ImportError:
-    import MediLink_ConfigLoader
-
-# Fetches the payer name from API based on the payer ID.
-def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
-    """
-    Fetches the payer name from the API using the provided payer ID.
-
-    Args:
-        payer_id (str): The ID of the payer.
-        config (dict): Configuration settings.
-        primary_endpoint (str): The primary endpoint for resolving payer information.
-
-    Raises:
-        ValueError: If all endpoints are exhausted without finding the payer.
-
-    Returns:
-        str: The fetched payer name.
-    """
-    # Reload for safety
-    config, _ = MediLink_ConfigLoader.load_configuration()
-    
-    # Step 1: Retrieve endpoint configurations
-    endpoints = config['MediLink_Config']['endpoints']
-    tried_endpoints = []
-
-    # Step 2: Check if the primary endpoint is specified and is valid
-    if primary_endpoint and primary_endpoint in endpoints:
-        endpoint_order = [primary_endpoint] + [endpoint for endpoint in endpoints if endpoint != primary_endpoint]
-    else:
-        endpoint_order = list(endpoints.keys())
-
-    # Step 3: Iterate through available endpoints in specified order
-    for endpoint_name in endpoint_order:
-        endpoint_config = endpoints[endpoint_name]
-        if not all(key in endpoint_config for key in ['token_url', 'client_id', 'client_secret']):
-            MediLink_ConfigLoader.log("Skipping {} due to missing API keys.".format(endpoint_name), config, level="WARNING")
-            continue
-
-        # Step 4: Get access token for the endpoint
-        token = get_access_token(endpoint_config)
-        api_url = endpoint_config.get("api_url", "")
-        headers = {'Authorization': 'Bearer {}'.format(token), 'Accept': 'application/json'}
-        params = {'payerId': payer_id}
-
-        try:
-            # Step 5: Make API call to fetch payer name
-            response = requests.get(api_url, headers=headers, params=params)
-            response.raise_for_status()
-            data = response.json()
-            if 'payers' in data and data['payers']:
-                payer = data['payers'][0]
-                payer_name = payer.get('displayName') or payer.get('name')
-                
-                # Log successful match
-                MediLink_ConfigLoader.log("Successfully found payer at {} for ID {}: {}".format(endpoint_name, payer_id, payer_name), config, level="INFO")
-                
-                return payer_name
-            else:
-                MediLink_ConfigLoader.log("No payer found at {} for ID: {}. Trying next available endpoint.".format(endpoint_name, payer_id), config, level="INFO")
-        except requests.RequestException as e:
-            # Step 6: Log API call failure
-            MediLink_ConfigLoader.log("API call failed at {} for Payer ID '{}': {}".format(endpoint_name, payer_id, str(e)), config, level="ERROR")
-            tried_endpoints.append(endpoint_name)
-    
-    # Step 7: Log all endpoints exhaustion and raise error
-    error_message = "All endpoints exhausted for Payer ID {}. Endpoints tried: {}".format(payer_id, ', '.join(tried_endpoints))
-    MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
-    raise ValueError(error_message)
-
-# Test Case for API fetch
-#payer_id = "11347"
-#config = load_configuration() 
-#payer_name = fetch_payer_name_from_api(payer_id, config, endpoint='AVAILITY')
-#print(payer_id, payer_name)
-
-# Initialize a global dictionary to store the access token and its expiry time
-# TODO (Low API) This will need to get setup for each endpoint separately. 
-token_cache = {
-    'access_token': None,
-    'expires_at': 0  # Timestamp of when the token expires
-}
-
-def get_access_token(endpoint_config):
-    current_time = time.time()
-    
-    # Check if the cached token is still valid
-    if token_cache['access_token'] and token_cache['expires_at'] > current_time:
-        return token_cache['access_token']
-
-    # Validate endpoint configuration
-    if not endpoint_config or not all(k in endpoint_config for k in ['client_id', 'client_secret', 'token_url']):
-        raise ValueError("Endpoint configuration is incomplete or missing necessary fields.")
-
-    # Extract credentials and URL from the config
-    CLIENT_ID = endpoint_config.get("client_id")
-    CLIENT_SECRET = endpoint_config.get("client_secret")
-    url = endpoint_config.get("token_url")
-
-    # Setup the data payload and headers for the HTTP request
-    data = {
-        'grant_type': 'client_credentials',
-        'client_id': CLIENT_ID,
-        'client_secret': CLIENT_SECRET,
-        'scope': 'hipaa'
-    }
-    headers = {
-        'Content-Type': 'application/x-www-form-urlencoded'
-    }
-
-    try:
-        # Perform the HTTP request to get the access token
-        response = requests.post(url, headers=headers, data=data)
-        response.raise_for_status()  # This will raise an exception for HTTP error statuses
-        json_response = response.json()
-        access_token = json_response.get('access_token')
-        expires_in = json_response.get('expires_in', 3600)  # Default to 3600 seconds if not provided
-
-        if not access_token:
-            raise ValueError("No access token returned by the server.")
-        
-        # Store the access token and calculate the expiry time
-        token_cache['access_token'] = access_token
-        token_cache['expires_at'] = current_time + expires_in - 120  # Subtracting 120 seconds to provide buffer
-
-        return access_token
-    except requests.RequestException as e:
-        # Handle HTTP errors (e.g., network problems, invalid response)
-        error_msg = "Failed to retrieve access token: {0}. Response status: {1}".format(str(e), response.status_code if response else 'No response')
-        raise Exception(error_msg)
-    except ValueError as e:
-        # Handle specific errors like missing access token
-        raise Exception("Configuration or server response error: {0}".format(str(e)))

MediLink/MediLink_ConfigLoader.py

@@ -1,87 +0,0 @@
-# MediLink_ConfigLoader.py
-import os, json, logging, sys, platform, yaml
-from datetime import datetime
-from collections import OrderedDict
-
-"""
-This function should be generalizable to have a initialization script over all the Medi* functions
-"""
-def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'config.json'), crosswalk_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'crosswalk.json')):
-    """
-    Loads endpoint configuration, credentials, and other settings from JSON or YAML files.
-        
-    Returns: A tuple containing dictionaries with configuration settings for the main config and crosswalk.
-    """
-    # TODO (Low Config Upgrade) The Medicare / Private differentiator flag probably needs to be pulled or passed to this.
-    # BUG Hardcode sucks. This should probably be some local env variable. 
-    # Detect the operating system
-    if platform.system() == 'Windows' and platform.release() == 'XP':
-        # Use F: paths for Windows XP
-        config_path = "F:\\Medibot\\json\\config.json"
-        crosswalk_path = "F:\\Medibot\\json\\crosswalk.json"
-    else:
-        # Use G: paths for other versions of Windows
-        config_path = "G:\\My Drive\\Codes\\MediCafe\\json\\config.json"
-        crosswalk_path = "G:\\My Drive\\Codes\\MediCafe\\json\\crosswalk.json"
-    
-    try:
-        with open(config_path, 'r') as config_file:
-            if config_path.endswith('.yaml') or config_path.endswith('.yml'):
-                config = yaml.safe_load(config_file)
-            elif config_path.endswith('.json'):
-                config = json.load(config_file, object_pairs_hook=OrderedDict)
-            else:
-                raise ValueError("Unsupported configuration format.")
-            
-            if 'MediLink_Config' not in config:
-                raise KeyError("MediLink_Config key is missing from the loaded configuration.")
-
-        with open(crosswalk_path, 'r') as crosswalk_file:
-            crosswalk = json.load(crosswalk_file)
-
-        return config, crosswalk
-    except ValueError as e:
-        if isinstance(e, UnicodeDecodeError):
-            print("Error decoding file: {}".format(e))
-        else:
-            print("Error parsing file: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
-    except FileNotFoundError:
-        print("One or both configuration files not found. Config: {}, Crosswalk: {}".format(config_path, crosswalk_path))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
-    except KeyError as e:
-        print("Critical configuration is missing: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
-    except Exception as e:
-        print("An unexpected error occurred while loading the configuration: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
-        
-# Logs messages with optional error type and claim data.
-def log(message, config=None, level="INFO", error_type=None, claim=None, verbose=False):
-    
-    # If config is not provided, load it
-    if config is None:
-        config, _ = load_configuration()
-    
-    # Setup logger if not already configured
-    if not logging.root.handlers:
-        local_storage_path = config['MediLink_Config'].get('local_storage_path', '.') if isinstance(config, dict) else '.'
-        log_filename = datetime.now().strftime("Log_%m%d%Y.log")
-        log_filepath = os.path.join(local_storage_path, log_filename)
-        
-        # Set logging level based on verbosity
-        logging_level = logging.DEBUG if verbose else logging.INFO
-        
-        logging.basicConfig(level=logging_level,
-                            format='%(asctime)s - %(levelname)s - %(message)s',
-                            filename=log_filepath,
-                            filemode='a')
-    
-    # Prepare log message
-    claim_data = " - Claim Data: {}".format(claim) if claim else ""
-    error_info = " - Error Type: {}".format(error_type) if error_type else ""
-    full_message = "{} {}{}".format(message, claim_data, error_info)
-
-    # Log the message
-    logger = logging.getLogger()
-    getattr(logger, level.lower())(full_message)

MediLink/MediLink_ERA_decoder.py

@@ -1,192 +0,0 @@
-import os
-import sys
-import csv
-from MediLink_ConfigLoader import load_configuration, log
-from MediLink_DataMgmt import consolidate_csvs
-
-
-"""
-1. ERA File Processing: Implement robust mechanisms for reading and parsing ERA files, addressing potential file integrity issues and accommodating scenarios with multiple payer addresses within a single ERA.
-2. Wildcard File Processing: Enable effective batch processing of ERA files using wildcard patterns in the `--era_file_path` argument, resulting in a unified CSV output.
-3. Date of Service Parsing: Enhance the parsing logic for 'Date of Service' to accommodate different segment identifiers, improving data extraction reliability.
-4. Payer Address Extraction: Fine-tune the logic for extracting payer and provider addresses from ERA files, ensuring only relevant information is captured.
-5. De-persisting Intermediate Files.
-"""
-
-# ERA Parser
-def parse_era_content(content):
-    extracted_data = []
-    normalized_content = content.replace('~\n', '~')
-    lines = normalized_content.split('~')
-    
-    # Reset these values for each new CLP segment
-    record = {}
-    check_eft, payer_address = None, None
-    allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
-    is_payer_section = False  # Flag to identify payer section for accurate address capture
-    
-    for line in lines:
-        segments = line.split('*')
-        
-        if segments[0] == 'TRN' and len(segments) > 2:
-            check_eft = segments[2]
-            
-        # Determine the start and end of the payer section to correctly capture the payer's address
-        if segments[0] == 'N1':
-            if segments[1] == 'PR':  # Payer information starts
-                is_payer_section = True
-                # payer_name = segments[2]  # Can capture payer name here if needed
-            elif segments[1] == 'PE':  # Provider information starts, ending payer section
-                is_payer_section = False
-        
-        # Correctly capture payer address only within payer section
-        if is_payer_section and segments[0] == 'N3' and len(segments) > 1:
-            payer_address = segments[1]
-        
-        if segments[0] == 'CLP' and len(segments) >= 5:
-            if record:
-                if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
-                    adjustment_amount = write_off + patient_responsibility
-
-                # Finalize and append the current record before starting a new one
-                record.update({
-                    # 'Payer Name': payer_name,
-                    'Payer Address': payer_address,
-                    'Allowed Amount': allowed_amount,
-                    'Write Off': write_off,
-                    'Patient Responsibility': patient_responsibility,
-                    'Adjustment Amount': adjustment_amount, 
-                })
-                extracted_data.append(record)
-                
-                # Reset variables for the next record
-                allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
-                # payer_address = None  # Reset address for the next CLP segment if it changes within one ERA file (so no. disable.)
-            
-            # Initialize a new record
-            record = {
-                'Check EFT': check_eft,
-                'Chart Number': segments[1],
-                'Payer Address': payer_address,
-                'Amount Paid': segments[4],
-                'Charge': segments[3],  # Total submitted charges for the claim
-            }
-        
-        elif segments[0] == 'CAS':
-            # Parsing CAS segments for Write Off and Patient Responsibility
-            if segments[1] == 'CO':  # Write Off
-                write_off += float(segments[3])
-            elif segments[1] == 'PR':  # Patient Responsibility
-                patient_responsibility += float(segments[3])
-            elif segments[1] == 'OA':  # Capture Adjustment Amount from CAS*OA segment
-                adjustment_amount += float(segments[3])
-        
-        elif segments[0] == 'AMT' and segments[1] == 'B6':
-            # Allowed Amount from AMT segment
-            allowed_amount += float(segments[2])
-        
-        elif segments[0] == 'DTM' and (segments[1] == '232' or segments[1] == '472'):
-            record['Date of Service'] = segments[2]
-    
-
-    if record:
-    # Final record handling
-        if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
-            adjustment_amount = write_off + patient_responsibility
-        # Append the last record
-        record.update({
-            'Allowed Amount': allowed_amount,
-            'Write Off': write_off,
-            'Patient Responsibility': patient_responsibility,
-            'Adjustment Amount': adjustment_amount, 
-        })
-        extracted_data.append(record)
-        
-    return extracted_data
-
-def translate_era_to_csv(files, output_directory):
-    if not os.path.exists(output_directory):
-        os.makedirs(output_directory)
-    
-    for file_path in files:
-        # Ensure the file is read correctly
-        with open(file_path, 'r') as era_file:
-            era_content = era_file.read()
-        
-        data = parse_era_content(era_content)
-        # print("Parsed Data: ", data)  # DEBUG
-        
-        csv_file_path = os.path.join(output_directory, os.path.basename(file_path) + '.csv')
-        
-        try:
-            # Open the CSV file with explicit newline handling
-            with open(csv_file_path, 'w', newline='') as csv_file:
-                fieldnames = ['Date of Service',
-                              'Check EFT', 
-                              'Chart Number', 
-                              'Payer Address', 
-                              'Amount Paid', 
-                              'Adjustment Amount',
-                              'Allowed Amount',
-                              'Write Off',
-                              'Patient Responsibility',
-                              'Charge'
-                              ]
-                writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
-                
-                writer.writeheader()
-                for record in data:
-                    
-                    # print("Writing record: ", record)
-                    
-                    writer.writerow({
-                        'Date of Service': record.get('Date of Service', ''),
-                        'Check EFT': record.get('Check EFT', ''),
-                        'Chart Number': record.get('Chart Number', ''),
-                        'Payer Address': record.get('Payer Address', ''),
-                        'Amount Paid': record.get('Amount Paid', ''),
-                        'Adjustment Amount': record.get('Adjustment Amount', ''),
-                        'Allowed Amount': record.get('Allowed Amount', ''),
-                        'Write Off': record.get('Write Off', ''),
-                        'Patient Responsibility': record.get('Patient Responsibility', ''),
-                        'Charge': record.get('Charge', ''),
-                    })
-                # Explicitly flush data to ensure it's written
-                csv_file.flush()
-        except Exception as e:
-            print("Error writing CSV: ", e)
-
-# User Interface
-def user_confirm_overwrite(chart_numbers):
-    """Asks the user for confirmation to overwrite an existing file, showing Chart Numbers."""
-    print("The following Chart Numbers are in the existing file:")
-    for number in chart_numbers:
-        print(number)
-    return input("The file already exists. Do you want to overwrite it? (y/n): ").strip().lower() == 'y'
-
-if __name__ == "__main__":
-    # Load configuration
-    
-    config, _ = load_configuration()
-    
-    # Setup logger
-    local_storage_path = config['MediLink_Config']['local_storage_path']
-    
-    # Define output directory
-    output_directory = os.path.join(local_storage_path, "translated_csvs")
-    
-    # Retrieve ERA files from command line arguments
-    files = sys.argv[1:]  # Exclude the script name
-    if not files:
-        log("No ERA files provided as arguments.")
-        sys.exit(1)
-
-    # Translate ERA files to CSV format
-    translate_era_to_csv(files, output_directory)
-    
-    # Consolidate CSVs
-    consolidate_csv_path = consolidate_csvs(output_directory)
-    if consolidate_csv_path:
-        print("Consolidated CSV File Created: {}".format(consolidate_csv_path))
-    else:
-        print("No CSV file was created.")