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

MediLink/MediLink_Decoder.py

@@ -1,57 +1,93 @@
 # MediLink_Decoder.py
-import os
-import sys
-import csv
+import os, sys, csv
 from MediLink_ConfigLoader import load_configuration, log
 from MediLink_Parser import parse_era_content, parse_277_content, parse_277IBR_content, parse_277EBR_content, parse_dpt_content, parse_ebt_content, parse_ibt_content
 
-def process_file(file_path, output_directory, return_records=False):
-    if not os.path.exists(output_directory):
-        os.makedirs(output_directory)
+# Define new_fieldnames globally
+new_fieldnames = ['Claim #', 'Payer', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+
+class UnifiedRecord:
+    def __init__(self, claim_number='', status='', patient='', payer='', proc_date='', serv_date='', allowed='', paid='', pt_resp='', charged=''):
+        self.claim_number = claim_number
+        self.payer = payer  # Added payer to the constructor
+        self.status = status
+        self.patient = patient
+        self.proc_date = proc_date
+        self.serv_date = serv_date
+        self.allowed = allowed
+        self.paid = paid
+        self.pt_resp = pt_resp
+        self.charged = charged
+
+    def to_dict(self):
+        return {
+            'Claim #': self.claim_number,
+            'Payer': self.payer,  # Added payer to the dictionary representation
+            'Status': self.status,
+            'Patient': self.patient,
+            'Proc.': self.proc_date,
+            'Serv.': self.serv_date,
+            'Allowed': self.allowed,
+            'Paid': self.paid,
+            'Pt Resp': self.pt_resp,
+            'Charged': self.charged
+        }
+
+    def __repr__(self):
+        return ("UnifiedRecord(claim_number='{0}', status='{1}', patient='{2}', payer='{3}', proc_date='{4}', serv_date='{5}', "
+                "allowed='{6}', paid='{7}', pt_resp='{8}', charged='{9}')").format(
+            self.claim_number, self.status, self.patient, self.payer, self.proc_date,
+            self.serv_date, self.allowed, self.paid, self.pt_resp, self.charged)  # Added payer to the repr
+
+def process_decoded_file(file_path, output_directory, return_records=False, debug=False): # Renamed from process_file
+    os.makedirs(output_directory, exist_ok=True)
 
     file_type = determine_file_type(file_path)
     content = read_file(file_path)
-    
-    if file_type == 'ERA':
-        records = parse_era_content(content)
-    elif file_type in ['277', '277IBR', '277EBR']:
-        records = parse_277_content(content) if file_type == '277' else parse_277IBR_content(content) if file_type == '277IBR' else parse_277EBR_content(content)
-    elif file_type == 'DPT':
-        records = parse_dpt_content(content)
-    elif file_type == 'EBT':
-        records = parse_ebt_content(content)
-    elif file_type == 'IBT':
-        records = parse_ibt_content(content)
-    else:
+
+    parse_functions = {
+        'ERA': parse_era_content,
+        '277': parse_277_content,
+        '277IBR': parse_277IBR_content,
+        '277EBR': parse_277EBR_content,
+        'DPT': parse_dpt_content,
+        'EBT': parse_ebt_content,
+        'IBT': parse_ibt_content
+    }
+
+    parse_function = parse_functions.get(file_type)
+    if parse_function is None:
         log("Unsupported file type: {}".format(file_type))
         return []
 
+    records = parse_function(content, debug=debug)
     formatted_records = format_records(records, file_type)
+
     if not return_records:
-        display_table(formatted_records)
-        output_file_path = os.path.join(output_directory, os.path.basename(file_path) + '_decoded.csv')
+        display_table([record.to_dict() for record in formatted_records])
+        output_file_path = os.path.join(output_directory, "{}_decoded.csv".format(os.path.basename(file_path)))
         write_records_to_csv(formatted_records, output_file_path)
         log("Decoded data written to {}".format(output_file_path))
-    return formatted_records
+
+    return formatted_records  # Returns list of UnifiedRecord instances
 
 def determine_file_type(file_path):
-    if file_path.endswith('.era'):
-        return 'ERA'
-    elif file_path.endswith('.277'):
-        return '277'
-    elif file_path.endswith('.277ibr'):
-        return '277IBR'
-    elif file_path.endswith('.277ebr'):
-        return '277EBR'
-    elif file_path.endswith('.dpt'):
-        return 'DPT'
-    elif file_path.endswith('.ebt'):
-        return 'EBT'
-    elif file_path.endswith('.ibt'):
-        return 'IBT'
-    else:
-        log("Unsupported file type for file: {}".format(file_path))
-        return None
+    file_extensions = {
+        '.era': 'ERA',
+        '.277': '277',
+        '.277ibr': '277IBR',
+        '.277ebr': '277EBR',
+        '.dpt': 'DPT',
+        '.ebt': 'EBT',
+        '.ibt': 'IBT'
+    }
+    
+    for ext, file_type in file_extensions.items():
+        if file_path.endswith(ext):
+            return file_type
+            
+    log("Unsupported file type for file: {}".format(file_path))
+    return None
 
 def read_file(file_path):
     with open(file_path, 'r') as file:
@@ -59,86 +95,209 @@ def read_file(file_path):
     return content
 
 def write_records_to_csv(records, output_file_path):
-    fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+    if not records:
+        log("No records to write.", 'error')
+        return
+
+    # Use the global variable for fieldnames
+    fieldnames = new_fieldnames
+    
     with open(output_file_path, 'w', newline='') as csvfile:
         writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
         writer.writeheader()
         for record in records:
-            writer.writerow(record)
+            writer.writerow(record.to_dict())
 
 def format_records(records, file_type):
     formatted_records = []
-    for record in records:
+    seen_claim_numbers = set()  # Set to track unique claim numbers
+
+    for i, record in enumerate(records):
+        # Determine the claim number based on the file type
         if file_type == 'IBT':
-            formatted_record = {
-                'Claim #': record.get('Patient Control Number', ''),
-                'Status': record.get('Status', ''),
-                'Patient': record.get('Patient Name', ''),
-                'Proc.': format_date(record.get('To Date', '')),
-                'Serv.': format_date(record.get('From Date', '')),
-                'Allowed': '',
-                'Paid': '',
-                'Pt Resp': '',
-                'Charged': record.get('Charge', '')
-            }
+            claim_number = record.get('Patient Control Number', '')
+        elif file_type == 'ERA':
+            claim_number = record.get('Chart Number', '')
+        elif file_type == 'EBT':
+            claim_number = record.get('Patient Control Number', '')
         else:
-            formatted_record = {
-                'Claim #': record.get('Chart Number', record.get('Claim Status Tracking #', record.get('Claim #', ''))),
-                'Status': record.get('claimStatus', record.get('Status', '')),
-                'Patient': record.get('memberInfo', {}).get('ptntFn', '') + ' ' + record.get('memberInfo', {}).get('ptntLn', '') if 'memberInfo' in record else record.get('Patient', ''),
-                'Proc.': format_date(record.get('processed_date', record.get('Received Date', ''))),
-                'Serv.': format_date(record.get('firstSrvcDt', record.get('Date of Service', ''))),
-                'Allowed': record.get('totalAllowdAmt', record.get('Allowed Amount', '')),
-                'Paid': record.get('totalPaidAmt', record.get('Amount Paid', '')),
-                'Pt Resp': record.get('totalPtntRespAmt', record.get('Patient Responsibility', '')),
-                'Charged': record.get('totalChargedAmt', record.get('Charge', ''))
-            }
-        formatted_records.append(formatted_record)
+            claim_number = ''  # Default to empty if file type is not recognized
+
+        # Skip records without a claim number
+        if not claim_number:
+            log("Record {} missing claim_number. Skipping.".format(i + 1), level="WARNING")
+            continue
+
+        # Check for duplicates
+        if claim_number in seen_claim_numbers:
+            log("Duplicate claim_number {} found at record {}. Skipping.".format(claim_number, i + 1), level="DEBUG")
+            continue
+
+        seen_claim_numbers.add(claim_number)  # Add claim number to the set. BUG This isn't successfully removing duplicate records. -- it might be across files and not within them.
+
+        unified_record = UnifiedRecord()
+
+        # Populate the unified_record based on the file type
+        if file_type == 'IBT':
+            unified_record.claim_number = claim_number
+            unified_record.status = record.get('Status', '')
+            unified_record.patient = record.get('Patient Name', '')
+            unified_record.proc_date = format_date(record.get('To Date', ''))
+            unified_record.serv_date = format_date(record.get('From Date', ''))
+            unified_record.charged = record.get('Charge', '')
+
+        elif file_type == 'ERA':
+            unified_record.claim_number = claim_number
+            unified_record.status = record.get('claimStatus', '')
+            unified_record.patient = record.get('Patient', '')
+            unified_record.proc_date = format_date(record.get('processed_date', ''))
+            unified_record.serv_date = format_date(record.get('Date of Service', ''))
+            unified_record.allowed = record.get('Allowed Amount', '')
+            unified_record.paid = record.get('Amount Paid', '')
+            unified_record.pt_resp = record.get('Patient Responsibility', '')
+            unified_record.charged = record.get('Charge', '')
+
+        elif file_type == 'EBT':
+            if 'Patient Control Number' in record:
+                unified_record.claim_number = claim_number
+                message_type = record.get('Message Type', '').upper()
+                status_mapping = {
+                    'A': 'Accepted',
+                    'R': 'Rejected',
+                }
+                # unified_record.status = status_mapping.get(message_type, message_type)
+                unified_record.status = record.get('Message', '')
+                unified_record.payer = record.get('Message Initiator', '')
+                unified_record.patient = record.get('Patient Name', '')
+                unified_record.proc_date = format_date(record.get('To Date', ''))
+                unified_record.serv_date = format_date(record.get('From Date', ''))
+                unified_record.allowed = ''
+                unified_record.paid = ''
+                unified_record.pt_resp = ''
+                unified_record.charged = record.get('Charge', '')
+                log("Formatted EBT Record {}: {}".format(i + 1, unified_record), level="DEBUG")
+            else:
+                log("Skipped non-claim EBT Record {}: {}".format(i + 1, record), level="DEBUG")
+                continue
+
+        # Append the unified record to the list
+        formatted_records.append(unified_record)
+
     return formatted_records
 
 def format_date(date_str):
-    if date_str and len(date_str) >= 10:
-        return date_str[5:7] + '-' + date_str[8:10]  # Assuming date format is YYYY-MM-DD, this returns MM-DD
+    if date_str and len(date_str) >= 8:
+        return date_str[4:6] + '-' + date_str[6:8]  # Adjusted to match sample date format 'YYYYMMDD'
     return ''
 
 def display_table(records):
-    # Define the new fieldnames and their respective widths
-    new_fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
-    col_widths = {field: len(field) for field in new_fieldnames}
+    """
+    Display records in a formatted table after deduplication.
     
-    # Update column widths based on records
+    Args:
+        records (list): List of UnifiedRecord instances.
+    """
+    # Deduplicate records before displaying
+    records = deduplicate_records(records)
+
+    if not records:
+        print("No records to display.")
+        return
+
+    # Determine which fields have at least one non-empty value
+    used_fields = [field for field in new_fieldnames if any(str(record.get(field, '')).strip() for record in records)]
+
+    if not used_fields:
+        print("No data to display.")
+        return
+
+    # Calculate column widths based on the longest item in each used column
+    col_widths = {field: len(field) for field in used_fields}
+
     for record in records:
-        for field in new_fieldnames:
+        for field in used_fields:
             col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
-    
+
     # Create table header
-    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in new_fieldnames)
+    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in used_fields)
     print(header)
     print("-" * len(header))
-    
+
     # Create table rows
     for record in records:
-        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in new_fieldnames)
+        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in used_fields)
         print(row)
 
 def display_consolidated_records(records):
-    if not records:
+    """
+    Display the consolidated records in a formatted table.
+    Removes any records that are completely empty or only contain whitespace.
+    If no valid records are found, displays a message to that effect.
+    """
+    # Deduplicate records before displaying
+    records = deduplicate_records(records)
+
+    # If records are UnifiedRecord instances, convert them to dictionaries
+    if records and isinstance(records[0], UnifiedRecord):
+        dict_records = [record.to_dict() for record in records]
+    elif records and isinstance(records[0], dict):
+        dict_records = records
+    else:
+        log("Invalid record format for display.", level="ERROR")
+        return
+    
+    # Filter out records that are completely empty or only contain whitespace
+    filtered_records = [
+        record for record in dict_records 
+        if any(str(record.get(field, '')).strip() for field in new_fieldnames)
+    ]
+    
+    if not filtered_records:
+        print("No valid records to display after filtering empty rows.")
         return
     
-    new_fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
-    col_widths = {field: len(field) for field in new_fieldnames}
+    # Determine which fields have at least one non-empty value
+    used_fields = [field for field in new_fieldnames if any(str(record.get(field, '')).strip() for record in filtered_records)]
 
-    for record in records:
-        for field in new_fieldnames:
+    if not used_fields:
+        print("No data to display.")
+        return
+    
+    # Calculate column widths based on the longest item in each used column
+    col_widths = {field: len(field) for field in used_fields}
+    
+    for record in filtered_records:
+        for field in used_fields:
             col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
-
-    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in new_fieldnames)
+    
+    # Print header
+    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in used_fields)
     print(header)
     print("-" * len(header))
+    
+    # Print each row
+    for record in filtered_records:
+        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in used_fields)
+        print(row)
 
+def deduplicate_records(records):
+    """
+    Remove duplicate records based on claim_number.
+    
+    Args:
+        records (list): List of UnifiedRecord instances.
+    
+    Returns:
+        list: List of unique UnifiedRecord instances.
+    """
+    unique_records_dict = {}
     for record in records:
-        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in new_fieldnames)
-        print(row)
+        if record.claim_number not in unique_records_dict:
+            unique_records_dict[record.claim_number] = record
+        else:
+            log("Duplicate record found for claim_number {}. Skipping.".format(record.claim_number), "DEBUG")
+    
+    return list(unique_records_dict.values())
 
 if __name__ == "__main__":
     config, _ = load_configuration()
@@ -152,14 +311,17 @@ if __name__ == "__main__":
     all_records = []
     for file_path in files:
         try:
-            records = process_file(file_path, output_directory, return_records=True)
+            records = process_decoded_file(file_path, output_directory, return_records=True)
             all_records.extend(records)
         except Exception as e:
             log("Failed to process {}: {}".format(file_path, e), 'error')
     
-    display_consolidated_records(all_records)
+    # Call the deduplication function
+    unique_records = deduplicate_records(all_records)
+
+    display_consolidated_records([record.to_dict() for record in unique_records])
 
     if input("Do you want to export the consolidated records to a CSV file? (y/n): ").strip().lower() == 'y':
         consolidated_csv_path = os.path.join(output_directory, "Consolidated_Records.csv")
-        write_records_to_csv(all_records, consolidated_csv_path)
+        write_records_to_csv(unique_records, consolidated_csv_path)
         log("Consolidated records written to {}".format(consolidated_csv_path))

MediLink/MediLink_Deductible.py

@@ -41,12 +41,10 @@ summary = {
 # print("\nDebug JSON Summary:")
 # print(json.dumps(summary, indent=2))
 """
+# MediLink_Deductible.py
 import MediLink_API_v3
-import os
-import sys
+import os, sys, requests, json
 from datetime import datetime
-import requests
-import json
 
 try:
     from MediLink import MediLink_ConfigLoader
@@ -54,7 +52,8 @@ except ImportError:
     import MediLink_ConfigLoader
 
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-sys.path.append(project_dir)
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
 
 try:
     from MediBot import MediBot_Preprocessor_lib
@@ -68,11 +67,15 @@ config, _ = MediLink_ConfigLoader.load_configuration()
 client = MediLink_API_v3.APIClient()
 
 # Get provider_last_name and npi from configuration
-provider_last_name = config['MediLink_Config'].get('default_billing_provider_last_name')
-npi = config['MediLink_Config'].get('default_billing_provider_npi')
+provider_last_name = config['MediLink_Config'].get('default_billing_provider_last_name', 'Unknown')
+npi = config['MediLink_Config'].get('default_billing_provider_npi', 'Unknown')
+
+# Check if the provider_last_name is still 'Unknown'
+if provider_last_name == 'Unknown':
+    MediLink_ConfigLoader.log("Warning: provider_last_name was not found in the configuration.", level="WARNING")
 
 # Define the list of payer_id's to iterate over
-payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']
+payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602'] # United Healthcare.
 
 # Get the latest CSV
 CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
@@ -101,12 +104,12 @@ patients = [
 def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi):
     try:
         # Log the parameters being sent to the function
-        MediLink_ConfigLoader.log("Calling get_eligibility_v3 with parameters:", level="INFO")
-        MediLink_ConfigLoader.log("payer_id: {}".format(payer_id), level="INFO")
-        MediLink_ConfigLoader.log("provider_last_name: {}".format(provider_last_name), level="INFO")
-        MediLink_ConfigLoader.log("date_of_birth: {}".format(date_of_birth), level="INFO")
-        MediLink_ConfigLoader.log("member_id: {}".format(member_id), level="INFO")
-        MediLink_ConfigLoader.log("npi: {}".format(npi), level="INFO")
+        MediLink_ConfigLoader.log("Calling get_eligibility_v3 with parameters:", level="DEBUG")
+        MediLink_ConfigLoader.log("payer_id: {}".format(payer_id), level="DEBUG")
+        MediLink_ConfigLoader.log("provider_last_name: {}".format(provider_last_name), level="DEBUG")
+        MediLink_ConfigLoader.log("date_of_birth: {}".format(date_of_birth), level="DEBUG")
+        MediLink_ConfigLoader.log("member_id: {}".format(member_id), level="DEBUG")
+        MediLink_ConfigLoader.log("npi: {}".format(npi), level="DEBUG")
 
         # Call the get_eligibility_v3 function
         eligibility = MediLink_API_v3.get_eligibility_v3(
@@ -114,7 +117,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
         )
         
         # Log the response
-        MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="INFO")
+        MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="DEBUG")
         
         return eligibility
     except requests.exceptions.HTTPError as e:
@@ -127,7 +130,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
     return None
 
 # Function to extract required fields and display in a tabular format
-def display_eligibility_info(data, dob, member_id):
+def display_eligibility_info(data, dob, member_id, output_file):
     if data is None:
         return
 
@@ -154,50 +157,53 @@ def display_eligibility_info(data, dob, member_id):
         ins_payerID = insurance_info.get("payerId", "")
 
         policy_info = policy["policyInfo"]
-        eligibilityDates = policy_info.get("eligibilityDates", "")
         policy_status = policy_info.get("policyStatus", "")
 
         patient_name = "{} {} {}".format(firstName, middleName, lastName).strip()[:20]
 
         # Display patient information in a table row format
-        eligibility_end_date = eligibilityDates.get("endDate", "")
-        table_row = "{:<20} | {:<10} | {:<5} | {:<30}".format(
-            patient_name, dob, ins_payerID, ins_insuranceType)
-        print(table_row)
-        table_row_details = "{:<20} | {:<10} | {:<5} | {:<15} | {:<8} | {:<15} | {:<20}".format(
-            "", "", "", ins_insuranceTypeCode, eligibility_end_date[-10:], policy_status, remaining_amount)
-        print(table_row_details)
+        table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+            patient_name, dob, ins_insuranceType, ins_payerID, policy_status, remaining_amount)
+        output_file.write(table_row + "\n")
+        print(table_row)  # Print to console for progressive display
 
 # Print the table header once before entering the loop
-table_header = "{:<20} | {:<10} | {:<5} | {:<30}".format(
-    "Patient Name", "DOB", "Payer ID", "Insurance Type")
-print(table_header)
-print("-" * len(table_header))
-sub_header = "{:<20} | {:<10} | {:<5} | {:<15} | {:<8} | {:<15} | {:<20}".format(
-    "", "", "", "Type Code", "End Date", "Policy Status", "Remaining Amount")
-print(sub_header)
-print("-" * len(sub_header))
-
-# Set to keep track of processed patients
-processed_patients = set()
-
-# Loop through each payer_id and patient to call the API, then display the eligibility information
-errors = []
-for payer_id in payer_ids:
-    for dob, member_id in patients:
-        # Skip if this patient has already been processed
-        if (dob, member_id) in processed_patients:
-            continue
-        try:
-            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi)
-            if eligibility_data is not None:
-                display_eligibility_info(eligibility_data, dob, member_id)  # Display as we get the result
-                processed_patients.add((dob, member_id))  # Mark this patient as processed
-        except Exception as e:
-            errors.append((dob, member_id, str(e)))
-
-# Display errors if any
-if errors:
-    print("\nErrors encountered during API calls:")
-    for error in errors:
-        print("DOB: {}, Member ID: {}, Error: {}".format(error[0], error[1], error[2]))
+output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
+with open(output_file_path, 'w') as output_file:
+    table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+        "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
+    output_file.write(table_header + "\n")
+    output_file.write("-" * len(table_header) + "\n")
+    print(table_header)
+    print("-" * len(table_header))
+
+    # Set to keep track of processed patients
+    processed_patients = set()
+
+    # Loop through each payer_id and patient to call the API, then display the eligibility information
+    errors = []
+    for payer_id in payer_ids:
+        for dob, member_id in patients:
+            # Skip if this patient has already been processed
+            if (dob, member_id) in processed_patients:
+                continue
+            try:
+                eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi)
+                if eligibility_data is not None:
+                    display_eligibility_info(eligibility_data, dob, member_id, output_file)  # Display as we get the result
+                    processed_patients.add((dob, member_id))  # Mark this patient as processed
+            except Exception as e:
+                errors.append((dob, member_id, str(e)))
+
+    # Display errors if any
+    if errors:
+        error_msg = "\nErrors encountered during API calls:\n"
+        output_file.write(error_msg)
+        print(error_msg)
+        for error in errors:
+            error_details = "DOB: {}, Member ID: {}, Error: {}\n".format(error[0], error[1], error[2])
+            output_file.write(error_details)
+            print(error_details)
+
+# Open the generated file in Notepad
+os.system('notepad.exe {}'.format(output_file_path))