medicafe 0.250728.9__py3-none-any.whl → 0.250805.0__py3-none-any.whl

MediLink/MediLink_main.py

@@ -0,0 +1,248 @@
+# MediLink.py - Orchestrating script for MediLink operations
+import os, sys, time
+
+# Add workspace directory to Python path for MediCafe imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+workspace_dir = os.path.dirname(current_dir)
+if workspace_dir not in sys.path:
+    sys.path.insert(0, workspace_dir)
+
+# Import centralized logging configuration
+try:
+    from MediCafe.logging_config import PERFORMANCE_LOGGING
+except ImportError:
+    # Fallback to local flag if centralized config is not available
+    PERFORMANCE_LOGGING = False
+
+# Add timing for import phase
+start_time = time.time()
+if PERFORMANCE_LOGGING:
+    print("Starting MediLink initialization...")
+
+
+# Now import core utilities after path setup
+from MediCafe.core_utils import get_shared_config_loader, setup_module_paths
+setup_module_paths(__file__)
+
+# Import modules after path setup
+import MediLink_Down
+import MediLink_Up
+import MediLink_DataMgmt
+import MediLink_UI  # Import UI module for handling all user interfaces
+import MediLink_PatientProcessor  # Import patient processing functions
+
+# Use core utilities for standardized config loader
+MediLink_ConfigLoader = get_shared_config_loader()
+
+try:
+    from tqdm import tqdm
+except ImportError:
+    # Fallback for when tqdm is not available
+    def tqdm(iterable, **kwargs):
+        return iterable
+
+import_time = time.time()
+if PERFORMANCE_LOGGING:
+    print("Import phase completed in {:.2f} seconds".format(import_time - start_time))
+
+# NOTE: Configuration loading moved to function level to avoid import-time dependencies
+
+# TODO There needs to be a crosswalk auditing feature right alongside where all the names get fetched during initial startup maybe? 
+# This already happens when MediLink is opened.
+
+def main_menu():
+    """
+    Initializes the main menu loop and handles the overall program flow,
+    including loading configurations and managing user input for menu selections.
+    """
+    menu_start_time = time.time()
+    print("Main menu function started...")
+    
+    # Load configuration settings and display the initial welcome message.
+    config_start_time = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Loading configuration...")
+    config, crosswalk = MediLink_ConfigLoader.load_configuration() 
+    config_end_time = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Configuration loading completed in {:.2f} seconds".format(config_end_time - config_start_time))
+    
+    # Check to make sure payer_id key is available in crosswalk, otherwise, go through that crosswalk initialization flow
+    crosswalk_check_start = time.time()
+    if 'payer_id' not in crosswalk:
+        print("\n" + "="*60)
+        print("SETUP REQUIRED: Payer Information Database Missing")
+        print("="*60)
+        print("\nThe system needs to build a database of insurance company information")
+        print("before it can process claims. This is a one-time setup requirement.")
+        print("\nThis typically happens when:")
+        print("- You're running MediLink for the first time")
+        print("- The payer database was accidentally deleted or corrupted")
+        print("- You're using a new installation of the system")
+        print("\nTO FIX THIS:")
+        print("1. Open a command prompt/terminal")
+        print("2. Navigate to the MediCafe directory")
+        print("3. Run: python MediBot/MediBot_Preprocessor.py --update-crosswalk")
+        print("4. Wait for the process to complete (this may take a few minutes)")
+        print("5. Return here and restart MediLink")
+        print("\nThis will download and build the insurance company database.")
+        print("="*60)
+        print("\nPress Enter to exit...")
+        input()
+        return  # Graceful exit instead of abrupt halt
+    
+    crosswalk_check_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Crosswalk validation completed in {:.2f} seconds".format(crosswalk_check_end - crosswalk_check_start))
+    
+    # Check if the application is in test mode
+    test_mode_start = time.time()
+    if config.get("MediLink_Config", {}).get("TestMode", False):
+        print("\n--- MEDILINK TEST MODE --- \nTo enable full functionality, please update the config file \nand set 'TestMode' to 'false'.")
+    test_mode_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Test mode check completed in {:.2f} seconds".format(test_mode_end - test_mode_start))
+    
+    # Display Welcome Message
+    welcome_start = time.time()
+    MediLink_UI.display_welcome()
+    welcome_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Welcome display completed in {:.2f} seconds".format(welcome_end - welcome_start))
+
+    # Normalize the directory path for file operations.
+    path_norm_start = time.time()
+    directory_path = os.path.normpath(config['MediLink_Config']['inputFilePath'])
+    path_norm_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Path normalization completed in {:.2f} seconds".format(path_norm_end - path_norm_start))
+
+    # Detect files and determine if a new file is flagged.
+    file_detect_start = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Starting file detection...")
+    all_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
+    file_detect_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("File detection completed in {:.2f} seconds".format(file_detect_end - file_detect_start))
+        print("Found {} files, flagged: {}".format(len(all_files), file_flagged))
+    MediLink_ConfigLoader.log("Found {} files, flagged: {}".format(len(all_files), file_flagged), level="INFO")
+
+    menu_init_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Main menu initialization completed in {:.2f} seconds".format(menu_init_end - menu_start_time))
+
+    while True:
+        # Define the menu options. Base options include checking remittances and exiting the program.
+        options = ["Check for new remittances", "Exit"]
+        # If any files are detected, add the option to submit claims.
+        if all_files:
+            options.insert(1, "Submit claims")
+
+        # Display the dynamically adjusted menu options.
+        menu_display_start = time.time()
+        MediLink_UI.display_menu(options)
+        menu_display_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("Menu display completed in {:.2f} seconds".format(menu_display_end - menu_display_start))
+        
+        # Retrieve user choice and handle it.
+        choice_start = time.time()
+        choice = MediLink_UI.get_user_choice()
+        choice_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("User choice retrieval completed in {:.2f} seconds".format(choice_end - choice_start))
+
+        if choice == '1':
+            # Handle remittance checking.
+            remittance_start = time.time()
+            MediLink_Down.check_for_new_remittances(config)
+            remittance_end = time.time()
+            if PERFORMANCE_LOGGING:
+                print("Remittance check completed in {:.2f} seconds".format(remittance_end - remittance_start))
+        elif choice == '2' and all_files:
+            # Handle the claims submission flow if any files are present.
+            submission_start = time.time()
+            if file_flagged:
+                # Extract the newest single latest file from the list if a new file is flagged.
+                selected_files = [max(all_files, key=os.path.getctime)]
+            else:
+                # Prompt the user to select files if no new file is flagged.
+                selected_files = MediLink_UI.user_select_files(all_files)
+
+            # Collect detailed patient data for selected files.
+            patient_data_start = time.time()
+            detailed_patient_data = MediLink_PatientProcessor.collect_detailed_patient_data(selected_files, config, crosswalk)
+            patient_data_end = time.time()
+            if PERFORMANCE_LOGGING:
+                print("Patient data collection completed in {:.2f} seconds".format(patient_data_end - patient_data_start))
+            
+            # Process the claims submission.
+            handle_submission(detailed_patient_data, config, crosswalk)
+            submission_end = time.time()
+            if PERFORMANCE_LOGGING:
+                print("Claims submission flow completed in {:.2f} seconds".format(submission_end - submission_start))
+        elif choice == '3' or (choice == '2' and not all_files):
+            # Exit the program if the user chooses to exit or if no files are present.
+            MediLink_UI.display_exit_message()
+            break
+        else:
+            # Display an error message if the user's choice does not match any valid option.
+            MediLink_UI.display_invalid_choice()
+
+def handle_submission(detailed_patient_data, config, crosswalk):
+    """
+    Handles the submission process for claims based on detailed patient data.
+    This function orchestrates the flow from user decision on endpoint suggestions to the actual submission of claims.
+    """
+    insurance_edited = False  # Flag to track if insurance types were edited
+
+    # Ask the user if they want to edit insurance types
+    edit_insurance = input("Do you want to edit insurance types? (y/n): ").strip().lower()
+    if edit_insurance in ['y', 'yes', '']:
+        insurance_edited = True  # User chose to edit insurance types
+        
+        # Get insurance options from config
+        insurance_options = config['MediLink_Config'].get('insurance_options', {})
+        
+        while True:
+            # Bulk edit insurance types
+            MediLink_DataMgmt.bulk_edit_insurance_types(detailed_patient_data, insurance_options)
+    
+            # Review and confirm changes
+            if MediLink_DataMgmt.review_and_confirm_changes(detailed_patient_data, insurance_options):
+                break  # Exit the loop if changes are confirmed
+            else:
+                print("Returning to bulk edit insurance types.")
+    
+    # Initiate user interaction to confirm or adjust suggested endpoints.
+    adjusted_data, updated_crosswalk = MediLink_UI.user_decision_on_suggestions(detailed_patient_data, config, insurance_edited, crosswalk)
+    
+    # Update crosswalk reference if it was modified
+    if updated_crosswalk:
+        crosswalk = updated_crosswalk
+    
+    # Confirm all remaining suggested endpoints.
+    confirmed_data = MediLink_DataMgmt.confirm_all_suggested_endpoints(adjusted_data)
+    if confirmed_data:  # Proceed if there are confirmed data entries.
+        # Organize data by confirmed endpoints for submission.
+        organized_data = MediLink_DataMgmt.organize_patient_data_by_endpoint(confirmed_data)
+        # Confirm transmission with the user and check for internet connectivity.
+        if MediLink_Up.confirm_transmission(organized_data):
+            if MediLink_Up.check_internet_connection():
+                # Submit claims if internet connectivity is confirmed.
+                _ = MediLink_Up.submit_claims(organized_data, config, crosswalk)
+                # TODO submit_claims will have a receipt return in the future.
+            else:
+                # Notify the user of an internet connection error.
+                print("Internet connection error. Please ensure you're connected and try again.")
+        else:
+            # Notify the user if the submission is cancelled.
+            print("Submission cancelled. No changes were made.")
+
+if __name__ == "__main__":
+    total_start_time = time.time()
+    main_menu()
+    total_end_time = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Total MediLink execution time: {:.2f} seconds".format(total_end_time - total_start_time))

MediLink/MediLink_smart_import.py

@@ -0,0 +1,264 @@
+#MediLink_smart_import.py
+"""
+Upgraded MediLink main module using MediCafe Smart Import System
+
+This is a demonstration of how MediLink_main.py should be migrated to use the
+new centralized smart import system, eliminating complex imports and
+circular dependency risks.
+"""
+
+import os, sys, time
+
+# Add workspace directory to Python path for MediCafe imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+workspace_dir = os.path.dirname(current_dir)
+if workspace_dir not in sys.path:
+    sys.path.insert(0, workspace_dir)
+
+# NEW SMART IMPORT APPROACH - Replace all complex imports with this
+from MediCafe import setup_for_medilink, get_components, get_api_access
+
+print("[*] Loading MediLink components via smart import system...")
+
+# Get everything needed for MediLink main functionality
+try:
+    components = setup_for_medilink('medilink_main')
+    print("[+] Loaded {} components for MediLink main".format(len(components)))
+    
+    # Extract core components
+    api_core = components.get('api_core')
+    logging_config = components.get('logging_config')
+    core_utils = components.get('core_utils')
+    
+    # MediLink specific components
+    medilink_datamgmt = components.get('medilink_datamgmt')
+    medilink_parser = components.get('medilink_parser')
+    medilink_up = components.get('medilink_up')
+    medilink_down = components.get('medilink_down')
+    medilink_ui = components.get('medilink_ui')
+    medilink_patient_processor = components.get('medilink_patient_processor')
+    
+    print("[+] MediLink components extracted")
+    
+except Exception as e:
+    print("[!] Some components unavailable (expected in dev): {}".format(e))
+    # Fallback to individual components
+    try:
+        api_core = get_components('api_core', silent_fail=True)
+        logging_config = get_components('logging_config', silent_fail=True)
+        core_utils = get_components('core_utils', silent_fail=True)
+        # Initialize MediLink components as None for fallback
+        medilink_datamgmt = None
+        medilink_parser = None
+        medilink_up = None
+        medilink_down = None
+        medilink_ui = None
+        medilink_patient_processor = None
+        print("[+] Fallback to core components")
+    except:
+        print("[-] Smart import system not available")
+        api_core = None
+        logging_config = None
+        core_utils = None
+        medilink_datamgmt = None
+        medilink_parser = None
+        medilink_up = None
+        medilink_down = None
+        medilink_ui = None
+        medilink_patient_processor = None
+
+# Configuration loader setup
+MediLink_ConfigLoader = None
+if core_utils:
+    try:
+        get_shared_config_loader = getattr(core_utils, 'get_shared_config_loader', None)
+        if get_shared_config_loader:
+            MediLink_ConfigLoader = get_shared_config_loader()
+            print("[+] Configuration loader initialized")
+    except Exception as e:
+        print("[!] Configuration loader issue: {}".format(e))
+
+# Performance logging setup
+PERFORMANCE_LOGGING = False
+if logging_config:
+    try:
+        PERFORMANCE_LOGGING = getattr(logging_config, 'PERFORMANCE_LOGGING', False)
+        print("[+] Performance logging: {}".format(PERFORMANCE_LOGGING))
+    except Exception as e:
+        print("[!] Performance logging setup issue: {}".format(e))
+
+# Legacy import compatibility
+try:
+    from tqdm import tqdm
+    print("[+] tqdm available")
+except ImportError:
+    # Fallback for when tqdm is not available
+    def tqdm(iterable, **kwargs):
+        return iterable
+    print("[!] tqdm not available - using fallback")
+
+# Module function extraction (if components are available)
+def get_medilink_function(component, function_name):
+    """Extract a function from a MediLink component safely."""
+    if component:
+        return getattr(component, function_name, None)
+    return None
+
+# Main menu function using smart imports
+def main_menu():
+    """
+    Main menu using smart import system.
+    All component access is now centralized and safe.
+    """
+    print("\n[*] MediLink Starting with Smart Import System")
+    print("=" * 50)
+    
+    # Check component availability
+    components_status = {
+        'Configuration': MediLink_ConfigLoader is not None,
+        'API Access': api_core is not None,
+        'Data Management': medilink_datamgmt is not None,
+        'Parser': medilink_parser is not None,
+        'Upload Module': medilink_up is not None,
+        'Download Module': medilink_down is not None,
+        'UI Module': medilink_ui is not None,
+        'Patient Processor': medilink_patient_processor is not None
+    }
+    
+    print("Component Status:")
+    for component, status in components_status.items():
+        status_icon = "[+]" if status else "[!]"
+        print("  {} {}".format(status_icon, component))
+    
+    # Get API access suite for additional functionality
+    try:
+        api_suite = get_api_access()
+        print("[+] API suite loaded with {} components".format(len(api_suite)))
+    except Exception as e:
+        print("[!] API suite issue: {}".format(e))
+    
+    print("\n[i] Smart Import Benefits:")
+    print("  - No complex import chains")
+    print("  - No circular dependency risks")
+    print("  - Graceful component fallbacks")
+    print("  - Centralized configuration")
+    print("  - Easy testing and validation")
+    
+    return components_status
+
+def demonstrate_claim_processing():
+    """Demonstrate claim processing with smart imports."""
+    print("\n[*] Claim Processing Demo")
+    print("-" * 30)
+    
+    try:
+        # Get specialized components for claim processing
+        claim_components = setup_for_medilink('medilink_claim_processing')
+        print("[+] Loaded {} claim processing components".format(len(claim_components)))
+        
+        # Extract claim-specific components
+        encoder_837p = claim_components.get('medilink_837p_encoder')
+        utilities_837p = claim_components.get('medilink_837p_utilities')
+        claim_status = claim_components.get('medilink_claim_status')
+        
+        if encoder_837p:
+            print("[+] 837P encoder ready")
+        if utilities_837p:
+            print("[+] 837P utilities ready")
+        if claim_status:
+            print("[+] Claim status module ready")
+        
+        return True
+        
+    except Exception as e:
+        print("[!] Claim processing setup issue: {}".format(e))
+        return False
+
+def demonstrate_deductible_processing():
+    """Demonstrate deductible processing with smart imports."""
+    print("\n[*] Deductible Processing Demo")
+    print("-" * 30)
+    
+    try:
+        # Get specialized components for deductible processing
+        deductible_components = setup_for_medilink('medilink_deductible_processing')
+        print("[+] Loaded {} deductible processing components".format(len(deductible_components)))
+        
+        # Extract deductible-specific components
+        deductible_module = deductible_components.get('medilink_deductible')
+        deductible_validator = deductible_components.get('medilink_deductible_validator')
+        insurance_utils = deductible_components.get('medilink_insurance_utils')
+        
+        if deductible_module:
+            print("[+] Deductible module ready")
+        if deductible_validator:
+            print("[+] Deductible validator ready")
+        if insurance_utils:
+            print("[+] Insurance utilities ready")
+        
+        return True
+        
+    except Exception as e:
+        print("[!] Deductible processing setup issue: {}".format(e))
+        return False
+
+def demonstrate_communication():
+    """Demonstrate communication functionality with smart imports."""
+    print("\n[*] Communication Demo")
+    print("-" * 30)
+    
+    try:
+        # Get specialized components for communication
+        comm_components = setup_for_medilink('medilink_communication')
+        print("[+] Loaded {} communication components".format(len(comm_components)))
+        
+        # Extract communication-specific components
+        gmail_module = comm_components.get('medilink_gmail')
+        mailer_module = comm_components.get('medilink_mailer')
+        display_utils = comm_components.get('medilink_display_utils')
+        
+        if gmail_module:
+            print("[+] Gmail module ready")
+        if mailer_module:
+            print("[+] Mailer module ready")
+        if display_utils:
+            print("[+] Display utilities ready")
+        
+        return True
+        
+    except Exception as e:
+        print("[!] Communication setup issue: {}".format(e))
+        return False
+
+def main():
+    """Main function demonstrating smart import usage."""
+    start_time = time.time()
+    
+    if PERFORMANCE_LOGGING:
+        print("Performance logging enabled")
+    
+    # Run main menu
+    status = main_menu()
+    
+    # Demonstrate different module types
+    print("\n[*] Testing Specialized Module Types:")
+    demonstrate_claim_processing()
+    demonstrate_deductible_processing()
+    demonstrate_communication()
+    
+    end_time = time.time()
+    print("\n[*] Total initialization time: {:.2f} seconds".format(end_time - start_time))
+    
+    # Summary
+    available_components = sum(status.values())
+    total_components = len(status)
+    print("\n[*] Summary: {}/{} components available".format(available_components, total_components))
+    
+    return available_components > 0
+
+if __name__ == "__main__":
+    success = main()
+    if success:
+        print("\n[+] MediLink smart import demonstration completed successfully!")
+    else:
+        print("\n[-] MediLink smart import demonstration had issues")

MediLink/__init__.py

@@ -1 +1,93 @@
-from .MediLink import enrich_with_insurance_type
+# MediLink package
+"""
+MediLink - Medical Claims Processing and Data Management
+
+MediLink provides comprehensive claims processing, data management, and
+communication capabilities for medical practice management.
+
+Smart Import Integration:
+    Instead of importing MediLink modules directly, use the MediCafe smart
+    import system for better dependency management and to avoid circular imports.
+    
+    Examples:
+        # Get everything for MediLink main functionality
+        from MediCafe import setup_for_medilink
+        components = setup_for_medilink('medilink_main')
+        
+        # Get everything for claims processing
+        components = setup_for_medilink('medilink_claim_processing')
+        
+        # Get specific MediLink components
+        from MediCafe import get_components
+        datamgmt = get_components('medilink_datamgmt')
+"""
+
+__version__ = "0.250728.9"
+__author__ = "Daniel Vidaud"
+__email__ = "daniel@personalizedtransformation.com"
+
+# Provide information about smart import integration
+def get_smart_import_info():
+    """Get information about using MediLink with the smart import system."""
+    return {
+        'recommended_approach': 'Use MediCafe smart import system',
+        'setup_function': 'setup_for_medilink(module_type)',
+        'available_module_types': [
+            'medilink_main',
+            'medilink_claim_processing',
+            'medilink_deductible_processing', 
+            'medilink_communication',
+            'medilink_data_management'
+        ],
+        'example': """
+# Recommended usage:
+from MediCafe import setup_for_medilink
+components = setup_for_medilink('medilink_claim_processing')
+
+# Access components:
+api_core = components.get('api_core')
+datamgmt = components.get('medilink_datamgmt')
+encoder = components.get('medilink_837p_encoder')
+"""
+    }
+
+# Show smart import guide
+def show_smart_import_guide():
+    """Display a guide for using MediLink with smart imports."""
+    info = get_smart_import_info()
+    print("MediLink Smart Import Guide")
+    print("=" * 40)
+    print("Recommended approach: {}".format(info['recommended_approach']))
+    print("Setup function: {}".format(info['setup_function']))
+    print("\nAvailable module types:")
+    for module_type in info['available_module_types']:
+        print("  - {}".format(module_type))
+    print("\nExample usage:\n{}".format(info['example']))
+
+# Legacy import warning
+def _show_legacy_warning():
+    """Show a warning about direct imports."""
+    import warnings
+    warnings.warn(
+        "Direct MediLink imports may cause circular dependencies. "
+        "Consider using 'from MediCafe import setup_for_medilink' instead.",
+        FutureWarning,
+        stacklevel=3
+    )
+
+# Package metadata
+__all__ = [
+    '__version__',
+    '__author__',
+    '__email__', 
+    'get_smart_import_info',
+    'show_smart_import_guide'
+]
+
+# Optional: Show guide on import (can be disabled)
+import os
+if os.environ.get('MEDILINK_SHOW_SMART_IMPORT_GUIDE', '').lower() == 'true':
+    try:
+        show_smart_import_guide()
+    except:
+        pass 

MediLink/insurance_type_integration_test.py

@@ -7,9 +7,12 @@ import json
 import sys, os
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
+# Use core utilities for standardized imports
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
+
 try:
-    from MediLink import MediLink_ConfigLoader
-    from MediLink_API_v3 import (
+    from MediCafe.api_core import (
         APIClient
     )
     from MediLink import (
@@ -92,7 +95,14 @@ def run_insurance_type_integration_tests():
     test_results['total_tests'] += 1
     try:
         print("\n4. Testing API Client Initialization...")
-        api_client = APIClient()
+        # Test both factory and direct instantiation
+        try:
+            from MediCafe.core_utils import get_api_client
+            api_client = get_api_client()
+            if api_client is None:
+                api_client = APIClient()
+        except ImportError:
+            api_client = APIClient()
         print("   PASS API client initialization PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'api_client_init', 'status': 'PASSED'})

MediLink/test.py

@@ -2,7 +2,7 @@ import re
 from datetime import datetime
 
 def log(message):
-    print(f"LOG: {message}")
+    print("LOG: {}".format(message))
 
 def parse_837p_file(content):
     patient_details = []