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

MediLink/MediLink_837p_utilities.py

@@ -11,6 +11,8 @@ Functions included:
 - File/path handling utilities
 - Processing utilities
 - Validation utilities
+- Insurance matching utilities
+- EDI segment utilities
 
 Import Strategy:
 This module only imports base Python modules and MediLink_ConfigLoader to avoid 
@@ -21,12 +23,11 @@ from datetime import datetime
 import sys
 import os
 import re
+import difflib
 
 # Import MediLink_ConfigLoader for logging functionality
-try:
-    from MediLink import MediLink_ConfigLoader
-except ImportError:
-    import MediLink_ConfigLoader
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
 
 # =============================================================================
 # DATE/TIME UTILITIES
@@ -246,6 +247,126 @@ def handle_validation_errors(transaction_set_control_number, validation_errors,
         MediLink_ConfigLoader.log("HALT: Processing halted at transaction set {} due to unresolved validation errors.".format(transaction_set_control_number), config, level="ERROR")
         sys.exit()  # Optionally halt further processing
 
+# =============================================================================
+# INSURANCE MATCHING UTILITIES
+# =============================================================================
+
+def find_closest_insurance_matches(insurance_name, insurance_to_id, max_matches=3):
+    """
+    Find the closest matches for an insurance name in the MAINS data.
+    
+    Args:
+        insurance_name (str): The insurance name to find matches for
+        insurance_to_id (dict): Dictionary mapping insurance names to IDs from MAINS
+        max_matches (int): Maximum number of matches to return
+        
+    Returns:
+        list: List of tuples (insurance_name, similarity_score) sorted by similarity
+    """
+    if not insurance_to_id:
+        return []
+    
+    # Normalize the search term
+    normalized_search = insurance_name.upper().strip()
+    
+    # Calculate similarity scores for all insurance names
+    matches = []
+    for mains_insurance_name in insurance_to_id.keys():
+        normalized_mains = mains_insurance_name.upper().strip()
+        
+        # Use difflib for similarity scoring
+        similarity = difflib.SequenceMatcher(None, normalized_search, normalized_mains).ratio()
+        
+        # Boost score for partial matches
+        if normalized_search in normalized_mains or normalized_mains in normalized_search:
+            similarity += 0.2
+        
+        # Boost score for word matches
+        search_words = set(normalized_search.split())
+        mains_words = set(normalized_mains.split())
+        word_overlap = len(search_words.intersection(mains_words))
+        if word_overlap > 0:
+            similarity += 0.1 * word_overlap
+        
+        matches.append((mains_insurance_name, similarity))
+    
+    # Sort by similarity score (highest first) and return top matches
+    matches.sort(key=lambda x: x[1], reverse=True)
+    return matches[:max_matches]
+
+def prompt_for_insurance_selection(insurance_name, closest_matches, config):
+    """
+    Prompt the user to select from the closest matches or choose manual intervention.
+    
+    Args:
+        insurance_name (str): The original insurance name that wasn't found
+        closest_matches (list): List of tuples (insurance_name, similarity_score)
+        config (dict): Configuration object
+        
+    Returns:
+        str or None: Selected insurance name or None for manual intervention
+    """
+    print("\n" + "="*60)
+    print("INSURANCE NAME NOT FOUND IN MAINS")
+    print("="*60)
+    print("Original insurance name: '{}'".format(insurance_name))
+    print("\nClosest matches found in MAINS:")
+    print("-" * 40)
+    
+    for i, (match_name, similarity) in enumerate(closest_matches, 1):
+        print("{}. {} (similarity: {:.1%})".format(i, match_name, similarity))
+    
+    print("\n{}. None of these - I need to fix this manually".format(len(closest_matches) + 1))
+    print("-" * 40)
+    
+    while True:
+        try:
+            choice = input("\nPlease select an option (1-{}): ".format(len(closest_matches) + 1))
+            choice_num = int(choice)
+            
+            if 1 <= choice_num <= len(closest_matches):
+                selected_name = closest_matches[choice_num - 1][0]
+                print("\nSelected: '{}'".format(selected_name))
+                MediLink_ConfigLoader.log("User selected insurance name '{}' for original '{}'".format(selected_name, insurance_name), config, level="INFO")
+                return selected_name
+            elif choice_num == len(closest_matches) + 1:
+                print("\n" + "="*60)
+                print("MANUAL INTERVENTION REQUIRED")
+                print("="*60)
+                print("To resolve this issue, you may need to:")
+                print("1. Check if the insurance name is spelled correctly in your source data")
+                print("2. Verify the insurance exists in MAINS with a different name")
+                print("3. Add the insurance to MAINS if it's missing")
+                print("4. Update the crosswalk with the correct payer ID mapping")
+                print("\nThe process will continue with other claims, but this claim will be skipped.")
+                print("="*60)
+                MediLink_ConfigLoader.log("User chose manual intervention for insurance name '{}'".format(insurance_name), config, level="WARNING")
+                return None
+            else:
+                print("Invalid choice. Please enter a number between 1 and {}.".format(len(closest_matches) + 1))
+        except ValueError:
+            print("Invalid input. Please enter a number.")
+        except KeyboardInterrupt:
+            print("\n\nProcess interrupted by user.")
+            return None
+
+# =============================================================================
+# EDI SEGMENT UTILITIES
+# =============================================================================
+
+def build_nm1_segment(payer_name, payer_id):
+    """
+    Build NM1 segment using payer name and ID.
+    
+    Args:
+        payer_name (str): Name of the payer
+        payer_id (str): Payer ID
+        
+    Returns:
+        str: Formatted NM1 segment
+    """
+    return "NM1*PR*2*{}*****PI*{}~".format(payer_name, payer_id)
+
 # =============================================================================
 # UTILITY FUNCTION REGISTRY
 # =============================================================================
@@ -260,5 +381,8 @@ __all__ = [
     'winscp_validate_output_directory', 
     'get_output_directory',
     'generate_segment_counts',
-    'handle_validation_errors'
+    'handle_validation_errors',
+    'find_closest_insurance_matches',
+    'prompt_for_insurance_selection',
+    'build_nm1_segment'
 ] 

MediLink/MediLink_API_Generator.py

@@ -1,29 +1,47 @@
 # This script requires Python 3.11 and is to be used for intalling new API clients.
 import os, time, subprocess, shutil, tempfile, shlex, re
 from pathlib import Path
-from watchdog.observers import Observer
-from watchdog.events import FileSystemEventHandler
-from MediLink_API_v3 import ConfigLoader
 
-class SwaggerHandler(FileSystemEventHandler):
+# 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)
+
+# Safe import for watchdog with fallback
+try:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler
+    WATCHDOG_AVAILABLE = True
+except ImportError:
+    Observer = None
+    FileSystemEventHandler = None
+    WATCHDOG_AVAILABLE = False
+    print("Warning: watchdog module not available. File monitoring functionality will be limited.")
+
+from MediCafe.api_core import ConfigLoader
+
+class SwaggerHandler(FileSystemEventHandler if WATCHDOG_AVAILABLE else object):
     def __init__(self, json_folder):
+        if WATCHDOG_AVAILABLE:
+            super().__init__()
         self.json_folder = json_folder
 
     def on_created(self, event):
         if event.is_directory:
             return
         if event.src_path.endswith('.yaml') or event.src_path.endswith('.json'):
-            print(f"New file detected: {event.src_path}")
+            print("New file detected: {}".format(event.src_path))
             time.sleep(2)  # Add a short delay to ensure the file is ready for reading
             self.process_swagger_file(event.src_path)
 
     def process_swagger_file(self, file_path):
-        print(f"Processing file: {file_path}")
+        print("Processing file: {}".format(file_path))
         # Sanitize filename to replace spaces with underscores
         sanitized_file_path = os.path.join(os.path.dirname(file_path), sanitize_filename(os.path.basename(file_path)))
         if sanitized_file_path != file_path:
             os.rename(file_path, sanitized_file_path)
-            print(f"Renamed file to: {sanitized_file_path}")
+            print("Renamed file to: {}".format(sanitized_file_path))
             file_path = sanitized_file_path
 
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -35,17 +53,17 @@ class SwaggerHandler(FileSystemEventHandler):
             shutil.copy(file_path, temp_file_path)
             config_source_path = Path(__file__).parent.parent / 'json' / 'openapi_config.json'
             shutil.copy(config_source_path, config_path)
-            print(f"Copied files to: {temp_file_path} and {config_path}")
+            print("Copied files to: {} and {}".format(temp_file_path, config_path))
 
             swagger_definitions = ConfigLoader.load_swagger_file(str(temp_file_path))
             if swagger_definitions:
-                print(f"Swagger definitions loaded successfully from: {temp_file_path}")
+                print("Swagger definitions loaded successfully from: {}".format(temp_file_path))
                 if generate_api_client(temp_file_path, output_dir, config_path):
                     backport_code(output_dir)
                     move_generated_client(temp_dir, file_path)
                     provide_instructions(file_path)
             else:
-                print(f"Failed to load Swagger definitions from: {temp_file_path}")
+                print("Failed to load Swagger definitions from: {}".format(temp_file_path))
 
 def sanitize_filename(filename):
     return filename.replace(' ', '_')
@@ -76,7 +94,7 @@ def generate_api_client(swagger_path, output_path, config_path):
         '-c', str(config_path)
     ]
     
-    print(f"Attempting command: {' '.join(command)}")
+    print("Attempting command: {}".format(' '.join(command)))
     
     try:
         result = subprocess.run(command, check=True, capture_output=True, text=True)
@@ -112,7 +130,7 @@ def generate_api_client(swagger_path, output_path, config_path):
             '-o', shlex.quote(str(output_path)),
             '-c', shlex.quote(str(config_path))
         ]
-        print(f"Attempting quoted command: {' '.join(quoted_command)}")
+        print("Attempting quoted command: {}".format(' '.join(quoted_command)))
         result = subprocess.run(' '.join(quoted_command), check=True, shell=True, capture_output=True, text=True)
         print("API client generated successfully with quoted command.")
         print(result.stdout)
@@ -126,10 +144,10 @@ def generate_api_client(swagger_path, output_path, config_path):
     
     try:
         print("Attempting with batch script.")
-        batch_script_content = f"""
-        @echo off
-        {openapi_generator_path} generate -i "{swagger_path}" -g python -o "{output_path}" -c "{config_path}"
-        """
+        batch_script_content = """
+@echo off
+{} generate -i "{}" -g python -o "{}" -c "{}"
+""".format(openapi_generator_path, swagger_path, output_path, config_path)
         batch_script_path = Path(tempfile.gettempdir()) / "generate_client.bat"
         with open(batch_script_path, 'w') as batch_script:
             batch_script.write(batch_script_content)
@@ -156,8 +174,8 @@ def backport_code(output_dir):
                 with open(file_path, 'r') as f:
                     code = f.read()
 
-                code = re.sub(r'f"(.*?)"', r'"\1".format', code)  # Replace f-strings
-                code = re.sub(r'async def', 'def', code)  # Remove async syntax
+                code = re.sub(r'"(.*?)".format()', r'"\1".format', code)  # Replace f-strings
+                code = re.sub(r'async de', 'def', code)  # Remove async syntax
                 code = re.sub(r'await ', '', code)  # Remove await syntax
                 code = re.sub(r':\s*\w+ =', '=', code)  # Remove type hints in variable assignments
                 code = re.sub(r'def (\w+)\(.*?\) -> .*?:', r'def \1(', code)  # Remove type hints in function definitions
@@ -166,7 +184,7 @@ def backport_code(output_dir):
 
                 with open(file_path, 'w') as f:
                     f.write(code)
-                print(f"Backported {file_path}")
+                print("Backported {}".format(file_path))
 
 def move_generated_client(temp_dir, original_file_path):
     api_name = Path(original_file_path).stem
@@ -175,60 +193,65 @@ def move_generated_client(temp_dir, original_file_path):
         shutil.rmtree(destination_dir)
     try:
         shutil.move(str(Path(temp_dir) / 'generated_client'), str(destination_dir))
-        print(f"Moved generated client to {destination_dir}")
+        print("Moved generated client to {}".format(destination_dir))
     except FileNotFoundError as e:
-        print(f"Error moving generated client: {e}")
+        print("Error moving generated client: {}".format(e))
     except Exception as e:
-        print(f"Unexpected error moving generated client: {e}")
+        print("Unexpected error moving generated client: {}".format(e))
 
 def provide_instructions(swagger_path):
     api_name = Path(swagger_path).stem
-    instructions = f"""
-    API Client for {api_name} has been generated successfully.
-    
-    Integration Steps:
-    1. Locate the generated client code in the 'generated_clients/{api_name}' directory.
-    2. Integrate the generated client code into your project by following these steps:
-        a. Copy the generated client directory to your project's client directory.
-        b. Import the client classes in your project as needed.
-        c. Ensure that the generated client adheres to the BaseAPIClient interface if integrating with the existing system.
-    3. Update your configuration to include the new API endpoint details.
-    4. Test the integration thoroughly to ensure compatibility and functionality.
-    
-    Example Integration:
-    from clients.generated.{api_name}.api_client import ApiClient as {api_name}Client
-
-    class New{api_name}APIClient(BaseAPIClient):
-        def __init__(self, config):
-            super().__init__(config)
-            self.generated_client = {api_name}Client()
-
-        def get_access_token(self, endpoint_name):
-            # Implement token retrieval logic
-            pass
-
-        def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None):
-            # Use the generated client to make the API call
-            if call_type == 'GET':
-                response = self.generated_client.call_api(url_extension, 'GET', params=params, header_params=headers)
-            elif call_type == 'POST':
-                response = self.generated_client.call_api(url_extension, 'POST', body=data, header_params=headers)
-            elif call_type == 'DELETE':
-                response = self.generated_client.call_api(url_extension, 'DELETE', header_params=headers)
-            else:
-                raise ValueError("Unsupported call type")
-            return response
-    
-    """
+    instructions = """
+API Client for {} has been generated successfully.
+
+Integration Steps:
+1. Locate the generated client code in the 'generated_clients/{}' directory.
+2. Integrate the generated client code into your project by following these steps:
+    a. Copy the generated client directory to your project's client directory.
+    b. Import the client classes in your project as needed.
+    c. Ensure that the generated client adheres to the BaseAPIClient interface if integrating with the existing system.
+3. Update your configuration to include the new API endpoint details.
+4. Test the integration thoroughly to ensure compatibility and functionality.
+
+Example Integration:
+from clients.generated.{}.api_client import ApiClient as {}Client
+
+class New{}APIClient(BaseAPIClient):
+    def __init__(self, config):
+        super().__init__(config)
+        self.generated_client = {}Client()
+
+    def get_access_token(self, endpoint_name):
+        # Implement token retrieval logic
+        pass
+
+    def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None):
+        # Use the generated client to make the API call
+        if call_type == 'GET':
+            response = self.generated_client.call_api(url_extension, 'GET', params=params, header_params=headers)
+        elif call_type == 'POST':
+            response = self.generated_client.call_api(url_extension, 'POST', body=data, header_params=headers)
+        elif call_type == 'DELETE':
+            response = self.generated_client.call_api(url_extension, 'DELETE', header_params=headers)
+        else:
+            raise ValueError("Unsupported call type")
+        return response
+
+""".format(api_name, api_name, api_name, api_name, api_name, api_name)
     print(instructions)
 
 def main():
     json_folder = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'json'))
+    if not WATCHDOG_AVAILABLE:
+        print("Watchdog is not available. Skipping file monitoring.")
+        print("Please ensure watchdog is installed and in your PATH.")
+        return
+
     event_handler = SwaggerHandler(json_folder)
     observer = Observer()
     observer.schedule(event_handler, path=json_folder, recursive=False)
     observer.start()
-    print(f"Monitoring folder: {json_folder}")
+    print("Monitoring folder: {}".format(json_folder))
     try:
         while True:
             time.sleep(1)

MediLink/MediLink_API_v3.py

@@ -1,4 +1,4 @@
-# MediLink_API_v3.py
+# api_core.py
 import time, requests, yaml, json, os, traceback
 
 try: