medicafe 0.240419.2__py3-none-any.whl → 0.240613.0__py3-none-any.whl

MediLink/MediLink_Down.py

@@ -1,146 +1,117 @@
+# MediLink_Down.py
 import os
-import logging
 import argparse
 import shutil
-from datetime import datetime
 import glob
-import MediLink_ERA_decoder
-from MediLink_DataMgmt import operate_winscp
+from MediLink_Decoder import process_file
+from MediLink_DataMgmt import operate_winscp, consolidate_csvs
 import MediLink_ConfigLoader
+# Import decoders for other file types
 
 """
-We need to make another function that figures out claim rejections and tries to solve them.
+Main triaging function for handling report downloads and processing from various endpoints. This function
+handles downloading reports, moving files, and decoding them into a readable format. The goal is to 
+provide detailed receipt and troubleshooting information for the claims.
 
-1. Config File Path Adjustment: Ensure the configuration file's path is adaptable for various environments, or clearly document the process for setting this path.
-2. Logging Enhancements: Improve the logging mechanism to offer comprehensive insights through both file and console outputs, aiding in troubleshooting and operational monitoring.
-3. CSV Output Refinement: Update the CSV output structure to include essential ERA data such as Payer Address, ensuring completeness and accuracy of information.
-4. CSV Consolidation Logic: Develop logic for intelligently consolidating CSV outputs from batch-processed ERA files, ensuring coherent and comprehensive data aggregation.
-5. Secure Endpoint Authentication: Establish a secure method for inputting and storing endpoint authentication details, enhancing script security.
-6. Automated Endpoint Processing: Integrate automated looping through configured endpoints for ERA file retrieval, maximizing efficiency and reducing manual oversight.
-7. Configuration Key Accuracy: Audit the script to correct any inaccuracies in configuration key references, ensuring seamless configuration data retrieval.
+Key Enhancements:
+- Handle multiple file types (ERA, 277, etc.) and integrate respective decoders.
+- Support multi-endpoint processing.
+- Implement progress tracking for long-running operations.
+- Provide both consolidated CSV output and in-memory parsed data for real-time display.
 """
-
-# Setup basic logging
-def setup_logger(local_storage_path):
-    # Define a reasonable name for the log file, e.g., "MediLink_Down_Process.log"
-    log_filename = datetime.now().strftime("MediLink_Down_Process_%m%d%Y.log")
-    log_filepath = os.path.join(local_storage_path, log_filename)
-
-    for handler in logging.root.handlers[:]:
-        logging.root.removeHandler(handler)
-    
-    # Setup logging to file
-    logging.basicConfig(level=logging.INFO,
-                        format='%(asctime)s - %(levelname)s - %(message)s',
-                        filename=log_filepath,  # Direct logging to a file in local_storage_path
-                        filemode='a')  # Append mode
-
-    # If you also want to see the logs in the console, add a StreamHandler
-    #console_handler = logging.StreamHandler()
-    #console_handler.setLevel(logging.INFO)
-    #formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-    #console_handler.setFormatter(formatter)
-    #logging.getLogger('').addHandler(console_handler)
-
-# Because I can't figure out how to get it to work directly in the WinSCP command.
-# And on the Windows XP machine apparently the default path is C:\\ ...
-# This needs to get fixed. Ugh.
-def move_downloaded_files(local_storage_path):
-    # Define the target directory for storing downloaded files
+def move_downloaded_files(local_storage_path, config):
     local_response_directory = os.path.join(local_storage_path, "responses")
     
     if not os.path.exists(local_response_directory):
         os.makedirs(local_response_directory)
     
-    # Identify all downloaded .era files in the current directory
-    # downloaded_files = [f for f in os.listdir('.') if f.endswith('.era')]
-    downloaded_files = [f for f in os.listdir('C:\\Users\\danie\\OneDrive\\Documents') if f.endswith('.era')]
+    download_dir = config['MediLink_Config']['local_storage_path']
+    file_extensions = ['.era', '.277']  # Extendable list of file extensions
     
-    # Move each file to the local_response_directory
-    for file in downloaded_files:
-        source_path = os.path.join('C:\\Users\\danie\\OneDrive\\Documents', file)
-        # source_path = os.path.join('.', file)    for the XP machine? -- This whole thing needs repaired. 
-        destination_path = os.path.join(local_response_directory, file)
-        shutil.move(source_path, destination_path)
-        logging.info("Moved '{}' to '{}'".format(file, local_response_directory))
+    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)
+            destination_path = os.path.join(local_response_directory, file)
+            shutil.move(source_path, destination_path)
+            MediLink_ConfigLoader.log("Moved '{}' to '{}'".format(file, local_response_directory))
 
-def find_era_files(era_file_path):
-    """
-    Find all files matching the era_file_path pattern.
-    This function normalizes the path and supports wildcard patterns.
-    """
-    # Normalize the path to handle slashes correctly
-    normalized_path = os.path.normpath(era_file_path)
+def find_files(file_path_pattern):
+    normalized_path = os.path.normpath(file_path_pattern)
 
-    # Handling different wildcard scenarios
     if "*" in normalized_path:
-        # Use glob to find all files matching the pattern
         matching_files = glob.glob(normalized_path)
-        # Normalize paths in the resulting list
         return [os.path.normpath(file) for file in matching_files]
     else:
-        # Single file specified, return it in a list if it exists
         return [normalized_path] if os.path.exists(normalized_path) else []
 
+def translate_files(files, output_directory):
+    translated_files = []
+    for file in files:
+        try:
+            process_file(file, output_directory)
+            csv_file_path = os.path.join(output_directory, os.path.basename(file) + '_decoded.csv')
+            MediLink_ConfigLoader.log("Translated file to CSV: {}".format(csv_file_path), level="INFO")
+            translated_files.append(csv_file_path)
+        except ValueError as ve:
+            MediLink_ConfigLoader.log("Unsupported file type: {}".format(file), level="WARNING")
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error processing file {}: {}".format(file, e), level="ERROR")
+    
+    consolidate_csv_path = consolidate_csvs(output_directory, file_prefix="Consolidated", interactive=True)
+    MediLink_ConfigLoader.log("Consolidated CSV path: {}".format(consolidate_csv_path), level="INFO")
+    return consolidate_csv_path, translated_files
+
+def display_translated_files(translated_files):
+    print("\nTranslated Files Summary:")
+    for file in translated_files:
+        print(" - {}",format(file))
+
 def main(desired_endpoint='AVAILITY'):
-    parser = argparse.ArgumentParser(description="Process ERA 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") # Default handling of json path
+    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('--desired_endpoint', type=str, help='The desired endpoint key from the configuration.', default=desired_endpoint)
-    parser.add_argument('--era_file_path', type=str, help='Optional: Specify a path to an ERA file for direct translation.', default=None)
+    parser.add_argument('--file_path_pattern', type=str, help='Optional: Specify a path pattern for files for direct translation.', default=None)
     args = parser.parse_args()
     
-    # Setup Logger, Load configuration and output directory
     config, _ = MediLink_ConfigLoader.load_configuration(args.config_path)
     local_storage_path = config['MediLink_Config']['local_storage_path']
-    setup_logger(local_storage_path)
     output_directory = os.path.join(local_storage_path, "translated_csvs")
-     
-    # Direct ERA file translation if a file path is provided
-    if args.era_file_path:
-        era_files = find_era_files(args.era_file_path)
-        if era_files:
-            era_files_str = ', '.join(era_files)
-            logging.info("Translating ERA files: {}".format(era_files_str))
-            MediLink_ERA_decoder.translate_era_to_csv(era_files, output_directory)
-            # Instead of returning a single CSV file path, consolidate here
-            consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
-            logging.info("Translation and consolidation completed.")
+    
+    if args.file_path_pattern:
+        files = find_files(args.file_path_pattern)
+        if files:
+            files_str = ', '.join(files)
+            MediLink_ConfigLoader.log("Translating files: {}".format(files_str), level="INFO")
+            consolidate_csv_path, translated_files = translate_files(files, output_directory)
+            MediLink_ConfigLoader.log("Translation and consolidation completed.", level="INFO")
+            display_translated_files(translated_files)
             return consolidate_csv_path
         else:
-            logging.error("No ERA files found matching: {}".format(args.era_file_path))
+            MediLink_ConfigLoader.log("No files found matching: {}".format(args.file_path_pattern), level="WARNING")
             return
     
-    # TODO This probably needs to be built into a loop that cycles through all 3 endpoints. 
-    # The loop should use the tdqa or whatever the progress bar is called.
-    print("Please wait...\n")
-    
-    # Validate endpoint key
     endpoint_key = args.desired_endpoint
     if endpoint_key not in config['MediLink_Config']['endpoints']:
-        logging.error("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key))
+        MediLink_ConfigLoader.log("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key), level="WARNING")
         endpoint_key = 'AVAILITY'
     
-    # Retrieve endpoint configuration and local storage path
-    endpoint_config = config['MediLink_Config']['endpoints'][endpoint_key]
-    local_storage_path = config['MediLink_Config']['local_storage_path']
-        
-    # Download ERA files from the configured endpoint
-    downloaded_files = operate_winscp("download", None, endpoint_config, local_storage_path)
+    endpoint_configs = [config['MediLink_Config']['endpoints'][key] for key in config['MediLink_Config']['endpoints']]
+    downloaded_files = []
+
+    for endpoint_config in endpoint_configs:
+        downloaded_files += operate_winscp("download", None, endpoint_config, local_storage_path, config)
+    
+    move_downloaded_files(local_storage_path, config)
     
-    # Translate downloaded ERA files to CSV format
-    translated_csv_paths = []
-    for file in downloaded_files:
-        # TODO This needs to add functionality for differentiating between ERA and 277 or 
-        # whatever else might be included in the download folders.
-        MediLink_ERA_decoder.translate_era_to_csv([file], output_directory)
-        csv_file_path = os.path.join(output_directory, os.path.basename(file) + '.csv')
-        translated_csv_paths.append(csv_file_path)
-        logging.info("Translated ERA to CSV: {}".format(csv_file_path))
+    # Implement progress tracking
+    # from tqdm import tqdm
+    # for file in tqdm(downloaded_files, desc="Translating files"):
+    #     translate_files([file], output_directory)
     
-    # Consolidate new CSVs
-    consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
+    consolidate_csv_path, translated_files = translate_files(downloaded_files, output_directory)
+    display_translated_files(translated_files)
     
-    # Return the list of translated CSV file paths
     return consolidate_csv_path
 
 if __name__ == "__main__":

MediLink/MediLink_ERA_decoder.py

@@ -1,9 +1,10 @@
 import os
-import logging
 import sys
-from MediLink_ConfigLoader import setup_logger, load_configuration
+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.
@@ -170,7 +171,6 @@ if __name__ == "__main__":
     
     # Setup logger
     local_storage_path = config['MediLink_Config']['local_storage_path']
-    setup_logger(local_storage_path)
     
     # Define output directory
     output_directory = os.path.join(local_storage_path, "translated_csvs")
@@ -178,7 +178,7 @@ if __name__ == "__main__":
     # Retrieve ERA files from command line arguments
     files = sys.argv[1:]  # Exclude the script name
     if not files:
-        logging.error("No ERA files provided as arguments.")
+        log("No ERA files provided as arguments.")
         sys.exit(1)
 
     # Translate ERA files to CSV format