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

MediLink/MediLink_Up.py

@@ -1,24 +1,12 @@
+from datetime import datetime
 import os
+import re
 import subprocess
-import logging
-import MediLink_837p_encoder
-from MediLink_837p_encoder_library import log
 from tqdm import tqdm
+import MediLink_837p_encoder
+from MediLink_ConfigLoader import log
 from MediLink_DataMgmt import operate_winscp
 
-"""
-Handles the transmission of files to endpoints and related tasks for the MediLink script.
-
-Functions:
-- check_internet_connection(): Checks for an active internet connection.
-- UPDATE THIS: transmit_files_to_endpoint(converted_files, endpoint_config, local_storage_path): Transmits files to a specified endpoint using WinSCP.
-- handle_transmission_result(transmission_result): Handles the result of the file transmission process.
-- submit_claims(detailed_patient_data_grouped_by_endpoint, config): Submits claims to respective endpoints based on patient data and configuration.
-- confirm_transmission(detailed_patient_data_grouped_by_endpoint): Displays patient data ready for transmission and asks for confirmation.
-
-This module provides functionality for transmitting files, confirming transmissions, and ensuring connectivity for the MediLink script.
-"""
-
 # Internet Connectivity Check
 def check_internet_connection():
     """
@@ -36,25 +24,13 @@ def check_internet_connection():
         else:
             return False
     except Exception as e:
-        print("An error occurred while checking internet connectivity:", e)
+        print("An error occurred checking for internet connectivity:", e)
         return False
-        
-def handle_transmission_result(transmission_result):
-    """
-    Handles the result of the file transmission process. Logs the outcome and provides user feedback.
-
-    :param transmission_result: The result of the file transmission process.
-    """
-    #if transmission_result:
-        #logging.info("Transmission successful")
-        # TODO This needs to do an actual check in the WinSCP log to make sure this is actually true.
-        #print("Files have been successfully transmitted.")
-    #else:
-        #logging.error("Transmission failed")
-        # TODO This needs to do a pull from the WinSCP log to show the user what happened.
-        #print("There was an issue with the file transmission.")
 
 def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
+    # Accumulate submission results
+    submission_results = {}
+    
     if not detailed_patient_data_grouped_by_endpoint:
         print("No new files detected for submission.")
         return
@@ -64,21 +40,35 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
         if not patients_data:  # Skip if no patient data for the endpoint
             continue
 
-        # Confirm transmission to each endpoint with detailed overview
-        if True: #confirm_transmission({endpoint: patients_data}):
+        # Attempt submission to each endpoint
+        if True: #confirm_transmission({endpoint: patients_data}): # Confirm transmission to each endpoint with detailed overview
             if check_internet_connection():
-                # Process and transmit files per endpoint
+                # Process files per endpoint
                 converted_files = MediLink_837p_encoder.convert_files_for_submission(patients_data, config)
                 if converted_files:  # Check if files were successfully converted
-                    # BUG DISABLE TRANSMISSION FOR TESTING
-                    # transmission_result = operate_winscp("upload", converted_files, config['MediLink_Config']['endpoints'][endpoint], config['MediLink_Config']['local_claims_path'])
-                    print("Would have uploaded here!") # DEBUG
-                    
-                    # handle_transmission_result(transmission_result)
-                    # This doesn't really do much
-                    # BUG This has to fail better. If one endpoint is unreachable, it should still try the next endpoint.
-                    # BUG handle_transmission_result is wrong.
+                    # Transmit files per endpoint
+                    try:
+                        operation_type = "upload"
+                        transmission_result = operate_winscp(operation_type, converted_files, config['MediLink_Config']['endpoints'][endpoint], config['MediLink_Config']['local_claims_path'], config)
+                        success_dict = handle_transmission_result(transmission_result, config, operation_type)
+                        submission_results[endpoint] = success_dict
+                        # TODO Future work: Availity SentFiles: Retrieve and interpret the response file from Availity SentFiles to acknowledge successful transfers.
+                    except FileNotFoundError as e:
+                        # Log that the log file is not found
+                        print("Failed to transmit files to {0}. Error: Log file not found - {1}".format(endpoint, str(e)))
+                        submission_results[endpoint] = {"status": False, "error": "Log file not found - " + str(e)}
+
+                    except IOError as e:
+                        # Log IO errors
+                        print("Failed to transmit files to {0}. Error: Input/output error - {1}".format(endpoint, str(e)))
+                        submission_results[endpoint] = {"status": False, "error": "Input/output error - " + str(e)}
+
+                    except Exception as e:
+                        # Log other exceptions
+                        print("Failed to transmit files to {0}. Error: {1}".format(endpoint, str(e)))
+                        submission_results[endpoint] = {"status": False, "error": str(e)}
                 else:
+                    
                     print("No files were converted for transmission to {0}.".format(endpoint))
             else:
                 print("No internet connection detected.")
@@ -88,8 +78,271 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
                     return  # Exiting the function if the user decides not to retry
         else:
             print("Transmission canceled for endpoint {0}.".format(endpoint))
+        
+        # Continue to next endpoint regardless of the previous outcomes
+
+    # Build and display receipt
+    build_and_display_receipt(submission_results, config)
+    
+    print("Claim submission process completed.\n")    
+
+def handle_transmission_result(transmission_result, config, operation_type):
+    """
+    Analyze the outcomes of file transmissions based on WinSCP log entries.
+    
+    :param transmission_result: List of paths for files that were attempted to be transmitted.
+    :param config: Configuration dictionary containing paths and settings.
+    :return: Dictionary mapping each file path to a boolean indicating successful transmission.
+    """
+    log_filename = "winscp_{}.log".format(operation_type)
+    
+    # BUG local_claims_path is where the uploads are only. this needs to have a switch. Check where WinSCP actually logs though.
+    log_path = os.path.join(config['MediLink_Config']['local_claims_path'], log_filename)
+    success_dict = {}
+
+    try:
+        with open(log_path, 'r') as log_file:
+            log_contents = log_file.readlines()
+
+        log("WinSCP Log file opened and contents read successfully.")
+
+        if log_contents is None:
+            log("Unexpected NoneType for log_contents")
+        elif not log_contents:
+            log("Log file '{}' is empty.".format(log_path))
+            success_dict = {file_path: False for file_path in transmission_result}
+        else:
+            last_lines = log_contents[-15:]
+            log("Processing the last {} lines of the log file.".format(len(last_lines)))
+            for file_path in transmission_result:
+                if file_path is None:
+                    log("Error: NoneType file path found in transmission results.")
+                    continue
+                try:
+                    success_message = "Transfer done: '{}'".format(file_path)
+                    log("Looking for: {} in WinSCP log.".format(success_message))
+                    success = any(success_message in line for line in last_lines)
+                    log("Validation: {0} - Transfer done for file: {1}".format(success, file_path))
+                    success_dict[file_path] = success
+                except TypeError as e:
+                    log("TypeError during processing file path '{}': {}".format(file_path, e))
+            log("Completed WinSCP log verification check.")
+
+    except FileNotFoundError:
+        log("Log file '{}' not found.".format(log_path))
+        success_dict = {file_path: False for file_path in transmission_result}
+
+    except IOError as e:
+        log("IO error when handling the log file '{}': {}".format(log_path, e))
+        success_dict = {file_path: False for file_path in transmission_result}
+
+    except Exception as e:
+        log("Error processing the transmission log: {}".format(e))
+        success_dict = {file_path: False for file_path in transmission_result}
+
+    return success_dict
+
+def build_and_display_receipt(submission_results, config):
+    """
+    Define Submission Receipt:
+
+    A receipt of submitted claims is typically attached to each printed facesheet for recordkeeping confirming submission.
+
+    input: accumulated success_dict
+    (historical record won't work because the winscp logs will be incomplete, use clearinghouse to check historical records.)
+
+    2.) Parse each of the 837p files from filepaths in success_dict:
+    
+    Note: each file will only have one receiver name and one date & time of submission. The dictionary should be organized such that the receiver name (for that file) is the key for a list of patients with patient data.
+
+    output: print to screen a pretty ASCII human-readable organized 'receipt' by receiver name using the dictionary data, then dump to a notepad called Receipt_[date of submission].txt at config[MediLink_Config][local_storage_path] and subprocess open the file to the user to see.
+    """
+    # Prepare data for receipt
+    # Organize submission results into a format suitable for the receipt
+    log("Preparing receipt data...")
+    receipt_data = prepare_receipt_data(submission_results)
+
+    # Build the receipt
+    receipt_content = build_receipt_content(receipt_data)
 
-    print("Claim submission completed.\n")
+    # Print the receipt to the screen
+    log("Printing receipt...")
+    print(receipt_content)
+
+    # Save the receipt to a text file
+    save_receipt_to_file(receipt_content, config)
+    
+    # Probably return receipt_data since its the easier to use dictionary
+    return receipt_data
+
+def prepare_receipt_data(submission_results):
+    """
+    Prepare submission results for a receipt, including data from both successful and failed submissions.
+    
+    This function extracts patient names, dates of service, amounts billed, and insurance names from an 837p file.
+    It also includes the date and time of batch claim submission, and the receiver name from the 1000B segment.
+    Data is organized by receiver name and includes both successful and failed submissions.
+    
+    Parameters:
+    - submission_results (dict): Contains submission results grouped by endpoint, with success status.
+    
+    Returns:
+    - dict: Organized data for receipt preparation, including both successful and failed submission details.
+    """
+    receipt_data = {}
+    for endpoint, files in submission_results.items():
+        for file_path, success in files.items():
+            # Parse the 837p file for patient data, regardless of success.
+            patient_data, date_of_submission = parse_837p_file(file_path)
+            
+            if endpoint not in receipt_data:
+                receipt_data[endpoint] = {
+                    "date_of_submission": date_of_submission,
+                    "patients": []
+                }
+
+            # Enhance patient data with success status
+            for patient in patient_data:
+                patient['status'] = success
+            
+            receipt_data[endpoint]["patients"].extend(patient_data)
+    
+    validate_data(receipt_data)
+    return receipt_data
+
+def validate_data(receipt_data):
+    # Simple validation to check if data fields are correctly populated
+    for endpoint, data in receipt_data.items():
+        patients = data.get("patients", [])
+        for index, patient in enumerate(patients, start=1):
+            missing_fields = [field for field in ('name', 'service_date', 'amount_billed', 'insurance_name', 'status') if not patient.get(field)]
+            
+            if missing_fields:
+                # Log the missing fields without revealing PHI
+                log("Receipt Data validation error for endpoint '{}', patient {}: Missing information in fields: {}".format(endpoint, index, ", ".join(missing_fields)))
+    return True
+
+def parse_837p_file(file_path):
+    """
+    Parse an 837p file to extract patient details and date of submission.
+
+    This function reads the specified 837p file, extracts patient details such as name, service date, and amount billed,
+    and retrieves the date of submission from the GS segment. It then organizes this information into a list of dictionaries
+    containing patient data. If the GS segment is not found, it falls back to using the current date and time.
+
+    Parameters:
+    - file_path (str): The path to the 837p file to parse.
+
+    Returns:
+    - tuple: A tuple containing two elements:
+        - A list of dictionaries, where each dictionary represents patient details including name, service date, and amount billed.
+        - A string representing the date and time of submission in the format 'YYYY-MM-DD HH:MM:SS'.
+    """
+    patient_details = []
+    date_of_submission = None
+    try:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            log("Parsing submitted 837p...")
+
+            # Extract the submission date from the GS segment
+            gs_match = re.search(r'GS\*HC\*[^*]*\*[^*]*\*([0-9]{8})\*([0-9]{4})', content)
+            if gs_match:
+                date = gs_match.group(1)
+                time = gs_match.group(2)
+                date_of_submission = datetime.strptime("{}{}".format(date, time), "%Y%m%d%H%M").strftime("%Y-%m-%d %H:%M:%S")
+            else:
+                # Fallback to the current date and time if GS segment is not found
+                date_of_submission = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+            # Split content using 'SE*{count}*{control_number}~' as delimiter
+            patient_records = re.split(r'SE\*\d+\*\d{4}~', content)
+            
+            # Remove any empty strings from list that may have been added from split
+            patient_records = [record for record in patient_records if record.strip()]
+            
+            for record in patient_records:
+                # Extract patient name
+                name_match = re.search(r'NM1\*IL\*1\*([^*]+)\*([^*]+)\*([^*]*)', record)
+                # Extract service date
+                service_date_match = re.search(r'DTP\*472\D*8\*([0-9]{8})', record)
+                # Extract claim amount
+                amount_match = re.search(r'CLM\*[^\*]*\*([0-9]+\.?[0-9]*)', record)
+                # Extract insurance name (payer_name)
+                insurance_name_match = re.search(r'NM1\*PR\*2\*([^*]+)\*', record)
+                
+                if name_match and service_date_match and amount_match:
+                    # Handle optional middle name
+                    middle_name = name_match.group(3).strip() if name_match.group(3) else ""
+                    patient_name = "{} {} {}".format(name_match.group(2), middle_name, name_match.group(1)).strip()
+                    service_date = "{}-{}-{}".format(service_date_match.group(1)[:4], service_date_match.group(1)[4:6], service_date_match.group(1)[6:])
+                    amount_billed = float(amount_match.group(1))
+                    insurance_name = insurance_name_match.group(1)
+                    
+                    patient_details.append({
+                        "name": patient_name,
+                        "service_date": service_date,
+                        "amount_billed": amount_billed,
+                        "insurance_name": insurance_name
+                    })
+    except Exception as e:
+        print("Error reading or parsing the 837p file: {0}".format(str(e)))
+    
+    return patient_details, date_of_submission
+
+def build_receipt_content(receipt_data):
+    """
+    Build the receipt content in a human-readable ASCII format with a tabular data presentation for patient information.
+
+    Args:
+        receipt_data (dict): Dictionary containing receipt data with patient details.
+
+    Returns:
+        str: Formatted receipt content as a string.
+    """
+    # Build the receipt content in a human-readable ASCII format
+    receipt_lines = ["Submission Receipt", "=" * 60, ""]  # Header
+
+    for endpoint, data in receipt_data.items():
+        header = "Endpoint: {0} (Submitted: {1})".format(endpoint, data['date_of_submission'])
+        receipt_lines.extend([header, "-" * len(header)])
+        
+        # Table headers
+        table_header = "{:<20} | {:<15} | {:<15} | {:<20} | {:<10}".format("Patient", "Service Date", "Amount Billed", "Insurance", "Status")
+        receipt_lines.append(table_header)
+        receipt_lines.append("-" * len(table_header))
+        
+        # Adding patient information in a tabular format
+        for patient in data["patients"]:
+            success_status = "SUCCESS" if patient['status'] else "FAILED"
+            patient_info = "{:<20} | {:<15} | ${:<14} | {:<20} | {:<10}".format(
+                patient['name'], 
+                patient['service_date'], 
+                patient['amount_billed'], 
+                patient['insurance_name'], 
+                success_status
+            )
+            receipt_lines.append(patient_info)
+        
+        receipt_lines.append("")  # Blank line for separation
+    
+    receipt_content = "\n".join(receipt_lines)
+    return receipt_content
+
+def save_receipt_to_file(receipt_content, config):
+    try:
+        # Save the receipt content to a text file named Receipt_[date_of_submission].txt
+        # Use the configured local storage path to determine the file location
+        file_name = "Receipt_{0}.txt".format(datetime.now().strftime('%Y%m%d_%H%M%S'))
+        file_path = os.path.join(config['MediLink_Config']['local_claims_path'], file_name)
+        
+        with open(file_path, 'w') as file:
+            file.write(receipt_content)
+        
+        # Open the file automatically for the user
+        os.startfile(file_path)
+    except Exception as e:
+        print("Failed to save or open receipt file:", e)
 
 # Secure File Transmission
 def confirm_transmission(detailed_patient_data_grouped_by_endpoint):
@@ -101,12 +354,15 @@ def confirm_transmission(detailed_patient_data_grouped_by_endpoint):
             lists of detailed patient data as values.
     :param config: Configuration settings loaded from a JSON file.
     """ 
+    # Clear terminal for clarity
+    os.system('cls')
+    
     print("\nReview of patient data ready for transmission:")
     for endpoint, patient_data_list in detailed_patient_data_grouped_by_endpoint.items():
         print("\nEndpoint: {0}".format(endpoint))
         for patient_data in patient_data_list:
             patient_info = "({1}) {0}".format(patient_data['patient_name'], patient_data['patient_id'])
-            print("- {:<35} | {:<5}, ${:<6}, Primary: {}".format(
+            print("- {:<33} | {:<5}, ${:<6}, {}".format(
                 patient_info, patient_data['surgery_date'][:5], patient_data['amount'], patient_data['primary_insurance']))
     
     confirmation = input("\nProceed with transmission to all endpoints? (Y/N): ").strip().lower()

MediLink/MediLink_batch.bat

@@ -1,7 +1,7 @@
 @echo off
 
 :: Execute the Python script
-py F:\TEST-MEDIBOT\MediLink.py
+py C:\Python34\Lib\site-packages\MediLink\MediLink.py
 
 :end_script
 pause

MediLink/test.py

@@ -0,0 +1,74 @@
+import re
+from datetime import datetime
+
+def log(message):
+    print(f"LOG: {message}")
+
+def parse_837p_file(content):
+    patient_details = []
+    date_of_submission = None
+    try:
+    
+        log("Parsing submitted 837p...")
+
+        # Extract the submission date from the GS segment
+        gs_match = re.search(r'GS\*HC\*[^*]*\*[^*]*\*([0-9]{8})\*([0-9]{4})', content)
+        if gs_match:
+            date = gs_match.group(1)
+            time = gs_match.group(2)
+            date_of_submission = datetime.strptime("{}{}".format(date, time), "%Y%m%d%H%M").strftime("%Y-%m-%d %H:%M:%S")
+        else:
+            # Fallback to the current date and time if GS segment is not found
+            date_of_submission = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # Split content using 'SE*{count}*{control_number}~' as delimiter
+        patient_records = re.split(r'SE\*\d+\*\d{4}~', content)
+        
+        # Remove any empty strings from list that may have been added from split
+        patient_records = [record for record in patient_records if record.strip()]
+        
+        for record in patient_records:
+            # Extract patient name
+            name_match = re.search(r'NM1\*IL\*1\*([^*]+)\*([^*]+)\*([^*]*)', record)
+            # Extract service date
+            service_date_match = re.search(r'DTP\*472\D*8\*([0-9]{8})', record)
+            # Extract claim amount
+            amount_match = re.search(r'CLM\*[^\*]*\*([0-9]+\.?[0-9]*)', record)
+            
+            if name_match and service_date_match and amount_match:
+                # Handle optional middle name
+                middle_name = name_match.group(3).strip() if name_match.group(3) else ""
+                patient_name = "{} {} {}".format(name_match.group(2), middle_name, name_match.group(1)).strip()
+                service_date = "{}-{}-{}".format(service_date_match.group(1)[:4], service_date_match.group(1)[4:6], service_date_match.group(1)[6:])
+                amount_billed = float(amount_match.group(1))
+                
+                patient_details.append({
+                    "name": patient_name,
+                    "service_date": service_date,
+                    "amount_billed": amount_billed
+                })
+    except Exception as e:
+        print("Error reading or parsing the 837p file: {0}".format(str(e)))
+    
+    # Optionally, return also date_of_submission as a separate variable  
+    return patient_details, date_of_submission
+
+# Mocked file content based on your provided sample data
+file_content = """
+GS*HC*ZCHC0113*OPTUM*20240414*1130*1*X*005010X222A1~
+NM1*IL*1*BURLAP*CAROLINE*A***MI*995796519~
+CLM*BURLO000032624*540.00***24:B:1*Y*A*Y*Y~
+DTP*472*D8*20240328~
+SE*26*0001~
+NM1*IL*1*GAMORA*WHOIS*R***MI*987654307~
+CLM*GAMOA000032824*450.00***24:B:1*Y*A*Y*Y~
+DTP*472*D8*20240318~
+SE*26*0002~
+ST*837*0002*005010X222A1~
+BHT*0019*00*GORJA000*20240414*1130*CH~
+"""
+
+# Run the function with the mocked content
+parsed_details = parse_837p_file(file_content)
+for detail in parsed_details:
+    print(detail)

medicafe-0.240613.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: medicafe
+Version: 0.240613.0
+Summary: MediCafe
+Home-page: https://github.com/katanada2
+Author: Daniel Vidaud
+Author-email: daniel@personalizedtransformation.com
+License: MIT
+Keywords: medicafe python34 medibot medilink
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: argparse
+Requires-Dist: numpy ==1.11.3
+Requires-Dist: pandas ==0.20.0
+Requires-Dist: tqdm ==4.14.0
+Requires-Dist: lxml ==4.2.0
+Requires-Dist: python-docx
+
+
+    # Project Overview: MediCafe
+
+    ## Project Description
+    MediCafe is a comprehensive suite designed to automate and streamline several aspects of medical administrative tasks within Medisoft, a popular medical practice management software. The system consists of two main components: MediBot and MediLink, each serving distinct functions but integrated to enhance the workflow of medical practices.
+
+    ## MediBot Module
+    MediBot is primarily focused on automating data entry processes in Medisoft. It utilizes AutoHotkey scripting to control and automate the GUI interactions required for inputting patient data into Medisoft. Key features and functionalities include:
+
+    - **Error Handling and Logging:** MediBot aims to implement a robust error handling mechanism that can log issues and provide feedback for troubleshooting.
+    - **Insurance Mode Adjustments:** The system can adjust data inputs based on specific requirements from various insurance providers, including Medicare.
+    - **Diagnosis Entry Automation:** MediBot automates the extraction and entry of diagnosis codes from surgical schedules into Medisoft.
+    - **Script Efficiency:** The module enhances the efficiency of scripts handling Medisoft’s quirks, such as fields that are skipped or require special navigation.
+    - **User Interface (UI) Enhancements:** Plans to develop a graphical user interface to help non-technical users manage and execute scripts more easily.
+    - **Documentation and Support:** Comprehensive documentation and support channels are being established to assist users in setup, configuration, and troubleshooting.
+
+    ## MediLink Module
+    MediLink focuses on the backend processes related to medical claims submission, particularly handling communications with multiple endpoints like Availity, Optum, and PNT Data. Its main features include:
+
+    - **Dynamic Configurations:** Supports multiple endpoints with environmental settings to ensure flexibility in claims submission.
+    - **File Detection and Integrity Checks:** Enhances the detection of new claim files with detailed logging and integrity checks for preprocessing validation.
+    - **Automated Response Handling:** Automates the process of receiving and integrating response files from endpoints into Medisoft, alerting users to exceptions.
+    - **Endpoint Management:** Allows dynamic updating of endpoints based on insurance provider changes, ensuring accurate and efficient claims processing.
+    - **User Interface (UI) Interactions:** Provides a user interface for managing claims submission, including confirming or adjusting suggested endpoints.
+
+    ## Integration and Workflow
+    The two modules work in tandem to provide a seamless experience. MediBot handles the initial data entry into Medisoft, preparing the system with up-to-date patient and treatment information. This data is then utilized by MediLink for preparing and submitting medical claims to various insurance providers. Errors and feedback from MediLink can prompt adjustments in MediBot's data entry processes, creating a feedback loop that enhances accuracy and efficiency.
+
+    The integration aims to reduce the administrative burden on medical practices, decrease the incidence of data entry errors, and ensure timely submission of medical claims, thereby improving the revenue cycle management of healthcare providers.
+
+    ## Target Users
+    The system is intended for use by administrative staff in medical practices who are responsible for patient data management and claims processing. By automating these tasks, the system not only saves time but also reduces the potential for human error, leading to more accurate billing and improved operational efficiency.
+
+    ## Future Directions
+    Future enhancements may include the development of additional modules for other aspects of medical practice management, further integrations with healthcare systems, and continuous improvements in user interface design to accommodate an even broader range of users.
+    

medicafe-0.240613.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+MediBot/MediBot.bat,sha256=9RK-ID3T2xPz3cDEeTlv7nhMy_GhbGYtbD4vutGOSeE,6153
+MediBot/MediBot.py,sha256=X7ZU-xYsnw7xL7nBZTDudhSXdsnEavcHORE4hPM4L58,16704
+MediBot/MediBot_Charges.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediBot/MediBot_Crosswalk_Library.py,sha256=PRsPtoGOwpHvqYnLl_ABTMNkKJlFHtqjgldWxnXQmQI,14669
+MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediBot/MediBot_Preprocessor.py,sha256=OI9rfDF01OLuLFZoSzIceO3r5fkKEFN7tynXPIceoo4,11941
+MediBot/MediBot_Preprocessor_lib.py,sha256=aU5VWwLqDxka8DGLkrji6C9rYMzoqjxLScZ64Ya-0ok,24170
+MediBot/MediBot_UI.py,sha256=_CS9BV3882mNp-UmMUPKZOsDI3ZGxft5mcr36-Nq1FQ,10318
+MediBot/MediBot_dataformat_library.py,sha256=AVRAl4oDHR6nq2bBiJf2YABrdtnfiQYdYzV0BMvL7U0,8346
+MediBot/MediBot_docx_decoder.py,sha256=y2OOjRPWKYn5LnCX3lngNQtGkOOEE6VDaeqvkkIc5ec,13341
+MediBot/MediPost.py,sha256=C1hZJFr65rN6F_dckjdBxFC0vL2CoqY9W3YFqU5HXtE,336
+MediBot/PDF_to_CSV_Cleaner.py,sha256=ZZphmq-5K04DkrZNlcwNAIoZPOD_ROWvS3PMkKFxeiM,8799
+MediBot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediBot/update_json.py,sha256=eAu3BPYtlGlwVGZdTUmrqq4qLTVcplt-6EnzcGCheG0,1557
+MediBot/update_medicafe.py,sha256=CYxRHNXb-ZwGELWSXJA90foMwac_GBdXhD9hwClUjpA,2249
+MediLink/MediLink.py,sha256=X95f6h3s5zgfPrmVO7jCIU8OHmxbiqiUB_XVQI5oVf8,19616
+MediLink/MediLink_277_decoder.py,sha256=Z3hQK2j-YzdXjov6aDlDRc7M_auFBnl3se4OF5q6_04,4358
+MediLink/MediLink_837p_encoder.py,sha256=onrbzk-6QG97oHRn-AvDtcsYyQ-OpqZJE4KWjgPTwxQ,23550
+MediLink/MediLink_837p_encoder_library.py,sha256=RdXsG-k_plNE4vMgFel7L00nwq3pG67iWCpJGXlUtjs,42676
+MediLink/MediLink_API_v2.py,sha256=P--ud2ENGsqnB8JLQQ_eiEJw8KGSlIO2eQKz0DfXeNo,7670
+MediLink/MediLink_APIs.py,sha256=_EFNjBFwtZsEJM771xa6g-zQCCRrebIHj73ElVVZ8Fs,6229
+MediLink/MediLink_ConfigLoader.py,sha256=rrZmy1_d8-2qx_G7pCph-zhlQq_6c6jorYl47J0DxYo,3914
+MediLink/MediLink_DataMgmt.py,sha256=y8nNe25mj2ajUmPo7508q_T1vxkYiKzwdRit0oX8V9s,20344
+MediLink/MediLink_Decoder.py,sha256=F_cCYhLwhQj72YgFpSuo1FNcxRrHWbaY2iVpD_fypxc,2418
+MediLink/MediLink_Down.py,sha256=ND0_QPhKXTqN8JYqbzwZbfxvn3X-iqFHn4SCm4EXkug,5916
+MediLink/MediLink_ERA_decoder.py,sha256=MiOtDcXnmevPfHAahIlTLlUc14VcQWAor9Xa7clA2Ts,8710
+MediLink/MediLink_Gmail.py,sha256=FV13-umZIouhetnwkGOBgFQYl5FTyOs__SpjaycUxKk,21195
+MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediLink/MediLink_Parser.py,sha256=U1hMkhTObNHk_4AXNnCAonnnPYaCiz9L0epP6a0KH2k,4271
+MediLink/MediLink_Scan.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediLink/MediLink_Scheduler.py,sha256=UJvxhDvHraqra2_TlQVlGeh5jRFrrfK6nCVUHnKOEMY,38
+MediLink/MediLink_StatusCheck.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediLink/MediLink_UI.py,sha256=k_Kz5tB2NC2CIZLd3JRWCu5IJfGUAr14Iw4kY6sECZo,6979
+MediLink/MediLink_Up.py,sha256=02KS_pRZxFd-dZek-YzYfph409BBRfNKCouAWph9op8,18460
+MediLink/MediLink_batch.bat,sha256=nqL5QwCLyRQFSPdv6kgtcV_cpky7FXSOWVl6OxjRXb4,118
+MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
+MediLink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MediLink/test.py,sha256=kSvvJRL_3fWuNS3_x4hToOnUljGLoeEw6SUTHQWQRJk,3108
+medicafe-0.240613.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.240613.0.dist-info/METADATA,sha256=v1DwnPeliwkBR2b7dA6YEdRGu_LEUAjwGZvINtuVpbM,4596
+medicafe-0.240613.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.240613.0.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
+medicafe-0.240613.0.dist-info/RECORD,,

{medicafe-0.240419.2.dist-info → medicafe-0.240613.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.33.6)
-Root-Is-Purelib: true
-Tag: py3-none-any
-
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

medicafe-0.240419.2.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.1
-Name: medicafe
-Version: 0.240419.2
-Summary: MediCafe
-Home-page: https://github.com/katanada2
-Author: Daniel Vidaud
-Author-email: daniel@personalizedtransformation.com
-License: MIT
-Keywords: medicafe python34 medibot medilink
-Platform: UNKNOWN
-Requires-Dist: requests
-Requires-Dist: argparse
-Requires-Dist: numpy (==1.11.3)
-Requires-Dist: pandas (==0.20.0)
-Requires-Dist: tqdm (==4.14.0)
-
-This module ensures that MediCafe remains up-to-date by performing version checks for its dependencies on startup. It utilizes PyPI, the official repository for Python packages, to retrieve information about the latest available versions of the required packages. When an internet connection is available, MediUpdate automatically installs any available updates using pip, the package installer for Python.
-
-

medicafe-0.240419.2.dist-info/RECORD

@@ -1,32 +0,0 @@
-MediBot/MediBot.bat,sha256=hqqTnQ1y09JEXlbhMAfh0yOxjoXtWFbBHfuuXHAgBro,2129
-MediBot/MediBot.py,sha256=0OAAfNlQ3H2SRc3likp2lyPwZ4kuuyI73vP5ovH1QzA,15522
-MediBot/MediBot_Charges.py,sha256=N-hjH6d44YlGAGRs3E17VaupIfpLgaNep_pfZqC2K2M,1963
-MediBot/MediBot_Preprocessor.py,sha256=A8x6sHzdUGdP4_sybUFIYl2s14RwwOZN8mPssA8LVxc,15904
-MediBot/MediBot_UI.py,sha256=Qt4J7yej50rFZ0WpGdSJbqigQ6DWuFQK4Bcxmm5TbdU,9190
-MediBot/MediBot_dataformat_library.py,sha256=UdVF-yW3ZJK0NAzzAAh4VVonorzvI6rY0FjBDnMF4_Y,6314
-MediBot/MediPost.py,sha256=C1hZJFr65rN6F_dckjdBxFC0vL2CoqY9W3YFqU5HXtE,336
-MediBot/PDF_to_CSV_Cleaner.py,sha256=ZZphmq-5K04DkrZNlcwNAIoZPOD_ROWvS3PMkKFxeiM,8799
-MediBot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediBot/update_json.py,sha256=eAu3BPYtlGlwVGZdTUmrqq4qLTVcplt-6EnzcGCheG0,1557
-MediBot/update_medicafe.py,sha256=Qyg7iHPTOxiHk3jCd7G01dxmUEbHxD5g1kEdcvr5XoU,840
-MediLink/MediLink.py,sha256=mIt1mS3W5FLBYWjFlCjH1Eh8v9JMxTB5l08m4B1VxHo,14234
-MediLink/MediLink_277_decoder.py,sha256=Z3hQK2j-YzdXjov6aDlDRc7M_auFBnl3se4OF5q6_04,4358
-MediLink/MediLink_837p_encoder.py,sha256=qtXhoIO15OnN4Dh9qXkK9g1fQs7IkcyVLnBfS1YnlpU,19913
-MediLink/MediLink_837p_encoder_library.py,sha256=0h54xX6OVGl7Jims9SY1BgF5DNUJ5mJ1cRvh4RI3rdo,32894
-MediLink/MediLink_ConfigLoader.py,sha256=Htyv1L2LQcTJuzbftMk9VeR8_zOfGVSZBezJs00tP3c,3325
-MediLink/MediLink_DataMgmt.py,sha256=Ep3_HRV6JhUNRt8jDJqCTM-YksHtJNz2uddinW49sYs,9462
-MediLink/MediLink_Down.py,sha256=Bn9AESEJ7Fp_35xf7b74Tk56sT-S70bokLlD8xeZArk,8136
-MediLink/MediLink_ERA_decoder.py,sha256=N_-sAUQH1Usy1hPkxjpH3eeB1rMxeqJSCotfYKlg0vU,8769
-MediLink/MediLink_Gmail.py,sha256=M-C2ns7mhaEime29jLT_O5-yWzEkxuwMnkbBGI_n3PM,133
-MediLink/MediLink_Scheduler.py,sha256=s7NeU0ukMjQVS3YB9FRSNvRdUcVmV52i7J76ijp4Ews,6040
-MediLink/MediLink_StatusCheck.py,sha256=NYDlS7eIuUThpoSWsLfp8dZcYwcSP3Rph1UmjyRBruU,222
-MediLink/MediLink_UI.py,sha256=fYEENDuO0s2XZL6Q7ltgJhZBSSG2VKdGJ1yrZBc8tdI,4797
-MediLink/MediLink_Up.py,sha256=nk_CdA9rz2iifIUddD9342gzWrXeS9RjfgxElwQ5hLY,6080
-MediLink/MediLink_batch.bat,sha256=it_t8dx6lKUc3QBTA0VRDWRpe-fIgSLb8gUL1p6Agos,95
-MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
-MediLink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-medicafe-0.240419.2.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.240419.2.dist-info/METADATA,sha256=g4AB0kqGZ_NF89pAcZlzkS0EURsounIJQxAGBIhn7vk,819
-medicafe-0.240419.2.dist-info/WHEEL,sha256=v8slff5hmCpvciQ3G55d2d1CnOBupjDFJHDE2dUb1Ao,97
-medicafe-0.240419.2.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
-medicafe-0.240419.2.dist-info/RECORD,,