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

MediBot/update_medicafe.py

@@ -1,8 +1,57 @@
-import subprocess
-import sys
-from tqdm import tqdm
-import requests
-import time
+#update_medicafe.py
+import subprocess, sys, requests, time
+
+def get_installed_version(package):
+    try:
+        process = subprocess.Popen(
+            [sys.executable, '-m', 'pip', 'show', package],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        stdout, stderr = process.communicate()
+        if process.returncode == 0:
+            for line in stdout.decode().splitlines():
+                if line.startswith("Version:"):
+                    return line.split(":", 1)[1].strip()
+        return None
+    except Exception as e:
+        print("Error retrieving installed version: {}".format(e))
+        return None
+
+def get_latest_version(package, retries=3, delay=1):
+    """
+    Fetch the latest version of the specified package from PyPI with retries.
+    """
+    for attempt in range(1, retries + 1):
+        try:
+            response = requests.get("https://pypi.org/pypi/{}/json".format(package), timeout=10)
+            response.raise_for_status()  # Raise an error for bad responses
+            data = response.json()
+            latest_version = data['info']['version']
+            
+            # Print the version with attempt information
+            if attempt == 1:
+                print("Latest available version: {}".format(latest_version))
+            else:
+                print("Latest available version: {} ({} attempt)".format(latest_version, attempt))
+            
+            # Check if the latest version is different from the current version
+            current_version = get_installed_version(package)
+            if current_version and compare_versions(latest_version, current_version) == 0:
+                # If the versions are the same, perform a second request
+                time.sleep(delay)
+                response = requests.get("https://pypi.org/pypi/{}/json".format(package), timeout=10)
+                response.raise_for_status()
+                data = response.json()
+                latest_version = data['info']['version']
+            
+            return latest_version  # Return the version after the check
+        except requests.RequestException as e:
+            print("Attempt {}: Error fetching latest version: {}".format(attempt, e))
+            if attempt < retries:
+                print("Retrying in {} seconds...".format(delay))
+                time.sleep(delay)
+    return None
 
 def check_internet_connection():
     try:
@@ -11,47 +60,88 @@ def check_internet_connection():
     except requests.ConnectionError:
         return False
 
-def upgrade_medicafe(package):
-    try:
-        # Check internet connection
-        if not check_internet_connection():
-            print("Error: No internet connection detected. Please check your internet connection and try again.")
-            sys.exit(1)
+def compare_versions(version1, version2):
+    v1_parts = list(map(int, version1.split(".")))
+    v2_parts = list(map(int, version2.split(".")))
+    return (v1_parts > v2_parts) - (v1_parts < v2_parts)
+
+def upgrade_package(package, retries=3, delay=2):  # Updated retries to 3
+    """
+    Attempts to upgrade the package multiple times with delays in between.
+    """
+    if not check_internet_connection():
+        print("Error: No internet connection detected. Please check your internet connection and try again.")
+        sys.exit(1)
+    
+    for attempt in range(1, retries + 1):
+        print("Attempt {} to upgrade {}...".format(attempt, package))
+        process = subprocess.Popen(
+            [
+                sys.executable, '-m', 'pip', 'install', '--upgrade',
+                package, '--no-cache-dir', '--disable-pip-version-check', '-q'
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
         
-        total_progress = 200  # Total progress for two runs
+        stdout, stderr = process.communicate()
         
-        with tqdm(total=total_progress, desc="Upgrading %s" % package, unit="%") as progress_bar:
-            stdout_accumulator = b""
-            stderr_accumulator = b""
-            
-            for _ in range(2):  # Run pip install twice
-                process = subprocess.Popen([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-cache-dir', '--disable-pip-version-check', '--no-deps'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = process.communicate()
-                stdout_accumulator += stdout
-                stderr_accumulator += stderr
-                
-                if process.returncode != 0:
-                    # If the return code is non-zero, print error details
-                    print("Error: Upgrade failed. Details:")
-                    print("stdout:", stdout)
-                    print("stderr:", stderr)
-                    sys.exit(1)
-                
-                progress_bar.update(total_progress // 2)  # Update progress bar
-                
-                # Add a 3-second sleep between runs
-                time.sleep(3)
-                
-            progress_bar.update(total_progress // 2)  # Update progress bar
-            print("stdout:", stdout_accumulator.decode("utf-8"))
-            print("stderr:", stderr_accumulator.decode("utf-8"))
-            time.sleep(1)
-    except Exception as e:
-        # Log any other exceptions
-        print("Error:", e)
-        time.sleep(3)
+        if process.returncode == 0:
+            print(stdout.decode().strip())
+            new_version = get_installed_version(package)  # Get new version after upgrade
+            if compare_versions(new_version, get_latest_version(package)) >= 0:  # Compare versions
+                if attempt == 1:
+                    print("Upgrade succeeded!")
+                else:
+                    print("Attempt {}: Upgrade succeeded!".format(attempt))
+                time.sleep(delay)
+                return True
+            else:
+                print("Upgrade failed. Current version remains: {}".format(new_version))
+                if attempt < retries:
+                    print("Retrying in {} seconds...".format(delay))
+                    time.sleep(delay)
+        else:
+            print(stderr.decode().strip())
+            print("Attempt {}: Upgrade failed.".format(attempt))
+            if attempt < retries:
+                print("Retrying in {} seconds...".format(delay))
+                time.sleep(delay)
+    
+    print("Error: All upgrade attempts failed.")
+    return False
+
+def main():
+    package = "medicafe"
+    
+    current_version = get_installed_version(package)
+    if not current_version:
+        print("{} is not installed.".format(package))
         sys.exit(1)
+    
+    latest_version = get_latest_version(package)
+    if not latest_version:
+        print("Could not retrieve the latest version information.")
+        sys.exit(1)
+    
+    print("Current version of {}: {}".format(package, current_version))
+    print("Latest version of {}: {}".format(package, latest_version))
+    
+    if compare_versions(latest_version, current_version) > 0:
+        print("A newer version is available. Proceeding with upgrade.")
+        if upgrade_package(package):
+            # Verify upgrade
+            time.sleep(3)
+            new_version = get_installed_version(package)
+            if compare_versions(new_version, latest_version) >= 0:
+                print("Upgrade successful. New version: {}".format(new_version))
+            else:
+                print("Upgrade failed. Current version remains: {}".format(new_version))
+                sys.exit(1)
+        else:
+            sys.exit(1)
+    else:
+        print("You already have the latest version installed.")
 
 if __name__ == "__main__":
-    medicafe_package = "medicafe"
-    upgrade_medicafe(medicafe_package)
+    main()

MediLink/MediLink.py

@@ -1,22 +1,21 @@
-import os
+# MediLink.py
+import os, sys
 import MediLink_Down
 import MediLink_Up
 import MediLink_ConfigLoader
 import MediLink_DataMgmt
 
 # For UI Functions
-import os
 import MediLink_UI  # Import UI module for handling all user interfaces
 from tqdm import tqdm
 
 # Add parent directory of the project to the Python path
-import 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)
 
 from MediBot import MediBot_Preprocessor_lib
 load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
-from MediBot import MediBot_Crosswalk_Library
 
 # Retrieve insurance options with codes and descriptions
 config, _ = MediLink_ConfigLoader.load_configuration()
@@ -58,7 +57,7 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     TODO: Implement a function to provide `patient_insurance_mapping` from a reliable source.
     """
     if patient_insurance_type_mapping is None:
-        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.")
+        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="WARNING")
         patient_insurance_type_mapping = {}
     
     for data in detailed_patient_data:
@@ -86,7 +85,7 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     
     # Load insurance data from MAINS to create a mapping from insurance names to their respective IDs
     insurance_to_id = load_insurance_data_from_mains(config)
-    MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)))
+    MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)), level="INFO")
 
     for personal_info, insurance_info, service_info, service_info_2, service_info_3 in MediLink_DataMgmt.read_fixed_width_data(file_path):
         parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
@@ -135,46 +134,86 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     # Return only the enriched detailed patient data, eliminating the need for a separate summary list
     return detailed_patient_data
 
-def check_for_new_remittances(config):
+def check_for_new_remittances(config=None):
+    """
+    Function to check for new remittance files across all configured endpoints.
+    Loads the configuration, validates it, and processes each endpoint to download and handle files.
+    Accumulates results from all endpoints and processes them together at the end.
+    """
+    # Start the process and log the initiation
+    MediLink_ConfigLoader.log("Starting check_for_new_remittances function")
     print("\nChecking for new files across all endpoints...")
-    endpoints = config['MediLink_Config']['endpoints']
-    processed_endpoints = []
-    
-    if isinstance(endpoints, dict): # BUG This check can probably be removed later.
-        for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
-            if 'remote_directory_down' in endpoint_info:  # Check if the 'remote_directory_down' key exists
-                #print("Processing endpoint: ", endpoint_info['name']) 
-                # BUG (Debug and verbosity removal) this is really for debug only. Positive statements can be muted.
-                try:
-                    ERA_path = MediLink_Down.main(desired_endpoint=endpoint_key)
-                    processed_endpoints.append((endpoint_info['name'], ERA_path))
-                    MediLink_ConfigLoader.log("Results for {} saved to: {}".format(endpoint_info['name'], ERA_path))
-                    # TODO (Low SFTP - Download side) This needs to check to see if this actually worked maybe winscplog before saying it completed successfully 
-                    # Check if there is commonality with the upload side so we can use the same validation function.
-                except Exception as e:
-                    print("An error occurred while checking remittances for {}: {}".format(endpoint_info['name'], e))
-            else:
-                MediLink_ConfigLoader.log("Skipping endpoint '{}' as it does not have 'remote_directory_down' configured.".format(endpoint_info['name']))
+    MediLink_ConfigLoader.log("Checking for new files across all endpoints...")
+
+    # Step 1: Load and validate the configuration
+    if config is None:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+
+    if not config or 'MediLink_Config' not in config or 'endpoints' not in config['MediLink_Config']:
+        MediLink_ConfigLoader.log("Error: Config is missing necessary sections. Aborting...", level="ERROR")
+        return
+
+    endpoints = config['MediLink_Config'].get('endpoints')
+    if not isinstance(endpoints, dict):
+        MediLink_ConfigLoader.log("Error: 'endpoints' is not a dictionary. Aborting...", level="ERROR")
+        return
+
+    # Lists to accumulate all consolidated records and translated files across all endpoints
+    all_consolidated_records = []
+    all_translated_files = []
+
+    # Step 2: Process each endpoint and accumulate results
+    for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
+        # Validate endpoint structure
+        if not endpoint_info or not isinstance(endpoint_info, dict):
+            MediLink_ConfigLoader.log("Error: Invalid endpoint structure for {}. Skipping...".format(endpoint_key), level="ERROR")
+            continue
+
+        if 'remote_directory_down' in endpoint_info:
+            # Process the endpoint and handle the files
+            MediLink_ConfigLoader.log("Processing endpoint: {}".format(endpoint_key))
+            consolidated_records, translated_files = process_endpoint(endpoint_key, endpoint_info, config)
+            
+            # Accumulate the results for later processing
+            if consolidated_records:
+                all_consolidated_records.extend(consolidated_records)
+            if translated_files:
+                all_translated_files.extend(translated_files)
+        else:
+            MediLink_ConfigLoader.log("Skipping endpoint '{}'. 'remote_directory_down' not configured.".format(endpoint_info.get('name', 'Unknown')), level="WARNING")
+
+    # Step 3: After processing all endpoints, handle the accumulated results
+    if all_consolidated_records:
+        MediLink_Down.display_consolidated_records(all_consolidated_records)  # Ensure this is called only once
+        MediLink_Down.prompt_csv_export(all_consolidated_records, config['MediLink_Config']['local_storage_path'])
     else:
-        print("Error: Endpoint config is not a 'dictionary' as expected.")
-    # Check if all ERA paths are the same
-    unique_era_paths = set(path for _, path in processed_endpoints)
-    if len(unique_era_paths) == 1:
-        common_era_path = unique_era_paths.pop()  # Get the common ERA path
-        endpoints_list = ", ".join(endpoint for endpoint, _ in processed_endpoints)
-        print("\nProcessed Endpoints: {}".format(endpoints_list))
-        print("File located at: {}\n".format(common_era_path))
-        # TODO (MediPost) These prints will eventually be logs when MediPost is made.
+        MediLink_ConfigLoader.log("No records to display after processing all endpoints.", level="WARNING")
+        print("No records to display after processing all endpoints.")
+
+def process_endpoint(endpoint_key, endpoint_info, config):
+    """
+    Helper function to process a single endpoint.
+    Downloads files from the endpoint, processes them, and returns the consolidated records and translated files.
+    """
+    try:
+        # Process the files for the given endpoint
+        local_storage_path = config['MediLink_Config']['local_storage_path']
+        MediLink_ConfigLoader.log("[Process Endpoint] Local storage path set to {}".format(local_storage_path))
+        downloaded_files = MediLink_Down.operate_winscp("download", None, endpoint_info, local_storage_path, config)
         
-    else:
-        if processed_endpoints:
-            print("\nProcessed Endpoints:")
-            for endpoint, path in processed_endpoints:
-                print("Endpoint: {}, ERA Path: {}".format(endpoint, path))
+        if downloaded_files:
+            MediLink_ConfigLoader.log("[Process Endpoint] WinSCP Downloaded the following files: \n{}".format(downloaded_files))
+            return MediLink_Down.handle_files(local_storage_path, downloaded_files)
         else:
-            print("No endpoints were processed.")
+            MediLink_ConfigLoader.log("[Process Endpoint]No files were downloaded for endpoint: {}.".format(endpoint_key), level="WARNING")
+            return [], []
+
+    except Exception as e:
+        # Handle any exceptions that occur during the processing
+        MediLink_ConfigLoader.log("Error processing endpoint {}: {}".format(endpoint_key, e), level="ERROR")
+        return [], []
 
-def user_decision_on_suggestions(detailed_patient_data, config):
+def user_decision_on_suggestions(detailed_patient_data, config, insurance_edited):
     """
     Presents the user with all patient summaries and suggested endpoints,
     then asks for confirmation to proceed with all or specify adjustments manually.
@@ -183,11 +222,11 @@ def user_decision_on_suggestions(detailed_patient_data, config):
     although the user decision is persisting. Possibly consider making the current/suggested/confirmed endpoint 
     part of a class that the user can interact with via these menus? Probably better handling that way.
     """
-    # Display summaries of patient details and endpoints.
-    MediLink_UI.display_patient_summaries(detailed_patient_data)
+    if insurance_edited:
+        # Display summaries only if insurance types were edited
+        MediLink_UI.display_patient_summaries(detailed_patient_data)
 
-    # Ask the user if they want to proceed with all suggested endpoints.
-    proceed = MediLink_UI.ask_for_proceeding_with_endpoints()
+    proceed = input("Do you want to proceed with all suggested endpoints? (Y/N): ").strip().lower() == 'y'
 
     # If the user agrees to proceed with all suggested endpoints, confirm them.
     if proceed:
@@ -244,7 +283,9 @@ def main_menu():
     config, crosswalk = MediLink_ConfigLoader.load_configuration() 
     
     # Check to make sure payer_id key is available in crosswalk, otherwise, go through that crosswalk initialization flow
-    MediBot_Crosswalk_Library.check_and_initialize_crosswalk(config)
+    if 'payer_id' not in crosswalk:
+        print("Crosswalk 'payer_id' not found. Please run MediBot_Preprocessor.py with the --update-crosswalk argument.")
+        exit() # BUG Halting the script execution here for now, should be handled in the preprocessor script.
     
     # Check if the application is in test mode
     if config.get("MediLink_Config", {}).get("TestMode", False):
@@ -287,7 +328,7 @@ def main_menu():
             detailed_patient_data = collect_detailed_patient_data(selected_files, config, crosswalk)
             
             # Process the claims submission.
-            handle_submission(detailed_patient_data, config)
+            handle_submission(detailed_patient_data, config, crosswalk)
         elif choice == '3' or (choice == '2' and not all_files):
             # Exit the program if the user chooses to exit or if no files are present.
             MediLink_UI.display_exit_message()
@@ -296,16 +337,17 @@ def main_menu():
             # Display an error message if the user's choice does not match any valid option.
             MediLink_UI.display_invalid_choice()
 
-def handle_submission(detailed_patient_data, config):
+def handle_submission(detailed_patient_data, config, crosswalk):
     """
     Handles the submission process for claims based on detailed patient data.
     This function orchestrates the flow from user decision on endpoint suggestions to the actual submission of claims.
     """
-    # TODO If we get here via a user decline we end up not displaying the patient summary data, but this doesn't happen in the first round. Can be de-tangled later.
-    
+    insurance_edited = False  # Flag to track if insurance types were edited
+
     # Ask the user if they want to edit insurance types
     edit_insurance = input("Do you want to edit insurance types? (y/n): ").strip().lower()
     if edit_insurance in ['y', 'yes', '']:
+        insurance_edited = True  # User chose to edit insurance types
         while True:
             # Bulk edit insurance types
             MediLink_DataMgmt.bulk_edit_insurance_types(detailed_patient_data, insurance_options)
@@ -317,7 +359,7 @@ def handle_submission(detailed_patient_data, config):
                 print("Returning to bulk edit insurance types.")
     
     # Initiate user interaction to confirm or adjust suggested endpoints.
-    adjusted_data = user_decision_on_suggestions(detailed_patient_data, config)
+    adjusted_data = user_decision_on_suggestions(detailed_patient_data, config, insurance_edited)
     
     # Confirm all remaining suggested endpoints.
     confirmed_data = MediLink_DataMgmt.confirm_all_suggested_endpoints(adjusted_data)
@@ -328,7 +370,7 @@ def handle_submission(detailed_patient_data, config):
         if MediLink_Up.confirm_transmission(organized_data):
             if MediLink_Up.check_internet_connection():
                 # Submit claims if internet connectivity is confirmed.
-                _ = MediLink_Up.submit_claims(organized_data, config)
+                _ = MediLink_Up.submit_claims(organized_data, config, crosswalk)
                 # TODO submit_claims will have a receipt return in the future.
             else:
                 # Notify the user of an internet connection error.