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

MediLink/MediLink_Up.py

@@ -4,8 +4,9 @@ import re
 import subprocess
 from tqdm import tqdm
 import MediLink_837p_encoder
-from MediLink_ConfigLoader import log
+from MediLink_ConfigLoader import log, load_configuration
 from MediLink_DataMgmt import operate_winscp
+import MediLink_API_v3
 
 # Internet Connectivity Check
 def check_internet_connection():
@@ -13,6 +14,12 @@ def check_internet_connection():
     Checks if there is an active internet connection.
     Returns: Boolean indicating internet connectivity status.
     """
+    # Check if TestMode is enabled
+    config, _ = load_configuration()
+    if config.get("MediLink_Config", {}).get("TestMode", True):
+        # If TestMode is True, skip the connectivity check and return True as if the internet connection were fine
+        return True
+        
     try:
         # Run a ping command to a reliable external server (e.g., Google's DNS server)
         ping_process = subprocess.Popen(["ping", "-n", "1", "8.8.8.8"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -28,6 +35,16 @@ def check_internet_connection():
         return False
 
 def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
+    """
+    Submits claims for each endpoint, either via WinSCP or API, based on configuration settings.
+
+    Parameters:
+    - detailed_patient_data_grouped_by_endpoint: Dictionary with endpoints as keys and lists of patient data as values.
+    - config: Configuration settings loaded from a JSON file.
+
+    Returns:
+    - None
+    """
     # Accumulate submission results
     submission_results = {}
     
@@ -35,41 +52,53 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
         print("No new files detected for submission.")
         return
 
-    # Wrap the iteration with tqdm for a progress bar
+    # Iterate through each endpoint and submit claims
     for endpoint, patients_data in tqdm(detailed_patient_data_grouped_by_endpoint.items(), desc="Progress", unit="endpoint"):
-        if not patients_data:  # Skip if no patient data for the endpoint
+        if not patients_data:
             continue
 
+        # Determine the submission method (e.g., "winscp" or "api")
+        method = config.get('MediLink_Config', {}).get('endpoints', {}).get(endpoint, {}).get('submission_method', 'winscp')
+
         # 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 files per endpoint
                 converted_files = MediLink_837p_encoder.convert_files_for_submission(patients_data, config)
-                if converted_files:  # Check if files were successfully converted
-                    # 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)}
+                if converted_files:
+                    if method == 'winscp':
+                        # Transmit files via WinSCP
+                        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, method)
+                            submission_results[endpoint] = success_dict
+                        except FileNotFoundError as e:
+                            print("Failed to transmit files to {}. Error: Log file not found - {}".format(endpoint, str(e)))
+                            submission_results[endpoint] = {"status": False, "error": "Log file not found - " + str(e)}
+                        except IOError as e:
+                            print("Failed to transmit files to {}. Error: Input/output error - {}".format(endpoint, str(e)))
+                            submission_results[endpoint] = {"status": False, "error": "Input/output error - " + str(e)}
+                        except Exception as e:
+                            print("Failed to transmit files to {}. Error: {}".format(endpoint, str(e)))
+                            submission_results[endpoint] = {"status": False, "error": str(e)}
+                    elif method == 'api':
+                        # Transmit files via API
+                        try:
+                            api_responses = []
+                            client = MediLink_API_v3.APIClient()
+                            for file_path in converted_files:
+                                with open(file_path, 'r') as file:
+                                    x12_request_data = file.read().replace('\n', '').replace('\r', '').strip()
+                                    response = MediLink_API_v3.submit_uhc_claim(client, x12_request_data)
+                                    api_responses.append((file_path, response))
+                            success_dict = handle_transmission_result(api_responses, config, "api", method)
+                            submission_results[endpoint] = success_dict
+                        except Exception as e:
+                            print("Failed to transmit files via API to {}. Error: {}".format(endpoint, str(e)))
+                            submission_results[endpoint] = {"status": False, "error": str(e)}
                 else:
-                    
-                    print("No files were converted for transmission to {0}.".format(endpoint))
+                    print("No files were converted for transmission to {}.".format(endpoint))
             else:
                 print("Error: No internet connection detected.")
                 log("Error: No internet connection detected.", level="ERROR")
@@ -78,89 +107,102 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config):
                     print("Exiting transmission process. Please try again later.")
                     return  # Exiting the function if the user decides not to retry
         else:
-            print("Transmission canceled for endpoint {0}.".format(endpoint))
+            # This else statement is inaccessible because it is preceded by an if True condition, 
+            # which is always true and effectively makes the else clause unreachable.
+            # To handle this, we need to decide under what conditions the submission should be canceled. 
+            # One option is to replace the if True with a condition that checks for some pre-submission criteria. 
+            # For instance, if there is a confirmation step or additional checks that need to be performed before 
+            # proceeding with the submission, these could be included here.
+            print("Transmission canceled for endpoint {}.".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")    
+    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.
+def handle_transmission_result(transmission_result, config, operation_type, method):
     """
-    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 = {}
+    Analyze the outcomes of file transmissions based on WinSCP log entries or API responses.
 
-    try:
-        with open(log_path, 'r') as log_file:
-            log_contents = log_file.readlines()
+    Parameters:
+    - transmission_result: List of paths for files that were attempted to be transmitted or API response details.
+    - config: Configuration dictionary containing paths and settings.
+    - operation_type: The type of operation being performed (e.g., "upload").
+    - method: The transmission method used ("winscp" or "api").
 
-        log("WinSCP Log file opened and contents read successfully.")
+    Returns:
+    - Dictionary mapping each file path or API response to a tuple indicating successful transmission and any relevant messages.
+    """
+    success_dict = {}
 
-        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:
+    if method == "winscp":
+        # Define the log filename based on the operation type
+        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)
+        
+        try:
+            # Read the contents of the WinSCP log file
+            with open(log_path, 'r') as log_file:
+                log_contents = log_file.readlines()
+
+            if not log_contents:
+                # Handle the case where the log file is empty
+                log("Log file '{}' is empty.".format(log_path))
+                success_dict = {file_path: (False, "Log file empty") for file_path in transmission_result}
+            else:
+                # Process the last few lines of the log file for transfer status
+                last_lines = log_contents[-15:]
+                for file_path in transmission_result:
                     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}
+                    message = "Success" if success else "Transfer incomplete or error occurred"
+                    success_dict[file_path] = (success, message)
+
+        except FileNotFoundError:
+            # Log file not found, handle the error
+            log("Log file '{}' not found.".format(log_path))
+            success_dict = {file_path: (False, "Log file not found") for file_path in transmission_result}
+        except IOError as e:
+            # Handle IO errors, such as issues reading the log file
+            log("IO error when handling the log file '{}': {}".format(log_path, e))
+            success_dict = {file_path: (False, "IO error: {}".format(e)) for file_path in transmission_result}
+        except Exception as e:
+            # Catch all other exceptions and log them
+            log("Error processing the transmission log: {}".format(e))
+            success_dict = {file_path: (False, "Error: {}".format(e)) for file_path in transmission_result}
+
+    elif method == "api":
+        # Process each API response to determine the success status
+        for file_path, response in transmission_result:
+            try:
+                # Check if the API response indicates a successful submission
+                success = response.get('message') in ["Claim validated and sent for further processing", "Acknowledgement pending"]
+                # Record the API message.
+                message = response.get('message', 'No message provided')
+                success_dict[file_path] = (success, message)
+            except Exception as e:
+                # Handle API exception
+                log("Error processing API response: {}".format(e))
+                success_dict[file_path] = (False, str(e))
 
     return success_dict
 
 def build_and_display_receipt(submission_results, config):
     """
-    Define Submission Receipt:
-
+    Builds and displays a receipt for submitted claims, including both successful and failed submissions.
     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.
+    Parameters:
+    - submission_results: Dictionary containing submission results with detailed information for each endpoint.
+    - config: Configuration settings loaded from a JSON file.
 
-    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.
+    Returns:
+    - None
     """
     # 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
@@ -172,43 +214,59 @@ def build_and_display_receipt(submission_results, config):
 
     # 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
+
+    log("Receipt has been generated and saved.")
 
 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.
-    
+    - submission_results (dict): Contains submission results grouped by endpoint, with detailed status information.
+
     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)
-            
+        log("Processing endpoint: {}".format(endpoint), level="INFO")
+        for file_path, file_result in files.items():
+            log("File path: {}".format(file_path), level="DEBUG")
+            log("File result: {}".format(file_result), level="DEBUG")
+
+            try:
+                # Unpack the tuple to get status and message
+                status, message = file_result
+            except ValueError as e:
+                log("ValueError: {} for file_result: {}".format(e, file_result), level="ERROR")
+                continue
+            except Exception as e:
+                log("Unexpected error: {}".format(e), level="ERROR")
+                continue
+
+            log("Status: {}, Message: {}".format(status, message), level="DEBUG")
+
             if endpoint not in receipt_data:
                 receipt_data[endpoint] = {
-                    "date_of_submission": date_of_submission,
-                    "patients": []
+                    "patients": [],
+                    "date_of_submission": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                 }
 
-            # Enhance patient data with success status
+            # Parse patient details and add the result status and message
+            patient_data, _ = parse_837p_file(file_path)
             for patient in patient_data:
-                patient['status'] = success
-            
+                patient['status'] = status
+                patient['message'] = message
+
             receipt_data[endpoint]["patients"].extend(patient_data)
     
     validate_data(receipt_data)
+    log("Receipt data: {}".format(receipt_data), level="DEBUG")
+    
     return receipt_data
 
 def validate_data(receipt_data):
@@ -216,7 +274,7 @@ def validate_data(receipt_data):
     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)]
+            missing_fields = [field for field in ('name', 'service_date', 'amount_billed', 'insurance_name', 'status') if patient.get(field) in (None, '')]
             
             if missing_fields:
                 # Log the missing fields without revealing PHI
@@ -315,13 +373,14 @@ def build_receipt_content(receipt_data):
         
         # Adding patient information in a tabular format
         for patient in data["patients"]:
-            success_status = "SUCCESS" if patient['status'] else "FAILED"
+            # Use the message as the status if the submission failed
+            status_display = "SUCCESS" if patient['status'] else patient['message']
             patient_info = "{:<20} | {:<15} | ${:<14} | {:<20} | {:<10}".format(
                 patient['name'], 
                 patient['service_date'], 
                 patient['amount_billed'], 
                 patient['insurance_name'], 
-                success_status
+                status_display
             )
             receipt_lines.append(patient_info)
         
@@ -331,17 +390,27 @@ def build_receipt_content(receipt_data):
     return receipt_content
 
 def save_receipt_to_file(receipt_content, config):
+    """
+    Saves the receipt content to a text file and opens it for the user.
+
+    Parameters:
+    - receipt_content (str): The formatted content of the receipt.
+    - config: Configuration settings loaded from a JSON file.
+
+    Returns:
+    - None
+    """
     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)
+        log("Receipt saved to:", file_path)
+        # Open the file automatically for the user (Windows-specific)
+        if os.name == 'nt':
+            os.startfile(file_path)
     except Exception as e:
         print("Failed to save or open receipt file:", e)
 

{medicafe-0.240716.2.dist-info → medicafe-0.240809.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.240716.2
+Version: 0.240809.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.240716.2.dist-info → medicafe-0.240809.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 MediBot/MediBot.bat,sha256=B_iUMQro6kPrTbGOePsTvOq3N9nXn5fE7xnkt4jfSrE,7032
-MediBot/MediBot.py,sha256=X7ZU-xYsnw7xL7nBZTDudhSXdsnEavcHORE4hPM4L58,16704
+MediBot/MediBot.py,sha256=JZ8AxdZRuilOXYUlkv8MFSb538INd9T0TQUplRkHI_I,17454
 MediBot/MediBot_Charges.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Crosswalk_Library.py,sha256=RxwihSpPtTlnDbPiQ1VWnPVVdjYA-L69OPWREXMTGiQ,14862
 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_Preprocessor_lib.py,sha256=7fxKFgDMVetX1QB5IQJoW9f5hz4Kpim0hfBx-yEP6M8,25083
 MediBot/MediBot_UI.py,sha256=_CS9BV3882mNp-UmMUPKZOsDI3ZGxft5mcr36-Nq1FQ,10318
 MediBot/MediBot_dataformat_library.py,sha256=AVRAl4oDHR6nq2bBiJf2YABrdtnfiQYdYzV0BMvL7U0,8346
 MediBot/MediBot_docx_decoder.py,sha256=nO5N8qPsZoiFzicSJ5mbBfjaqGinxgh_VzjLhEsj95U,13712
@@ -13,20 +13,20 @@ MediBot/PDF_to_CSV_Cleaner.py,sha256=ZZphmq-5K04DkrZNlcwNAIoZPOD_ROWvS3PMkKFxeiM
 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=GRMe3OiskBGVpHDGIrTmY4_t2pc5J_pznHt5Z5mU8X8,18054
+MediLink/MediLink.py,sha256=JsTGXQVCbwaYir_2BoeZzFq43g8UoqAp_kB4s94BL38,18117
 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=_K162u1spMWZg-7HMebEU2yciGx_1T6lX7FW02Ek3fA,41831
+MediLink/MediLink_837p_encoder.py,sha256=X94So0mQpl_x1p_lz1_1HMMhyLvlnIDOMr_r5ZxhfLQ,24069
+MediLink/MediLink_837p_encoder_library.py,sha256=7Sn0g46AwyVShGPX_qzrd3rojaHRySuor4Ej3_dYrO0,42414
 MediLink/MediLink_API_Generator.py,sha256=AvKJOoQKl2_dJG517chsVAjBKqEEIEz_c12OL03J428,10387
 MediLink/MediLink_API_v2.py,sha256=mcIgLnXPS_NaUBrkKJ8mxCUaQ0AuQUeU1vG6DoplbVY,7733
-MediLink/MediLink_API_v3.py,sha256=8X-5ldKnAJzfE2R0nywa6xYq6C7kqJ3lLDCyqXg9FP4,15911
+MediLink/MediLink_API_v3.py,sha256=ZggkLisZ8tLDuHBIPxg7yr1CHQvGMWiWyiEsfvmWSYU,23081
 MediLink/MediLink_APIs.py,sha256=_EFNjBFwtZsEJM771xa6g-zQCCRrebIHj73ElVVZ8Fs,6229
 MediLink/MediLink_ClaimStatus.py,sha256=s6Ll46yU2-jJueF-3jqVyJ53s1Qll1MONkX2vm1alLY,8655
-MediLink/MediLink_ConfigLoader.py,sha256=p1Fkm-KeRR1vcIS-7K6RUP7g1B7HrgO_KbjmwwNCX4A,4161
-MediLink/MediLink_DataMgmt.py,sha256=y8nNe25mj2ajUmPo7508q_T1vxkYiKzwdRit0oX8V9s,20344
+MediLink/MediLink_ConfigLoader.py,sha256=4cEaA9ulNHPuXLV76EUIDr0YHPuFjIlg3MvTH0-s1x4,4211
+MediLink/MediLink_DataMgmt.py,sha256=nJ74pXR_PeHS2ODuqw6EP4HzB1tqWZVHprcAkEVEMo0,20461
 MediLink/MediLink_Decoder.py,sha256=L4b3OnVERhgP68T4Lvty9MJNXutPAjXRPBjYpzSj2ZM,7139
-MediLink/MediLink_Deductible.py,sha256=3uCUluPx6sHsU7tj9wM62PZK_WY8VOPFlXG3Iccgiy4,8520
-MediLink/MediLink_Down.py,sha256=1SIzPLSI4w4Prb2u0FXsf1Bd6Nksb0tMv0N8w1aWzyE,7110
+MediLink/MediLink_Deductible.py,sha256=BUa_vx084KRyJfS0x3lOZGNw-8ppeeePEEnX1oAbpiU,8967
+MediLink/MediLink_Down.py,sha256=ykDGxV7j9gVyUibfCfvCvyoKXgP7AgiVXSKY4QH05ac,7097
 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
@@ -34,14 +34,14 @@ MediLink/MediLink_Parser.py,sha256=p2RlCut84hESXjR7tyCZ9O-gUbsUQeYqRp1bXhKbxu4,6
 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=kAtWApyvaE1qMOy5Vzszy3zPBI25wT29jG1XkIWnAAs,6164
-MediLink/MediLink_Up.py,sha256=tKkMaz0FvbIXCJ9eQ2LXp6r4_Ou4yDaqRtekfZE6bF0,18546
+MediLink/MediLink_UI.py,sha256=lPRmbZ54swIVpyHgwb612v3rUZo_DkCthokqdHPf5Vo,6367
+MediLink/MediLink_Up.py,sha256=iMWrCqbRrreVDoR-_zNeaHYArX3WS9L5WWiz6WQHWKM,22185
 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.240716.2.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.240716.2.dist-info/METADATA,sha256=edgBR0DGETtGim21JGQ13iz2K-kqqJwl41hXGAYJxRQ,4625
-medicafe-0.240716.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-medicafe-0.240716.2.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
-medicafe-0.240716.2.dist-info/RECORD,,
+medicafe-0.240809.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.240809.0.dist-info/METADATA,sha256=fwdrZBF0Ut7DkLoegPj4xCDEyGFBxkVhik-MxaA4KAo,4625
+medicafe-0.240809.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.240809.0.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
+medicafe-0.240809.0.dist-info/RECORD,,

{medicafe-0.240716.2.dist-info → medicafe-0.240809.0.dist-info}/WHEEL

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