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

MediBot/MediBot.bat

@@ -11,6 +11,8 @@ set "medicafe_package=medicafe"
 set "upgrade_medicafe=F:\Medibot\update_medicafe.py"
 set "temp_file=F:\Medibot\last_update_timestamp.txt"
 set "firefox_path=C:\Program Files\Mozilla Firefox\firefox.exe"
+set "claims_status_script=..\MediLink\MediLink_ClaimStatus.py"
+set "deductible_script=..\MediLink\MediLink_Deductible.py"
 set "package_version="
 set PYTHONWARNINGS=ignore
 
@@ -99,14 +101,18 @@ if "!internet_available!"=="1" (
     echo 1. Check for MediCafe Package Updates
     echo 2. Download Email de Carol
     echo 3. MediLink Claims
+    echo 4. United Claims Status
+    echo 5. United Deductible
 )
-echo 4. Run MediBot
-echo 5. Exit
+echo 6. Run MediBot
+echo 7. Exit
 echo.
 set /p choice=Enter your choice:  
 
-if "!choice!"=="5" goto end_script
-if "!choice!"=="4" goto medibot_flow
+if "!choice!"=="7" goto end_script
+if "!choice!"=="6" goto medibot_flow
+if "!choice!"=="5" goto united_deductible
+if "!choice!"=="4" goto united_claims_status
 if "!choice!"=="3" goto medilink_flow
 if "!choice!"=="2" goto download_emails
 if "!choice!"=="1" goto check_updates
@@ -168,6 +174,32 @@ if errorlevel 1 echo MediLink failed to execute.
 pause
 goto main_menu
 
+:: United Claims Status
+:united_claims_status
+if "!internet_available!"=="0" (
+    echo No internet connection available.
+    goto main_menu
+)
+cls
+echo Checking United Claims Status...
+py "%claims_status_script%"
+if errorlevel 1 echo Failed to check United Claims Status.
+pause
+goto main_menu
+
+:: United Deductible
+:united_deductible
+if "!internet_available!"=="0" (
+    echo No internet connection available.
+    goto main_menu
+)
+cls
+echo Checking United Deductible...
+py "%deductible_script%"
+if errorlevel 1 echo Failed to check United Deductible.
+pause
+goto main_menu
+
 :: Process CSV Files
 :process_csvs
 for /f "tokens=1-5 delims=/: " %%a in ('echo %time%') do (
@@ -203,4 +235,4 @@ goto :eof
 :end_script
 echo Exiting MediCafe.
 pause
-exit /b
+exit /b

MediBot/MediBot_Crosswalk_Library.py

@@ -14,10 +14,10 @@ except ImportError:
     from MediLink import MediLink_ConfigLoader
 
 try:
-    from MediLink_API_v2 import fetch_payer_name_from_api
+    from MediLink_API_v3 import fetch_payer_name_from_api
 except ImportError:
-    from MediLink import MediLink_API_v2
-    fetch_payer_name_from_api = MediLink_API_v2.fetch_payer_name_from_api
+    from MediLink import MediLink_API_v3
+    fetch_payer_name_from_api = MediLink_API_v3.fetch_payer_name_from_api
 
 try:
     from MediBot import MediBot_Preprocessor_lib
@@ -127,7 +127,7 @@ def initialize_crosswalk_from_mapat():
     validate_and_correct_payer_ids(crosswalk, config)
     
     # Save the initial crosswalk
-    if save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk):
+    if save_crosswalk(config, crosswalk):
         message = "Crosswalk initialized with mappings for {} payers.".format(len(crosswalk.get('payer_id', {})))
         print(message)
         MediLink_ConfigLoader.log(message, config, level="INFO")
@@ -197,7 +197,7 @@ def crosswalk_update(config, crosswalk):
             crosswalk['payer_id'][payer_id]['medisoft_medicare_id'] = list(crosswalk['payer_id'][payer_id]['medisoft_medicare_id'])
             
     # Save the updated crosswalk to the specified file
-    return save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk)
+    return save_crosswalk(config, crosswalk)
 
 def update_crosswalk_with_corrected_payer_id(old_payer_id, corrected_payer_id, config, crosswalk):
     """Updates the crosswalk with the corrected payer ID."""
@@ -216,7 +216,7 @@ def update_crosswalk_with_corrected_payer_id(old_payer_id, corrected_payer_id, c
     MediLink_ConfigLoader.log("Crosswalk csv_replacements updated: added {} -> {}".format(old_payer_id, corrected_payer_id), config, level="INFO")
     
     # Save the updated crosswalk
-    return save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk)
+    return save_crosswalk(config, crosswalk)
 
 def update_crosswalk_with_new_payer_id(insurance_name, payer_id, config):
     """Updates the crosswalk with a new payer ID."""
@@ -229,14 +229,14 @@ def update_crosswalk_with_new_payer_id(insurance_name, payer_id, config):
             crosswalk['payer_id'][payer_id] = {"medisoft_id": [medisoft_id_str], "medisoft_medicare_id": []}
         else:
             crosswalk['payer_id'][payer_id]['medisoft_id'].append(medisoft_id_str)
-        save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk)
+        save_crosswalk(config, crosswalk)
         MediLink_ConfigLoader.log("Updated crosswalk with new payer ID {} for insurance name {}".format(payer_id, insurance_name), config, level="INFO")
     else:
         message = "Failed to update crosswalk: Medisoft ID not found for insurance name {}".format(insurance_name)
         print(message)
         MediLink_ConfigLoader.log(message, config, level="ERROR")
         
-def save_crosswalk(crosswalk_path, crosswalk):
+def save_crosswalk(config, crosswalk):
     """
     Saves the updated crosswalk to a JSON file.
     Args:
@@ -245,6 +245,13 @@ def save_crosswalk(crosswalk_path, crosswalk):
     Returns:
         bool: True if the file was successfully saved, False otherwise.
     """
+    # Attempt to fetch crosswalkPath from MediLink_Config
+    try:
+        crosswalk_path = config['MediLink_Config']['crosswalkPath']
+    except KeyError:
+        # If KeyError occurs, fall back to fetching crosswalkPath directly
+        crosswalk_path = config.get('crosswalkPath', None)  # Replace None with a default value if needed
+
     try:
         # Initialize 'payer_id' key if not present
         if 'payer_id' not in crosswalk:

MediBot/MediBot_docx_decoder.py

@@ -238,10 +238,19 @@ def parse_patient_id(text):
 
 def parse_diagnosis_code(text):
     try:
-        if '(' in text and ')' in text:  # Extract the diagnosis code before the '/'
-            full_code = text[text.index('(')+1:text.index(')')]
-            return full_code.split('/')[0]
-        return text.split('/')[0]
+        # Regular expression to find all ICD-10 codes starting with 'H' and containing a period
+        pattern = re.compile(r'H\d{2}\.\d+')
+        matches = pattern.findall(text)
+        
+        if matches:
+            return matches[0]  # Return the first match
+        else:
+            # Fallback to original method if no match is found
+            if '(' in text and ')' in text:  # Extract the diagnosis code before the '/'
+                full_code = text[text.index('(')+1:text.index(')')]
+                return full_code.split('/')[0]
+            return text.split('/')[0]
+    
     except Exception as e:
         MediLink_ConfigLoader.log("Error parsing diagnosis code: {}. Error: {}".format(text, e))
         return "Unknown"
@@ -268,7 +277,6 @@ def parse_femto_yes_or_no(text):
         MediLink_ConfigLoader.log("Error parsing femto yes or no: {}. Error: {}".format(text, e))
         return False
 
-
 def rotate_docx_files(directory):
     # List all files in the directory
     files = os.listdir(directory)

MediLink/MediLink.py

@@ -2,7 +2,6 @@ import os
 import MediLink_Down
 import MediLink_Up
 import MediLink_ConfigLoader
-import MediLink_837p_encoder
 import MediLink_DataMgmt
 
 # For UI Functions
@@ -19,73 +18,31 @@ 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
 
-# Define insurance options with codes and descriptions. 
-# TODO This needs to move to the config file
-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"
-}
-
-def detect_and_display_file_summaries(directory_path, config, crosswalk):
+# Retrieve insurance options with codes and descriptions
+config, _ = MediLink_ConfigLoader.load_configuration()
+insurance_options = config['MediLink_Config'].get('insurance_options')
+    
+def collect_detailed_patient_data(selected_files, config, crosswalk):
     """
-    Detects new files in the specified directory and prepares detailed patient data for processing,
-    including suggestions for endpoints based on insurance provider information found in the config.
+    Collects detailed patient data from the selected files.
     
-    :param directory_path: Path to the directory containing files to be detected.
+    :param selected_files: List of selected file paths.
     :param config: Configuration settings loaded from a JSON file.
     :param crosswalk: Crosswalk data for mapping purposes.
-    :return: A tuple containing a list of new file paths and the detailed patient data.
+    :return: A list of detailed patient data.
     """
-    try:
-        new_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
-        if not new_files:
-            print("No new claims detected. Check Medisoft claims output.")
-            MediLink_ConfigLoader.log("No new claims detected. Check Medisoft claims output.")
-            return False, []
-        
-        if not file_flagged:
-            selected_files = MediLink_UI.user_select_files(new_files)
-        else:
-            # Extract the newest single latest file from the list
-            selected_files = [max(new_files, key=os.path.getctime)]
-        
-        detailed_patient_data = []  # Initialize list for detailed patient data
-        for file_path in selected_files:
-            detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
-            detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
-            
-        # Enrich the detailed patient data with insurance type
-        detailed_patient_data = enrich_with_insurance_type(detailed_patient_data, insurance_options)
+    detailed_patient_data = []
+    for file_path in selected_files:
+        detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
+        detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
         
-        # Display summaries and provide an option for bulk edit
-        MediLink_UI.display_patient_summaries(detailed_patient_data)
+    # Enrich the detailed patient data with insurance type
+    detailed_patient_data = enrich_with_insurance_type(detailed_patient_data, insurance_options)
+    
+    # Display summaries and provide an option for bulk edit
+    MediLink_UI.display_patient_summaries(detailed_patient_data)
 
-        # Return the list of new files and the enriched detailed patient data
-        return selected_files, detailed_patient_data
-    except Exception as e:
-        MediLink_ConfigLoader.log("Error in detect_and_display_file_summaries: {}".format(e))
-        return False, []
+    return detailed_patient_data
 
 def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_mapping=None):
     """
@@ -299,17 +256,14 @@ def main_menu():
     # Normalize the directory path for file operations.
     directory_path = os.path.normpath(config['MediLink_Config']['inputFilePath'])
 
-    # Detect new files and collect detailed patient data if available.
-    new_files, detailed_patient_data = detect_and_display_file_summaries(directory_path, config, crosswalk)
-    
-    if new_files:
-        handle_submission(detailed_patient_data, config)
+    # Detect files and determine if a new file is flagged.
+    all_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
 
     while True:
         # Define the menu options. Base options include checking remittances and exiting the program.
         options = ["Check for new remittances", "Exit"]
-        # If new files are detected, add the option to submit claims.
-        if new_files:
+        # 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.
@@ -320,11 +274,22 @@ def main_menu():
         if choice == '1':
             # Handle remittance checking.
             check_for_new_remittances(config)
-        elif choice == '2' and new_files:
-            # Handle the claims submission flow if new files are present.
-            handle_submission(detailed_patient_data, config) # Since we have the bulk edit, we should actually go there first 
-        elif choice == '3' or (choice == '2' and not new_files):
-            # Exit the program if the user chooses to exit or if no new files are present.
+        elif choice == '2' and all_files:
+            # Handle the claims submission flow if any files are present.
+            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.
+            detailed_patient_data = collect_detailed_patient_data(selected_files, config, crosswalk)
+            
+            # Process the claims submission.
+            handle_submission(detailed_patient_data, config)
+        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:

MediLink/MediLink_837p_encoder_library.py

@@ -12,7 +12,7 @@ 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
+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,32 +520,9 @@ def insurance_type_selection(parsed_data):
     
     print("\nInsurance Type Validation Error: 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"
-    }
+    # 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

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