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

MediLink/MediLink_837p_encoder.py

@@ -7,31 +7,6 @@ from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
 import MediLink_837p_encoder_library
 #from tqdm import tqdm
 
-"""
-Single File Processing Flow:
-
-This flow is triggered when the -d (directory) flag is not set. It handles the conversion of a single file specified by the -p flag.
-It directly processes the single file specified, without the need to iterate over a directory.
-The conversion initializes and processes this single file, appending the necessary EDI segments, and directly writes the output once processing is complete.
-
-Batch Directory Processing Flow:
-
-Activated when the -d flag is set, indicating that the -p flag points to a directory rather than a single file.
-Iterates over all files in the specified directory, processing only those that end with the ".DAT" extension.
-Each file is processed in sequence, with each undergoing a full cycle of reading, processing, and output file generation as in the single file flow.
-
-Development Task List:
-
-- [ ] 1. File Path Management: Enhance the handling of input paths to efficiently manage both individual files and directories, accommodating a range of file processing scenarios.
-- [ ] 2. User Interface Improvement: Advance the CLI for intuitive user interaction, offering clear options for file processing and real-time progress updates.
-- [ ] 3. Validation and Logging: Strengthen validation processes for input data, incorporating thorough checks against business rules and enhanced detailed logging for improved traceability and troubleshooting.
-- [ ] 4. Batch Processing and Output Handling: Enhance output file management to support efficient batch operations, including systematic naming and organization for output files.
-- [ ] 5. Comprehensive Documentation: Maintain up-to-date and detailed documentation within the codebase, ensuring all functions and complex logic are clearly explained.
-- [ ] 6. De-persisting Intermediate Files.
-- [ ] 7. Determination of Relationship to Patient for insurance holder. Can Compare Insured Name & closeness of DOB (usually spouse [2], child [3]). 
-- [ ] 8. Consolidation of certain functions needs to happen here.
-"""
-
 def format_single_claim(patient_data, config, endpoint, transaction_set_control_number):
     """
     Formats a single claim into 837P segments based on the provided patient data and endpoint.
@@ -196,9 +171,9 @@ def read_and_validate_claims(file_path, config):
     validation_errors = []  # List to store validation errors
 
     # Iterate over data in the file
-    for personal_info, insurance_info, service_info in read_fixed_width_data(file_path):
+    for personal_info, insurance_info, service_info, service_info_2, service_info_3 in read_fixed_width_data(file_path):
         # Parse data into a usable format
-        parsed_data = parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', config))
+        parsed_data = parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
         # Validate the parsed data
         is_valid, errors = validate_claim_data(parsed_data, config)
         if is_valid:
@@ -263,7 +238,7 @@ def validate_claim_data(parsed_data, config, required_fields=[]):
         ]
     """    
     errors = []
-    MediLink_ConfigLoader.log("Starting claim vata validation...")
+    MediLink_ConfigLoader.log("Starting claim data validation...")
     if not required_fields:
         # If no required fields are specified, assume validation is true
         return True, []

MediLink/MediLink_837p_encoder_library.py

@@ -1,30 +1,18 @@
 from datetime import datetime
 import sys
-from MediLink import MediLink_ConfigLoader
+from MediLink import MediLink_ConfigLoader, MediLink_UI
 
 # Add parent directory of the project to the Python path
 import sys
 import os
+
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 sys.path.append(project_dir)
 
 from MediBot import MediBot_Preprocessor_lib
 load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
 from MediBot import MediBot_Crosswalk_Library
-from MediLink_API_v2 import fetch_payer_name_from_api
-
-"""
-- [ ] 1. Code Refactoring: Increase modularity and clarity, particularly in segment creation functions (e.g., `create_st_segment`, `create_nm1_billing_provider_segment`), for better maintenance and readability.
-- [ ] 2. Endpoint Support: Extend support within segment creation for additional endpoints with attention to their unique claim submission requirements.
-- [ ] 3. Payer Identification Mechanism: Refine the mechanism for dynamically identifying payers, leveraging payer mappings and integrating with external APIs like Availity for precise payer information retrieval.
-- [ ] 4. Adherence to Endpoint-Specific Standards: Implement and verify the compliance of claim data formatting and inclusion based on the specific demands of each target endpoint within the segment creation logic.
-- [ ] 5. De-persisting Intermediate Files.
-- [ ] 6. Get an API for Optum "Entered As". 
-- [ ] 7. (MED) Add Authorization Number 
-- [X] 8. (HIGH) Interchange number should be 000HHMMSS instead of fixed constant.
-- [ ] 9. Upgrade Interchange formation to consolidate the batch processor and also de-risk batch 
-         interchange number matching for multiple .DAT.
-"""
+from MediLink_API_v3 import fetch_payer_name_from_api
 
 # Converts date format from one format to another.
 def convert_date_format(date_str):
@@ -520,43 +508,21 @@ def insurance_type_selection(parsed_data):
     - str: The insurance type code selected by the user.
     
     """
-    print("\nHorrible Temporary Menu: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
-
-    # Define insurance options with codes and descriptions
-    insurance_options = {
-        "11": "Other Non-Federal Programs",
-        "12": "Preferred Provider Organization (PPO)",
-        "13": "Point of Service (POS)",
-        "14": "Exclusive Provider Organization (EPO)",
-        "15": "Indemnity Insurance",
-        "16": "Health Maintenance Organization (HMO) Medicare Risk",
-        "17": "Dental Maintenance Organization",
-        "AM": "Automobile Medical",
-        "BL": "Blue Cross/Blue Shield",
-        "CH": "Champus",
-        "CI": "Commercial Insurance Co.",
-        "DS": "Disability",
-        "FI": "Federal Employees Program",
-        "HM": "Health Maintenance Organization",
-        "LM": "Liability Medical",
-        "MA": "Medicare Part A",
-        "MB": "Medicare Part B",
-        "MC": "Medicaid",
-        "OF": "Other Federal Program",
-        "TV": "Title V",
-        "VA": "Veterans Affairs Plan",
-        "WC": "Workers Compensation Health Claim",
-        "ZZ": "Mutually Defined"
-    }
-
-    # Function to display full list of insurance options
-    def display_insurance_options(options):
-        print("Insurance Type Options:")
-        # Sorting the dictionary keys to ensure consistent order
-        sorted_keys = sorted(options.keys())
-        for code in sorted_keys:
-            description = options[code]
-            print("{} - {}".format(code, description))
+    MediLink_ConfigLoader.log("insurance_type_selection(parsed_data): {}".format(parsed_data), level="DEBUG")
+    
+    # Check if insurance type is already assigned and is valid
+    insurance_type_code = parsed_data.get('insurance_type')
+    if insurance_type_code and len(insurance_type_code) == 2 and insurance_type_code.isalnum():
+        MediLink_ConfigLoader.log("Insurance type already assigned: {}".format(insurance_type_code), level="DEBUG")
+        return insurance_type_code
+    elif insurance_type_code:
+        MediLink_ConfigLoader.log("Invalid insurance type: {}".format(insurance_type_code), level="WARNING")
+    
+    print("\nInsurance Type Validation Error: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
+
+    # Retrieve insurance options with codes and descriptions
+    config, _ = MediLink_ConfigLoader.load_configuration()
+    insurance_options = config['MediLink_Config'].get('insurance_options')
 
     def prompt_display_insurance_options():
         # Prompt to display full list
@@ -564,7 +530,7 @@ def insurance_type_selection(parsed_data):
 
         # Display full list if user confirms
         if display_full_list in ['yes', 'y']:
-            display_insurance_options(insurance_options)
+            MediLink_UI.display_insurance_options(insurance_options)
 
     # Horrible menu
     prompt_display_insurance_options()

MediLink/MediLink_API_Generator.py

@@ -0,0 +1,246 @@
+# This script requires Python 3.11 and is to be used for intalling new API clients.
+import os
+import time
+import subprocess
+import shutil
+import tempfile
+from pathlib import Path
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from MediLink_API_v3 import ConfigLoader
+import shlex
+import re
+
+class SwaggerHandler(FileSystemEventHandler):
+    def __init__(self, json_folder):
+        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}")
+            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}")
+        # 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}")
+            file_path = sanitized_file_path
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_dir_path = Path(temp_dir)
+            temp_file_path = temp_dir_path / Path(file_path).name
+            config_path = temp_dir_path / 'openapi_config.json'
+            output_dir = temp_dir_path / "generated_client"
+
+            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}")
+
+            swagger_definitions = ConfigLoader.load_swagger_file(str(temp_file_path))
+            if swagger_definitions:
+                print(f"Swagger definitions loaded successfully from: {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}")
+
+def sanitize_filename(filename):
+    return filename.replace(' ', '_')
+
+def find_executable(name):
+    """Find the full path to an executable."""
+    for path in os.environ["PATH"].split(os.pathsep):
+        full_path = Path(path) / name
+        if full_path.is_file():
+            return str(full_path)
+    return None
+
+def generate_api_client(swagger_path, output_path, config_path):
+    """
+    Generate the API client using openapi-generator-cli.
+    """
+    openapi_generator_path = find_executable('openapi-generator-cli.cmd')
+    if not openapi_generator_path:
+        print("openapi-generator-cli not found in PATH.")
+        return False
+    
+    command = [
+        openapi_generator_path,
+        'generate',
+        '-i', str(swagger_path),
+        '-g', 'python',
+        '-o', str(output_path),
+        '-c', str(config_path)
+    ]
+    
+    print(f"Attempting command: {' '.join(command)}")
+    
+    try:
+        result = subprocess.run(command, check=True, capture_output=True, text=True)
+        print("API client generated successfully.")
+        print(result.stdout)
+        print(result.stderr)
+        return True
+    except subprocess.CalledProcessError as e:
+        print("First attempt failed.")
+        print("Error generating API client:")
+        print(e.stdout)
+        print(e.stderr)
+    
+    try:
+        print("Attempting with shell=True.")
+        result = subprocess.run(' '.join(command), check=True, shell=True, capture_output=True, text=True)
+        print("API client generated successfully with shell=True.")
+        print(result.stdout)
+        print(result.stderr)
+        return True
+    except subprocess.CalledProcessError as e:
+        print("Second attempt with shell=True failed.")
+        print("Error generating API client:")
+        print(e.stdout)
+        print(e.stderr)
+    
+    try:
+        quoted_command = [
+            openapi_generator_path,
+            'generate',
+            '-i', shlex.quote(str(swagger_path)),
+            '-g', 'python',
+            '-o', shlex.quote(str(output_path)),
+            '-c', shlex.quote(str(config_path))
+        ]
+        print(f"Attempting quoted command: {' '.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)
+        print(result.stderr)
+        return True
+    except subprocess.CalledProcessError as e:
+        print("Third attempt with quoted command failed.")
+        print("Error generating API client:")
+        print(e.stdout)
+        print(e.stderr)
+    
+    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_path = Path(tempfile.gettempdir()) / "generate_client.bat"
+        with open(batch_script_path, 'w') as batch_script:
+            batch_script.write(batch_script_content)
+        
+        result = subprocess.run(str(batch_script_path), check=True, shell=True, capture_output=True, text=True)
+        print("API client generated successfully with batch script.")
+        print(result.stdout)
+        print(result.stderr)
+        return True
+    except subprocess.CalledProcessError as e:
+        print("Fourth attempt with batch script failed.")
+        print("Error generating API client:")
+        print(e.stdout)
+        print(e.stderr)
+    
+    print("All attempts to generate API client failed.")
+    return False
+
+def backport_code(output_dir):
+    for root, _, files in os.walk(output_dir):
+        for file in files:
+            if file.endswith('.py'):
+                file_path = os.path.join(root, file)
+                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'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
+                code = re.sub(r'(from pydantic import.*)', '# \1', code)  # Comment out pydantic imports
+                code = re.sub(r'(import pydantic)', '# \1', code)  # Comment out pydantic imports
+
+                with open(file_path, 'w') as f:
+                    f.write(code)
+                print(f"Backported {file_path}")
+
+def move_generated_client(temp_dir, original_file_path):
+    api_name = Path(original_file_path).stem
+    destination_dir = Path('generated_clients') / api_name
+    if destination_dir.exists():
+        shutil.rmtree(destination_dir)
+    try:
+        shutil.move(str(Path(temp_dir) / 'generated_client'), str(destination_dir))
+        print(f"Moved generated client to {destination_dir}")
+    except FileNotFoundError as e:
+        print(f"Error moving generated client: {e}")
+    except Exception as e:
+        print(f"Unexpected error moving generated client: {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
+    
+    """
+    print(instructions)
+
+def main():
+    json_folder = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'json'))
+    event_handler = SwaggerHandler(json_folder)
+    observer = Observer()
+    observer.schedule(event_handler, path=json_folder, recursive=False)
+    observer.start()
+    print(f"Monitoring folder: {json_folder}")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+    observer.join()
+
+if __name__ == "__main__":
+    main()

MediLink/MediLink_API_v2.py

@@ -1,3 +1,5 @@
+# Unused archive backup. This has been superceded by API_v3
+
 import time
 import requests