medicafe 0.250723.5__py3-none-any.whl → 0.250724.0__py3-none-any.whl

MediBot/MediBot.py

@@ -187,8 +187,10 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
     # last_processed_entry, parsed_address_components = None, {} // BUG should this just be this line rather than the global line above?
     error_message = ''  # Initialize error_message once
     current_row_index = 0
+    # PERFORMANCE FIX: Cache list length to avoid repeated len() calls
+    csv_data_length = len(csv_data)
 
-    while current_row_index < len(csv_data):
+    while current_row_index < csv_data_length:
         row = csv_data[current_row_index]
         
         # PERFORMANCE FIX: Clear accumulating memory while preserving F11 menu context

MediBot/MediBot_Preprocessor_lib.py

@@ -1,7 +1,7 @@
 #MediBot_Preprocessor_lib.py
 from collections import OrderedDict, defaultdict
 from datetime import datetime, timedelta
-import os, csv, sys
+import os, csv, sys, time
 import chardet  # Ensure chardet is imported
 
 # Add the parent directory of the project to the Python path
@@ -120,8 +120,8 @@ def load_csv_data(csv_file_path):
             # Clean the headers
             cleaned_headers = clean_header(reader.fieldnames)
 
-            # Create a mapping of cleaned headers to original headers (pre-compute once)
-            header_mapping = {cleaned_headers[i]: reader.fieldnames[i] for i in range(len(cleaned_headers))}
+            # PERFORMANCE FIX: Use zip() instead of range(len()) for header mapping
+            header_mapping = {clean: orig for clean, orig in zip(cleaned_headers, reader.fieldnames)}
 
             # Process the remaining rows - optimize by pre-allocating the list
             csv_data = []
@@ -129,9 +129,8 @@ def load_csv_data(csv_file_path):
             # csv_data = [None] * estimated_size  # if we had row count
             
             for row in reader:
-                # Use dict() constructor with generator expression for better performance
-                cleaned_row = dict((cleaned_headers[i], row[header_mapping[cleaned_headers[i]]]) 
-                                 for i in range(len(cleaned_headers)))
+                # PERFORMANCE FIX: Use zip() instead of range(len()) for row processing
+                cleaned_row = {clean: row[header_mapping[clean]] for clean in cleaned_headers}
                 csv_data.append(cleaned_row)
 
             return csv_data  # Return a list of dictionaries
@@ -161,9 +160,10 @@ def add_columns(csv_data, column_headers):
     elif not isinstance(column_headers, list):
         raise ValueError("column_headers should be a list or a string")
 
+    # PERFORMANCE FIX: Optimize column initialization to avoid nested loop
     for row in csv_data:
-        for header in column_headers:
-            row[header] = ''  # Initialize the column with empty values
+        # Use dict.update() to set multiple columns at once
+        row.update({header: '' for header in column_headers})
 
 # Extracting the list to a variable for future refactoring:
 def filter_rows(csv_data):
@@ -304,6 +304,17 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
     processed_payer_ids = set()  # Track processed Payer IDs
     MediLink_ConfigLoader.log("Starting update of insurance IDs.", level="INFO")
 
+    # PERFORMANCE FIX: Pre-build flattened payer lookup cache to avoid nested dictionary access
+    payer_cache = {}
+    crosswalk_payers = crosswalk.get('payer_id', {})
+    for payer_id, details in crosswalk_payers.items():
+        payer_cache[payer_id] = {
+            'medisoft_id': details.get('medisoft_id', []),
+            'medisoft_medicare_id': details.get('medisoft_medicare_id', []),
+            'endpoint': details.get('endpoint', None)
+        }
+    MediLink_ConfigLoader.log("Built payer cache for {} payers".format(len(payer_cache)), level="DEBUG")
+
     # Load MAINS data to get mapping from Medisoft ID to MAINS names
     insurance_to_id = load_insurance_data_from_mains(config)  # Assuming it returns a dict mapping insurance names to IDs
     MediLink_ConfigLoader.log("Loaded MAINS data for insurance to ID mapping.", level="DEBUG")
@@ -313,7 +324,9 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
     for insurance_name, medisoft_id in insurance_to_id.items():
         medisoft_to_mains_names[medisoft_id].append(insurance_name)
 
-    for row in csv_data:
+    for row_idx, row in enumerate(csv_data, 1):
+        # PERFORMANCE FIX: Store row index to avoid O(n) csv_data.index() calls later
+        row['_row_index'] = row_idx
         ins1_payer_id = row.get('Ins1 Payer ID', '').strip()
         MediLink_ConfigLoader.log("Processing row with Ins1 Payer ID: '{}'.".format(ins1_payer_id), level="DEBUG")
         
@@ -323,20 +336,24 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
                 processed_payer_ids.add(ins1_payer_id)  # Add to set
                 MediLink_ConfigLoader.log("Marked Payer ID '{}' as processed.".format(ins1_payer_id), level="DEBUG")
                 
-                # Retrieve Medisoft IDs for the current Payer ID
-                medisoft_ids = crosswalk.get('payer_id', {}).get(ins1_payer_id, {}).get('medisoft_id', [])
+                # PERFORMANCE FIX: Use flattened cache instead of nested dictionary lookups
+                payer_info = payer_cache.get(ins1_payer_id, {})
+                medisoft_ids = payer_info.get('medisoft_id', [])
                 MediLink_ConfigLoader.log("Retrieved Medisoft IDs for Payer ID '{}': {}".format(ins1_payer_id, medisoft_ids), level="DEBUG")
 
         if not medisoft_ids:
             MediLink_ConfigLoader.log("No Medisoft IDs available for Payer ID '{}', creating placeholder entry.".format(ins1_payer_id), level="WARNING")
-            # Create a placeholder entry in the crosswalk
-            if 'payer_id' not in crosswalk:
-                crosswalk['payer_id'] = {}
-            crosswalk['payer_id'][ins1_payer_id] = {
+            # Create a placeholder entry in the crosswalk and cache
+            placeholder_entry = {
                 'medisoft_id': [],  # Placeholder for future Medisoft IDs
                 'medisoft_medicare_id': [],  # Placeholder for future Medicare IDs
                 'endpoint': None  # Placeholder for future endpoint
             }
+            if 'payer_id' not in crosswalk:
+                crosswalk['payer_id'] = {}
+            crosswalk['payer_id'][ins1_payer_id] = placeholder_entry
+            # PERFORMANCE FIX: Update cache with placeholder entry
+            payer_cache[ins1_payer_id] = placeholder_entry
             continue  # Skip further processing for this Payer ID
 
         # If only one Medisoft ID is associated, assign it directly
@@ -344,7 +361,9 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
             try:
                 medisoft_id = int(medisoft_ids[0])
                 row['Ins1 Insurance ID'] = medisoft_id
-                MediLink_ConfigLoader.log("Assigned Medisoft ID '{}' to row number {} with Payer ID '{}'.".format(medisoft_id, csv_data.index(row) + 1, ins1_payer_id), level="DEBUG")
+                # PERFORMANCE FIX: Use enumerate index instead of csv_data.index() which is O(n)
+                row_number = getattr(row, '_row_index', 'Unknown')
+                MediLink_ConfigLoader.log("Assigned Medisoft ID '{}' to row number {} with Payer ID '{}'.".format(medisoft_id, row_number, ins1_payer_id), level="DEBUG")
             except ValueError as e:
                 MediLink_ConfigLoader.log("Error converting Medisoft ID '{}' to integer for Payer ID '{}': {}".format(medisoft_ids[0], ins1_payer_id, e), level="ERROR")
                 row['Ins1 Insurance ID'] = None
@@ -398,9 +417,10 @@ def update_insurance_ids(csv_data, config, crosswalk):
             payer_id, medisoft_ids, medicare_ids), level="DEBUG")
 
     # PERFORMANCE FIX: Single pass through CSV data with optimized Medicare ID resolution
-    for row in csv_data:
+    for row_idx, row in enumerate(csv_data, 1):
         ins1_payer_id = row.get('Ins1 Payer ID', '').strip()
-        MediLink_ConfigLoader.log("Processing row #{} with Ins1 Payer ID '{}'.".format(csv_data.index(row) + 1, ins1_payer_id), level="DEBUG")
+        # PERFORMANCE FIX: Use enumerate index instead of csv_data.index() which is O(n)
+        MediLink_ConfigLoader.log("Processing row #{} with Ins1 Payer ID '{}'.".format(row_idx, ins1_payer_id), level="DEBUG")
         
         # Try Medicare ID first, then fall back to regular ID (optimized Medicare processing)
         insurance_id = (payer_id_to_medicare.get(ins1_payer_id) or 
@@ -517,19 +537,22 @@ def update_diagnosis_codes(csv_data):
 
         MediLink_ConfigLoader.log("BAD IDEA: Processing DOCX files modified between {} and {}.".format(threshold_start, threshold_end), level="INFO")
 
-        # PERFORMANCE OPTIMIZATION: Use os.scandir() for more efficient file system operations
-        # This reduces the number of file system calls and improves performance with large directories
+        # PERFORMANCE OPTIMIZATION: Batch file system operations with caching
+        # Pre-convert threshold timestamps for efficient comparison (Windows XP compatible)
+        threshold_start_ts = threshold_start.timestamp() if hasattr(threshold_start, 'timestamp') else time.mktime(threshold_start.timetuple())
+        threshold_end_ts = threshold_end.timestamp() if hasattr(threshold_end, 'timestamp') else time.mktime(threshold_end.timetuple())
+        
         valid_files = []
         try:
-            # Use os.scandir() for better performance (XP/3.4.4 compatible)
+            # Use os.scandir() with optimized timestamp comparison (XP/3.4.4 compatible)
             with os.scandir(local_storage_path) as entries:
                 for entry in entries:
                     if entry.name.endswith('.docx'):
                         # Get file modification time in single operation
                         try:
                             stat_info = entry.stat()
-                            mtime = stat_info.st_mtime
-                            if threshold_start <= datetime.fromtimestamp(mtime) <= threshold_end:
+                            # Direct timestamp comparison avoids datetime conversion overhead
+                            if threshold_start_ts <= stat_info.st_mtime <= threshold_end_ts:
                                 valid_files.append(entry.path)
                         except (OSError, ValueError):
                             # Skip files with invalid modification times
@@ -537,6 +560,9 @@ def update_diagnosis_codes(csv_data):
         except OSError:
             MediLink_ConfigLoader.log("Error accessing directory: {}".format(local_storage_path), level="ERROR")
             return
+            
+        # PERFORMANCE OPTIMIZATION: Log file count for debugging without processing overhead
+        MediLink_ConfigLoader.log("Found {} DOCX files within date threshold".format(len(valid_files)), level="INFO")
 
         # PERFORMANCE OPTIMIZATION: Pre-process patient IDs for efficient lookup
         # Create a set of patient IDs from CSV data for faster lookups
@@ -821,13 +847,12 @@ def capitalize_all_fields(csv_data):
     Returns:
     None: The function modifies the csv_data in place.
     """
+    # PERFORMANCE FIX: Optimize uppercase conversion using dict comprehension
     for row in csv_data:
-        for key, value in row.items():
-            if isinstance(value, str):
-                row[key] = value.upper()
-            elif isinstance(value, datetime):
-                # Keep datetime objects as they are
-                pass
-            elif value is not None:
-                # Convert any other non-None values to string and then uppercase
-                row[key] = str(value).upper()
+        # Single-pass update using dict comprehension
+        row.update({
+            key: (value.upper() if isinstance(value, str) 
+                  else str(value).upper() if value is not None and not isinstance(value, datetime)
+                  else value)
+            for key, value in row.items()
+        })

MediBot/MediBot_dataformat_library.py

@@ -78,14 +78,17 @@ def enforce_significant_length(output):
         # First line of defense: Replace ' APT ' or ' UNIT ' with ' #' if the original length is longer than 30 characters.
         temp_output = temp_output.replace(' APT ', ' #').replace(' UNIT ', ' #')
         
-        # Remove spaces in a controlled manner from right to left if still too long
-        while len(temp_output) > 30:
+        # PERFORMANCE FIX: Remove spaces in a controlled manner from right to left if still too long
+        # Cache length calculation to avoid repeated calls
+        temp_length = len(temp_output)
+        while temp_length > 30:
             # Find the last space
             last_space_index = temp_output.rfind(' ')
             if last_space_index == -1:
                 break
             # Remove the last space
             temp_output = temp_output[:last_space_index] + temp_output[last_space_index+7:]
+            temp_length = len(temp_output)  # Update cached length
 
         # If still greater than 30, truncate to 30 characters
         if len(temp_output) > 30:

MediBot/MediBot_docx_decoder.py

@@ -407,9 +407,11 @@ def reassemble_year(text):
     
     # Handle the less common cases where the year might be split as (1,1,2) or (2,1,1) or (1,2,1)
     parts = _DIGIT_PARTS_PATTERN.findall(text)
-    if len(parts) >= 4:
-        # Early exit: only process if we have enough parts
-        for i in range(len(parts) - 3):
+    parts_len = len(parts)
+    if parts_len >= 4:
+        # PERFORMANCE FIX: Use direct indexing instead of range(len()) pattern
+        max_index = parts_len - 3
+        for i in range(max_index):
             candidate = ''.join(parts[i:i + 4])
             if len(candidate) == 4 and candidate.isdigit():
                 # More efficient pattern construction

MediLink/MediLink_Decoder.py

@@ -204,20 +204,30 @@ def display_table(records):
         print("No records to display.")
         return
 
-    # Determine which fields have at least one non-empty value
-    used_fields = [field for field in new_fieldnames if any(str(record.get(field, '')).strip() for record in records)]
+    # PERFORMANCE FIX: Single-pass optimization - determine used fields and calculate widths in one pass
+    used_fields = []
+    col_widths = {}
+    
+    # First pass: identify used fields and initialize widths
+    for field in new_fieldnames:
+        col_widths[field] = len(field)  # Header width
+        
+    # Second pass: check for used fields and calculate max widths
+    for record in records:
+        for field in new_fieldnames:
+            value_str = str(record.get(field, ''))
+            if value_str.strip() and field not in used_fields:
+                used_fields.append(field)
+            if field in col_widths:
+                col_widths[field] = max(col_widths[field], len(value_str))
+    
+    # Filter col_widths to only used fields
+    col_widths = {field: col_widths[field] for field in used_fields}
 
     if not used_fields:
         print("No data to display.")
         return
 
-    # Calculate column widths based on the longest item in each used column
-    col_widths = {field: len(field) for field in used_fields}
-
-    for record in records:
-        for field in used_fields:
-            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
-
     # Create table header
     header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in used_fields)
     print(header)
@@ -256,20 +266,30 @@ def display_consolidated_records(records):
         print("No valid records to display after filtering empty rows.")
         return
     
-    # Determine which fields have at least one non-empty value
-    used_fields = [field for field in new_fieldnames if any(str(record.get(field, '')).strip() for record in filtered_records)]
+    # PERFORMANCE FIX: Single-pass optimization - determine used fields and calculate widths in one pass
+    used_fields = []
+    col_widths = {}
+    
+    # First pass: initialize column widths with header lengths
+    for field in new_fieldnames:
+        col_widths[field] = len(field)
+        
+    # Second pass: check for used fields and calculate max widths
+    for record in filtered_records:
+        for field in new_fieldnames:
+            value_str = str(record.get(field, ''))
+            if value_str.strip() and field not in used_fields:
+                used_fields.append(field)
+            if field in col_widths:
+                col_widths[field] = max(col_widths[field], len(value_str))
+    
+    # Filter col_widths to only used fields
+    col_widths = {field: col_widths[field] for field in used_fields}
 
     if not used_fields:
         print("No data to display.")
         return
     
-    # Calculate column widths based on the longest item in each used column
-    col_widths = {field: len(field) for field in used_fields}
-    
-    for record in filtered_records:
-        for field in used_fields:
-            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
-    
     # Print header
     header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in used_fields)
     print(header)

MediLink/MediLink_Deductible.py

@@ -725,33 +725,39 @@ if __name__ == "__main__":
                 print(table_header)
                 print("-" * len(table_header))
 
-                # Set to keep track of processed patients
-                processed_patients = set()
-
-                # Loop through each payer_id and patient to call the API, then display the eligibility information
+                # PERFORMANCE FIX: Optimize patient-payer processing to avoid O(P×N) complexity
+                # Instead of nested loops, process each patient once and try payer_ids until success
+                # TODO: We should be able to determine the correct payer_id for each patient ahead of time
+                # by looking up their insurance information from the CSV data or crosswalk mapping.
+                # This would eliminate the need to try multiple payer_ids per patient and make this O(N).
                 errors = []
                 validation_reports = []
-                total_patients = len(patients) * len(payer_ids)
                 processed_count = 0
                 
-                for payer_id in payer_ids:
-                    for dob, member_id in patients:
-                        # Skip if this patient has already been processed
-                        if (dob, member_id) in processed_patients:
-                            continue
+                for dob, member_id in patients:
+                    processed_count += 1
+                    print("Processing patient {}/{}: Member ID {}, DOB {}".format(
+                        processed_count, len(patients), member_id, dob))
+                    
+                    # Try each payer_id for this patient until we get a successful response
+                    patient_processed = False
+                    for payer_id in payer_ids:
                         try:
-                            processed_count += 1
-                            print("Processing patient {}/{}: Member ID {}, DOB {}".format(
-                                processed_count, total_patients, member_id, dob))
-                            
                             # Run with validation enabled only in debug mode
                             run_validation = DEBUG_MODE
                             eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation)
                             if eligibility_data is not None:
-                                display_eligibility_info(eligibility_data, dob, member_id, output_file)  # Display as we get the result
-                                processed_patients.add((dob, member_id))  # Mark this patient as processed
+                                display_eligibility_info(eligibility_data, dob, member_id, output_file)
+                                patient_processed = True
+                                break  # Stop trying other payer_ids for this patient once we get a response
                         except Exception as e:
-                            errors.append((dob, member_id, str(e)))
+                            # Continue trying other payer_ids
+                            continue
+                    
+                    # If no payer_id worked for this patient, log the error
+                    if not patient_processed:
+                        error_msg = "No successful payer_id found for patient"
+                        errors.append((dob, member_id, error_msg))
 
                 # Display errors if any
                 if errors:

MediLink/MediLink_Parser.py

@@ -1,7 +1,5 @@
 # MediLink_Parser.py
-
 import re
-from collections import defaultdict
 
 # Pre-compile regex patterns for better performance
 _EBT_KEY_VALUE_PATTERN = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+:|$)')

{medicafe-0.250723.5.dist-info → medicafe-0.250724.0.dist-info}/METADATA

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

{medicafe-0.250723.5.dist-info → medicafe-0.250724.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 MediBot/MediBot.bat,sha256=anz5i-Td1k3HhRUvkCqHsw9lBLVmO6q9bt5kLTfr1Iw,13282
-MediBot/MediBot.py,sha256=iO9rQPFJky9jxYKU8b3jbxcnTdipnfeCU2VS-2vLBI8,24172
+MediBot/MediBot.py,sha256=PQvAlfc-B15tr3Lbv1tV16ws2P1B04x0uCJ725fOlEc,24283
 MediBot/MediBot_Charges.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Crosswalk_Library.py,sha256=Ix4QlAcg3O9Y6n6ZeSUtbmtV-_n-t0-jnefXDBFlhhI,51441
 MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Preprocessor.py,sha256=Lc9uQnE5SAa0dQTOREdPV1QUB2cywXTHJ1h2w-fyeeQ,13331
-MediBot/MediBot_Preprocessor_lib.py,sha256=E759aYflr6GbOIaFJjMSkV4Y_dPUyjxNdbfbWEWS5JM,43940
+MediBot/MediBot_Preprocessor_lib.py,sha256=LXzV85uq7YoAWbZi88HzAs_GObl7vP8mhFbWZQbd0M8,45687
 MediBot/MediBot_UI.py,sha256=mJiLud8C6mztP4APA_LKgxj8dJ05YxLag47khhkLj20,13087
-MediBot/MediBot_dataformat_library.py,sha256=JXTV-HWahqeYF_lbNn1UYxqUtZ6ZBeFXHOyRGlDq4xM,8406
-MediBot/MediBot_docx_decoder.py,sha256=d_t5LsdXUQ5713BTBIcRxDx9Go422dRUDhNtPRh786I,27293
+MediBot/MediBot_dataformat_library.py,sha256=XNyeiOC6uJUp15UXP_rhtB3rMTPus9ZXDnz5zHNoRYM,8586
+MediBot/MediBot_docx_decoder.py,sha256=GbhX58pMAsWNhBF7B8AtWiNpUOB4bU0zAM81moXYkkE,27370
 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
@@ -27,15 +27,15 @@ MediLink/MediLink_Azure.py,sha256=Ow70jctiHFIylskBExN7WUoRgrKOvBR6jNTnQMk6lJA,21
 MediLink/MediLink_ClaimStatus.py,sha256=kXIDidxSGuqTwjFNMQIKms42jqIu5Qmnet-7Ohe8zjE,11645
 MediLink/MediLink_ConfigLoader.py,sha256=u9ecB0SIN7zuJAo8KcoQys95BtyAo-8S2n4mRd0S3XU,4356
 MediLink/MediLink_DataMgmt.py,sha256=MjCF1L-4RkQnz_vBULPB-DVsEtv0X1WHT1o9YjCGQ7s,33280
-MediLink/MediLink_Decoder.py,sha256=Suw9CmUHgoe0ZW8sJP_pIO8URBrhO5FmxFF8RcUj9lI,13318
-MediLink/MediLink_Deductible.py,sha256=btFzmW48biiSce8zES_giAGQggPs5foutNG2slk-Pcw,38916
+MediLink/MediLink_Decoder.py,sha256=lKWiOcRClz8F5P3jrvFTq_hW9XF4OrPfA4LFz2zLSLg,14013
+MediLink/MediLink_Deductible.py,sha256=els8CQMK3pRzlqzs12HDgqx42WLXuHFU-nfXiA4y0Js,39426
 MediLink/MediLink_Deductible_Validator.py,sha256=2g-lZd-Y5fJ1mfP87vM6oABg0t5Om-7EkEkilVvDWYY,22888
 MediLink/MediLink_Down.py,sha256=hrDODhs-zRfOKCdiRGENN5Czu-AvdtwJj4Q7grcRXME,6518
 MediLink/MediLink_ERA_decoder.py,sha256=MiOtDcXnmevPfHAahIlTLlUc14VcQWAor9Xa7clA2Ts,8710
 MediLink/MediLink_Gmail.py,sha256=OYsASNgP4YSTaSnj9XZxPPiy0cw41JC-suLIgRyNrlQ,31439
 MediLink/MediLink_GraphQL.py,sha256=O6OCaumT0zIC7YcIAwLOOYxiQnYhoMc48UL8ilNIBec,45720
 MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediLink/MediLink_Parser.py,sha256=SdXquRIviDPG5q1R6nnjp9n3lDs9bUNXHL4IyAGp8NU,9826
+MediLink/MediLink_Parser.py,sha256=w2ZD4minjwkaMz7nzP_r8v_Ow_uM5KHjpPSY8mIHcdE,9787
 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
@@ -49,8 +49,8 @@ MediLink/test.py,sha256=kSvvJRL_3fWuNS3_x4hToOnUljGLoeEw6SUTHQWQRJk,3108
 MediLink/test_cob_library.py,sha256=wUMv0-Y6fNsKcAs8Z9LwfmEBRO7oBzBAfWmmzwoNd1g,13841
 MediLink/test_validation.py,sha256=FJrfdUFK--xRScIzrHCg1JeGdm0uJEoRnq6CgkP2lwM,4154
 MediLink/webapp.html,sha256=JPKT559aFVBi1r42Hz7C77Jj0teZZRumPhBev8eSOLk,19806
-medicafe-0.250723.5.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250723.5.dist-info/METADATA,sha256=Xi59ITdlqeJUrbhkW8OLaaj57BeBa2xTCogCZR6tsTY,5501
-medicafe-0.250723.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250723.5.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
-medicafe-0.250723.5.dist-info/RECORD,,
+medicafe-0.250724.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250724.0.dist-info/METADATA,sha256=wQblamJ71lD6awYx3z5wDMZ-PZYp3tCMg1z36lmlhMg,5501
+medicafe-0.250724.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250724.0.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
+medicafe-0.250724.0.dist-info/RECORD,,