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

MediLink/MediLink_API_v3.py

@@ -1,8 +1,5 @@
-import time
-import requests
-import yaml
-import json
-import os
+# MediLink_API_v3.py
+import time, requests, yaml, json, os, traceback
 
 try:
     from MediLink import MediLink_ConfigLoader
@@ -64,18 +61,37 @@ class TokenCache:
 
     def get(self, endpoint_name, current_time):
         token_info = self.tokens.get(endpoint_name, {})
-        if token_info and token_info['expires_at'] > current_time:
-            return token_info['access_token']
+        if token_info:
+            expires_at = token_info['expires_at']
+            # Log cache hit and expiration time
+            log_message = "Token for {} expires at {}. Current time: {}".format(endpoint_name, expires_at, current_time)
+            MediLink_ConfigLoader.log(log_message, level="DEBUG")
+
+            if expires_at > current_time:
+                return token_info['access_token']
+
+        # Log cache miss
+        log_message = "No valid token found for {}".format(endpoint_name)
+        MediLink_ConfigLoader.log(log_message, level="INFO")
+
         return None
 
     def set(self, endpoint_name, access_token, expires_in, current_time):
-        # Ensure types are correct
         current_time = ensure_numeric(current_time)
         expires_in = ensure_numeric(expires_in)
-        
+
+        # Log the expires_in value to debug
+        log_message = "Token expires in: {} seconds for {}".format(expires_in, endpoint_name)
+        MediLink_ConfigLoader.log(log_message, level="INFO")
+
+        # Adjust expiration time by subtracting a buffer of 120 seconds
+        expires_at = current_time + expires_in - 120
+        log_message = "Setting token for {}. Expires at: {}".format(endpoint_name, expires_at)
+        MediLink_ConfigLoader.log(log_message, level="INFO")
+
         self.tokens[endpoint_name] = {
             'access_token': access_token,
-            'expires_at': current_time + expires_in - 120
+            'expires_at': expires_at
         }
 
 class BaseAPIClient:
@@ -95,12 +111,16 @@ class APIClient(BaseAPIClient):
         super().__init__(config)
 
     def get_access_token(self, endpoint_name):
+        MediLink_ConfigLoader.log("[Get Access Token] Called for {}".format(endpoint_name), level="DEBUG")
         current_time = time.time()
         cached_token = self.token_cache.get(endpoint_name, current_time)
+        
         if cached_token:
-            MediLink_ConfigLoader.log("Using cached token for endpoint: {}".format(endpoint_name), level="INFO")
+            expires_at = self.token_cache.tokens[endpoint_name]['expires_at']
+            MediLink_ConfigLoader.log("Cached token expires at {}".format(expires_at), level="DEBUG")
             return cached_token
-
+        
+        # If no valid token, fetch a new one
         endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
         token_url = endpoint_config['token_url']
         data = {
@@ -122,65 +142,225 @@ class APIClient(BaseAPIClient):
         expires_in = token_data.get('expires_in', 3600)
 
         self.token_cache.set(endpoint_name, access_token, expires_in, current_time)
-        MediLink_ConfigLoader.log("Obtained new token for endpoint: {}".format(endpoint_name), level="INFO")
+        MediLink_ConfigLoader.log("Obtained NEW token for endpoint: {}".format(endpoint_name), level="INFO")
         return access_token
 
     def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
         token = self.get_access_token(endpoint_name)
+        if token:
+            MediLink_ConfigLoader.log("[Make API Call] Token found for {}".format(endpoint_name), level="DEBUG")
+        else:
+            MediLink_ConfigLoader.log("[Make API Call] No token obtained for {}".format(endpoint_name), level="ERROR")
+            raise ValueError("No access token available for endpoint: {}".format(endpoint_name))
+
         if headers is None:
             headers = {}
         headers.update({'Authorization': 'Bearer {}'.format(token), 'Accept': 'application/json'})
-        url = self.config['MediLink_Config']['endpoints'][endpoint_name]['api_url'] + url_extension
-        
-        # Debug: Print request details
-        # print("Request URL: {}".format(url))
-        # print("Request Headers: {}".format(headers))
-        # print("Request Params: {}".format(params))
-        # print("Request Data: {}".format(data))
-        
-        if call_type == 'GET':
-            response = requests.get(url, headers=headers, params=params)
-        elif call_type == 'POST':
-            headers['Content-Type'] = 'application/json'
-            response = requests.post(url, headers=headers, json=data)
-        elif call_type == 'DELETE':
-            response = requests.delete(url, headers=headers)
-        else:
-            raise ValueError("Unsupported call type")
+        base_url = self.config['MediLink_Config']['endpoints'][endpoint_name]['api_url']
+        url = base_url + url_extension
+
+        try:
+            # Make the API call based on call_type
+            if call_type == 'GET':
+                response = requests.get(url, headers=headers, params=params)
+            elif call_type == 'POST':
+                headers['Content-Type'] = 'application/json'
+                response = requests.post(url, headers=headers, json=data)
+            elif call_type == 'DELETE':
+                response = requests.delete(url, headers=headers)
+            else:
+                raise ValueError("Unsupported call type: {}".format(call_type))
+
+            masked_headers = headers.copy()
+            if 'Authorization' in masked_headers:
+                masked_headers['Authorization'] = 'Bearer ***'
 
-        if response.status_code >= 400:
-            error_message = "Error {}: {}".format(response.status_code, response.text)
-            MediLink_ConfigLoader.log(error_message, level="ERROR")
+            # Raise an HTTPError if the response was unsuccessful
             response.raise_for_status()
 
-        return response.json()
+            return response.json()
+
+        except requests.exceptions.HTTPError as http_err:
+            # If http_err.response is None, handle it separately
+            if http_err.response is None:
+                log_message = (
+                    "HTTPError with no response. "
+                    "URL: {url}, "
+                    "Method: {method}, "
+                    "Params: {params}, "
+                    "Data: {data}, "
+                    "Headers: {masked_headers}, "
+                    "Error: {error}"
+                ).format(
+                    url=url,
+                    method=call_type,
+                    params=params,
+                    data=data,
+                    masked_headers=masked_headers,
+                    error=str(http_err)
+                )
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+            else:
+                # Extract status code and full response content
+                status_code = http_err.response.status_code
+                try:
+                    # Try to log the JSON content if available
+                    response_content = http_err.response.json()
+                except ValueError:
+                    # Fallback to raw text if JSON decoding fails
+                    response_content = http_err.response.text
+
+                log_message = (
+                    "HTTPError: Status Code: {status}, "
+                    "URL: {url}, "
+                    "Method: {method}, "
+                    "Params: {params}, "
+                    "Data: {data}, "
+                    "Headers: {masked_headers}, "
+                    "Response Content: {content}"
+                ).format(
+                    status=status_code,
+                    url=url,
+                    method=call_type,
+                    params=params,
+                    data=data,
+                    masked_headers=masked_headers,
+                    content=response_content
+                )
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+            raise
+
+        except requests.exceptions.RequestException as req_err:
+            # Log connection-related issues or other request exceptions
+            log_message = (
+                "RequestException: No response received. "
+                "URL: {url}, "
+                "Method: {method}, "
+                "Params: {params}, "
+                "Data: {data}, "
+                "Headers: {masked_headers}, "
+                "Error: {error}"
+            ).format(
+                url=url,
+                method=call_type,
+                params=params,
+                data=data,
+                masked_headers=masked_headers,
+                error=str(req_err)
+            )
+            MediLink_ConfigLoader.log(log_message, level="ERROR")
+            raise
 
-def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
-    client = APIClient()
-    config, _ = MediLink_ConfigLoader.load_configuration()
-    endpoints = config['MediLink_Config']['endpoints']
+        except Exception as e:
+            # Capture traceback for unexpected exceptions
+            tb = traceback.format_exc()
+            log_message = (
+                "Unexpected error: {error}. "
+                "URL: {url}, "
+                "Method: {method}, "
+                "Params: {params}, "
+                "Data: {data}, "
+                "Headers: {masked_headers}. "
+                "Traceback: {traceback}"
+            ).format(
+                error=str(e),
+                url=url,
+                method=call_type,
+                params=params,
+                data=data,
+                masked_headers=masked_headers,
+                traceback=tb
+            )
+            MediLink_ConfigLoader.log(log_message, level="ERROR")
+            raise
+
+def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILITY'):
+    """
+    Fetches the payer name using the provided APIClient instance.
 
-    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())
+    :param client: An instance of APIClient
+    :param payer_id: The payer ID to fetch
+    :param primary_endpoint: The primary endpoint to use
+    :return: The payer name if found
+    """
+    # Ensure client is an instance of APIClient
+    if not isinstance(client, APIClient):
+        error_message = "Invalid client provided. Expected an instance of APIClient."
+        print(error_message)
+        MediLink_ConfigLoader.log(error_message, level="ERROR")
+        exit(1)  # Exit the script
+    
+    # BUG Force AVAILITY until I can get a payer-list api from any of the other endpoints. 
+    MediLink_ConfigLoader.log("[Fetch payer name from API] Overriding {} with AVAILITY.".format(primary_endpoint), level="DEBUG")
+    primary_endpoint = 'AVAILITY'
+    
+    try:
+        endpoints = config['MediLink_Config']['endpoints']
+    except KeyError as e:
+        error_message = "Configuration loading error: Missing key {0}".format(e)
+        print(error_message)
+        MediLink_ConfigLoader.log(error_message, level="CRITICAL")
+        # Attempt to reload configuration if key is missing
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        endpoints = config['MediLink_Config']['endpoints']  # Re-attempt to access endpoints
+    
+    # Define endpoint rotation logic
+    endpoint_order = ([primary_endpoint] + 
+                      [endpoint for endpoint in endpoints if endpoint != primary_endpoint]
+                      if primary_endpoint in endpoints else list(endpoints.keys()))
 
     for endpoint_name in endpoint_order:
         try:
-            response = client.make_api_call(endpoint_name, 'GET', config['MediLink_Config']['endpoints'][endpoint_name].get('payer_list_endpoint', '/availity-payer-list'), {'payerId': payer_id})
+            endpoint_url = endpoints[endpoint_name].get('payer_list_endpoint', '/availity-payer-list')
+            response = client.make_api_call(endpoint_name, 'GET', endpoint_url, {'payerId': payer_id})
+            
+            # Check if response exists
+            if not response:
+                log_message = "No response from {0} for Payer ID {1}".format(endpoint_name, payer_id)
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+                continue
+            
+            # Check if the status code is not 200
+            status_code = response.get('statuscode', 200)
+            if status_code != 200:
+                log_message = "Invalid response status code {0} from {1} for Payer ID {2}. Message: {3}".format(
+                    status_code, endpoint_name, payer_id, response.get('message', 'No message'))
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+                continue
+            
+            # Extract payers and validate the response structure
             payers = response.get('payers', [])
-            if payers:
-                payer_name = payers[0].get('displayName', payers[0].get('name'))
-                MediLink_ConfigLoader.log("Successfully found payer at {} for ID {}: {}".format(endpoint_name, payer_id, payer_name), level="INFO")
-                return payer_name
-            else:
-                MediLink_ConfigLoader.log("No payer found at {} for ID: {}. Trying next available endpoint.".format(endpoint_name, payer_id), level="INFO")
+            if not payers:
+                log_message = "No payer found at {0} for ID {1}. Response: {2}".format(endpoint_name, payer_id, response)
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="INFO")
+                continue
+            
+            # Extract the payer name from the first payer in the list
+            payer_name = payers[0].get('displayName') or payers[0].get('name')
+            if not payer_name:
+                log_message = "Payer name not found in the response from {0} for ID {1}. Response: {2}".format(
+                    endpoint_name, payer_id, response)
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+                continue
+            
+            # Log successful payer retrieval
+            log_message = "Found payer at {0} for ID {1}: {2}".format(endpoint_name, payer_id, payer_name)
+            MediLink_ConfigLoader.log(log_message, level="INFO")
+            return payer_name
+        
         except Exception as e:
-            MediLink_ConfigLoader.log("API call to {} failed: {}".format(endpoint_name, e), level="ERROR")
+            error_message = "Error calling {0} for Payer ID {1}. Exception: {2}".format(endpoint_name, payer_id, e)
+            MediLink_ConfigLoader.log(error_message, level="INFO")
 
-    error_message = "All endpoints exhausted for Payer ID {}.".format(payer_id)
-    MediLink_ConfigLoader.log(error_message, level="CRITICAL")
-    raise ValueError(error_message)
+    # If all endpoints fail
+    final_error_message = "All endpoints exhausted for Payer ID {0}.".format(payer_id)
+    print(final_error_message)
+    MediLink_ConfigLoader.log(final_error_message, level="CRITICAL")
+    raise ValueError(final_error_message)
 
 def get_claim_summary_by_provider(client, tin, first_service_date, last_service_date, payer_id, get_standard_error='false'):
     endpoint_name = 'UHCAPI'
@@ -273,7 +453,8 @@ def is_test_mode(client, body, endpoint_type):
     if client.config.get("MediLink_Config", {}).get("TestMode", True):
         print("Test Mode is enabled! API Call not executed.")
         print("\nIntended request body:", body)
-        MediLink_ConfigLoader.log("Test Mode is enabled! Simulating API response for {}.".format(endpoint_type), level="INFO")
+        MediLink_ConfigLoader.log("Test Mode is enabled! Simulating 1 second delay for API response for {}.".format(endpoint_type), level="INFO")
+        time.sleep(1)
         MediLink_ConfigLoader.log("Intended request body: {}".format(body), level="INFO")
 
         if endpoint_type == 'claim_submission':
@@ -350,11 +531,11 @@ if __name__ == "__main__":
     
     # Define a configuration to enable or disable tests
     test_config = {
-        'test_fetch_payer_name': False,
+        'test_fetch_payer_name': True,
         'test_claim_summary': False,
         'test_eligibility': False,
         'test_eligibility_v3': False,
-        'test_claim_submission': True,
+        'test_claim_submission': False,
     }
     
     try:
@@ -364,10 +545,10 @@ if __name__ == "__main__":
         if test_config.get('test_fetch_payer_name', False):
             try:
                 for case in api_test_cases:
-                    payer_name = fetch_payer_name_from_api(case['payer_id'], client.config)
-                    print("TEST API: Payer Name: {}".format(payer_name))
+                    payer_name = fetch_payer_name_from_api(client, case['payer_id'], client.config)
+                    print("*** TEST API: Payer Name: {}".format(payer_name))
             except Exception as e:
-                print("TEST API: Error in Fetch Payer Name Test: {}".format(e))
+                print("*** TEST API: Error in Fetch Payer Name Test: {}".format(e))
         
         # Test 2: Get Claim Summary
         if test_config.get('test_claim_summary', False):

MediLink/MediLink_APIs.py

@@ -1,7 +1,6 @@
 # Unused archive backup. This has been superceded by API_v2
 
-import time
-import requests
+import time, requests
 try:
     from MediLink import MediLink_ConfigLoader
 except ImportError:

MediLink/MediLink_ClaimStatus.py

@@ -1,4 +1,6 @@
+# MediLink_ClaimStatus.py
 from datetime import datetime, timedelta
+import os
 import MediLink_API_v3
 
 try:
@@ -19,7 +21,7 @@ start_date_str = start_date.strftime('%m/%d/%Y')
 billing_provider_tin = config['MediLink_Config'].get('billing_provider_tin')
 
 # Define the list of payer_id's to iterate over
-payer_ids = ['87726']  # Default value
+payer_ids = ['87726']  # Default value, getting a bad request error when trying to get all payer_ids.
 # Allowed payer id's for UHC
 # payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']
 
@@ -27,19 +29,23 @@ payer_ids = ['87726']  # Default value
 client = MediLink_API_v3.APIClient()
 
 # Function to process and display the data in a compact, tabular format
-def display_claim_summary(claim_summary, payer_id):
+def display_claim_summary(claim_summary, payer_id, output_file):
     claims = claim_summary.get('claims', [])
     
     # Display header
     header = "Payer ID: {} | Start Date: {} | End Date: {}".format(payer_id, start_date_str, end_date_str)
     print(header)
+    output_file.write(header + "\n")  # Write header to the output file
     print("=" * len(header))
+    output_file.write("=" * len(header) + "\n")  # Write separator to the output file
 
     # Table header
     table_header = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
         "Claim #", "Status", "Patient", "Proc.", "Serv.", "Allowed", "Paid", "Pt Resp", "Charged")
     print(table_header)
+    output_file.write(table_header + "\n")  # Write table header to the output file
     print("-" * len(table_header))
+    output_file.write("-" * len(table_header) + "\n")  # Write separator to the output file
 
     # Process each claim and display it in a compact format
     claims_dict = {}
@@ -90,6 +96,7 @@ def display_claim_summary(claim_summary, payer_id):
                     claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
                 )
                 print(table_row)
+                output_file.write(table_row + "\n")  # Write each row to the output file
 
                 if claim_data['total_paid_amount'] == '0.00':
                     for xwalk in claim_data['claim_xwalk_data']:
@@ -109,6 +116,7 @@ def display_claim_summary(claim_summary, payer_id):
                         claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
                     )
                     print(table_row + " (Duplicate with different data)")
+                    output_file.write(table_row + " (Duplicate with different data)\n")  # Write each row to the output file
 
                     if claim_data['total_paid_amount'] == '0.00':
                         for xwalk in claim_data['claim_xwalk_data']:
@@ -128,6 +136,7 @@ def display_claim_summary(claim_summary, payer_id):
                 claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
             )
             print(table_row)
+            output_file.write(table_row + "\n")  # Write each row to the output file
 
             if claim_data['total_paid_amount'] == '0.00':
                 for xwalk in claim_data['claim_xwalk_data']:
@@ -138,7 +147,13 @@ def display_claim_summary(claim_summary, payer_id):
                     clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
                     print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
 
-# Loop through each payer_id and call the API, then display the claim summary
-for payer_id in payer_ids:
-    claim_summary = MediLink_API_v3.get_claim_summary_by_provider(client, billing_provider_tin, start_date_str, end_date_str, payer_id=payer_id)
-    display_claim_summary(claim_summary, payer_id)
+# Create a temporary file to store the claim summary
+output_file_path = os.path.join(os.getenv('TEMP'), 'claim_summary_report.txt')
+with open(output_file_path, 'w') as output_file:
+    # Loop through each payer_id and call the API, then display the claim summary
+    for payer_id in payer_ids:
+        claim_summary = MediLink_API_v3.get_claim_summary_by_provider(client, billing_provider_tin, start_date_str, end_date_str, payer_id=payer_id)
+        display_claim_summary(claim_summary, payer_id, output_file)  # Pass output_file to the display function
+
+# Open the generated file in Notepad
+os.startfile(output_file_path)  # Use os.startfile for better handling

MediLink/MediLink_ConfigLoader.py

@@ -1,11 +1,7 @@
-import os
-import json
-import logging
+# MediLink_ConfigLoader.py
+import os, json, logging, sys, platform, yaml
 from datetime import datetime
 from collections import OrderedDict
-import sys
-import platform
-import yaml
 
 """
 This function should be generalizable to have a initialization script over all the Medi* functions
@@ -61,7 +57,7 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
         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):
+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:
@@ -72,7 +68,11 @@ def log(message, config=None, level="INFO", error_type=None, claim=None):
         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)
-        logging.basicConfig(level=logging.INFO,
+        
+        # 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')