medicafe 0.240415.1__py3-none-any.whl → 0.240517.0__py3-none-any.whl

MediBot/MediBot_dataformat_library.py

@@ -0,0 +1,198 @@
+import re
+from datetime import datetime
+import re  #for addresses
+
+# Add parent directory of the project to the Python path
+import os
+import sys
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try: 
+    from MediLink import MediLink_ConfigLoader
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
+except ImportError:
+    from MediLink_ConfigLoader import load_configuration
+    config, crosswalk = load_configuration()
+
+from MediBot_Preprocessor_lib import open_csv_for_editing, initialize
+from MediBot_UI import manage_script_pause, app_control
+
+
+"""
+- [X] (TEST) Address Formatting 30-character Limit:
+    (LOW) Address the issue where the format_street function in Medibot may produce addresses exceeding
+    the 30-character limit. Current stop-gap is removing period characters and the abbreviation "APT" 
+    surrounded by spaces from all records as a temporary solution. 
+    If the address still exceeds 30 characters, the function will attempt to remove spaces from right to left
+    until it reaches 30 significant digits or runs out of spaces, then truncate to 30 characters if necessary.
+"""
+
+# Bring in all the constants
+initialize(config)
+
+# Format Data
+def format_name(value):  
+    if ',' in value:
+        return value
+    hyphenated_name_pattern = r'(?P<First>[\w-]+)\s+(?P<Middle>[\w-]?)\s+(?P<Last>[\w-]+)'
+    match = re.match(hyphenated_name_pattern, value)
+    if match:
+        first_name = match.group('First')
+        middle_name = match.group('Middle') or ''
+        if len(middle_name) > 1:
+            middle_name = middle_name[0]  # take only the first character
+        last_name = match.group('Last')
+        return '{}, {} {}'.format(last_name, first_name, middle_name).strip()
+    parts = value.split()
+    return '{}, {}'.format(parts[-1], ' '.join(parts[:-1]))
+
+def format_date(value):
+    try:
+        date_obj = datetime.strptime(value, '%m/%d/%Y')
+        return date_obj.strftime('%m%d%Y')
+    except ValueError as e:
+        print("Date format error:", e)
+        return value
+
+def format_phone(value):
+    digits = ''.join(filter(str.isdigit, value))
+    if len(digits) == 10:
+        return digits
+    print("Phone number format error: Invalid number of digits")
+    return value
+
+def format_policy(value):
+    alphanumeric = ''.join(filter(str.isalnum, value))
+    return alphanumeric
+
+def format_gender(value):
+    return value[0].upper()
+
+def enforce_significant_length(output):
+    # Replace spaces with a placeholder that counts as one significant digit
+    temp_output = output.replace('{Space}', ' ')
+    
+    # Check if the number of significant digits exceeds 30
+    if len(temp_output) > 30:
+        
+        # First line of defense: Replace ' APT ' with ' #' if the original length is longer than 30 characters.
+        temp_output = temp_output.replace(' APT ', ' #')
+        
+        # Remove spaces in a controlled manner from right to left if still too long
+        while len(temp_output) > 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:]
+
+        # If still greater than 30, truncate to 30 characters
+        if len(temp_output) > 30:
+            temp_output = temp_output[:30]
+
+    # Replace placeholder back with actual space for final return
+    return temp_output.replace(' ', '{Space}')
+
+def format_street(value, csv_data, reverse_mapping, parsed_address_components):
+    # Temporarily disable script pause status
+    app_control.set_pause_status(False)
+    
+    # Remove period characters.
+    value = value.replace('.', '')
+    
+    # Proceed only if there's a comma, indicating a likely full address
+    if ',' in value:
+        try:
+            MediLink_ConfigLoader.log("Attempting to resolve address via regex...")
+            # Retrieve common city names from configuration and prepare a regex pattern
+            common_cities = config.get('cities', [])
+            city_pattern = '|'.join(re.escape(city) for city in common_cities)
+            city_regex_pattern = r'(?P<City>{})'.format(city_pattern)
+            city_regex = re.compile(city_regex_pattern, re.IGNORECASE)
+
+            # Search for a common city in the address
+            city_match = city_regex.search(value)
+                    
+            if city_match:
+                # Extract city name and partition the value around it
+                city = city_match.group('City').upper()
+                street, _, remainder = value.partition(city)
+                
+                # Regex pattern to find state and zip code in the remainder
+                address_pattern = r',\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(?:-\d{4})?)?'
+                match = re.search(address_pattern, remainder)
+
+                if match:
+                    # Update parsed address components
+                    parsed_address_components['City'] = city
+                    parsed_address_components['State'] = match.group('State')
+                    parsed_address_components['Zip Code'] = match.group('Zip')
+                    # Return formatted street address, enforcing significant length
+                    return enforce_significant_length(street.strip())
+            else:
+                # Fallback regex for parsing addresses without a common city
+                address_pattern = r'(?P<Street>[\w\s]+),?\s+(?P<City>[\w\s]+),\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(-\d{4})?)'
+                match = re.match(address_pattern, value)
+
+                if match:
+                    # Update parsed address components
+                    parsed_address_components['City'] = match.group('City')
+                    parsed_address_components['State'] = match.group('State')
+                    parsed_address_components['Zip Code'] = match.group('Zip')
+                    # Return formatted street address, enforcing significant length
+                    return enforce_significant_length(match.group('Street').strip())
+                    
+        except Exception as e:
+            # Handle exceptions by logging and offering to correct data manually
+            print("Address format error: Unable to parse address '{}'. Error: {}".format(value, e))
+            app_control.set_pause_status(True)
+            open_csv_for_editing(CSV_FILE_PATH)
+            manage_script_pause(csv_data, e, reverse_mapping)
+            # Return original value with spaces formatted, enforcing significant length
+            return enforce_significant_length(value.replace(' ', '{Space}'))
+    else:
+        # If no comma is present, treat the input as a simple street name
+        formatted_value = value.replace(' ', '{Space}')
+        enforced_format = enforce_significant_length(formatted_value)
+        return enforced_format
+
+    # Fallback return in case no address components are matched even though a comma was present
+    return enforce_significant_length(value.replace(' ', '{Space}')) 
+
+def format_zip(value):
+    # Ensure the value is a string, in case it's provided as an integer
+    value_str = str(value)
+    # Return only the first 5 characters of the zip code
+    return value_str[:5]
+
+def format_data(medisoft_field, value, csv_data, reverse_mapping, parsed_address_components):
+    if medisoft_field == 'Patient Name':
+        formatted_value = format_name(value)
+    elif medisoft_field == 'Birth Date':
+        formatted_value = format_date(value)
+    elif medisoft_field == 'Phone':
+        formatted_value = format_phone(value)
+    elif medisoft_field == 'Phone #2':
+        formatted_value = format_phone(value)
+    elif medisoft_field == 'Gender':
+        formatted_value = format_gender(value)
+    elif medisoft_field == 'Street':
+        formatted_value = format_street(value, csv_data, reverse_mapping, parsed_address_components)
+    elif medisoft_field == 'Zip Code':
+        formatted_value = format_zip(value)
+    elif medisoft_field == 'Primary Policy Number':
+        formatted_value = format_policy(value)
+    elif medisoft_field == 'Secondary Policy Number':
+        formatted_value = format_policy(value)
+    elif medisoft_field == 'Primary Group Number':
+        formatted_value = format_policy(value)
+    elif medisoft_field == 'Secondary Group Number':
+        formatted_value = format_policy(value)
+    else:
+        formatted_value = str(value) # Ensure value is always a string
+
+    formatted_value = formatted_value.replace(',', '{,}').replace(' ', '{Space}')
+    ahk_command = 'SendInput, {}{{Enter}}'.format(formatted_value)
+    return ahk_command

MediBot/MediBot_docx_decoder.py

@@ -0,0 +1,80 @@
+"""
+Using docx-utils 0.1.3,
+
+This script parses a .docx file containing a table of patient information and extracts
+relevant data into a dictionary. Each row in the table corresponds to a new patient, 
+and the data from each cell is parsed into specific variables. The resulting dictionary 
+uses the 'Patient ID Number' as keys and lists containing 'Diagnosis Code', 
+'Left or Right Eye', and 'Femto yes or no' as values.
+
+Functions:
+    parse_docx(filepath): Reads the .docx file and constructs the patient data dictionary.
+    parse_patient_id(text): Extracts the Patient ID Number from the text.
+    parse_diagnosis_code(text): Extracts the Diagnosis Code from the text.
+    parse_left_or_right_eye(text): Extracts the eye information (Left or Right) from the text.
+    parse_femto_yes_or_no(text): Extracts the Femto information (yes or no) from the text.
+"""
+
+from docx import Document
+
+def parse_docx(filepath):
+    # Open the .docx file
+    doc = Document(filepath)
+    
+    # Initialize the dictionary to store data
+    patient_data = {}
+    
+    # Assuming the first table contains the required data
+    table = doc.tables[0]
+    
+    # Iterate over the rows in the table
+    for row in table.rows[1:]:  # Skip header row if it exists
+        cells = row.cells
+        
+        # Extract and parse data from each cell
+        patient_id = parse_patient_id(cells[0].text.strip())
+        diagnosis_code = parse_diagnosis_code(cells[1].text.strip())
+        left_or_right_eye = parse_left_or_right_eye(cells[2].text.strip())
+        femto_yes_or_no = parse_femto_yes_or_no(cells[3].text.strip())
+        
+        # Construct the dictionary entry
+        patient_data[patient_id] = [diagnosis_code, left_or_right_eye, femto_yes_or_no]
+    
+    return patient_data
+
+def parse_patient_id(text):
+    # Implement parsing logic for Patient ID Number
+    # Example: Assume the ID is the first part of the text, separated by a space or newline
+    return text.split()[0]
+
+def parse_diagnosis_code(text):
+    # Implement parsing logic for Diagnosis Code
+    # Example: Extract the code from a known pattern or location in the text
+    return text.split(':')[1].strip() if ':' in text else text
+
+def parse_left_or_right_eye(text):
+    # Implement parsing logic for Left or Right Eye
+    # Example: Assume the text contains 'Left' or 'Right' and extract it
+    if 'Left' in text:
+        return 'Left'
+    elif 'Right' in text:
+        return 'Right'
+    else:
+        return 'Unknown'
+
+def parse_femto_yes_or_no(text):
+    # Implement parsing logic for Femto yes or no
+    # Example: Check for presence of keywords 'yes' or 'no'
+    if 'yes' in text.lower():
+        return 'Yes'
+    elif 'no' in text.lower():
+        return 'No'
+    else:
+        return 'Unknown'
+
+# Placeholder function call (replace 'path_to_docx' with the actual file path)
+filepath = 'path_to_docx'
+patient_data_dict = parse_docx(filepath)
+
+# Print the resulting dictionary
+print(patient_data_dict)

MediBot/MediPost.py

@@ -0,0 +1,5 @@
+"""
+Takes CSV from MediLink_Down.py and utilizes config and MediBot to post the CSV to Medisoft.
+This script now also processes ERAs and responses (277CA/277A) to update claims status and finalize billing records.
+Handles parsing and cleaning of input CSV files to ensure data accuracy and compliance with Medisoft requirements.
+"""

MediBot/PDF_to_CSV_Cleaner.py

@@ -0,0 +1,211 @@
+import pandas as pd
+import re
+
+def load_csv(file_path):
+    # Loads a CSV file and returns a pandas DataFrame
+    return pd.read_csv(file_path, header=None)
+
+def segment_data(data):
+    # Segments the data into individual patient records
+    
+    patient_records = []
+    current_record = []
+    
+    for line in data.itertuples(index=False):
+        # Convert the tuple to a list to process it easier
+        line = list(line)
+        # Flatten the list and filter out NaN values
+        line = [item for item in line if pd.notna(item)]
+        
+        if line:  # Make sure there is data in the line
+            # Check for the delimiter indicating a new patient record
+            if 'PATIENT INFORMATION' in line[0]:
+                if current_record:
+                    # If there's an existing record, this means we've reached a new one
+                    # Save the current record and start a new one
+                    patient_records.append(current_record)
+                    current_record = []
+            # Add the line to the current patient record
+            current_record.extend(line)
+    
+    # Don't forget to add the last record after exiting the loop
+    if current_record:
+        patient_records.append(current_record)
+    
+    return patient_records
+
+# Function to extract key-value pairs from a patient record segment
+def extract_patient_data(patient_record):
+    patient_data = {
+        "Name": None,
+        "Patient ID": None,
+        "Address": None,
+        "Home Phone": None,
+        "DOB": None,
+        "Gender": None
+    }
+    
+    # Function to extract value after a specific key in the patient record
+    def extract_value_after_key(lines, key):
+        for index, line in enumerate(lines):
+            if key in line:
+                try:
+                    split_line = line.split('\n')
+                    if len(split_line) > 1:
+                        # Return the value only if it exists after the newline character
+                        return split_line[1].strip()                
+                except AttributeError:
+                    # Handle the case where 'line' is not a string and doesn't have the 'split' method
+                    print("Error extracting value after key:", line)
+                    pass     
+    
+    # For each key in patient_data, extract its value from the patient_record
+    for key in patient_data.keys():
+        patient_data[key] = extract_value_after_key(patient_record, key)
+    return patient_data
+
+
+def parse_insurance_info(patient_record):
+    insurance_data = {
+        "Primary Insurance": None,
+        "Primary Policy Number": None,
+        "Primary Group Number": None,
+        "Secondary Insurance": None,
+        "Secondary Policy Number": None,
+        "Secondary Group Number": None
+    }
+
+    insurance_section_started = False
+    secondary_insurance_detected = False
+    group_header_detected = False
+
+    for element in patient_record:
+        if 'INSURANCE INFORMATION' in element:
+            insurance_section_started = True
+            secondary_insurance_detected = False
+            continue
+
+        if insurance_section_started:
+            split_element = element.split('\n')
+            if 'Primary Insurance' in element:
+                insurance_data["Primary Insurance"] = element.split('\n')[1].strip() if len(element.split('\n')) > 1 else None
+            elif 'Secondary Insurance' in element and len(split_element) > 1 and split_element[1].strip():
+                insurance_data["Secondary Insurance"] = element.split('\n')[1].strip() if len(element.split('\n')) > 1 else None
+                secondary_insurance_detected = True
+            elif 'Policy Number' in element:
+                split_element = element.split('\n')
+                if len(split_element) > 1:
+                    if not insurance_data["Primary Policy Number"]:
+                        insurance_data["Primary Policy Number"] = split_element[1].strip()
+                    elif secondary_insurance_detected and not insurance_data["Secondary Policy Number"]:
+                        insurance_data["Secondary Policy Number"] = split_element[1].strip()
+            elif 'Group Number' in element:
+                #print("Group Detected: ", element, secondary_insurance_detected)
+                group_header_detected = not group_header_detected # toggle between T/F to proxy as first or second position.
+                split_element = element.split('\n')
+                if len(split_element) > 1:
+                    if not insurance_data["Primary Group Number"] and group_header_detected:
+                        insurance_data["Primary Group Number"] = split_element[1].strip()
+                    elif secondary_insurance_detected and not insurance_data["Secondary Group Number"] and not group_header_detected:
+                        insurance_data["Secondary Group Number"] = split_element[1].strip()
+
+    return insurance_data
+
+def structure_data(patient_data_list):
+    # Define the column headers based on the sample data provided earlier
+    column_headers = [
+        "Name", 
+        "Patient ID", 
+        "Address", 
+        "Home Phone", 
+        "DOB", 
+        "Gender", 
+        "Primary Insurance", 
+        "Primary Policy Number", 
+        "Primary Group Number",
+        "Secondary Insurance", 
+        "Secondary Policy Number",
+        "Secondary Group Number"
+    ]
+
+    # Initialize a list to hold structured patient records
+    structured_patient_records = []
+
+    # Iterate over each patient record in the list
+    for patient_record in patient_data_list:
+        # Extract the basic patient data
+        patient_data = extract_patient_data(patient_record)
+        # Extract the insurance information
+        insurance_data = parse_insurance_info(patient_record)
+        # Merge the two dictionaries
+        full_patient_data = {**patient_data, **insurance_data}
+        
+        # Add the cleaned and transformed data to the list
+        structured_patient_records.append(full_patient_data)
+
+    # Create the DataFrame with the structured patient data
+    structured_patient_df = pd.DataFrame(structured_patient_records, columns=column_headers)
+
+    # Return the structured DataFrame
+    return structured_patient_df
+
+def validate_data(data_frame):
+    # Performing Quality Assurance and Validation checks on the structured data
+
+    # Completeness Check: Check for missing values in critical fields
+    missing_values_check = data_frame.isnull().sum()
+
+    # Consistency Check: Ensure data formats are consistent
+    date_format_check = data_frame['DOB'].apply(lambda x: bool(re.match(r'\d{4}-\d{2}-\d{2}', x)) if pd.notnull(x) else True)
+    phone_format_check = data_frame['Home Phone'].apply(lambda x: bool(re.match(r'\+\d-\d{3}-\d{3}-\d{4}', x)) if pd.notnull(x) else True)
+
+    # Anomaly Detection: This can be complex and domain-specific. As a basic check, we can look for outliers in data like dates.
+    dob_anomalies_check = data_frame['DOB'].describe()
+
+    # Compile the results of the checks
+    validation_results = {
+        "Missing Values Check": missing_values_check,
+        "Date Format Consistency": all(date_format_check),
+        "Phone Format Consistency": all(phone_format_check),
+        "DOB Anomalies Check": dob_anomalies_check
+    }
+    
+    print(validation_results)  # Display validation results
+    return data_frame  # Return the validated DataFrame
+
+
+# Main function to orchestrate the cleaning process
+def clean_patient_data(file_path):
+    # Load the CSV file
+    sxpatient_data = load_csv(file_path)
+
+    # Segment the data
+    segmented_patient_records = segment_data(sxpatient_data)
+
+    # Structure the data
+    structured_data_frame = structure_data(segmented_patient_records)
+
+    # Validate the data
+    validated_data = validate_data(structured_data_frame)
+    
+    return validated_data
+
+# Path to the CSV file with escaped backslashes
+file_path_sxpatient = 'C:\\Users\\danie\\OneDrive\\Desktop\\CSV02012024.CSV'
+# Define the file path for the output CSV file
+output_file_path = 'G:\\My Drive\\CocoWave\\XP typing bot\\cleaned_FEB01SXcsv_group.csv'
+
+# Call the main function to clean the patient data
+cleaned_patient_data = clean_patient_data(file_path_sxpatient)
+
+# Display the first few rows of the cleaned and validated data to verify the output
+print(cleaned_patient_data.head())
+
+# Save the processed data to a CSV file
+cleaned_patient_data.to_csv(output_file_path, index=False)
+
+print(f"Processed data saved to {output_file_path}")
+
+# Development Roadmap
+
+# Do not delete leading zeros from insurance numbers

MediBot/update_json.py

@@ -0,0 +1,43 @@
+import json
+import sys
+from collections import OrderedDict
+
+def update_csv_path(json_file, new_path):
+    try:
+        with open(json_file, 'r', encoding='utf-8') as file:
+            try:
+                data = json.load(file, object_pairs_hook=OrderedDict)
+            except ValueError as decode_err:
+                print("Error decoding JSON file '{}': {}".format(json_file, decode_err))
+                sys.exit(1)
+
+        # Ensure correct backslash formatting for JSON
+        if "\\" in new_path and "\\\\" not in new_path:
+            formatted_path = new_path.replace("\\", "\\\\")
+        else:
+            formatted_path = new_path
+
+        data['CSV_FILE_PATH'] = formatted_path
+
+        with open(json_file, 'w', encoding='utf-8') as file:
+            try:
+                json.dump(data, file, ensure_ascii=False, indent=4)
+            except ValueError as encode_err:
+                print("Error encoding JSON data to file '{}': {}".format(json_file, encode_err))
+                sys.exit(1)
+
+    except IOError as io_err:
+        print("Error accessing file '{}': {}".format(json_file, io_err))
+        sys.exit(1)
+    except Exception as e:
+        print("An unexpected error occurred: {}".format(e))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    if len(sys.argv) == 3:
+        json_path = sys.argv[1]
+        new_csv_path = sys.argv[2]
+        update_csv_path(json_path, new_csv_path)
+    else:
+        print("Usage: update_json.py <path_to_json_file> <new_csv_path>")
+        sys.exit(1)

MediBot/update_medicafe.py

@@ -0,0 +1,57 @@
+import subprocess
+import sys
+from tqdm import tqdm
+import requests
+import time
+
+def check_internet_connection():
+    try:
+        requests.get("http://www.google.com", timeout=5)
+        return True
+    except requests.ConnectionError:
+        return False
+
+def upgrade_medicafe(package):
+    try:
+        # Check internet connection
+        if not check_internet_connection():
+            print("Error: No internet connection detected. Please check your internet connection and try again.")
+            sys.exit(1)
+        
+        total_progress = 200  # Total progress for two runs
+        
+        with tqdm(total=total_progress, desc="Upgrading %s" % package, unit="%") as progress_bar:
+            stdout_accumulator = b""
+            stderr_accumulator = b""
+            
+            for _ in range(2):  # Run pip install twice
+                process = subprocess.Popen([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-cache-dir', '--disable-pip-version-check', '--no-deps'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                stdout, stderr = process.communicate()
+                stdout_accumulator += stdout
+                stderr_accumulator += stderr
+                
+                if process.returncode != 0:
+                    # If the return code is non-zero, print error details
+                    print("Error: Upgrade failed. Details:")
+                    print("stdout:", stdout)
+                    print("stderr:", stderr)
+                    sys.exit(1)
+                
+                progress_bar.update(total_progress // 2)  # Update progress bar
+                
+                # Add a 3-second sleep between runs
+                time.sleep(3)
+                
+            progress_bar.update(total_progress // 2)  # Update progress bar
+            print("stdout:", stdout_accumulator.decode("utf-8"))
+            print("stderr:", stderr_accumulator.decode("utf-8"))
+            time.sleep(1)
+    except Exception as e:
+        # Log any other exceptions
+        print("Error:", e)
+        time.sleep(3)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    medicafe_package = "medicafe"
+    upgrade_medicafe(medicafe_package)